summaryrefslogtreecommitdiffstats
path: root/examples/lisp-esque.conf
blob: 3a65c3b9afaf83e5e82ca975a6d46b5737f9c960 (plain) (blame)
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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
; -*- lisp -*-
; The line above sets the editors to LISP mode, which probably
; is the mode with best syntax highlighting for this file.
; This configuration file requires the LISP-esque example
; configuration scripts

; Both ; (semicolon) and # (pound) start commands ending the end of the line

; If you know LISP, you might find this the be a bit different,
; it is only superficially like LISP. Anthing it is inside brackets
; is a list of strings. A string starting with a colon is a function
; call with next string being its argument, or the next list being
; its arguments. The first string in a list may or may not be function
; call, depending on situation; it can be first not to be bit adding
; a dot the string before it, the first string is ignored if it is a dot.
; Quotes have no effect other than cancelling out the effect of whitespace.


(blueshift
	; Indices of monitors to use.
	(monitors) ; For all monitors
	;    For the primary monitor:                       (monitors 0)
	;    For the first two monitors:                    (monitors 0 1)
	;    For the primary on the screen 0 and screen 1:  (monitors 0:0 1:0)
	;    For all monitors on screen 0:                  (monitors 0:)
	;    For monitors with output name DVI-0:           (monitors :crtc "DVI-0")
	;    For monitors with output name DVI-0 or VGA-0:  (monitors :crtc ("DVI-0" "VGA-0"))
	;    For monitors with size 364 mm × 291 mm:        (monitors :size (364 291))
	
	
	; Geographical coodinates: latitude longitude (northwards and eastwards in degrees)
	(coordinates 59.3472 18.0728)
	;    If you have this store in ~/.location you can use
	;        (coordinates :parse (read "~/.location"))
	;    If the command `~/.location` prints the information you can use
	;        (coordinates :parse (spawn "~/.location"))
	;        Or if you want to the location to be updates continuously:
	;            (coordinates:cont :parse (spawn "~/.location"))
	;    You can also store the text "(coordinates 59.3472 18.0728)" in
	;    file named ~/.location:
	;        :include "~/.location"
	;    A more advance alternative is to have a Python file named "~/.location.py"
	;    that is parsed and have its function `location` invoked with not arguments:
	;        (source "~/.location.py")
	;        (coordinates :eval "location()")
	;        If location can continuously update your location you can use:
	;            (source "~/.location.py")
	;            (coordinates:cont :eval location)
	;    You can combine having a static location and continuously updating,
	;    which allows Blueshift to use the static location if the dynamic cannot
	;    be fetch when Blueshift starts:
	;        (coordinates 59.3472 18.0728)
	;        (coordinates:cont :parse (spawn "~/.location"))
	
	; Time points when different settings are applied, continuous transition
	; betweem them will be used. This are not used by default, be can be
	; enabled in the next section.
	(timepoints 2:00 8:00 22:00)
	
	; Select method for calculating the time the different settings are (fully) applied
	(points solar)
        ;    Use the two default solar elevations
	; (points solar :eval SOLAR_ELEVATION_ASTRONOMICAL_DUSK_DAWN :eval SOLAR_ELEVATION_SUNSET_SUNRISE)
	;    Use two standard solar elevations
	; (points solar -18 -12 -6 0 6)
	;    Use four custom solar elevations
	; (points time)
	;    Use the time points from (timepoints) (from the previous section)
	; (points constant)
	;    Assume it 100 % are day long, and exit when settings have been applied.
	;    (One shot mode instead of continuous mode)
	
	; If you have multiple values in (points) they can be reduced to two:
	; (dayness 0 1 1)
	; For example, if we have (points time) and (timepoints 2:00 8:00 22:00)
	; than (dayness 0 1 1) will reduce it so that the settings only have to
	; define values for day and night (in that order). At 2:00 it would be
	; 100 % night, and at 8:00 to 22:00 it would be 100 % day.
	
	
	; Colour curve applying method.
	(method randr) ### --- MODERATE LEVEL ---
	;    Alternatively (limited to primary monitors):  (method vidmode)
	;    For debugging (or passing to another application) you can use
	;        (method print)
	;    It is possible to use both:
	;        (method print randr)
	
	
	(transfrom randr) ; yes, this it says ‘from’ not ‘form’
	; This lets Blueshift transition from the currently applied settings
	; when it starts. If you prefer to use vidmode instead of randr you
	; can use
	;     (transfrom randr)
	; If you do not want to do this you can use
	;     (transfrom nil)
	; It an also be configured individually for the monitors:
	;     (transfrom randr nil)
	;         This will not do this for the second monitor
	
	
	;; Important: The following options are applied in order of appearance
	;;            moving them around can cause inexact monitors calibration
	;;            or other unwanted effects. But it could perhaps also do
	;;            something wonderful.
	
	; ICC profile for video filtering (monitor calibration will be later.)
	; Replace `nil` with the pathname of the profile. It is assumed to not be
	; already applied and it is assumed that it should not be applied on exit.
	#(icc:filter nil) ### --- MODERATE LEVEL ---
	;     If you have three monitors: (icc:filter (nil nil nil))
	;     On all the monitors but time dependent: (icc:filter nil nil)
	;     The two above combined: (icc:filter (nil nil nil) (nil nil nil))
	
	; Negative image settings.
	(negative no)            ; Does nothing
	; (negative yes)         ; Inverts the colours on the encoding axes
	; (negative (yes no no)) ; Inverts the red colour on the encoding axis
	; (negative yes no)      ; Inverts the colours on the encoding axes on the first monitor
	;                        ; but not the second monitor selected by (monitors)
	; (invert yes)           ; Inverts the colours on the output axes using the sRGB colour space
	; (invert (yes no no))   ; Inverts the red colour on the output axes using the sRGB colour space
	; (invert:cie yes)       ; Inverts the colours on the output axes using the CIE xyY colour space
	;     These cannot be time dependent.
	
	; Colour temperature at high day and high night, respectively.
	(temperature 6500 3700)
	;    If you the second monitor selected by (monitors) to always be at 6500K you can use
	;        (temperature (6500 6500) (3700 6500))
	
	### --- EXPERT LEVEL ---
	; If you want a more advance calculation of the correlated colour
	; temperature you can replace (temperature) in the step about with
	; (temperature') and add the following *before* it:
	;     (compose temperature' as-is (divide_by_maximum cmf_10deg))
	;         This is the default, but you can also use for example and of the following:
	;             (compose temperature' as-is (divide_by_maximum series_d))
	;             (compose temperature' as-is (clip_whitepoint simple_whitepoint))
	;             (compose temperature' as-is (divide_by_maximum cmf_2deg))
	;             (compose temperature' as-is redshift')
	;             Where Redshift' needs to be composed by temperature':
	;                 (compose redshift' as-is yes)     ; as in redshift<=1.8
	;                 (compose redshift' as-is no)      ; as in redshift>1.8
	;                 (compose redshift' as-is yes yes) ; as in redshift<=1.8 but interpolating in linear RGB
	;                 (compose redshift' as-is no yes)  ; as in redshift>1.8  but interpolating in linear RGB
	;         See `info blueshift 'configuration api' 'colour curve manipulators'`
	;         and look for ‘temperature’ for details.
	
	; It is possible to calibrations that were applied when Blueshift started.
	#(current nil) ### --- EXPERT LEVEL ---
	;    This is ignored if --panicgate is used (it is assumed that Blueshift
	;    crashed if --panicgate is used). It also has no effect in one shot mode.
	;    `nil` means that it does nothing, but you can also use `randr` or
	;    `vidmode`, but `vidmode` is restricted to primary monitors:
	;        (current randr)   ; of using randr
	;        (current vidmode) ; of using vidmode
	;    You can also controll the monitors individually:
	;        (current randr nil) ; does this only for the first monitor
	
	; Colour brightness at high day and high night, respectively.
	; This setting uses the CIE xyY colour space for calculating values.
	(brightness:cie 1 1)
	;    If you have multiple monitors, they can be configured indiviudally.
	;    For example if you have two monitors, we can keep the first monitor
	;    on full brightness all day long, but make the second monitor be
	;    at 75 % during the night:
	;        (brightness:cie (1 1) (1 0.75))
	
	; Colour brightness of the red, green and blue components,
	; respectively, at high day and high night, respectively.
	; This settings uses the sRGB colour space for calculating values.
	(brightness (1 1 1) (1 1 1)) ### --- MODERATE LEVEL ---
	;    Because red, green and blue are identical in this example,
	;    writting (brightness 1 1) instead with do the same thing.
	;    If you want the second monitor selected by (monitors) to always
	;    be at 100 % but the primary to shift between 100 % and 75 % you can use
	;        (brightness ((1) (1)) ((1) (0.75)))
	;    As this indicates you use the following if you want only the blue
	;    part to shift to 75 %:
	;        (brightness ((1) (1)) ((1) (0.75 1 1)))
	;     Or alternatively:
	;        (brightness:red (1 1) (1 0.75))
	
	; Colour contrast at high day and high night, respectively.
	; This setting uses the CIE xyY colour space for calculating values.
	#(contrast:cie 1 1) ### --- MODERATE LEVEL ---
	;    This can be done monitors dependently as in (brightness:cie).
	
	; Colour contrast of the red, green and blue components,
	; respectively, at high day and high night, respectively.
	; This settings uses the sRGB colour space for calculating values.
	#(contrast (1 1 1) (1 1 1)) ### --- MODERATE LEVEL ---
	;    Because red, green and blue are identical in this example,
	;    writting (contrast 1 1) instead with do the same thing.
	;    This can be done monitors dependently as in (brightness).
	
	
	;; Note: brightness and contrast is not intended for colour
	;;       calibration, it should be calibrated on the monitors'
	;;       control panels.
	
	
	; These are fun curve manipulator settings that lowers the
	; colour resolution ont encoding and output axes respectively.
	; In this example (resolution:encoding) only has one argument,
	; it applies all day long on each colour curve.
	#(resolution:encoding :eval i_size) ### -- ADVANCED LEVEL --
	;    This is evaluated into:
	;        (resolution:encoding 256)
	; (resolution:output) in this example one argument that is
	; a tuple of three values which represent red, green, and
	; blue respectively. Because it is only one argument it
	; applies all day long as well.
	#(resolution:output (:eval (o_size o_size o_size))) ### -- ADVANCED LEVEL --
	;    This is evaluated into:
	;        (resolution:output (65536 65536 65536))
	;    As always you can control the monitors individually:
	;        (resolution:output (:eval ((o_size o_size o_size) (o_size o_size o_size))))
	;        This evaluated into:
	;            (resolution:output ((65536 65536 65536) (65536 65536 65536)))
	
	; Gamma correction for the red, green and blue components, respectively,
	; at high day, high night and monitor default, respectively.
	; This settings uses the sRGB colour space for calculating values.
	#(gamma (1 1 1) (1 1 1)) ### --- MODERATE LEVEL ---
	(gamma:default (1 1 1))
	;    All configurations can use :default, but it only makes since
	;    for gamma because it is the only actual monitors calibration
	;    configurations, with the exception of ICC profiles and white
	;    point and black point calibration and sigmoid curve correction.
	;    (gamma) automatically run (clip) to avoid mathematical errors,
	;    If you prefer not to run (clip) you can use
	;        ('gamma (1 1 1) (1 1 1))
	;        ('gamma:default (1 1 1))
	;    You can also run clip manually:
	;        (clip)
	;        Or for the first but not second monitor:
	;            (clip yes no)
	;        Clipping cannot time dependent.
	
	
	;; Note: gamma is supposted to be static, it purpose is to
	;;       correct the colours on the monitors the monitor's gamma
	;;       is exactly 2,2 and the colours look correct in relation
	;;       too each other. It is supported to have different settings
	;;       at day and night because there are no technical limitings
	;;       and it can presumable increase readability on text when
	;;       the colour temperature is low.
	
	
	; If you have an LCD monitor you can use (well you could on CRT as
	; well but it would not make since) sigmoid curve correction to
	; calibrate your monitor. 4.5 is a good value to start testing at,
	; but be aware, it is very difficult to get right is it depens on
	; other calibrations as well. For now we have `nil` which means that
	; no sigmoid curve correction will take place.
	#(sigmoid:default (nil nil nil)) ### -- EXPERT LEVEL --
	;    This three `nil`:s are for red, green and blue respectively,
	;    but you can just one argument instead of a tuple of three, if
	;    the colour curves should have the same sigmoid curve correction.
	;    If you have two monitors you can use (and replace nil with
	;    your correction parameters):
	;        (sigmoid:default (nil nil nil) (nil nil nil))
	;        or
	;        (sigmoid:default nil nil)
	; You can also so time dependent correction:
	#(sigmoid (nil nil nil) (nil nil nil)) ### -- EXPERT LEVEL --
	;    (sigmoid ((nil nil nil) (nil nil nil)) ((nil nil nil) (nil nil nil)))
	;    (sigmoid (nil nil) (nil nil))
	
	; If you have require software level brightness and contract
	; calibration (needed to calibrate most LCD monitors), you and
	; use (limits) and (limits:cie). These will calibrate the
	; black point (brightness) and the white point (contrast). This
	; brightness and contrast is not the same thing as the settings
	; (brightness) and (contrast). (brightness) is more similar to
	; backlight and (contrast) is a flattening of the colour curves
	; towards 50 %. In (limits:cie) and first argument (for each time)
	; is the brightness [black point] and the second is the [white point].
	#(limits:cie:default 0 1) ### -- ADVANCED LEVEL --
	; If you have three monitors they can be controlled individually:
	;    (limits:cie:default (0 1) (0 1) (0 1))
	; You can so also do time dependent correction:
	;(cie_limits (0 1) (0 1))
	;    (limits:cie ((0 1) (0 1) (0 1)) ((0 1) (0 1) (0 1)))
	
	; ICC profile for monitor calibration will be later.
	; Replace `nil` with the pathname of the profile. It is assumed to
	; already be applied and that it should be applied on exit.
	#(icc:calib nil) ### -- MODERATE LEVEL --
	;     If you have three monitors: (icc (nil nil nil))
	;     On all the monitors but time dependent: (icc nil nil)
	;     The two above combined: (icc (nil nil nil) (nil nil nil))
	;     (icc) is a synonym for (icc:calib).
	
	### -- EXPERT LEVEL --
	; It is also possible to some of your own manipulations:
	; where is an example that temporary switches to linear RGB
	; change makes the colour curves logarithmical:
	;     (linearise)
	;     (manipulate 'lambda x : math.log(x + 1, 2)')
	;          Or for the colour colurves individually:
	;              (manipulate 'lambda x : math.log(x + 1, 2)'
	;                          'lambda x : math.log(x + 1, 2)'
	;                          'lambda x : math.log(x + 1, 2)' 
	;              )
	;     (standardise)
	; As with (clip) (linearise) and (standardise) can depend
	; on the monitor, so can (manipulate):
	;     (linearise yes no)
	;     (manipulate 'lambda x : math.log(x + 1, 2)')
	;          Or for the colour colurves individually:
	;              (manipulate ('lambda x : math.log(x + 1, 2)'
	;                           'lambda x : math.log(x + 1, 2)'
	;                           'lambda x : math.log(x + 1, 2)'
	;                          )
	;                          nil ; Do nothing on the second monitor
	;              )
	;     (standardise yes no)
)