1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/* See LICENSE file for copyright and license details. */
#include "libgamma_AdjustmentMethod.h"
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <libgamma.h>
#if LIBGAMMA_METHOD_COUNT > 6
# error LIBGAMMA_METHOD_COUNT has been updated
#endif
/**
* List available adjustment methods by their order of preference based on the environment
*
* @param operation Allowed values:
* 0: Methods that the environment suggests will work, excluding fake
* 1: Methods that the environment suggests will work, including fake
* 2: All real non-fake methods
* 3: All real methods
* 4: All methods
* Other values invoke undefined behaviour
* @return List available adjustment methods by their order of preference
*/
jintArray
Java_libgamma_AdjustmentMethod_libgamma_1list_1methods(JNIEnv *env, jclass class, jint operation)
{
int methods[LIBGAMMA_METHOD_COUNT];
size_t i, n;
jintArray rc;
n = libgamma_list_methods(methods, LIBGAMMA_METHOD_COUNT, operation);
if (n > LIBGAMMA_METHOD_COUNT)
abort(); /* Prevented by the #if above and package maintenance */
rc = (*env)->NewIntArray(env, (jsize)n);
/* Remember, jint is 32 bits, int is 16+ bits. */
for (i = 0; i < n; i++)
(*env)->SetIntArrayRegion(env, rc, (jsize)i, 1, methods + i);
return rc;
(void) class;
}
/**
* Check whether an adjustment method is available, non-existing (invalid) methods will be
* identified as not available under the rationale that the library may be out of date
*
* @param method The adjustment method
* @return Whether the adjustment method is available
*/
jint
Java_libgamma_AdjustmentMethod_libgamma_1is_1method_1available(JNIEnv *env, jclass class, jint method)
{
return libgamma_is_method_available(method);
(void) env;
(void) class;
}
/**
* Return the capabilities of an adjustment method
*
* @param method The adjustment method (display server and protocol)
* @return Element 0: Input parameter to the constructor of {@link AdjustmentMethodCapabilities}
* Element 1: Error code, zero on success
*/
jlongArray
Java_libgamma_AdjustmentMethod_libgamma_1method_1capabilities(JNIEnv *env, jclass class, jint method)
{
jlongArray rv = (*env)->NewLongArray(env, 2);
struct libgamma_method_capabilities caps;
jlong rc = 0, e = 0;
int r = libgamma_method_capabilities(&caps, sizeof(caps), method);
if (r) {
e = (jlong)(r == LIBGAMMA_ERRNO_SET ? errno : r);
goto out;
}
rc = (jlong)(caps.crtc_information);
rc &= 0xFFFFFFFFLL;
rc |= caps.default_site_known ? (1LL << 33) : 0;
rc |= caps.multiple_sites ? (1LL << 34) : 0;
rc |= caps.multiple_partitions ? (1LL << 35) : 0;
rc |= caps.multiple_crtcs ? (1LL << 36) : 0;
rc |= caps.partitions_are_graphics_cards ? (1LL << 37) : 0;
rc |= caps.site_restore ? (1LL << 38) : 0;
rc |= caps.partition_restore ? (1LL << 39) : 0;
rc |= caps.crtc_restore ? (1LL << 40) : 0;
rc |= caps.identical_gamma_sizes ? (1LL << 41) : 0;
rc |= caps.fixed_gamma_size ? (1LL << 42) : 0;
rc |= caps.fixed_gamma_depth ? (1LL << 43) : 0;
rc |= caps.real ? (1LL << 44) : 0;
rc |= caps.fake ? (1LL << 45) : 0;
out:
(*env)->SetLongArrayRegion(env, rv, 0, 1, &rc);
(*env)->SetLongArrayRegion(env, rv, 1, 1, &e);
return rv;
(void) env;
(void) class;
}
/**
* Return the default site for an adjustment method
*
* @param method The adjustment method (display server and protocol)
* @return The default site, {@code null} if it cannot be determined or
* if multiple sites are not supported by the adjustment method
*/
jstring
Java_libgamma_AdjustmentMethod_libgamma_1method_1default_1site(JNIEnv *env, jclass class, jint method)
{
/* It is really unlikely that `malloc` returns `NULL` here
* and error handing makes this unnecessarily comples,
* therefore we will simply skip it */
const char *do_not_free_this = libgamma_method_default_site(method);
char *this_will_be_freed;
size_t n;
if (!do_not_free_this)
return NULL;
n = strlen(do_not_free_this) + 1;
this_will_be_freed = malloc(n * sizeof(char));
memcpy(this_will_be_freed, do_not_free_this, n * sizeof(char));
return (*env)->NewStringUTF(env, this_will_be_freed);
(void) class;
}
/**
* Return the default variable that determines
* the default site for an adjustment method
*
* @param method The adjustment method (display server and protocol)
* @return The environ variables that is used to determine the
* default site; {@code null} if there is none, that is,
* if the method does not support multiple sites
*/
jstring
Java_libgamma_AdjustmentMethod_libgamma_1method_1default_1site_1variable(JNIEnv *env, jclass class, jint method)
{
/* It is really unlikely that `malloc` returns `NULL` here
* and error handing makes this unnecessarily comples,
* therefore we will simply skip it */
const char *do_not_free_this = libgamma_method_default_site_variable(method);
char *this_will_be_freed;
size_t n;
if (!do_not_free_this)
return NULL;
n = strlen(do_not_free_this) + 1;
this_will_be_freed = malloc(n * sizeof(char));
memcpy(this_will_be_freed, do_not_free_this, n * sizeof(char));
return (*env)->NewStringUTF(env, this_will_be_freed);
(void) class;
}
|
