-
Notifications
You must be signed in to change notification settings - Fork 3
/
ScreensaverWindowExists addon test template.js
1824 lines (1689 loc) · 75.9 KB
/
ScreensaverWindowExists addon test template.js
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
const {classes: Cc, interfaces: Ci, utils: Cu} = Components;
const self = {
name: 'js-macosx',
id: 'js-macosx@jetpack',
packagename: 'js-macosx',
path: {
content: 'chrome://js-macosx/content/',
modules: 'chrome://js-macosx/content/modules/'
},
aData: 0
};
Cu.import('resource://gre/modules/Services.jsm');
Cu.import('resource://gre/modules/devtools/Console.jsm');
Cu.import('resource://gre/modules/ctypes.jsm')
var nixtypesInit = function() {
// BASIC TYPES (ones that arent equal to something predefined by me)
this.ATOM = ctypes.unsigned_long;
this.BOOL = ctypes.int;
this.CHAR = ctypes.char;
this.DATA = ctypes.voidptr_t;
this.DISPLAY = new ctypes.StructType('Display');
this.INT = ctypes.int;
this.LONG = ctypes.long;
this.SCREEN = ctypes.StructType('Screen');
this.SHORT = ctypes.short;
this.STATUS = ctypes.int;
this.TIME = ctypes.unsigned_long;
this.UNSIGNED_CHAR = ctypes.unsigned_char;
this.UNSIGNED_INT = ctypes.unsigned_int;
this.UNSIGNED_LONG = ctypes.unsigned_long;
this.VISUAL = ctypes.StructType('Visual');
this.WINDOW = ctypes.unsigned_long;
this.XID = ctypes.unsigned_long;
// ADVANCED TYPES (ones that are equal to something predefined by me)
if (/^(Alpha|hppa|ia64|ppc64|s390|x86_64)-/.test(Services.appinfo.XPCOMABI)) { // https://github.com/foudfou/FireTray/blob/a0c0061cd680a3a92b820969b093cc4780dfb10c/src/modules/ctypes/linux/x11.jsm#L45 // // http://mxr.mozilla.org/mozilla-central/source/configure.in
this.CARD32 = this.UNSIGNED_INT;
} else {
this.CARD32 = this.UNSIGNED_LONG;
}
this.COLORMAP = this.XID;
this.DRAWABLE = this.XID; // /usr/include/X11/X.h:102 //https://github.com/hazelnusse/sympy-old/blob/65f802573e5963731a3e7e643676131b6a2500b8/sympy/thirdparty/pyglet/pyglet/window/xlib/xlib.py#L80
/* https://github.com/foudfou/FireTray/blob/a0c0061cd680a3a92b820969b093cc4780dfb10c/src/modules/ctypes/linux/x11.jsm#L168
*/
this.XWINDOWATTRIBUTES = ctypes.StructType('XWindowAttributes', [
{ 'x': this.INT },
{ 'y': this.INT }, /* location of window */
{ 'width': this.INT },
{ 'height': this.INT }, /* width and height of window */
{ 'border_width': this.INT }, /* border width of window */
{ 'depth': this.INT }, /* depth of window */
{ 'visual': this.VISUAL.ptr }, /* the associated visual structure */
{ 'root': this.WINDOW }, /* root of screen containing window */
{ 'class': this.INT }, /* InputOutput, InputOnly*/
{ 'bit_gravity': this.INT }, /* one of bit gravity values */
{ 'win_gravity': this.INT }, /* one of the window gravity values */
{ 'backing_store': this.INT }, /* NotUseful, WhenMapped, Always */
{ 'backing_planes': this.UNSIGNED_LONG }, /* planes to be preserved if possible */
{ 'backing_pixel': this.UNSIGNED_LONG }, /* value to be used when restoring planes */
{ 'save_under': this.BOOL }, /* boolean, should bits under be saved? */
{ 'colormap': this.COLORMAP }, /* color map to be associated with window */
{ 'map_installed': this.BOOL }, /* boolean, is color map currently installed*/
{ 'map_state': this.INT }, /* IsUnmapped, IsUnviewable, IsViewable */
{ 'all_event_masks': this.LONG }, /* set of events all people have interest in*/
{ 'your_event_mask': this.LONG }, /* my event mask */
{ 'do_not_propagate_mask': this.LONG }, /* set of events that should not propagate */
{ 'override_redirect': this.BOOL }, /* boolean value for override-redirect */
{ 'screen': this.SCREEN.ptr } /* back pointer to correct screen */
]);
/* http://www.man-online.org/page/3-XTextProperty/
* typedef struct {
* unsigned char *value; // property data
* Atom encoding; // type of property
* int format; // 8, 16, or 32
* unsigned long nitems; // number of items in value
* );
*/
this.XTEXTPROPERTY = ctypes.StructType('XTextProperty', [
{ value: this.UNSIGNED_CHAR.ptr }, // *value
{ encoding: this.ATOM }, // encoding
{ format: this.INT }, // format
{ nitems: this.UNSIGNED_LONG } // nitems
]);
// CONSTANTS
// this has a bunch a bunch bunch of contants with references to .h file: https://github.com/hazelnusse/sympy-old/blob/65f802573e5963731a3e7e643676131b6a2500b8/sympy/thirdparty/pyglet/pyglet/window/xlib/xlib.py#L88
this.ANYPROPERTYTYPE = this.ATOM(0);
this.BADATOM = 5;
this.BADVALUE = 2;
this.BADWINDOW = 3;
this.ISUNMAPPED = 0; //# /usr/include/X11/X.h:449 //Used in GetWindowAttributes reply
this.ISUNVIEWABLE = 1; //# /usr/include/X11/X.h:450 //Used in GetWindowAttributes reply
this.ISVIEWABLE = 2; //# /usr/include/X11/X.h:451 //Used in GetWindowAttributes reply
this.NONE = 0; // /usr/include/X11/X.h:120
this.SUCCESS = 0 // # /usr/include/X11/X.h:354
this.XA_ATOM = 4;
this.XA_WINDOW = 33;
this.XA_CARDINAL = 6;
}
var ostypes = new nixtypesInit();
var lib = {};
function _lib(path) {
//ensures path is in lib, if its in lib then its open, if its not then it adds it to lib and opens it. returns lib
//path is path to open library
//returns lib so can use straight away
if (!(path in lib)) {
//need to open the library
//default it opens the path, but some things are special like libc in mac is different then linux or like x11 needs to be located based on linux version
switch (path) {
case 'x11':
try {
lib[path] = ctypes.open('libX11.so.6');
} catch (e) {
try {
var libName = ctypes.libraryName('X11');
} catch (e) {
console.error('Integration Level 1: Could not get libX11 name; not activating', 'e:' + e);
throw new Error('Integration Level 1: Could not get libX11 name; not activating, e:' + e);
}
try {
lib[path] = ctypes.open(libName);
} catch (e) {
console.error('Integration Level 2: Could not get libX11 name; not activating', 'e:' + e);
throw new Error('Integration Level 2: Could not get libX11 name; not activating, e:' + e);
}
}
break;
default:
try {
lib[path] = ctypes.open(path);
} catch (e) {
console.error('Integration Level 1: Could not get open path:', path, 'e:' + e);
throw new Error('Integration Level 1: Could not get open path:"' + path + '" e: "' + e + '"');
}
}
}
return lib[path];
}
// declares in this worker, i set them all = to null for the scratchpad because i may declare it wrong and it wont re-declare unless if it first the var is !
var dec = {};
function _dec(declaration) { // it means ensureDeclared and return declare. if its not declared it declares it. else it returns the previously declared.
if (!(declaration in dec)) {
dec[declaration] = preDec[declaration](); //if declaration is not in preDec then dev messed up
}
return dec[declaration];
}
var preDec = { //stands for pre-declare (so its just lazy stuff) //this must be pre-populated by dev // do it alphabateized by key so its ez to look through
DefaultRootWindow: function() {
// MACRO
// I created a macro helper function in body outside of preDec, see it
/* http://www.xfree86.org/4.4.0/DefaultRootWindow.3.html
* Window DefaultRootWindow(
* Display *display
* );
*/
return _lib('x11').declare('XDefaultRootWindow', ctypes.default_abi,
ostypes.WINDOW, // return
ostypes.DISPLAY.ptr // *display
);
},
DefaultScreenOfDisplay: function() {
// MACRO
// I created a macro helper function in body outside of preDec, see it
/* http://www.xfree86.org/4.4.0/DefaultScreenOfDisplay.3.html
* Screen *DefaultScreenOfDisplay(
* Display *display
* );
*/
return _lib('x11').declare('XDefaultScreenOfDisplay', ctypes.default_abi,
ostypes.SCREEN.ptr, // return
ostypes.DISPLAY.ptr // *display
);
},
HeightOfScreen: function() {
// MACRO
/* http://www.xfree86.org/4.4.0/HeightOfScreen.3.html
* int HeightOfScreen(
* Screen *screen
* );
*/
return _lib('x11').declare('XHeightOfScreen', ctypes.default_abi,
ostypes.INT, // return
ostypes.SCREEN.ptr // *screen
);
},
WidthOfScreen: function() {
// MACRO
/* http://www.xfree86.org/4.4.0/WidthOfScreen.3.html
* int WidthOfScreen(
* Screen *screen
* );
*/
return _lib('x11').declare('XWidthOfScreen', ctypes.default_abi,
ostypes.INT, // return
ostypes.SCREEN.ptr // *screen
);
},
XCloseDisplay: function() {
/* http://www.xfree86.org/4.4.0/XCloseDisplay.3.html
* int XCloseDisplay(
* Display *display
* );
*/
return _lib('x11').declare('XCloseDisplay', ctypes.default_abi,
ostypes.INT, // return
ostypes.DISPLAY.ptr // *display
);
},
XFlush: function() {
/* http://www.xfree86.org/4.4.0/XFlush.3.html
* int XFlush(
* Display *display
* );
*/
return _lib('x11').declare('XFlush', ctypes.default_abi,
ostypes.INT, // return
ostypes.DISPLAY.ptr // *display
);
},
XFree: function() {
/* http://www.xfree86.org/4.4.0/XFree.3.html
* int XFree(
* void *data
* );
*/
return _lib('x11').declare('XFree', ctypes.default_abi,
ostypes.INT, // return
ostypes.DATA // *data
);
},
XGetGeometry: function() {
/* http://www.xfree86.org/4.4.0/XGetGeometry.3.html
* Status XGetGeometry(
* Display *display,
* Drawable d,
* Window *root_return,
* int *x_return,
* int *y_return,
* unsigned int *width_return,
* unsigned int *height_return,
* unsigned int *border_width_return,
* unsigned int *depth_return
* );
*/
return _lib('x11').declare('XGetGeometry', ctypes.default_abi,
ostypes.STATUS, // return
ostypes.DISPLAY.ptr, // *display
ostypes.DRAWABLE, // d
ostypes.WINDOW.ptr, // *root_return
ostypes.INT.ptr, // *x_return
ostypes.INT.ptr, // *y_return
ostypes.UNSIGNED_INT.ptr, // *width_return
ostypes.UNSIGNED_INT.ptr, // *height_return
ostypes.UNSIGNED_INT.ptr, // *border_width_return
ostypes.UNSIGNED_INT.ptr // *depth_return
);
},
XGetWindowAttributes: function() {
/* http://www.xfree86.org/4.4.0/XGetWindowAttributes.3.html
* Status XGetWindowAttributes(
* Display *display,
* Window w,
* XWindowAttributes *window_attributes_return
* );
*/
return _lib('x11').declare('XGetWindowAttributes', ctypes.default_abi,
ostypes.STATUS, // return
ostypes.DISPLAY.ptr, // *display
ostypes.WINDOW, // *display_name
ostypes.XWINDOWATTRIBUTES.ptr // *window_attributes_return
);
},
XGetWindowProperty: function() {
/* http://www.xfree86.org/4.4.0/XGetWindowProperty.3.html
* int XGetWindowProperty(
* Display *display,
* Window w,
* Atom property,
* long long_offset,
* long long_length,
* Bool delete,
* Atom req_type,
* Atom *actual_type_return,
* int *actual_format_return,
* unsigned long *nitems_return,
* unsigned long *bytes_after_return,
* unsigned char **prop_return
* );
*/
return _lib('x11').declare('XGetWindowProperty', ctypes.default_abi,
ostypes.INT, // return
ostypes.DISPLAY.ptr, // *display
ostypes.WINDOW, // w
ostypes.ATOM, // property
ostypes.LONG, // long_offset
ostypes.LONG, // long_length
ostypes.BOOL, // delete
ostypes.ATOM, // req_type
ostypes.ATOM.ptr, // *actual_type_return
ostypes.INT.ptr, // *actual_format_return
ostypes.UNSIGNED_LONG.ptr, // *nitems_return
ostypes.UNSIGNED_LONG.ptr, // *bytes_after_return
ostypes.UNSIGNED_CHAR.ptr.ptr // **prop_return
);
},
XGetWMName: function() {
/* http://www.xfree86.org/4.4.0/XGetWMName.3.html
* Status XGetWMName(
* Display *display,
* Window w,
* XTextProperty *text_prop_return
* );
*/
return _lib('x11').declare('XGetWMName', ctypes.default_abi,
ostypes.STATUS, // return
ostypes.DISPLAY.ptr, // *display
ostypes.WINDOW, // w
ostypes.XTEXTPROPERTY.ptr // *text_prop_return
);
},
XInternAtom: function() {
/* http://www.xfree86.org/4.4.0/XInternAtom.3.html
* Atom XInternAtom(
* Display *display,
* char *atom_name,
* Bool only_if_exists
* );
*/
return _lib('x11').declare('XInternAtom', ctypes.default_abi,
ostypes.ATOM, // return
ostypes.DISPLAY.ptr, // *display
ostypes.CHAR.ptr, // *atom_name
ostypes.BOOL // only_if_exists
);
},
XOpenDisplay: function() {
/* http://www.xfree86.org/4.4.0/XOpenDisplay.3.html
* Display *XOpenDisplay(
* char *display_name
* );
*/
return _lib('x11').declare('XOpenDisplay', ctypes.default_abi,
ostypes.DISPLAY.ptr, // return
ostypes.CHAR.ptr // *display_name
);
},
XQueryTree: function() {
/* http://www.xfree86.org/4.4.0/XQueryTree.3.html
* Status XQueryTree(
* Display *display,
* Window w,
* Window *root_return,
* Window *parent_return,
* Window **children_return,
* unsigned int *nchildren_return
* );
*/
return _lib('x11').declare('XQueryTree', ctypes.default_abi,
ostypes.STATUS, // return
ostypes.DISPLAY.ptr, // *display
ostypes.WINDOW, // w
ostypes.WINDOW.ptr, // *root_return
ostypes.WINDOW.ptr, // *parent_return
ostypes.WINDOW.ptr.ptr, // **children_return
ostypes.UNSIGNED_INT.ptr // *nchildren_return
);
},
XTranslateCoordinates: function() {
/* http://www.xfree86.org/4.4.0/XTranslateCoordinates.3.html
* Bool XTranslateCoordinates(
* Display *display,
* Window src_w,
* Window dest_w,
* int src_x,
* int src_y,
* int *dest_x_return,
* int *dest_y_return,
* Window *child_return
* );
*/
return _lib('x11').declare('XTranslateCoordinates', ctypes.default_abi,
ostypes.BOOL, // return
ostypes.DISPLAY.ptr, // *display
ostypes.WINDOW, // src_w
ostypes.WINDOW, // dest_w
ostypes.INT, // src_x
ostypes.INT, // src_y
ostypes.INT.ptr, // *dest_x_return
ostypes.INT.ptr, // *dest_y_return
ostypes.WINDOW.ptr // *child_return
);
},
}
/* start - main display and root window get and hold constant functions */
function OpenNewXDisplay() {
//returns ostypes.DISPLAY
//consider: http://mxr.mozilla.org/chromium/source/src/ui/gfx/x/x11_types.cc#26
// std::string display_str = base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switches::kX11Display);
// return XOpenDisplay(display_str.empty() ? NULL : display_str.c_str());
// i asked about it here: https://ask.mozilla.org/question/1321/proper-way-to-xopendisplay/
return _dec('XOpenDisplay')(null);
/* http://mxr.mozilla.org/chromium/source/src/ui/gfx/x/x11_types.cc#22
22 XDisplay* OpenNewXDisplay() {
23 #if defined(OS_CHROMEOS)
24 return XOpenDisplay(NULL);
25 #else
26 std::string display_str = base::CommandLine::ForCurrentProcess()->
27 GetSwitchValueASCII(switches::kX11Display);
28 return XOpenDisplay(display_str.empty() ? NULL : display_str.c_str());
29 #endif
30 }
*/
}
var GetXDisplayConst; //ostypes.DISPLAY // runtime defined constants
function GetXDisplay() { //two functions that hold const, GetX11RootWindow and GetXDisplay because some functions need the root window (like XFindWindow and XSendEvent) and others need the root display (like XGetWindowProperty and XSendEvent)
//http://stackoverflow.com/questions/27602246/is-this-a-global
//i posted here asking why are they doing if (!display) when they set display to null on line before, i want to know if i should make my `GetXDisplay` function have an argument of `getFreshDisp` meaning, even if display is held in `GetXDisplayConst` i open a new x display and overwrite the one in global
//answer was, no dont override, get it into global once and hold it forever, on future calls to this func just return that global
if (!GetXDisplayConst) {
GetXDisplayConst = OpenNewXDisplay();
}
return GetXDisplayConst;
/* http://mxr.mozilla.org/chromium/source/src/ui/gfx/x/x11_types.cc#15
15 XDisplay* GetXDisplay() {
16 static XDisplay* display = NULL;
17 if (!display)
18 display = OpenNewXDisplay();
19 return display;
20 }
*/
}
function DefaultScreenOfDisplay(display) { //macro helper to the XDefaultScreenOfDisplay defined in preDec
//not defined in chromium, i figured out this is XDefaultScreenOfDisplay from the xfree86 docs page
//its described as: "The DefaultScreenOfDisplay macro returns the default screen of the specified display."
//because the description says "of the specified display" i am not doing this like `GetXDisplay` func where i define global `GetXDisplayConst` and on future calls to `GetXDisplay` it recalls from the global if available
//so i guess that this macro is NOT used JUST for the root display (which is: returned by `GetXDisplay`/held in `GetXDisplayConst`)
//also im thinking a reason for not storing defaultscreen of the GetXDisplayConst (main/root display) is because it may be changing (like user changes monitor setup) but root never changes so we can just store that to global forever, thats why in c codes the make this GetXDisplayConst static (todo: could be worth asking about this someday, but not high priority as this is probably little overhead for possible better accuracy if my thinking [what i typed here in comments] is correct)
return _dec('DefaultScreenOfDisplay')(display);
}
var DefaultRootWindowConst; // ostypes.XID // runtime defined constants
function DefaultRootWindow(disp) { //macro helper to the XDefaultRootWindow defined in preDec
// returns XID
//not defined in chromium, i figured out this is XDefaultRootWindow from the xfree86 docs page
//its described as: "The DefaultRootWindow macro returns the root window for the default screen."
// im not sure if i should do the DefaultRootWindowConst technique that i do with GetXDisplay, GetXDisplay for sure is static GetXDisplayConst
// for same reasoning in DefaultScreenOfDisplay, im thinking user may be able change the root window, but the main display (GetXDisplay/GetXDisplayConst) are not changeable
// but DefaultRootWindow is ALWAYS called with GetXDisplay which is static. but maybe still user can change root window around so maybe dont do DefaultRootWindowConst
/* // todo: worth asking in future, the overhead is low probably so priority is low
if (!DefaultRootWindowConst) {
DefaultRootWindowConst = _dec('DefaultRootWindow')(disp);
}
return DefaultRootWindowConst;
*/
return _dec('DefaultRootWindow')(disp);
}
function GetX11RootWindow() { //two functions that hold const, GetX11RootWindow and GetXDisplay because some functions need the root window (like XFindWindow and XSendEvent) and others need the root display (like XGetWindowProperty and XSendEvent)
return DefaultRootWindow(GetXDisplay());
/* http://mxr.mozilla.org/chromium/source/src/ui/base/x/x11_util.cc#504
504 XID GetX11RootWindow() {
505 return DefaultRootWindow(gfx::GetXDisplay());
506 }
*/
}
/* end - main display and root window get and hold constant functions */
var GetAtomCache = {};
function GetAtom(name) {
// name is ostypes.CHAR.ptr
// returns ostypes.ATOM
if (!(name in GetAtomCache)) {
var atom = _dec('XInternAtom')(GetXDisplay(), name, 0); //passing 3rd arg of false, means even if atom doesnt exist it returns a created atom, this can be used with GetProperty to see if its supported etc, this is how Chromium does it
if (atom == ostypes.NONE) { //will never equal ostypes.NONE because i pass 3rd arg of `false` to XInternAtom
console.warn('No atom with name:', name, 'return val of atom:', atom, uneval(atom), atom.toString());
throw new Error('No atom with name "' + name + '"), return val of atom:"' + atom + '" toString:"' + atom.toString() + '"');
}
GetAtomCache[name] = atom;
}
return GetAtomCache[name];
}
//start - GetProperty and variants
function GetProperty(win, propertyName, max_length, params) {
// ON SUCCESS: returns obj, returns object with key of data, and data_descriptor
// ON FAIL: returns false
// if `trueForReturnData_else_falseForReturnBool` is `false` then returns if `XGetWindowProperty` was successful or not
// if false this will release the data
//params is object of optionals:
//max_length, if not specified, 1024 is used // 1024 because two places use it, for string prop on chromium: mxr.mozilla.org/chromium/source/src/ui/base/x/x11_util.cc#830 // and zotero //chromium uses -1 for just returning bool and i dont see an xfree
//property_type, if not specified ostypes.ANYPROPERTYTYPE is used
//free_data, if not specified, it will be freed in function
//free_data is js bool
//max_length just js number
//property_type is ostypes.INT
if (!params) {
params = {};
}
var paramsDefaults = {
free_data: true,
//max_length: 1024, // 1024 because two places use it, for string prop on chromium: mxr.mozilla.org/chromium/source/src/ui/base/x/x11_util.cc#830 // and zotero // but i think its cuz both the places i looked were looking to expect single string returned so maybe make this a required arg
property_type: ostypes.ANYPROPERTYTYPE
}
for (var p in paramsDefaults) {
if (!(p in params)) {
params[p] = paramsDefaults[p];
}
}
// this function is a combination of chromium's GetProperty (http://mxr.mozilla.org/chromium/source/src/ui/base/x/x11_util.cc#86) and zotero's (_X11GetProperty https://github.com/zotero/zotero/blob/15108eea3f099a5a39a145ed55043d1ed9889e6a/chrome/content/zotero/xpcom/integration.js#L571) // the reason i did this, i was originally going by chromium but i couldnt see where they were XFree'ing the data, it could be that because bytes returned was -1 there was no need to XFree, but this function also returns data which i can use in future
var property_atom = GetAtom(propertyName);
var actualTypeReturned = new ostypes.ATOM();
var actualFormatReturned = new ostypes.INT();
var NItemsReturned = new ostypes.UNSIGNED_LONG();
var BytesAfterReturn = new ostypes.UNSIGNED_LONG();
var DataReturned = new ostypes.UNSIGNED_CHAR.ptr()
var rez_XGWP = _dec('XGetWindowProperty')(GetXDisplay(), win, property_atom, 0 /*offset into property data to read*/, max_length, false /*deleted*/, params.property_type, actualTypeReturned.address(), actualFormatReturned.address(), NItemsReturned.address(), BytesAfterReturn.address(), DataReturned.address());
console.info('debug-msg :: rez_XGWP:', rez_XGWP);
if (rez_XGWP == ostypes.SUCCESS) {
//important note: make sure to XFree DataReturned
//note: if params.free_data is true, then i might need to cast the DataReturned before freeing, which may still be too early, so if need data returned and freed, i probably have to cast the DataReturned and then push to array as values by doing .addresOfElement(i) on the casted THEN i can free it im pretty sure - so ill have to ask for dev to supply type they wanted it casted to
if (actualTypeReturned == ostypes.NONE && actualFormatReturned == 0 && BytesAfterReturn == 0) {
console.log('debug-msg :: BECAUSE PER DOCS: because of the conditions in this if which are, actualtypereturned is none and formatreturned is 0 and bytes is 0 :: the specific property_atom does not exist for the window, nitems_return should be empty, it is, NItemsReturned:', NItemsReturned);
}
if (params.property_type != ostypes.ANYPROPERTYTYPE && params.property_type != actualTypeReturned) {
console.log('debug-msg :: the specified property exists BECAUE PER DOCS: :: specified property type was not anypropertytype and the returnedPropertyType does not match the specified proeprty type :: the specified property type was not AnyPropertyType as actualTypeReturned differently; actualFormatReturned should not be 0 and BytesAfterReturn is te property length and NItemsReturned should be empty', 'params.property_type', params.property_type, 'actualTypeReturned:', actualTypeReturned, 'actualFormatReturned:', actualFormatReturned, 'BytesAfterReturn:', BytesAfterReturn, 'NItemsReturned:', NItemsReturned);
}
if (params.property_type == actualTypeReturned || (params.property_type == ostypes.ANYPROPERTYTYPE && actualTypeReturned != ostypes.ANYPROPERTYTYPE)) {
console.log('debug-msg :: the specified property exists BECAUSE PER DOCS: specified property matched returned property type OR anypropertytype was specified and another type was returned in actualTypeReturned:: actualFormatReturned should not be 0 and BytesAfterReturn/NItemsReturned should have true value PER: read that large paragraph starting with: "N = actual length of the stored property in bytes" at http://www.xfree86.org/4.4.0/XGetWindowProperty.3.html');
}
var ret = {
data: DataReturned,
data_descriptor: {
count: NItemsReturned.value,
type: actualTypeReturned.value,
format: actualFormatReturned.value,
bytes_after_return: BytesAfterReturn.value
}
};
console.log('ok the ret was populated with data from XGWP:', uneval(ret));
} else {
console.error('XGetWindowProperty failed! it didnt return SUCCCESS', 'rez_XGWP:', rez_XGWP, uneval(rez_XGWP));
var ret = false;
//throw new Error('XGetWindowProperty failed to get data! rez_XGWP: "' + rez_XGWP + '" toString: "' rez_XGWP.toString() + '"');
}
if (params.free_data) {
if (rez_XGWP == ostypes.SUCCESS) {
var rez_DXF = doXFree(DataReturned);
if (!rez_DXF) {
console.warn('debug-msg :: GetProperty failed to free memory, leak imminent!');
}
} else {
console.log('debug-msg :: XGetWindowProperty failed so nothing to free will try it though, DXF should fail and be 0:');
var rez_DXF = doXFree(DataReturned);
if (rez_DXF) {
console.warn('debug-msg :: very odd, xfree success when i expected it to fail');
} else {
console.log('debug-msg :: verify yes dxf failed as i had expected');
}
}
} else {
if (rez_XGWP == ostypes.SUCCESS) {
console.info('debug-msg :: make sure you remember to free the data then');
} else {
console.log('debug-msg :: no need to free data, as XGetWindowProperty failed to return SUCCESS');
}
}
console.info('debug-msg :: ready to return ret is: ', uneval(ret));
return ret;
/*
what to do with rez of this func: https://github.com/zotero/zotero/blob/15108eea3f099a5a39a145ed55043d1ed9889e6a/chrome/content/zotero/xpcom/integration.js#L627
ctypes.cast(rez.DataReturned, ostypes.WINDOW.array(rez.NItemsReturnedValue).ptr).contents;
XFree(rez.data);
*/
/*
//how to use from https://github.com/zotero/zotero/blob/15108eea3f099a5a39a145ed55043d1ed9889e6a/chrome/content/zotero/xpcom/integration.js#L625
var res = _X11GetProperty(w, "_NET_CLIENT_LIST", XA_WINDOW) //33 xawin
|| _X11GetProperty(w, "_WIN_CLIENT_LIST", XA_CARDINAL); //6 is cacard
if(!res) return false;
var nClients = res[1],
clientList = ctypes.cast(res[0], X11Window.array(nClients).ptr).contents,
foundName = new ctypes.char.ptr();
for(var i=0; i<nClients; i++) {
if(XFetchName(_x11Display, clientList.addressOfElement(i).contents,foundName.address())) {
var foundNameString = undefined;
try {
foundNameString = foundName.readString();
} catch(e) {}
XFree(foundName);
if(foundNameString === searchName) return clientList.addressOfElement(i).contents;
}
}
XFree(res[0]);
*/
/* chromium :: http://mxr.mozilla.org/chromium/source/src/ui/base/x/x11_util.cc#85
85 // Note: The caller should free the resulting value data.
86 bool GetProperty(XID window, const std::string& property_name, long max_length,
87 XAtom* type, int* format, unsigned long* num_items,
88 unsigned char** property) {
89 XAtom property_atom = GetAtom(property_name.c_str());
90 unsigned long remaining_bytes = 0;
91 return XGetWindowProperty(gfx::GetXDisplay(),
92 window,
93 property_atom,
94 0, // offset into property data to read
95 max_length, // max length to get
96 False, // deleted
97 AnyPropertyType,
98 type,
99 format,
100 num_items,
101 &remaining_bytes,
102 property);
103 }
*/
}
function PropertyExists(win, property_name) {
//checks to see if window has a property for this atom
//returns
//success: js true
//fail: js false
//win is ostypes.WINDOW
//property_name is js string;
var rez_GP = GetProperty(win, property_name, 1); //by default will XFree the data
if (rez_GP === false) {
console.info('debug-msg :: PropertyExists due to GetProperty returned FALSE');
return false;
} else {
console.info('debug-msg :: PropertyExists - GetProperty succeeded and count is ', rez_GP.data_descriptor.count, ' it will return true if this is greater than 0, it is:', rez_GP.data_descriptor.count > 0);
return rez_GP.data_descriptor.count > 0;
}
/* http://mxr.mozilla.org/chromium/source/src/ui/base/x/x11_util.cc#665
665 bool PropertyExists(XID window, const std::string& property_name) {
666 XAtom type = None;
667 int format = 0; // size in bits of each item in 'property'
668 unsigned long num_items = 0;
669 unsigned char* property = NULL;
670
671 int result = GetProperty(window, property_name, 1,
672 &type, &format, &num_items, &property);
673 if (result != Success)
674 return false;
675
676 XFree(property);
677 return num_items > 0;
678 }
*/
}
function GetTypeProperty(win, property_name, type, ret_array) {
//this function gets a certain type, it checks the format, and count, and it returns it in js readable and frees the data
//returns
//success: js int if !ret_array
//success: array js int if ret_array
//fail: js false
//win is ostypes.WINDOW
//property_name is js string;
switch (type) {
case 'Atom':
var castTo = ostypes.ATOM;
var useMaxLenForNonRetArray = 1; //im guessing on this one, chromium never does GetProp for just one atom, ostypes.ATOM is = to ctypes.unsigned_long, so maybe whatever is the size of that
var useFormatCheck = null;
var useTypeCheck = ostypes.XA_ATOM;
break;
case 'Int':
var castTo = ostypes.LONG; //i would expect ostypes.INT here but Chromium wants it casted to long
var useMaxLenForNonRetArray = 1;
var useFormatCheck = 32;
var useTypeCheck = null;
break;
case 'String':
if (ret_array) {
throw new Error('String holding atoms never return an array, set ret_array to false');
}
var castTo = null; //ostypes.CHAR; //docs say no need to cast if format is 8, and for string format should be 8. this is obvious as we set te dataReturned to be unsigned_char before running XGetWindowProperty
var useMaxLenForNonRetArray = 1024;
var useFormatCheck = 8;
var useTypeCheck = null;
break;
case 'short':
var castTo = ostypes.SHORT; //i cant find x11 using short anywhere so i havent added SHORT to ostypes
var useMaxLenForNonRetArray = 1; // im not sure about this i just added this short thing in
var useFormatCheck = 16; //docs tell me if its 16 it should cast to short, 32 its long, and 8 its char
var useTypeCheck = null;
break;
default:
throw new Error('type not valid');
}
var rez_GetProperty = GetProperty(win, property_name, ret_array ? ostypes.LONG(~0) /*(all of them)*/ : useMaxLenForNonRetArray, {free_data:false}); //will be using defaults of 1024 max_length and free_data //chromium uses type of NONE which is just 0
if (rez_GetProperty === false) {
//nothing returned so no need to free
console.warn('in GetTypeProperty, returning FALSE due to GetProperty returning FALSE nothing to free but will try it anyways');
doXFree(rez_GetProperty.data);
return false;
}
if (useFormatCheck !== null) {
console.log('rez_GetProperty.data_descriptor.format == useFormatCheck', rez_GetProperty.data_descriptor.format == useFormatCheck, rez_GetProperty.data_descriptor.format.toString(), useFormatCheck.toString());
if (rez_GetProperty.data_descriptor.format.toString() != useFormatCheck.toString()) {
console.warn('in GetTypeProperty, returning FALSE due to FORMAT check fail');
doXFree(rez_GetProperty.data);
return false;
}
} else {
console.log('no need for format check');
}
if (useTypeCheck !== null) {
console.log('rez_GetProperty.data_descriptor.type == useTypeCheck', rez_GetProperty.data_descriptor.type == useTypeCheck, rez_GetProperty.data_descriptor.type, useTypeCheck, rez_GetProperty.data_descriptor.type.toString(), useTypeCheck.toString());
//if (rez_GetProperty.data_descriptor.type != useTypeCheck) { //tested this, it works, but to be safe im going with .toString on line below
if (rez_GetProperty.data_descriptor.type.toString() != useTypeCheck.toString()) {
console.warn('in GetTypeProperty, returning FALSE due to TYPE check fail');
doXFree(rez_GetProperty.data);
return false;
}
} else {
console.log('no need for type check');
}
if (rez_GetProperty.data_descriptor.count > 1) {
if (!ret_array) {
if (type != 'String') {
console.warn('in GetTypeProperty, returning FALSE (im forcing this) due to dev requested single return, but GetProperty found more than 1, it found count:', rez_GetProperty.data_descriptor.count);
doXFree(rez_GetProperty.data);
return false;
}
}
} else if (rez_GetProperty.data_descriptor.count == 0) {
console.warn('in GetTypeProperty, returning FALSE 0 elements returned in data, will try xfree despite no data returned, count:', rez_GetProperty.data_descriptor.count);
var rez_DXF = doXFree(rez_GetProperty.data);
if (rez_DXF) {
console.warn('debug-msg :: odd: DXF was success when reutrned count was 0');
}
return false;
}
if (type == 'String') {
var val;
try {
val = rez_GetProperty.data.readString();
console.error('returning string val as readString:', val);
} catch (ex if ex.message.indexOf('malformed UTF-8 character sequence at offset ') == 0) {
console.warn('ex of offset utf8 read error when trying to do readString so using alternative method, ex:', ex);
var dataCasted = ctypes.cast(rez_GetProperty.data, ostypes.UNSIGNED_CHAR.array(rez_GetProperty.data_descriptor.count).ptr).contents;
//console.log('debug-msg :: dataCasted:', dataCasted, uneval(dataCasted), dataCasted.toString());
var charCode = [];
var fromCharCode = []
for (var i=0; i<rez_GetProperty.data_descriptor.count; i++) {
charCode.push(dataCasted.addressOfElement(i).contents);
fromCharCode.push(String.fromCharCode(charCode[charCode.length-1]));
}
val = fromCharCode.join('');
console.error('returning string val as charCode method:', val);
}
} else {
var dataCasted = ctypes.cast(rez_GetProperty.data, castTo.array(rez_GetProperty.data_descriptor.count).ptr).contents;
if (ret_array) {
var val = [];
for (var i=0; i<rez_GetProperty.data_descriptor.count; i++) {
val.push(dataCasted.addressOfElement(i).contents);
}
} else {
var val = dataCasted.addressOfElement(0).contents;
}
}
doXFree(rez_GetProperty.data);
return val;
}
// Chromium uses GetIntProperty, GetIntArrayProperty, GetAtomArrayProperty, and GetStringProperty, I merged them all into GetTypeProperty (even before merge, i was using GetIntProperty with ret_array arg set to true in place of GetIntArrayProperty)
/* http://mxr.mozilla.org/chromium/source/src/ui/base/x/x11_util.cc#734
734 bool GetIntProperty(XID window, const std::string& property_name, int* value) {
735 XAtom type = None;
736 int format = 0; // size in bits of each item in 'property'
737 unsigned long num_items = 0;
738 unsigned char* property = NULL;
739
740 int result = GetProperty(window, property_name, 1,
741 &type, &format, &num_items, &property);
742 if (result != Success)
743 return false;
744
745 if (format != 32 || num_items != 1) {
746 XFree(property);
747 return false;
748 }
749
750 *value = static_cast<int>(*(reinterpret_cast<long*>(property)));
751 XFree(property);
752 return true;
753 }
*/
/* mxr.mozilla.org/chromium/source/src/ui/base/x/x11_util.cc#776
776 bool GetIntArrayProperty(XID window,
777 const std::string& property_name,
778 std::vector<int>* value) {
779 XAtom type = None;
780 int format = 0; // size in bits of each item in 'property'
781 unsigned long num_items = 0;
782 unsigned char* properties = NULL;
783
784 int result = GetProperty(window, property_name,
785 (~0L), // (all of them)
786 &type, &format, &num_items, &properties);
787 if (result != Success)
788 return false;
789
790 if (format != 32) {
791 XFree(properties);
792 return false;
793 }
794
795 long* int_properties = reinterpret_cast<long*>(properties);
796 value->clear();
797 for (unsigned long i = 0; i < num_items; ++i) {
798 value->push_back(static_cast<int>(int_properties[i]));
799 }
800 XFree(properties);
801 return true;
802 }
*/
/*
830 bool GetStringProperty(
831 XID window, const std::string& property_name, std::string* value) {
832 XAtom type = None;
833 int format = 0; // size in bits of each item in 'property'
834 unsigned long num_items = 0;
835 unsigned char* property = NULL;
836
837 int result = GetProperty(window, property_name, 1024,
838 &type, &format, &num_items, &property);
839 if (result != Success)
840 return false;
841
842 if (format != 8) {
843 XFree(property);
844 return false;
845 }
846
847 value->assign(reinterpret_cast<char*>(property), num_items);
848 XFree(property);
849 return true;
850 }
*/
/* http://mxr.mozilla.org/chromium/source/src/ui/base/x/x11_util.cc#804
//example usage by chromium: GetAtomArrayProperty(window, "_NET_WM_STATE", &wm_states)
804 bool GetAtomArrayProperty(XID window,
805 const std::string& property_name,
806 std::vector<XAtom>* value) {
807 XAtom type = None;
808 int format = 0; // size in bits of each item in 'property'
809 unsigned long num_items = 0;
810 unsigned char* properties = NULL;
811
812 int result = GetProperty(window, property_name,
813 (~0L), // (all of them)
814 &type, &format, &num_items, &properties);
815 if (result != Success)
816 return false;
817
818 if (type != XA_ATOM) {
819 XFree(properties);
820 return false;
821 }
822
823 XAtom* atom_properties = reinterpret_cast<XAtom*>(properties);
824 value->clear();
825 value->insert(value->begin(), atom_properties, atom_properties + num_items);
826 XFree(properties);
827 return true;
828 }
*/
//end - GetProperty and variants
function doXFree(data) {
var rez_doXFree = _dec('XFree')(data);
console.info('debug-msg :: rez_doXFree:', rez_doXFree);
if (!rez_doXFree) {
console.warn('debug-msg :: doXFree failed to free memory, leak imminent!');
}
return rez_doXFree;
}
function GetXWindowStack(win) {
// returns stack on success
// returns js false on fail
var rez_GP = GetProperty(win, '_NET_CLIENT_LIST_STACKING', ostypes.LONG(~0) /*(all of them)*/, {free_data:false});
if (rez_GP === false) {
//GP got no DataReturned so nothing to free
console.log('debug-msg :: GetXWindowStack FALSE due to GetProperty failing');
return false;
}
console.info('debug-msg :: XWindowStack prop is available');
var result = false;
if (rez_GP.data_descriptor.type == ostypes.XA_WINDOW && rez_GP.data_descriptor.format == 32 && rez_GP.data_descriptor.count > 0) {
console.log('debug-msg :: GetXWindowStack found reason to not go FALSE it is now populating result with data');
var result = [];
var prestack_casted = ctypes.cast(rez_GP.data, ostypes.XID.array(rez_GP.data_descriptor.count).ptr).contents;
for(var i=0; i<rez_GP.data_descriptor.count; i++) {
result.push(prestack_casted.addressOfElement(i).contents);
}
/*
XID* stack = reinterpret_cast<XID*>(data);
for (long i = static_cast<long>(count) - 1; i >= 0; i--)
windows->push_back(stack[i]);
*/
}
doXFree(rez_GP.data);
return result;
//var result = false;
//if (type == ostypes.XA_WINDOW
/*
1078
1079 bool GetXWindowStack(Window window, std::vector<XID>* windows) {
1080 windows->clear();
1081
1082 Atom type;
1083 int format;
1084 unsigned long count;
1085 unsigned char *data = NULL;
1086 if (GetProperty(window,
1087 "_NET_CLIENT_LIST_STACKING",
1088 ~0L,
1089 &type,
1090 &format,
1091 &count,
1092 &data) != Success) {
1093 return false;
1094 }
1095
1096 bool result = false;
1097 if (type == XA_WINDOW && format == 32 && data && count > 0) {
1098 result = true;
1099 XID* stack = reinterpret_cast<XID*>(data);
1100 for (long i = static_cast<long>(count) - 1; i >= 0; i--)
1101 windows->push_back(stack[i]);
1102 }
1103
1104 if (data)
1105 XFree(data);
1106
1107 return result;
1108 }
*/
}
function EnumerateChildren(shouldStopIteratingDelegate, win, max_depth, depth) {
//shouldStopIteratingDelegate is pointer to EnumerateWindowsDelegate*
//win is ostypes.XID
//max_depth is ostypes.INT
//depth is ostypes.INT
if (depth > max_depth) {
console.log('debug-msg :: EnumerateChildren FALSE due to depth > max_depth', depth, max_depth);
return false;
}
var windows = []; // ostypes.XID
if (depth == 0) {
//this block is not needed: http://stackoverflow.com/questions/27587122/menu-enumeration-functions-in-x11#comment43604147_27587122