forked from Raymo111/i3lock-color
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathunlock_indicator.c
1328 lines (1188 loc) · 50.4 KB
/
unlock_indicator.c
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
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* vim:ts=4:sw=4:expandtab
*
* © 2010 Michael Stapelberg
* © 2015 Cassandra Fox
* © 2021 Raymond Li
*
* See LICENSE for licensing information
*
*/
#include <pthread.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <xcb/xcb.h>
#include <xcb/randr.h>
#include <ev.h>
#include <cairo.h>
#include <cairo/cairo-xcb.h>
#include "i3lock.h"
#include "xcb.h"
#include "unlock_indicator.h"
#include "randr.h"
#include "dpi.h"
#include "tinyexpr.h"
#include "fonts.h"
/* clock stuff */
#include <time.h>
extern double circle_radius;
extern double ring_width;
#define BUTTON_RADIUS (circle_radius)
#define RING_WIDTH (ring_width)
#define BUTTON_SPACE (BUTTON_RADIUS + (RING_WIDTH / 2))
#define BUTTON_DIAMETER (2 * BUTTON_SPACE)
/*******************************************************************************
* Variables defined in i3lock.c.
******************************************************************************/
extern bool debug_mode;
/* The current position in the input buffer. Useful to determine if any
* characters of the password have already been entered or not. */
extern int input_position;
/* The lock window. */
extern xcb_window_t win;
/* The current resolution of the X11 root window. */
extern uint32_t last_resolution[2];
/* Whether the unlock indicator is enabled (defaults to true). */
extern bool unlock_indicator;
/* List of pressed modifiers, or NULL if none are pressed. */
extern char *modifier_string;
/* A Cairo surface containing the specified image (-i), if any. */
extern cairo_surface_t *img;
extern char *image_path;
extern char *slideshow_path;
extern char *img_slideshow[256];
extern cairo_surface_t *blur_bg_img;
extern int slideshow_image_count;
extern int slideshow_interval;
extern bool slideshow_random_selection;
int slideshow_image_now = 0;
unsigned long lastCheck;
/* How the background image should be displayed */
extern background_type_t bg_type;
/* The background color to use (in hex). */
extern char color[9];
/* indicator color options */
extern char insidevercolor[9];
extern char insidewrongcolor[9];
extern char insidecolor[9];
extern char ringvercolor[9];
extern char ringwrongcolor[9];
extern char ringcolor[9];
extern char linecolor[9];
extern char verifcolor[9];
extern char wrongcolor[9];
extern char layoutcolor[9];
extern char timecolor[9];
extern char datecolor[9];
extern char modifcolor[9];
extern char keyhlcolor[9];
extern char bshlcolor[9];
extern char separatorcolor[9];
extern char greetercolor[9];
extern int internal_line_source;
extern char verifoutlinecolor[9];
extern char wrongoutlinecolor[9];
extern char layoutoutlinecolor[9];
extern char timeoutlinecolor[9];
extern char dateoutlinecolor[9];
extern char greeteroutlinecolor[9];
extern char modifoutlinecolor[9];
extern int screen_number;
extern float refresh_rate;
extern bool show_clock;
extern bool always_show_clock;
extern bool show_indicator;
extern int verif_align;
extern int wrong_align;
extern int time_align;
extern int date_align;
extern int layout_align;
extern int modif_align;
extern int greeter_align;
extern char time_format[32];
extern char date_format[32];
extern char *fonts[6];
extern char ind_x_expr[32];
extern char ind_y_expr[32];
extern char time_x_expr[32];
extern char time_y_expr[32];
extern char date_x_expr[32];
extern char date_y_expr[32];
extern char layout_x_expr[32];
extern char layout_y_expr[32];
extern char status_x_expr[32];
extern char status_y_expr[32];
extern char verif_x_expr[32];
extern char verif_y_expr[32];
extern char wrong_x_expr[32];
extern char wrong_y_expr[32];
extern char modif_x_expr[32];
extern char modif_y_expr[32];
extern char greeter_x_expr[32];
extern char greeter_y_expr[32];
extern double time_size;
extern double date_size;
extern double verif_size;
extern double wrong_size;
extern double modifier_size;
extern double layout_size;
extern double greeter_size;
extern double timeoutlinewidth;
extern double dateoutlinewidth;
extern double verifoutlinewidth;
extern double wrongoutlinewidth;
extern double modifieroutlinewidth;
extern double layoutoutlinewidth;
extern double greeteroutlinewidth;
extern char *verif_text;
extern char *wrong_text;
extern char *noinput_text;
extern char *lock_text;
extern char *lock_failed_text;
extern char *layout_text;
extern char *greeter_text;
bool load_slideshow_images(const char *path);
cairo_surface_t* load_image(char* image_path);
/* Whether the failed attempts should be displayed. */
extern bool show_failed_attempts;
/* Number of failed unlock attempts. */
extern int failed_attempts;
/*******************************************************************************
* Variables defined in xcb.c.
******************************************************************************/
/* The root screen, to determine the DPI. */
extern xcb_screen_t *screen;
/*******************************************************************************
* Local variables.
******************************************************************************/
/* time stuff */
static struct ev_periodic *time_redraw_tick;
/* Cache the screen’s visual, necessary for creating a Cairo context. */
static xcb_visualtype_t *vistype;
int current_slideshow_index = 0;
/* Maintain the current unlock/PAM state to draw the appropriate unlock
* indicator. */
unlock_state_t unlock_state;
auth_state_t auth_state;
// color arrays
rgba_t insidever16;
rgba_t insidewrong16;
rgba_t inside16;
rgba_t ringver16;
rgba_t ringwrong16;
rgba_t ring16;
rgba_t line16;
rgba_t verif16;
rgba_t wrong16;
rgba_t layout16;
rgba_t time16;
rgba_t date16;
rgba_t modif16;
rgba_t keyhl16;
rgba_t bshl16;
rgba_t sep16;
rgba_t bar16;
rgba_t greeter16;
rgba_t background;
rgba_t verifoutline16;
rgba_t wrongoutline16;
rgba_t layoutoutline16;
rgba_t timeoutline16;
rgba_t dateoutline16;
rgba_t greeteroutline16;
rgba_t modifoutline16;
// experimental bar stuff
#define BAR_VERT 0
#define BAR_FLAT 1
// experimental bar stuff
extern bool bar_enabled;
extern double *bar_heights;
extern double bar_step;
extern double bar_base_height;
extern double bar_periodic_step;
extern double max_bar_height;
extern double bar_position;
extern int bar_count;
extern int bar_orientation;
extern char bar_base_color[9];
extern char bar_x_expr[32];
extern char bar_y_expr[32];
extern char bar_width_expr[32];
extern bool bar_bidirectional;
extern bool bar_reversed;
static cairo_font_face_t *font_faces[6] = {
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
};
static control_char_config_t control_characters[] = {
{'\n', CC_POS_RESET, 0, CC_POS_CHANGE, 1},
{'\b', CC_POS_CHANGE, -1, CC_POS_KEEP, 0},
{'\r', CC_POS_RESET, 0, CC_POS_KEEP, 0},
{'\t', CC_POS_TAB, 4, CC_POS_KEEP, 0},
};
size_t control_char_count = sizeof control_characters / sizeof(control_char_config_t);
static cairo_font_face_t *get_font_face(int which) {
if (font_faces[which]) {
return font_faces[which];
}
const unsigned char *face_name = (const unsigned char *)fonts[which];
FcResult result;
/*
* Loads the default config.
* On successive calls, does no work and just returns true.
*/
if (!FcInit()) {
DEBUG("Fontconfig init failed. No text will be shown.\n");
return NULL;
}
/*
* converts a font face name to a pattern for that face name
*/
FcPattern *pattern = FcNameParse(face_name);
if (!pattern) {
DEBUG("no sans-serif font available\n");
return NULL;
}
/*
* Gets the default font for our pattern. (Gets the default sans-serif font face)
* Without these two calls, the FcFontMatch call will fail due to FcConfigGetCurrent()
* not giving it a valid/useful config.
*/
FcDefaultSubstitute(pattern);
if (!FcConfigSubstitute(FcConfigGetCurrent(), pattern, FcMatchPattern)) {
DEBUG("config sub failed?\n");
return NULL;
}
/*
* Looks up the font pattern and does some internal RenderPrepare work,
* then returns the resulting pattern that's ready for rendering.
*/
FcPattern *pattern_ready = FcFontMatch(FcConfigGetCurrent(), pattern, &result);
FcPatternDestroy(pattern);
pattern = NULL;
if (!pattern_ready) {
DEBUG("no sans-serif font available\n");
return NULL;
}
/*
* Passes the given pattern into cairo, which loads it into a cairo freetype font face.
* Increment its reference count and cache it.
*/
cairo_font_face_t *face = cairo_ft_font_face_create_for_pattern(pattern_ready);
FcPatternDestroy(pattern_ready);
font_faces[which] = cairo_font_face_reference(face);
FcFini();
return face;
}
/*
* Splits the given text by "control chars",
* And then draws the given text onto the cairo context.
*/
static void draw_text_with_cc(cairo_t *ctx, text_t text, double start_x) {
// get scaled_font
cairo_scaled_font_t *sft;
cairo_matrix_t fm, ctm;
cairo_matrix_init_scale(&fm, text.size, text.size);
cairo_get_matrix(ctx, &ctm);
cairo_font_options_t *opts;
opts = cairo_font_options_create();
sft = cairo_scaled_font_create(text.font, &fm, &ctm, opts);
cairo_font_options_destroy(opts);
/* use `a` to represent common character width, using in `\t` */
cairo_text_extents_t te;
cairo_text_extents(ctx, "a", &te);
// convert text to glyphs.
cairo_status_t status;
cairo_glyph_t* glyphs;
int nglyphs = 0,
len = 0,
start = 0,
lineno = 0,
x = start_x,
y = text.y;
size_t cur_cc;
while (text.str[start + len] != '\0') {
char is_cc = 0;
do {
for (cur_cc = 0; cur_cc < control_char_count; cur_cc++) {
if (text.str[start+len] == control_characters[cur_cc].character) {
is_cc = 1;
break;
}
}
} while (text.str[start+(len++)] != '\0' && !is_cc);
if (len > is_cc) {
status = cairo_scaled_font_text_to_glyphs(
sft, x, y, text.str + start, is_cc ? len - 1: len,
&glyphs, &nglyphs,
NULL, NULL, NULL
);
if (status == CAIRO_STATUS_SUCCESS) {
cairo_glyph_path(ctx, glyphs, nglyphs);
} else {
DEBUG("draw %c failed\n", text.str[start]);
}
}
if (is_cc && (cur_cc < control_char_count)) {
if (control_characters[cur_cc].x_behavior == CC_POS_CHANGE) {
char x_offset = control_characters[cur_cc].x_behavior_arg;
if (x_offset < 0 && x_offset > -nglyphs) {
x = glyphs[nglyphs+x_offset].x;
} else if (x_offset > 0) {
if (nglyphs >= 1) { // the case is some leading control chars.(although there is none now)
x = glyphs[nglyphs - 1].x + x_offset * te.x_advance;
} else { // deal the leading control chars.
x += x_offset * te.x_advance;
}
}
} else if (control_characters[cur_cc].x_behavior == CC_POS_RESET) {
x = start_x;
} else if (control_characters[cur_cc].x_behavior == CC_POS_TAB) {
if (nglyphs > 0) { // there may be leading tab, such as '\t\t' or '\n\t'
int advance = control_characters[cur_cc].x_behavior_arg - ((nglyphs - 1) % control_characters[cur_cc].x_behavior_arg);
x = glyphs[nglyphs - 1].x + advance * te.x_advance;
} else { // deal the leading tab.
x += control_characters[cur_cc].x_behavior_arg * te.x_advance;
}
}
if (control_characters[cur_cc].y_behavior == CC_POS_CHANGE) {
lineno += control_characters[cur_cc].y_behavior_arg;
} // CC_POS_KEEP is default for y
}
y = text.y + text.size * lineno;
if (len > is_cc) {
cairo_glyph_free(glyphs);
}
nglyphs = 0;
start += len;
len = 0;
}
cairo_scaled_font_destroy(sft);
}
/*
* Draws the given text onto the cairo context
*/
static void draw_text(cairo_t *ctx, text_t text) {
if (!text.show)
return;
cairo_text_extents_t extents;
cairo_set_font_face(ctx, text.font);
cairo_set_font_size(ctx, text.size);
cairo_text_extents(ctx, text.str, &extents);
double x;
switch (text.align) {
case 1:
x = text.x;
break;
case 2:
x = text.x - (extents.width + extents.x_bearing);
break;
case 0:
default:
x = text.x - extents.x_advance / 2;
break;
}
cairo_set_source_rgba(ctx, text.color.red, text.color.green, text.color.blue, text.color.alpha);
draw_text_with_cc(ctx, text, x);
cairo_fill_preserve(ctx);
cairo_set_source_rgba(ctx, text.outline_color.red, text.outline_color.green, text.outline_color.blue, text.outline_color.alpha);
cairo_set_line_width(ctx, text.outline_width);
cairo_stroke(ctx);
}
static void draw_single_bar(cairo_t *ctx, double pos, double offset, double width, double height) {
if (bar_reversed) {
offset -= height;
} else if (bar_bidirectional) {
offset -= height / 2;
}
if (bar_orientation == BAR_VERT)
cairo_rectangle(ctx, offset, pos, height, width);
else
cairo_rectangle(ctx, pos, offset, width, height);
cairo_fill(ctx);
}
static void draw_bar(cairo_t *ctx, double bar_x, double bar_y, double bar_width, double screen_x, double screen_y) {
cairo_save(ctx);
switch (auth_state) {
case STATE_AUTH_VERIFY:
case STATE_AUTH_LOCK:
cairo_set_source_rgba(ctx, ringver16.red, ringver16.green, ringver16.blue, ringver16.alpha);
break;
case STATE_AUTH_WRONG:
case STATE_I3LOCK_LOCK_FAILED:
cairo_set_source_rgba(ctx, ringwrong16.red, ringwrong16.green, ringwrong16.blue, ringwrong16.alpha);
break;
default:
cairo_set_source_rgba(ctx, bar16.red, bar16.green, bar16.blue, bar16.alpha);
break;
}
if (bar_orientation == BAR_VERT)
draw_single_bar(ctx, bar_y, bar_x, bar_width, bar_base_height);
else
draw_single_bar(ctx, bar_x, bar_y, bar_width, bar_base_height);
if (unlock_state == STATE_BACKSPACE_ACTIVE)
cairo_set_source_rgba(ctx, bshl16.red, bshl16.green, bshl16.blue, bshl16.alpha);
else
cairo_set_source_rgba(ctx, keyhl16.red, keyhl16.green, keyhl16.blue, keyhl16.alpha);
cairo_set_operator(ctx, CAIRO_OPERATOR_SOURCE);
double base_width = bar_width / bar_count;
double bar_pos, bar_offset;
if (bar_orientation == BAR_VERT) {
bar_pos = bar_y;
bar_offset = bar_x;
} else {
bar_pos = bar_x;
bar_offset = bar_y;
}
for (int i = 0; i < bar_count; ++i) {
double bar_height = bar_heights[i];
if (bar_bidirectional) bar_height *= 2;
if (bar_height > 0) {
draw_single_bar(ctx, bar_pos + i * base_width, bar_offset, base_width, bar_height);
}
}
for (int i = 0; i < bar_count; ++i) {
if (bar_heights[i] > 0) {
bar_heights[i] -= bar_periodic_step;
}
}
cairo_restore(ctx);
}
static void draw_indic(cairo_t *ctx, double ind_x, double ind_y) {
if (unlock_indicator &&
(unlock_state >= STATE_KEY_PRESSED || auth_state > STATE_AUTH_IDLE || show_indicator)) {
/* Draw a (centered) circle with transparent background. */
cairo_set_line_width(ctx, RING_WIDTH);
cairo_arc(ctx, ind_x, ind_y, BUTTON_RADIUS, 0, 2 * M_PI);
/* Use the appropriate color for the different PAM states
* (currently verifying, wrong password, or default) */
switch (auth_state) {
case STATE_AUTH_VERIFY:
case STATE_AUTH_LOCK:
cairo_set_source_rgba(ctx, insidever16.red, insidever16.green, insidever16.blue, insidever16.alpha);
break;
case STATE_AUTH_WRONG:
case STATE_I3LOCK_LOCK_FAILED:
cairo_set_source_rgba(ctx, insidewrong16.red, insidewrong16.green, insidewrong16.blue, insidewrong16.alpha);
break;
default:
if (unlock_state == STATE_NOTHING_TO_DELETE) {
cairo_set_source_rgba(ctx, insidewrong16.red, insidewrong16.green, insidewrong16.blue, insidewrong16.alpha);
break;
}
cairo_set_source_rgba(ctx, inside16.red, inside16.green, inside16.blue, inside16.alpha);
break;
}
cairo_fill_preserve(ctx);
switch (auth_state) {
case STATE_AUTH_VERIFY:
case STATE_AUTH_LOCK:
cairo_set_source_rgba(ctx, ringver16.red, ringver16.green, ringver16.blue, ringver16.alpha);
if (internal_line_source == 1) {
line16.red = ringver16.red;
line16.green = ringver16.green;
line16.blue = ringver16.blue;
line16.alpha = ringver16.alpha;
}
break;
case STATE_AUTH_WRONG:
case STATE_I3LOCK_LOCK_FAILED:
cairo_set_source_rgba(ctx, ringwrong16.red, ringwrong16.green, ringwrong16.blue, ringwrong16.alpha);
if (internal_line_source == 1) {
line16.red = ringwrong16.red;
line16.green = ringwrong16.green;
line16.blue = ringwrong16.blue;
line16.alpha = ringwrong16.alpha;
}
break;
case STATE_AUTH_IDLE:
if (unlock_state == STATE_NOTHING_TO_DELETE) {
cairo_set_source_rgba(ctx, ringwrong16.red, ringwrong16.green, ringwrong16.blue, ringwrong16.alpha);
if (internal_line_source == 1) {
line16.red = ringwrong16.red;
line16.green = ringwrong16.green;
line16.blue = ringwrong16.blue;
line16.alpha = ringwrong16.alpha;
}
break;
}
cairo_set_source_rgba(ctx, ring16.red, ring16.green, ring16.blue, ring16.alpha);
if (internal_line_source == 1) {
line16.red = ring16.red;
line16.green = ring16.green;
line16.blue = ring16.blue;
line16.alpha = ring16.alpha;
}
break;
}
cairo_stroke(ctx);
/* Draw an inner separator line. */
if (internal_line_source != 2) { //pretty sure this only needs drawn if it's being drawn over the inside?
cairo_set_source_rgba(ctx, line16.red, line16.green, line16.blue, line16.alpha);
cairo_set_line_width(ctx, 2.0);
cairo_arc(ctx, ind_x, ind_y, BUTTON_RADIUS - 5, 0, 2 * M_PI);
cairo_stroke(ctx);
}
if (unlock_state == STATE_KEY_ACTIVE || unlock_state == STATE_BACKSPACE_ACTIVE) {
cairo_set_line_width(ctx, RING_WIDTH);
cairo_new_sub_path(ctx);
double highlight_start = (rand() % (int)(2 * M_PI * 100)) / 100.0;
cairo_arc(ctx, ind_x, ind_y, BUTTON_RADIUS,
highlight_start, highlight_start + (M_PI / 3.0));
if (unlock_state == STATE_KEY_ACTIVE) {
/* For normal keys, we use a lighter green. */
cairo_set_source_rgba(ctx, keyhl16.red, keyhl16.green, keyhl16.blue, keyhl16.alpha);
} else {
/* For backspace, we use red. */
cairo_set_source_rgba(ctx, bshl16.red, bshl16.green, bshl16.blue, bshl16.alpha);
}
cairo_stroke(ctx);
/* Draw two little separators for the highlighted part of the
* unlock indicator. */
cairo_set_source_rgba(ctx, sep16.red, sep16.green, sep16.blue, sep16.alpha);
cairo_arc(ctx, ind_x, ind_y, BUTTON_RADIUS,
highlight_start, highlight_start + (M_PI / 128.0));
cairo_stroke(ctx);
cairo_arc(ctx, ind_x, ind_y, BUTTON_RADIUS,
(highlight_start + (M_PI / 3.0)) - (M_PI / 128.0),
highlight_start + (M_PI / 3.0));
cairo_stroke(ctx);
}
}
}
/*
* Initialize all the color arrays once.
* Called once after options are parsed.
*/
/*
colorstring: 8-character RGBA string ("ff0000ff", "00000000", "ffffffff", etc)
colorstring16: array of 4 integers (r, g, b, a).
MAKE_COLORGROUPS(colorstring, colorstring16) =>
char colorstring_tmparr[4][3] = {{colorstring[0], colorstring[1], '\0'},
{colorstring[2], colorstring[3], '\0'},
{colorstring[4], colorstring[5], '\0'},
{colorstring[6], colorstring[7], '\0'}};
uint32_t colorstring16[4] = {(strtol(colorstring_tmparr[0], NULL, 16)),
(strtol(colorstring_tmparr[1], NULL, 16)),
(strtol(colorstring_tmparr[2], NULL, 16)),
(strtol(colorstring_tmparr[3], NULL, 16))};
*/
static void set_color(char *dest, const char *src, int offset) {
dest[0] = src[offset];
dest[1] = src[offset + 1];
dest[2] = '\0';
}
static void colorgen(rgba_str_t *tmp, const char *src, rgba_t *dest) {
set_color(tmp->red, src, 0);
set_color(tmp->green, src, 2);
set_color(tmp->blue, src, 4);
set_color(tmp->alpha, src, 6);
dest->red = strtol(tmp->red, NULL, 16) / 255.0;
dest->green = strtol(tmp->green, NULL, 16) / 255.0;
dest->blue = strtol(tmp->blue, NULL, 16) / 255.0;
dest->alpha = strtol(tmp->alpha, NULL, 16) / 255.0;
}
void init_colors_once(void) {
/* initialize for slideshow time interval */
lastCheck = (unsigned long)time(NULL);
rgba_str_t tmp;
/* build indicator color arrays */
colorgen(&tmp, insidevercolor, &insidever16);
colorgen(&tmp, insidewrongcolor, &insidewrong16);
colorgen(&tmp, insidecolor, &inside16);
colorgen(&tmp, ringvercolor, &ringver16);
colorgen(&tmp, ringwrongcolor, &ringwrong16);
colorgen(&tmp, ringcolor, &ring16);
colorgen(&tmp, linecolor, &line16);
colorgen(&tmp, verifcolor, &verif16);
colorgen(&tmp, wrongcolor, &wrong16);
colorgen(&tmp, layoutcolor, &layout16);
colorgen(&tmp, timecolor, &time16);
colorgen(&tmp, datecolor, &date16);
colorgen(&tmp, modifcolor, &modif16);
colorgen(&tmp, keyhlcolor, &keyhl16);
colorgen(&tmp, bshlcolor, &bshl16);
colorgen(&tmp, separatorcolor, &sep16);
colorgen(&tmp, bar_base_color, &bar16);
colorgen(&tmp, greetercolor, &greeter16);
colorgen(&tmp, color, &background);
colorgen(&tmp, verifoutlinecolor, &verifoutline16);
colorgen(&tmp, wrongoutlinecolor, &wrongoutline16);
colorgen(&tmp, layoutoutlinecolor, &layoutoutline16);
colorgen(&tmp, timeoutlinecolor, &timeoutline16);
colorgen(&tmp, dateoutlinecolor, &dateoutline16);
colorgen(&tmp, greeteroutlinecolor, &greeteroutline16);
colorgen(&tmp, modifoutlinecolor, &modifoutline16);
}
static te_expr *compile_expression(const char *const from, const char *expression, const te_variable *variables, int var_count) {
int te_err = 0;
te_expr *expr = te_compile(expression, variables, var_count, &te_err);
if (te_err) {
fprintf(stderr, "Failed to reason about '%s' given by '%s'\n", expression, from);
exit(EXIT_FAILURE);
}
return expr;
}
static DrawData create_draw_data() {
DrawData draw_data;
memset(&draw_data, 0, sizeof(DrawData));
return draw_data;
}
static void draw_elements(cairo_t *const ctx, DrawData const *const draw_data) {
// indicator stuff
if (!bar_enabled) {
draw_indic(ctx, draw_data->indicator_x, draw_data->indicator_y);
} else {
if (unlock_state == STATE_KEY_ACTIVE ||
unlock_state == STATE_BACKSPACE_ACTIVE) {
// note: might be biased to cause more hits on lower indices
// maybe see about doing ((double) rand() / RAND_MAX) * bar_count
int index = rand() % bar_count;
bar_heights[index] = max_bar_height;
for (int i = 0; i < ((max_bar_height / bar_step) + 1); ++i) {
int low_ind = index - i;
while (low_ind < 0) {
low_ind += bar_count;
}
int high_ind = (index + i) % bar_count;
int tmp_height = max_bar_height - (bar_step * i);
if (tmp_height < 0)
tmp_height = 0;
if (bar_heights[low_ind] < tmp_height)
bar_heights[low_ind] = tmp_height;
if (bar_heights[high_ind] < tmp_height)
bar_heights[high_ind] = tmp_height;
if (tmp_height == 0)
break;
}
}
draw_bar(ctx, draw_data->bar_x, draw_data->bar_y, draw_data->bar_width, draw_data->screen_x, draw_data->screen_y);
}
draw_text(ctx, draw_data->status_text);
draw_text(ctx, draw_data->keylayout_text);
draw_text(ctx, draw_data->mod_text);
draw_text(ctx, draw_data->time_text);
draw_text(ctx, draw_data->date_text);
draw_text(ctx, draw_data->greeter_text);
}
/*
* Renders the lock screen on the provided drawable with the given resolution.
*/
void render_lock(uint32_t *resolution, xcb_drawable_t drawable) {
const double scaling_factor = get_dpi_value() / 96.0;
int button_diameter_physical = ceil(scaling_factor * BUTTON_DIAMETER);
DEBUG("scaling_factor is %.f, physical diameter is %d px\n",
scaling_factor, button_diameter_physical);
if (!vistype)
vistype = get_visualtype_by_depth(32, screen);
/* Initialize cairo: Create one in-memory surface to render the unlock
* indicator on, create one XCB surface to actually draw (one or more,
* depending on the amount of screens) unlock indicators on.
* create two more surfaces for time and date display
*/
cairo_surface_t *output = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, resolution[0], resolution[1]);
cairo_t *ctx = cairo_create(output);
cairo_scale(ctx, scaling_factor, scaling_factor);
// cairo_set_font_face(ctx, get_font_face(0));
cairo_surface_t *xcb_output = cairo_xcb_surface_create(conn, drawable, vistype, resolution[0], resolution[1]);
cairo_t *xcb_ctx = cairo_create(xcb_output);
/*update image according to the slideshow_interval*/
if (slideshow_image_count > 0) {
unsigned long now = (unsigned long)time(NULL);
if (img == NULL || now - lastCheck >= slideshow_interval) {
if (slideshow_random_selection) {
img = load_image(img_slideshow[rand() % slideshow_image_count]);
} else {
img = load_image(img_slideshow[current_slideshow_index]);
}
current_slideshow_index++;
if (current_slideshow_index >= slideshow_image_count) {
current_slideshow_index = 0;
load_slideshow_images(slideshow_path);
}
lastCheck = now;
}
}
if (blur_bg_img) {
cairo_set_source_surface(xcb_ctx, blur_bg_img, 0, 0);
cairo_paint(xcb_ctx);
} else {
cairo_set_source_rgba(xcb_ctx, background.red, background.green, background.blue, background.alpha);
cairo_rectangle(xcb_ctx, 0, 0, resolution[0], resolution[1]);
cairo_fill(xcb_ctx);
}
if (img) {
draw_image(resolution, img, xcb_ctx);
}
/*
* gen text
* calc vars
* process if keystroke or not
* draw indicator
* draw text
*/
DrawData draw_data = create_draw_data();
if (unlock_indicator &&
(unlock_state >= STATE_KEY_PRESSED || auth_state > STATE_AUTH_IDLE || show_indicator)) {
switch (auth_state) {
case STATE_AUTH_VERIFY:
draw_data.status_text.show = true;
strncpy(draw_data.status_text.str, verif_text, sizeof(draw_data.status_text.str) - 1);
draw_data.status_text.font = get_font_face(VERIF_FONT);
draw_data.status_text.color = verif16;
draw_data.status_text.outline_color = verifoutline16;
draw_data.status_text.size = verif_size;
draw_data.status_text.outline_width = verifoutlinewidth;
draw_data.status_text.align = verif_align;
break;
case STATE_AUTH_LOCK:
draw_data.status_text.show = true;
strncpy(draw_data.status_text.str, lock_text, sizeof(draw_data.status_text.str) - 1);
draw_data.status_text.font = get_font_face(VERIF_FONT);
draw_data.status_text.color = verif16;
draw_data.status_text.outline_color = verifoutline16;
draw_data.status_text.size = verif_size;
draw_data.status_text.outline_width = verifoutlinewidth;
draw_data.status_text.align = verif_align;
break;
case STATE_AUTH_WRONG:
draw_data.status_text.show = true;
strncpy(draw_data.status_text.str, wrong_text, sizeof(draw_data.status_text.str) - 1);
draw_data.status_text.font = get_font_face(WRONG_FONT);
draw_data.status_text.color = wrong16;
draw_data.status_text.outline_color = wrongoutline16;
draw_data.status_text.size = wrong_size;
draw_data.status_text.outline_width = wrongoutlinewidth;
draw_data.status_text.align = wrong_align;
break;
case STATE_I3LOCK_LOCK_FAILED:
draw_data.status_text.show = true;
strncpy(draw_data.status_text.str, lock_failed_text, sizeof(draw_data.status_text.str) - 1);
draw_data.status_text.font = get_font_face(WRONG_FONT);
draw_data.status_text.color = wrong16;
draw_data.status_text.outline_color = wrongoutline16;
draw_data.status_text.size = wrong_size;
draw_data.status_text.outline_width = wrongoutlinewidth;
draw_data.status_text.align = wrong_align;
break;
default:
if (unlock_state == STATE_NOTHING_TO_DELETE) {
draw_data.status_text.show = true;
strncpy(draw_data.status_text.str, noinput_text, sizeof(draw_data.status_text.str) - 1);
draw_data.status_text.font = get_font_face(WRONG_FONT);
draw_data.status_text.color = wrong16;
draw_data.status_text.outline_color = wrongoutline16;
draw_data.status_text.size = wrong_size;
draw_data.status_text.outline_width = wrongoutlinewidth;
draw_data.status_text.align = wrong_align;
break;
}
if (show_failed_attempts && failed_attempts > 0) {
draw_data.status_text.show = true;
draw_data.status_text.font = get_font_face(WRONG_FONT);
draw_data.status_text.color = wrong16;
draw_data.status_text.outline_color = wrongoutline16;
draw_data.status_text.size = wrong_size;
draw_data.status_text.outline_width = wrongoutlinewidth;
draw_data.status_text.align = wrong_align;
// TODO: variable for this
draw_data.status_text.size = 32.0;
if (failed_attempts > 999) {
strncpy(draw_data.status_text.str, "> 999", sizeof(draw_data.status_text.str));
} else {
snprintf(draw_data.status_text.str, sizeof(draw_data.status_text.str), "%d", failed_attempts);
}
}
break;
}
}
if (modifier_string) {
draw_data.mod_text.show = true;
strncpy(draw_data.mod_text.str, modifier_string, sizeof(draw_data.mod_text.str) - 1);
draw_data.mod_text.size = modifier_size;
draw_data.mod_text.outline_width = modifieroutlinewidth;
draw_data.mod_text.font = get_font_face(WRONG_FONT);
draw_data.mod_text.align = modif_align;
draw_data.mod_text.color = modif16;
draw_data.mod_text.outline_color = modifoutline16;
}
if (layout_text) {
draw_data.keylayout_text.show = true;
strncpy(draw_data.keylayout_text.str, layout_text, sizeof(draw_data.keylayout_text.str) - 1);
draw_data.keylayout_text.size = layout_size;
draw_data.keylayout_text.outline_width = layoutoutlinewidth;
draw_data.keylayout_text.font = get_font_face(LAYOUT_FONT);
draw_data.keylayout_text.color = layout16;
draw_data.keylayout_text.outline_color = layoutoutline16;
draw_data.keylayout_text.align = layout_align;
}
if (greeter_text) {
draw_data.greeter_text.show = true;
strncpy(draw_data.greeter_text.str, greeter_text, sizeof(draw_data.greeter_text.str) - 1);
draw_data.greeter_text.size = greeter_size;
draw_data.greeter_text.outline_width = greeteroutlinewidth;
draw_data.greeter_text.font = get_font_face(GREETER_FONT);
draw_data.greeter_text.color = greeter16;
draw_data.greeter_text.outline_color = greeteroutline16;
draw_data.greeter_text.align = greeter_align;
}
if (show_clock && (!draw_data.status_text.show || always_show_clock)) {
time_t rawtime;
struct tm *timeinfo;
time(&rawtime);
timeinfo = localtime(&rawtime);
strftime(draw_data.time_text.str, 40, time_format, timeinfo);
if (*draw_data.time_text.str) {
draw_data.time_text.show = true;
draw_data.time_text.size = time_size;
draw_data.time_text.outline_width = timeoutlinewidth;
draw_data.time_text.color = time16;
draw_data.time_text.outline_color = timeoutline16;
draw_data.time_text.font = get_font_face(TIME_FONT);
draw_data.time_text.align = time_align;
}
strftime(draw_data.date_text.str, 40, date_format, timeinfo);
if (*draw_data.date_text.str) {
draw_data.date_text.show = true;
draw_data.date_text.size = date_size;
draw_data.date_text.outline_width = dateoutlinewidth;
draw_data.date_text.color = date16;
draw_data.date_text.outline_color = dateoutline16;
draw_data.date_text.font = get_font_face(DATE_FONT);
draw_data.date_text.align = date_align;
}
if (*draw_data.greeter_text.str) {
draw_data.greeter_text.show = true;
draw_data.greeter_text.size = greeter_size;
draw_data.greeter_text.outline_width = greeteroutlinewidth;
draw_data.greeter_text.color = greeter16;
draw_data.greeter_text.outline_color = greeteroutline16;
draw_data.greeter_text.font = get_font_face(GREETER_FONT);
draw_data.greeter_text.align = greeter_align;
}
}
// initialize positioning vars
double screen_x = 0, screen_y = 0,
width = 0, height = 0;
double radius = (circle_radius + ring_width);
DEBUG("scaling_factor is %f, physical diameter is %d px\n",
scaling_factor, button_diameter_physical);
// variable mapping for evaluating the clock position expression
const unsigned int vars_size = 14;
te_variable vars[] =
{{"w", &width},
{"h", &height},
{"x", &screen_x},
{"y", &screen_y},
{"ix", &draw_data.indicator_x},
{"iy", &draw_data.indicator_y},
{"tx", &draw_data.time_text.x},
{"ty", &draw_data.time_text.y},
{"dx", &draw_data.date_text.x},
{"dy", &draw_data.date_text.y},
{"bw", &draw_data.bar_width},
{"bx", &draw_data.bar_x},
{"by", &draw_data.bar_y},
{"r", &radius}};
te_expr *te_ind_x_expr = compile_expression("--indpos", ind_x_expr, vars, vars_size);
te_expr *te_ind_y_expr = compile_expression("--indpos", ind_y_expr, vars, vars_size);
te_expr *te_time_x_expr = compile_expression("--timepos", time_x_expr, vars, vars_size);