/
pdcscrn.c
2616 lines (2300 loc) · 99.6 KB
/
pdcscrn.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
/* Public Domain Curses */
#include "pdcwin.h"
#include <tchar.h>
#include <stdint.h>
#include <assert.h>
/* COLOR_PAIR to attribute encoding table. */
static short *color_pair_indices = (short *)NULL;
COLORREF *pdc_rgbs = (COLORREF *)NULL;
static int menu_shown = 1;
static int min_lines = 25, max_lines = 25;
static int min_cols = 80, max_cols = 80;
#if defined( CHTYPE_LONG) && CHTYPE_LONG >= 2 && defined( PDC_WIDE)
#define USING_COMBINING_CHARACTER_SCHEME
int PDC_expand_combined_characters( const cchar_t c, cchar_t *added); /* addch.c */
#endif
/* Some older versions of Microsoft C/C++ don't understand about
inlined functions. Until we puzzle out which ones do and which
don't, we'll just leave "inlined" functions as plain old static
functions. */
#ifdef _MSC_VER
#define INLINE static
#else
#define INLINE static inline
#endif
static int keep_size_within_bounds( int *lines, int *cols);
INLINE int set_default_sizes_from_registry( const int n_cols, const int n_rows,
const int xloc, const int yloc, const int menu_shown);
void PDC_transform_line_given_hdc( const HDC hdc, const int lineno,
int x, int len, const chtype *srcp);
#define N_COLORS 256
#ifdef A_OVERLINE
#define A_ALL_LINES (A_UNDERLINE | A_LEFTLINE | A_RIGHTLINE | A_OVERLINE | A_STRIKEOUT)
#else
#define A_ALL_LINES (A_UNDERLINE | A_LEFTLINE | A_RIGHTLINE)
#endif
/* If PDC_MAX_MOUSE_BUTTONS is undefined, it means the user hasn't */
/* gotten a current 'curses.h' in which five-button mice are supported. */
/* To handle this gracefully, we'll just fall back to three buttons. */
#ifndef PDC_MAX_MOUSE_BUTTONS
#define PDC_MAX_MOUSE_BUTTONS 3
#endif
#define VERTICAL_WHEEL_EVENT PDC_MAX_MOUSE_BUTTONS
#define HORIZONTAL_WHEEL_EVENT (PDC_MAX_MOUSE_BUTTONS + 1)
unsigned long pdc_key_modifiers = 0L;
int PDC_show_ctrl_alts = 0;
/* RR: Removed statis on next line */
bool PDC_bDone = FALSE;
static HWND originally_focussed_window;
int debug_printf( const char *format, ...)
{
static bool debugging = TRUE;
if( debugging)
{
const char *output_filename = getenv( "PDC_DEBUG");
if( !output_filename)
debugging = FALSE; /* don't bother trying again */
else
{
FILE *ofile = fopen( output_filename, "a");
if( ofile)
{
va_list argptr;
va_start( argptr, format);
vfprintf( ofile, format, argptr);
va_end( argptr);
fclose( ofile);
}
else
{
printf( "Opening '%s' failed\n", output_filename);
exit( 0);
debugging = FALSE; /* don't bother trying again */
}
}
}
return( 0);
}
HWND PDC_hWnd;
static int PDC_argc = 0;
static char **PDC_argv = NULL;
static void final_cleanup( void)
{
debug_printf( "final_cleanup: SP = %p\n", SP);
if (SP)
{
RECT rect;
GetWindowRect( PDC_hWnd, &rect);
set_default_sizes_from_registry( SP->cols, SP->lines,
rect.left, rect.top, menu_shown);
}
PDC_LOG(( "final_cleanup: freeing fonts\n"));
PDC_transform_line( 0, 0, 0, NULL); /* free any fonts */
if( originally_focussed_window)
SetForegroundWindow( originally_focussed_window);
if( PDC_argc)
{
int i;
for( i = 0; i < PDC_argc; i++)
free( PDC_argv[i]);
free( PDC_argv);
PDC_argc = 0;
PDC_argv = NULL;
}
#ifdef USING_COMBINING_CHARACTER_SCHEME
PDC_expand_combined_characters( 0, NULL); /* free internal buffer */
#endif
debug_printf( "reset foreground window\n");
}
void PDC_scr_close(void)
{
PDC_LOG(("PDC_scr_close() - called\n"));
final_cleanup( );
PDC_bDone = TRUE;
}
/* NOTE that PDC_scr_free( ) is called only from delscreen( ), */
/* which is rarely called. It appears that most programs simply */
/* rely on the memory getting freed when the program terminates. */
/* It seems conceivable to me that we could get into some trouble */
/* here, if SP is freed and NULLed, but then accessed again, */
/* possibly within the Win32a window thread. */
void PDC_scr_free(void)
{
if (SP)
free(SP);
SP = (SCREEN *)NULL;
if (color_pair_indices)
free(color_pair_indices);
color_pair_indices = (short *)NULL;
if (pdc_rgbs)
free(pdc_rgbs);
pdc_rgbs = (COLORREF *)NULL;
}
int PDC_choose_a_new_font( void); /* pdcdisp.c */
void PDC_add_clipboard_to_key_queue( void); /* pdckbd.c */
#define KEY_QUEUE_SIZE 30
/* By default, the PDC_shutdown_key[] array contains 0 */
/* (i.e., there's no key that's supposed to be returned for */
/* exit handling), and 22 = Ctrl-V (i.e., hit Ctrl-V to */
/* paste text from the clipboard into the key queue); then */
/* Ctl-= (enlarge font) and Ctl-Minus (decrease font); then */
/* Ctl-, (select font from dialog). */
static int PDC_shutdown_key[PDC_MAX_FUNCTION_KEYS] = { 0, 22, CTL_EQUAL, CTL_MINUS,
CTL_COMMA };
int PDC_n_rows, PDC_n_cols;
int PDC_cxChar, PDC_cyChar, PDC_key_queue_low = 0, PDC_key_queue_high = 0;
int PDC_key_queue[KEY_QUEUE_SIZE];
/* If the following is true, you can enter Unicode values by hitting */
/* Alt and holding it down while typing the value of the character on */
/* the numeric keypad (for decimal entry); _or_ you can hit Alt-Padplus */
/* and then enter a hex value, while holding down the Alt key. In */
/* either case, when you release the Alt key, the Unicode character */
/* is added to the queue. For hex entry, 0-9 can come either from */
/* the numeric keypad or the "usual" keyboard. */
bool PDC_allow_numpad_unicode = TRUE;
static int numpad_unicode_value = 0;
static void adjust_font_size( const int font_size_change);
static void add_key_to_queue( const int new_key)
{
const int new_idx = ((PDC_key_queue_high + 1) % KEY_QUEUE_SIZE);
/* This is usually 10, but is set to 16 if the user */
/* hits ALT_PADPLUS and is about to enter a hex value: */
static int unicode_radix = 10;
if( PDC_allow_numpad_unicode)
{
int digit = -1;
if( new_key >= ALT_PAD0 && new_key <= ALT_PAD9)
digit = new_key - ALT_PAD0;
/* In hex Unicode entry, you can enter digits on both */
/* the numeric and "standard" keyboards : */
if( unicode_radix == 16 && new_key >= ALT_0 && new_key <= ALT_9)
digit = new_key - ALT_0;
if( unicode_radix == 16 && new_key >= ALT_A && new_key <= ALT_F)
digit = new_key - ALT_A + 10;
if( digit >= 0)
{
numpad_unicode_value = numpad_unicode_value * unicode_radix + digit;
return;
}
if( new_key == ALT_PADPLUS)
{ /* signal to begin hex Unicode entry */
unicode_radix = 16;
return;
}
}
unicode_radix = 10;
if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_PASTE])
PDC_add_clipboard_to_key_queue( );
else if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_ABORT])
exit( -1);
else if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_ENLARGE_FONT])
adjust_font_size( 1);
else if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_SHRINK_FONT])
adjust_font_size( -1);
else if( new_key && new_key == PDC_shutdown_key[FUNCTION_KEY_CHOOSE_FONT])
{
if( PDC_choose_a_new_font( ))
adjust_font_size( 0);
}
else if( new_idx != PDC_key_queue_low)
{
PDC_key_queue[PDC_key_queue_high] = new_key;
PDC_key_queue_high = new_idx;
}
}
/************************************************************************
* Table for key code translation of function keys in keypad mode *
* These values are for strict IBM keyboard compatibles only *
************************************************************************/
typedef struct
{
unsigned short normal;
unsigned short shift;
unsigned short control;
unsigned short alt;
unsigned short extended;
} KPTAB;
static const KPTAB kptab[] =
{
{0, 0, 0, 0, 0 }, /* 0 */
{0, 0, 0, 0, 0 }, /* 1 VK_LBUTTON */
{0, 0, 0, 0, 0 }, /* 2 VK_RBUTTON */
{CTL_PAUSE, 'a', 'b', 'c', 0 }, /* 3 VK_CANCEL */
{0, 0, 0, 0, 0 }, /* 4 VK_MBUTTON */
{0, 0, 0, 0, 0 }, /* 5 */
{0, 0, 0, 0, 0 }, /* 6 */
{0, 0, 0, 0, 0 }, /* 7 */
{0x08, 0x08, 0x7F, ALT_BKSP, 0 }, /* 8 VK_BACK */
{0x09, KEY_BTAB, CTL_TAB, ALT_TAB, 999 }, /* 9 VK_TAB */
{0, 0, 0, 0, 0 }, /* 10 */
{0, 0, 0, 0, 0 }, /* 11 */
{KEY_B2, 0x35, CTL_PAD5, ALT_PAD5, 0 }, /* 12 VK_CLEAR */
{0x0D, 0x0D, CTL_ENTER, ALT_ENTER, 1 }, /* 13 VK_RETURN */
{0, 0, 0, 0, 0 }, /* 14 */
{0, 0, 0, 0, 0 }, /* 15 */
{0, 0, 0, 0, 0 }, /* 16 VK_SHIFT HANDLED SEPARATELY */
{0, 0, 0, 0, 0 }, /* 17 VK_CONTROL HANDLED SEPARATELY */
{0, 0, 0, 0, 0 }, /* 18 VK_MENU HANDLED SEPARATELY */
{KEY_PAUSE, KEY_SPAUSE,CTL_PAUSE, 0, 0 }, /* 19 VK_PAUSE */
{0, 0, 0, 0, 0 }, /* 20 VK_CAPITAL HANDLED SEPARATELY */
{0, 0, 0, 0, 0 }, /* 21 VK_HANGUL */
{0, 0, 0, 0, 0 }, /* 22 */
{0, 0, 0, 0, 0 }, /* 23 VK_JUNJA */
{0, 0, 0, 0, 0 }, /* 24 VK_FINAL */
{0, 0, 0, 0, 0 }, /* 25 VK_HANJA */
{0, 0, 0, 0, 0 }, /* 26 */
{0x1B, 0x1B, 0x1B, ALT_ESC, 0 }, /* 27 VK_ESCAPE */
{0, 0, 0, 0, 0 }, /* 28 VK_CONVERT */
{0, 0, 0, 0, 0 }, /* 29 VK_NONCONVERT */
{0, 0, 0, 0, 0 }, /* 30 VK_ACCEPT */
{0, 0, 0, 0, 0 }, /* 31 VK_MODECHANGE */
{0x20, 0x20, 0x20, 0x20, 0 }, /* 32 VK_SPACE */
{KEY_A3, 0x39, CTL_PAD9, ALT_PAD9, 3 }, /* 33 VK_PRIOR */
{KEY_C3, 0x33, CTL_PAD3, ALT_PAD3, 4 }, /* 34 VK_NEXT */
{KEY_C1, 0x31, CTL_PAD1, ALT_PAD1, 5 }, /* 35 VK_END */
{KEY_A1, 0x37, CTL_PAD7, ALT_PAD7, 6 }, /* 36 VK_HOME */
{KEY_B1, 0x34, CTL_PAD4, ALT_PAD4, 7 }, /* 37 VK_LEFT */
{KEY_A2, 0x38, CTL_PAD8, ALT_PAD8, 8 }, /* 38 VK_UP */
{KEY_B3, 0x36, CTL_PAD6, ALT_PAD6, 9 }, /* 39 VK_RIGHT */
{KEY_C2, 0x32, CTL_PAD2, ALT_PAD2, 10 }, /* 40 VK_DOWN */
{0, 0, 0, 0, 0 }, /* 41 VK_SELECT */
{0, 0, 0, 0, 0 }, /* 42 VK_PRINT */
{0, 0, 0, 0, 0 }, /* 43 VK_EXECUTE */
{KEY_PRINTSCREEN, 0, 0, ALT_PRINTSCREEN, 0 }, /* 44 VK_SNAPSHOT*/
{PAD0, 0x30, CTL_PAD0, ALT_PAD0, 11 }, /* 45 VK_INSERT */
{PADSTOP, 0x2E, CTL_PADSTOP, ALT_PADSTOP,12 }, /* 46 VK_DELETE */
{0, 0, 0, 0, 0 }, /* 47 VK_HELP */
{0x30, 0x29, CTL_0, ALT_0, 0 }, /* 48 */
{0x31, 0x21, CTL_1, ALT_1, 0 }, /* 49 */
{0x32, 0x40, CTL_2, ALT_2, 0 }, /* 50 */
{0x33, 0x23, CTL_3, ALT_3, 0 }, /* 51 */
{0x34, 0x24, CTL_4, ALT_4, 0 }, /* 52 */
{0x35, 0x25, CTL_5, ALT_5, 0 }, /* 53 */
{0x36, 0x5E, CTL_6, ALT_6, 0 }, /* 54 */
{0x37, 0x26, CTL_7, ALT_7, 0 }, /* 55 */
{0x38, 0x2A, CTL_8, ALT_8, 0 }, /* 56 */
{0x39, 0x28, CTL_9, ALT_9, 0 }, /* 57 */
{0, 0, 0, 0, 0 }, /* 58 */
{0, 0, 0, 0, 0 }, /* 59 */
{0, 0, 0, 0, 0 }, /* 60 */
{0, 0, 0, 0, 0 }, /* 61 */
{0, 0, 0, 0, 0 }, /* 62 */
{0, 0, 0, 0, 0 }, /* 63 */
{0, 0, 0, 0, 0 }, /* 64 */
{0x61, 0x41, 0x01, ALT_A, 0 }, /* 65 */
{0x62, 0x42, 0x02, ALT_B, 0 }, /* 66 */
{0x63, 0x43, 0x03, ALT_C, 0 }, /* 67 */
{0x64, 0x44, 0x04, ALT_D, 0 }, /* 68 */
{0x65, 0x45, 0x05, ALT_E, 0 }, /* 69 */
{0x66, 0x46, 0x06, ALT_F, 0 }, /* 70 */
{0x67, 0x47, 0x07, ALT_G, 0 }, /* 71 */
{0x68, 0x48, 0x08, ALT_H, 0 }, /* 72 */
{0x69, 0x49, 0x09, ALT_I, 0 }, /* 73 */
{0x6A, 0x4A, 0x0A, ALT_J, 0 }, /* 74 */
{0x6B, 0x4B, 0x0B, ALT_K, 0 }, /* 75 */
{0x6C, 0x4C, 0x0C, ALT_L, 0 }, /* 76 */
{0x6D, 0x4D, 0x0D, ALT_M, 0 }, /* 77 */
{0x6E, 0x4E, 0x0E, ALT_N, 0 }, /* 78 */
{0x6F, 0x4F, 0x0F, ALT_O, 0 }, /* 79 */
{0x70, 0x50, 0x10, ALT_P, 0 }, /* 80 */
{0x71, 0x51, 0x11, ALT_Q, 0 }, /* 81 */
{0x72, 0x52, 0x12, ALT_R, 0 }, /* 82 */
{0x73, 0x53, 0x13, ALT_S, 0 }, /* 83 */
{0x74, 0x54, 0x14, ALT_T, 0 }, /* 84 */
{0x75, 0x55, 0x15, ALT_U, 0 }, /* 85 */
{0x76, 0x56, 0x16, ALT_V, 0 }, /* 86 */
{0x77, 0x57, 0x17, ALT_W, 0 }, /* 87 */
{0x78, 0x58, 0x18, ALT_X, 0 }, /* 88 */
{0x79, 0x59, 0x19, ALT_Y, 0 }, /* 89 */
{0x7A, 0x5A, 0x1A, ALT_Z, 0 }, /* 90 */
{0, 0, 0, 0, 0 }, /* 91 VK_LWIN */
{0, 0, 0, 0, 0 }, /* 92 VK_RWIN */
{KEY_APPS, KEY_SAPPS, CTL_APPS, ALT_APPS, 13 }, /* 93 VK_APPS */
{0, 0, 0, 0, 0 }, /* 94 */
{0, 0, 0, 0, 0 }, /* 95 */
{0x30, 0, CTL_PAD0, ALT_PAD0, 0 }, /* 96 VK_NUMPAD0 */
{0x31, 0, CTL_PAD1, ALT_PAD1, 0 }, /* 97 VK_NUMPAD1 */
{0x32, 0, CTL_PAD2, ALT_PAD2, 0 }, /* 98 VK_NUMPAD2 */
{0x33, 0, CTL_PAD3, ALT_PAD3, 0 }, /* 99 VK_NUMPAD3 */
{0x34, 0, CTL_PAD4, ALT_PAD4, 0 }, /* 100 VK_NUMPAD4 */
{0x35, 0, CTL_PAD5, ALT_PAD5, 0 }, /* 101 VK_NUMPAD5 */
{0x36, 0, CTL_PAD6, ALT_PAD6, 0 }, /* 102 VK_NUMPAD6 */
{0x37, 0, CTL_PAD7, ALT_PAD7, 0 }, /* 103 VK_NUMPAD7 */
{0x38, 0, CTL_PAD8, ALT_PAD8, 0 }, /* 104 VK_NUMPAD8 */
{0x39, 0, CTL_PAD9, ALT_PAD9, 0 }, /* 105 VK_NUMPAD9 */
{PADSTAR, SHF_PADSTAR,CTL_PADSTAR, ALT_PADSTAR,999 }, /* 106 VK_MULTIPLY*/
{PADPLUS, SHF_PADPLUS,CTL_PADPLUS, ALT_PADPLUS,999 }, /* 107 VK_ADD */
{0, 0, 0, 0, 0 }, /* 108 VK_SEPARATOR */
{PADMINUS, SHF_PADMINUS,CTL_PADMINUS,ALT_PADMINUS,999}, /* 109 VK_SUBTRACT*/
{0x2E, 0, CTL_PADSTOP, ALT_PADSTOP,0 }, /* 110 VK_DECIMAL */
{PADSLASH, SHF_PADSLASH,CTL_PADSLASH,ALT_PADSLASH,2 }, /* 111 VK_DIVIDE */
{KEY_F(1), KEY_F(13), KEY_F(25), KEY_F(37), 0 }, /* 112 VK_F1 */
{KEY_F(2), KEY_F(14), KEY_F(26), KEY_F(38), 0 }, /* 113 VK_F2 */
{KEY_F(3), KEY_F(15), KEY_F(27), KEY_F(39), 0 }, /* 114 VK_F3 */
{KEY_F(4), KEY_F(16), KEY_F(28), KEY_F(40), 0 }, /* 115 VK_F4 */
{KEY_F(5), KEY_F(17), KEY_F(29), KEY_F(41), 0 }, /* 116 VK_F5 */
{KEY_F(6), KEY_F(18), KEY_F(30), KEY_F(42), 0 }, /* 117 VK_F6 */
{KEY_F(7), KEY_F(19), KEY_F(31), KEY_F(43), 0 }, /* 118 VK_F7 */
{KEY_F(8), KEY_F(20), KEY_F(32), KEY_F(44), 0 }, /* 119 VK_F8 */
{KEY_F(9), KEY_F(21), KEY_F(33), KEY_F(45), 0 }, /* 120 VK_F9 */
{KEY_F(10), KEY_F(22), KEY_F(34), KEY_F(46), 0 }, /* 121 VK_F10 */
{KEY_F(11), KEY_F(23), KEY_F(35), KEY_F(47), 0 }, /* 122 VK_F11 */
{KEY_F(12), KEY_F(24), KEY_F(36), KEY_F(48), 0 }, /* 123 VK_F12 */
/* 124 through 218 */
{0, 0, 0, 0, 0}, /* 124 VK_F13 */
{0, 0, 0, 0, 0}, /* 125 VK_F14 */
{0, 0, 0, 0, 0}, /* 126 VK_F15 */
{0, 0, 0, 0, 0}, /* 127 VK_F16 */
{0, 0, 0, 0, 0}, /* 128 VK_F17 */
{0, 0, 0, 0, 0}, /* 129 VK_F18 */
{0, 0, 0, 0, 0}, /* 130 VK_F19 */
{0, 0, 0, 0, 0}, /* 131 VK_F20 */
{0, 0, 0, 0, 0}, /* 132 VK_F21 */
{0, 0, 0, 0, 0}, /* 133 VK_F22 */
{0, 0, 0, 0, 0}, /* 134 VK_F23 */
{0, 0, 0, 0, 0}, /* 135 VK_F24 */
{0, 0, 0, 0, 0}, /* 136 unassigned */
{0, 0, 0, 0, 0}, /* 137 unassigned */
{0, 0, 0, 0, 0}, /* 138 unassigned */
{0, 0, 0, 0, 0}, /* 139 unassigned */
{0, 0, 0, 0, 0}, /* 140 unassigned */
{0, 0, 0, 0, 0}, /* 141 unassigned */
{0, 0, 0, 0, 0}, /* 142 unassigned */
{0, 0, 0, 0, 0}, /* 143 unassigned */
{0, 0, 0, 0, 0}, /* 144 VK_NUMLOCK */
{KEY_SCROLLLOCK, 0, 0, ALT_SCROLLLOCK, 0}, /* 145 VKSCROLL */
{0, 0, 0, 0, 0}, /* 146 OEM specific */
{0, 0, 0, 0, 0}, /* 147 OEM specific */
{0, 0, 0, 0, 0}, /* 148 OEM specific */
{0, 0, 0, 0, 0}, /* 149 OEM specific */
{0, 0, 0, 0, 0}, /* 150 OEM specific */
{0, 0, 0, 0, 0}, /* 151 Unassigned */
{0, 0, 0, 0, 0}, /* 152 Unassigned */
{0, 0, 0, 0, 0}, /* 153 Unassigned */
{0, 0, 0, 0, 0}, /* 154 Unassigned */
{0, 0, 0, 0, 0}, /* 155 Unassigned */
{0, 0, 0, 0, 0}, /* 156 Unassigned */
{0, 0, 0, 0, 0}, /* 157 Unassigned */
{0, 0, 0, 0, 0}, /* 158 Unassigned */
{0, 0, 0, 0, 0}, /* 159 Unassigned */
{0, 0, 0, 0, 0}, /* 160 VK_LSHIFT */
{0, 0, 0, 0, 0}, /* 161 VK_RSHIFT */
{0, 0, 0, 0, 0}, /* 162 VK_LCONTROL */
{0, 0, 0, 0, 0}, /* 163 VK_RCONTROL */
{0, 0, 0, 0, 0}, /* 164 VK_LMENU */
{0, 0, 0, 0, 0}, /* 165 VK_RMENU */
{0, 0, 0, 0, 14}, /* 166 VK_BROWSER_BACK */
{0, 0, 0, 0, 15}, /* 167 VK_BROWSER_FORWARD */
{0, 0, 0, 0, 16}, /* 168 VK_BROWSER_REFRESH */
{0, 0, 0, 0, 17}, /* 169 VK_BROWSER_STOP */
{0, 0, 0, 0, 18}, /* 170 VK_BROWSER_SEARCH */
{0, 0, 0, 0, 19}, /* 171 VK_BROWSER_FAVORITES */
{0, 0, 0, 0, 20}, /* 172 VK_BROWSER_HOME */
{0, 0, 0, 0, 21}, /* 173 VK_VOLUME_MUTE */
{0, 0, 0, 0, 22}, /* 174 VK_VOLUME_DOWN */
{0, 0, 0, 0, 23}, /* 175 VK_VOLUME_UP */
{0, 0, 0, 0, 24}, /* 176 VK_MEDIA_NEXT_TRACK */
{0, 0, 0, 0, 25}, /* 177 VK_MEDIA_PREV_TRACK */
{0, 0, 0, 0, 26}, /* 178 VK_MEDIA_STOP */
{0, 0, 0, 0, 27}, /* 179 VK_MEDIA_PLAY_PAUSE */
{0, 0, 0, 0, 28}, /* 180 VK_LAUNCH_MAIL */
{0, 0, 0, 0, 29}, /* 181 VK_LAUNCH_MEDIA_SELECT */
{0, 0, 0, 0, 30}, /* 182 VK_LAUNCH_APP1 */
{0, 0, 0, 0, 31}, /* 183 VK_LAUNCH_APP2 */
{0, 0, 0, 0, 0}, /* 184 Reserved */
{0, 0, 0, 0, 0}, /* 185 Reserved */
{';', ':', CTL_SEMICOLON, ALT_SEMICOLON, 0}, /* 186 VK_OEM_1 */
{'=', '+', CTL_EQUAL, ALT_EQUAL, 0}, /* 187 VK_OEM_PLUS */
{',', '<', CTL_COMMA, ALT_COMMA, 0}, /* 188 VK_OEM_COMMA */
{'-', '_', CTL_MINUS, ALT_MINUS, 0}, /* 189 VK_OEM_MINUS */
{'.', '>', CTL_STOP, ALT_STOP, 0}, /* 190 VK_OEM_PERIOD */
{'/', '?', CTL_FSLASH, ALT_FSLASH, 0}, /* 191 VK_OEM_2 */
{'`', '~', CTL_BQUOTE, ALT_BQUOTE, 0}, /* 192 VK_OEM_3 */
{0, 0, 0, 0, 0}, /* 193 */
{0, 0, 0, 0, 0}, /* 194 */
{0, 0, 0, 0, 0}, /* 195 */
{0, 0, 0, 0, 0}, /* 196 */
{0, 0, 0, 0, 0}, /* 197 */
{0, 0, 0, 0, 0}, /* 198 */
{0, 0, 0, 0, 0}, /* 199 */
{0, 0, 0, 0, 0}, /* 200 */
{0, 0, 0, 0, 0}, /* 201 */
{0, 0, 0, 0, 0}, /* 202 */
{0, 0, 0, 0, 0}, /* 203 */
{0, 0, 0, 0, 0}, /* 204 */
{0, 0, 0, 0, 0}, /* 205 */
{0, 0, 0, 0, 0}, /* 206 */
{0, 0, 0, 0, 0}, /* 207 */
{0, 0, 0, 0, 0}, /* 208 */
{0, 0, 0, 0, 0}, /* 209 */
{0, 0, 0, 0, 0}, /* 210 */
{0, 0, 0, 0, 0}, /* 211 */
{0, 0, 0, 0, 0}, /* 212 */
{0, 0, 0, 0, 0}, /* 213 */
{0, 0, 0, 0, 0}, /* 214 */
{0, 0, 0, 0, 0}, /* 215 */
{0, 0, 0, 0, 0}, /* 216 */
{0, 0, 0, 0, 0}, /* 217 */
{0, 0, 0, 0, 0}, /* 218 */
{0x5B, 0x7B, 0x1B, ALT_LBRACKET,0 }, /* 219 VK_OEM_4 */
{0x5C, 0x7C, 0x1C, ALT_BSLASH, 0 }, /* 220 VK_OEM_5 */
{0x5D, 0x7D, 0x1D, ALT_RBRACKET,0 }, /* 221 VK_OEM_6 */
{'\'', '"', 0x27, ALT_FQUOTE, 0 }, /* 222 VK_OEM_7 */
{0, 0, 0, 0, 0 }, /* 223 VK_OEM_8 */
{0, 0, 0, 0, 0 }, /* 224 */
{0, 0, 0, 0, 0 } /* 225 */
};
/* End of kptab[] */
static const KPTAB ext_kptab[] =
{
{0, 0, 0, 0, }, /* 0 MUST BE EMPTY */
{PADENTER, SHF_PADENTER, CTL_PADENTER, ALT_PADENTER}, /* 1 13 */
{PADSLASH, SHF_PADSLASH, CTL_PADSLASH, ALT_PADSLASH}, /* 2 111 */
{KEY_PPAGE, KEY_SPREVIOUS, CTL_PGUP, ALT_PGUP }, /* 3 33 */
{KEY_NPAGE, KEY_SNEXT, CTL_PGDN, ALT_PGDN }, /* 4 34 */
{KEY_END, KEY_SEND, CTL_END, ALT_END }, /* 5 35 */
{KEY_HOME, KEY_SHOME, CTL_HOME, ALT_HOME }, /* 6 36 */
{KEY_LEFT, KEY_SLEFT, CTL_LEFT, ALT_LEFT }, /* 7 37 */
{KEY_UP, KEY_SUP, CTL_UP, ALT_UP }, /* 8 38 */
{KEY_RIGHT, KEY_SRIGHT, CTL_RIGHT, ALT_RIGHT }, /* 9 39 */
{KEY_DOWN, KEY_SDOWN, CTL_DOWN, ALT_DOWN }, /* 10 40 */
{KEY_IC, KEY_SIC, CTL_INS, ALT_INS }, /* 11 45 */
{KEY_DC, KEY_SDC, CTL_DEL, ALT_DEL }, /* 12 46 */
{KEY_APPS, KEY_SAPPS , CTL_APPS, ALT_APPS }, /* 13 93 VK_APPS */
{KEY_BROWSER_BACK, KEY_SBROWSER_BACK, KEY_CBROWSER_BACK, KEY_ABROWSER_BACK, }, /* 14 166 VK_BROWSER_BACK */
{KEY_BROWSER_FWD, KEY_SBROWSER_FWD, KEY_CBROWSER_FWD, KEY_ABROWSER_FWD, }, /* 15 167 VK_BROWSER_FORWARD */
{KEY_BROWSER_REF, KEY_SBROWSER_REF, KEY_CBROWSER_REF, KEY_ABROWSER_REF, }, /* 16 168 VK_BROWSER_REFRESH */
{KEY_BROWSER_STOP, KEY_SBROWSER_STOP, KEY_CBROWSER_STOP, KEY_ABROWSER_STOP, }, /* 17 169 VK_BROWSER_STOP */
{KEY_SEARCH, KEY_SSEARCH, KEY_CSEARCH, KEY_ASEARCH, }, /* 18 170 VK_BROWSER_SEARCH */
{KEY_FAVORITES, KEY_SFAVORITES, KEY_CFAVORITES, KEY_AFAVORITES, }, /* 19 171 VK_BROWSER_FAVORITES */
{KEY_BROWSER_HOME, KEY_SBROWSER_HOME, KEY_CBROWSER_HOME, KEY_ABROWSER_HOME, }, /* 20 172 VK_BROWSER_HOME */
{KEY_VOLUME_MUTE, KEY_SVOLUME_MUTE, KEY_CVOLUME_MUTE, KEY_AVOLUME_MUTE, }, /* 21 173 VK_VOLUME_MUTE */
{KEY_VOLUME_DOWN, KEY_SVOLUME_DOWN, KEY_CVOLUME_DOWN, KEY_AVOLUME_DOWN, }, /* 22 174 VK_VOLUME_DOWN */
{KEY_VOLUME_UP, KEY_SVOLUME_UP, KEY_CVOLUME_UP, KEY_AVOLUME_UP, }, /* 23 175 VK_VOLUME_UP */
{KEY_NEXT_TRACK, KEY_SNEXT_TRACK, KEY_CNEXT_TRACK, KEY_ANEXT_TRACK, }, /* 24 176 VK_MEDIA_NEXT_TRACK */
{KEY_PREV_TRACK, KEY_SPREV_TRACK, KEY_CPREV_TRACK, KEY_APREV_TRACK, }, /* 25 177 VK_MEDIA_PREV_TRACK */
{KEY_MEDIA_STOP, KEY_SMEDIA_STOP, KEY_CMEDIA_STOP, KEY_AMEDIA_STOP, }, /* 26 178 VK_MEDIA_STOP */
{KEY_PLAY_PAUSE, KEY_SPLAY_PAUSE, KEY_CPLAY_PAUSE, KEY_APLAY_PAUSE, }, /* 27 179 VK_MEDIA_PLAY_PAUSE */
{KEY_LAUNCH_MAIL, KEY_SLAUNCH_MAIL, KEY_CLAUNCH_MAIL, KEY_ALAUNCH_MAIL, }, /* 28 180 VK_LAUNCH_MAIL */
{KEY_MEDIA_SELECT, KEY_SMEDIA_SELECT, KEY_CMEDIA_SELECT, KEY_AMEDIA_SELECT, }, /* 29 181 VK_LAUNCH_MEDIA_SELECT */
{KEY_LAUNCH_APP1, KEY_SLAUNCH_APP1, KEY_CLAUNCH_APP1, KEY_ALAUNCH_APP1, }, /* 30 182 VK_LAUNCH_APP1 */
{KEY_LAUNCH_APP2, KEY_SLAUNCH_APP2, KEY_CLAUNCH_APP2, KEY_ALAUNCH_APP2, }, /* 31 183 VK_LAUNCH_APP2 */
};
HFONT PDC_get_font_handle( const int is_bold); /* pdcdisp.c */
/* Mouse handling is done as follows:
What we want is a setup wherein, if the user presses and releases a
mouse button within SP->mouse_wait milliseconds, there will be a
KEY_MOUSE issued through getch( ) and the "button state" for that button
will be set to BUTTON_CLICKED.
If the user presses and releases the button, and it takes _longer_
than SP->mouse_wait milliseconds, then there should be a KEY_MOUSE
issued with the "button state" set to BUTTON_PRESSED. Then, later,
another KEY_MOUSE with a BUTTON_RELEASED.
To accomplish this: when a message such as WM_LBUTTONDOWN,
WM_RBUTTONDOWN, or WM_MBUTTONDOWN is issued (and more recently WM_XBUTTONDOWN
for five-button mice), we set up a timer with a period of SP->mouse_wait
milliseconds. There are then two possibilities. The user will release the
button quickly (so it's a "click") or they won't (and it's a "press/release").
In the first case, we'll get the WM_xBUTTONUP message before the
WM_TIMER one. We'll kill the timer and set up the BUTTON_CLICKED state. (*)
In the second case, we'll get the WM_TIMER message first, so we'll
set the BUTTON_PRESSED state and kill the timer. Eventually, the user
will get around to letting go of the mouse button, and we'll get that
WM_xBUTTONUP message. At that time, we'll set the BUTTON_RELEASED state
and add the second KEY_MOUSE to the key queue.
Also, note that if there is already a KEY_MOUSE to the queue, there's
no point in adding another one. At least at present, the actual mouse
events aren't queued anyway. So if there was, say, a click and then a
release without getch( ) being called in between, you'd then have two
KEY_MOUSEs on the queue, but would have lost all information about what
the first one actually was. Hence the code near the end of this function
to ensure there isn't already a KEY_MOUSE in the queue.
Also, a note about wheel handling. Pre-Vista, you could just say
"the wheel went up" or "the wheel went down". Vista introduced the possibility
that the mouse motion could be a smoothly varying quantity. So on each
mouse move, we add in the amount moved, then check to see if that's
enough to trigger a wheel up/down event (or possibly several). The idea
is that whereas before, each movement would be 120 units (the default),
you might now get a series of 40-unit moves and should emit a wheel up/down
event on every third move.
(*) Things are actually slightly more complicated than this. In general,
it'll just be a plain old BUTTON_CLICKED state. But if there was another
BUTTON_CLICKED within the last 2 * SP->mouse_wait milliseconds, then this
must be a _double_ click, so we set the BUTTON_DOUBLE_CLICKED state. And
if, within that time frame, there was a double or triple click, then we
set the BUTTON_TRIPLE_CLICKED state. There isn't a "quad" or higher state,
so if you quadruple-click the mouse, with each click separated by less
than 2 * SP->mouse_wait milliseconds, then the messages sent will be
BUTTON_CLICKED, BUTTON_DOUBLE_CLICKED, BUTTON_TRIPLE_CLICKED, and
then another BUTTON_TRIPLE_CLICKED. */
static int set_mouse( const int button_index, const int button_state,
const LPARAM lParam)
{
int i, n_key_mouse_to_add = 1;
POINT pt;
pt.x = LOWORD( lParam);
pt.y = HIWORD( lParam);
if( button_index == -1) /* mouse moved, no button */
n_key_mouse_to_add = 1;
else
{
memset(&pdc_mouse_status, 0, sizeof(MOUSE_STATUS));
if( button_index < PDC_MAX_MOUSE_BUTTONS)
{
if( button_index < 3)
{
pdc_mouse_status.button[button_index] = (short)button_state;
pdc_mouse_status.changes = (1 << button_index);
}
else
{
pdc_mouse_status.xbutton[button_index - 3] = (short)button_state;
pdc_mouse_status.changes = (0x40 << button_index);
}
}
else /* actually a wheel mouse movement */
{ /* button_state = number of units moved */
static int mouse_wheel_vertical_loc = 0;
static int mouse_wheel_horizontal_loc = 0;
const int mouse_wheel_sensitivity = 120;
n_key_mouse_to_add = 0;
if( button_index == VERTICAL_WHEEL_EVENT)
{
mouse_wheel_vertical_loc += button_state;
while( mouse_wheel_vertical_loc > mouse_wheel_sensitivity / 2)
{
n_key_mouse_to_add++;
mouse_wheel_vertical_loc -= mouse_wheel_sensitivity;
pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_UP;
}
while( mouse_wheel_vertical_loc < -mouse_wheel_sensitivity / 2)
{
n_key_mouse_to_add++;
mouse_wheel_vertical_loc += mouse_wheel_sensitivity;
pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_DOWN;
}
}
else /* must be a horizontal event: */
{
mouse_wheel_horizontal_loc += button_state;
while( mouse_wheel_horizontal_loc > mouse_wheel_sensitivity / 2)
{
n_key_mouse_to_add++;
mouse_wheel_horizontal_loc -= mouse_wheel_sensitivity;
pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_RIGHT;
}
while( mouse_wheel_horizontal_loc < -mouse_wheel_sensitivity / 2)
{
n_key_mouse_to_add++;
mouse_wheel_horizontal_loc += mouse_wheel_sensitivity;
pdc_mouse_status.changes |= PDC_MOUSE_WHEEL_LEFT;
}
}
/* I think it may be that for wheel events, we */
/* return x = y = -1, rather than getting the */
/* actual mouse position. I don't like this, but */
/* I like messing up existing apps even less. */
pt.x = -PDC_cxChar;
pt.y = -PDC_cyChar;
/* ScreenToClient( PDC_hWnd, &pt); Wheel posns are in screen, */
} /* not client, coords; gotta xform them */
}
pdc_mouse_status.x = pt.x / PDC_cxChar;
pdc_mouse_status.y = pt.y / PDC_cyChar;
/* if( SP->save_key_modifiers) */
{
int i, button_flags = 0;
if( GetKeyState( VK_MENU) & 0x8000)
button_flags |= PDC_BUTTON_ALT;
if( GetKeyState( VK_SHIFT) & 0x8000)
button_flags |= PDC_BUTTON_SHIFT;
if( GetKeyState( VK_CONTROL) & 0x8000)
button_flags |= PDC_BUTTON_CONTROL;
for (i = 0; i < 3; i++)
pdc_mouse_status.button[i] |= button_flags;
for (i = 0; i < PDC_N_EXTENDED_MOUSE_BUTTONS; i++)
pdc_mouse_status.xbutton[i] |= button_flags;
}
/* If there is already a KEY_MOUSE in the queue, we */
/* don't really want to add another one. See above. */
i = PDC_key_queue_low;
while( i != PDC_key_queue_high)
{
if( PDC_key_queue[i] == KEY_MOUSE)
{
debug_printf( "Mouse key already in queue\n");
return( 0);
}
i = (i + 1) % KEY_QUEUE_SIZE;
}
/* If the window is maximized, the click may occur just */
/* outside the "real" screen area. If so, we again */
/* don't want to add a key to the queue: */
if( pdc_mouse_status.x >= PDC_n_cols || pdc_mouse_status.y >= PDC_n_rows)
n_key_mouse_to_add = 0;
/* OK, there isn't a KEY_MOUSE already in the queue. */
/* So we'll add one (or zero or more, for wheel mice): */
while( n_key_mouse_to_add--)
add_key_to_queue( KEY_MOUSE);
return( 0);
}
/* The following should be #defined in 'winuser.h', but such is */
/* not always the case. The following fixes the exceptions: */
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x020A
#endif
#ifndef WM_MOUSEHWHEEL
#define WM_MOUSEHWHEEL 0x020E
#endif
#ifndef WM_XBUTTONDOWN
#define WM_XBUTTONDOWN 0x020B
#define WM_XBUTTONUP 0x020C
#define MK_XBUTTON1 0x0020
#define MK_XBUTTON2 0x0040
#endif
#ifdef USE_FALLBACK_FONT
extern GLYPHSET *PDC_unicode_range_data;
#endif /* #ifdef USE_FALLBACK_FONT */
int PDC_blink_state = 0;
#define TIMER_ID_FOR_BLINKING 0x2000
/* When first loading a font, we use 'get_character_sizes' to briefly
load the (non-bold, non-italic flavor of the) font, get its height and
width, and call GetFontUnicodeRanges to determine which characters are
actually available from that font. That set of ranges is used so that,
when we come across characters not in the font, we can switch to a
"fallback" font (Unifont, most likely). */
static void get_character_sizes( const HWND hwnd,
int *xchar_size, int *ychar_size)
{
HFONT hFont = PDC_get_font_handle( 0);
HFONT prev_font;
HDC hdc = GetDC (hwnd) ;
TEXTMETRIC tm ;
#ifdef USE_FALLBACK_FONT
DWORD size;
#endif
prev_font = SelectObject (hdc, hFont);
GetTextMetrics (hdc, &tm) ;
#ifdef USE_FALLBACK_FONT
assert( !PDC_unicode_range_data);
size = GetFontUnicodeRanges( hdc, NULL);
PDC_unicode_range_data = (GLYPHSET *)calloc( 1, size);
PDC_unicode_range_data->cbThis = size;
size = GetFontUnicodeRanges( hdc, PDC_unicode_range_data);
#endif /* #ifdef USE_FALLBACK_FONT */
SelectObject( hdc, prev_font);
ReleaseDC (hwnd, hdc) ;
DeleteObject( hFont);
*xchar_size = tm.tmAveCharWidth ;
*ychar_size = tm.tmHeight;
}
INLINE void sort_out_rect( RECT *rect)
{
int temp;
if( rect->left > rect->right)
{
temp = rect->right;
rect->right = rect->left;
rect->left = temp;
}
if( rect->top > rect->bottom)
{
temp = rect->bottom;
rect->bottom = rect->top;
rect->top = temp;
}
}
static int rectangle_from_chars_to_pixels( RECT *rect)
{
int rval = 1;
if( rect->right == rect->left && rect->top == rect->bottom)
rval = 0;
sort_out_rect( rect);
if( rect->top < 0)
rval = 0;
rect->right++;
rect->bottom++;
rect->left *= PDC_cxChar;
rect->right *= PDC_cxChar;
rect->top *= PDC_cyChar;
rect->bottom *= PDC_cyChar;
return( rval);
}
/* When updating the mouse rectangle, you _could_ just remove the old one
and draw the new one. But that sometimes caused flickering if the mouse
area was large. In such cases, it's better to determine what areas
actually changed, and invert just those. So the following checks to
see if two overlapping rectangles are being drawn (this is the norm)
and figures out the area that actually needs to be flipped. It does
seem to decrease flickering to near-zero. */
static int PDC_selecting_rectangle = 1;
int PDC_find_ends_of_selected_text( const int line,
const RECT *rect, int *x)
{
int rval = 0, i;
if( (rect->top - line) * (rect->bottom - line) <= 0
&& (rect->top != rect->bottom || rect->left != rect->right))
{
if( PDC_selecting_rectangle || rect->top == rect->bottom)
{
x[0] = min( rect->right, rect->left);
x[1] = max( rect->right, rect->left);
rval = 1;
}
else if( rect->top <= line && line <= rect->bottom)
{
x[0] = (line == rect->top ? rect->left : 0);
x[1] = (line == rect->bottom ? rect->right : SP->cols - 1);
rval = 1;
}
else if( rect->top >= line && line >= rect->bottom)
{
x[0] = (line == rect->bottom ? rect->right : 0);
x[1] = (line == rect->top ? rect->left : SP->cols - 1);
rval = 1;
}
}
if( rval)
for( i = 0; i < 2; i++)
if( x[i] > SP->cols - 1)
x[i] = SP->cols - 1;
return( rval);
}
/* Called in only one place, so let's inline it */
INLINE void show_mouse_rect( const HWND hwnd, RECT before, RECT after)
{
if( before.top > -1 || after.top > -1)
if( memcmp( &after, &before, sizeof( RECT)))
{
const HDC hdc = GetDC( hwnd) ;
if( PDC_selecting_rectangle)
{
const int show_before = rectangle_from_chars_to_pixels( &before);
const int show_after = rectangle_from_chars_to_pixels( &after);
if( show_before && show_after)
{
RECT temp;
if( before.top < after.top)
{
temp = before; before = after; after = temp;
}
if( before.top < after.bottom && after.right > before.left
&& before.right > after.left)
{
const int tval = min( after.bottom, before.bottom);
temp = after;
temp.bottom = before.top;
InvertRect( hdc, &temp);
temp.top = temp.bottom;
temp.bottom = tval;
temp.right = max( after.right, before.right);
temp.left = min( after.right, before.right);
InvertRect( hdc, &temp);
temp.right = max( after.left, before.left);
temp.left = min( after.left, before.left);
InvertRect( hdc, &temp);
temp = (after.bottom > before.bottom ? after : before);
temp.top = tval;
InvertRect( hdc, &temp);
}
}
else if( show_before)
InvertRect( hdc, &before);
else if( show_after)
InvertRect( hdc, &after);
}
else /* _not_ selecting rectangle; selecting lines */
{
int line;
for( line = 0; line < SP->lines; line++)
{
int x[4], n_rects = 0, i;
n_rects = PDC_find_ends_of_selected_text( line, &before, x);
n_rects += PDC_find_ends_of_selected_text( line, &after, x + n_rects * 2);
if( n_rects == 2)
if( x[0] == x[2] && x[1] == x[3])
n_rects = 0; /* Rects are same & will cancel */
for( i = 0; i < n_rects; i++)
{
RECT trect;
trect.left = x[i + i];
trect.right = x[i + i + 1];
trect.top = line;
trect.bottom = line;
rectangle_from_chars_to_pixels( &trect);
InvertRect( hdc, &trect);
}
}
}
ReleaseDC( hwnd, hdc) ;
}
}
/* This function looks at the full command line, which includes a fully
specified path to the executable and arguments; and strips out just the
name of the app, with the arguments optionally appended. Hence,
C:\PDCURSES\WIN32A\TESTCURS.EXE arg1 arg2
would be reduced to 'Testcurs' (if include_args == 0) or
'Testcurs arg1 arg2' (if include_args == 1). The former case is used to
create a (hopefully unique) registry key for the app, so that the app's
specific settings (screen and font size) will be stored for the next run.
The latter case is used to generate a default window title.
Unfortunately, this code has to do some pretty strange things. In the
Unicode (PDC_WIDE) case, we really should use __wargv; but that pointer
may or may not be NULL. If it's NULL, we fall back on __argv. In at
least one case, where this code is compiled into a DLL using MinGW and
then used in an app compiled with MS Visual C, __argv isn't set either,
and we drop back to looking at GetCommandLine( ). Which leads to a real
oddity: GetCommandLine( ) may return something such as, say,
"C:\PDCurses\Win32a\testcurs.exe" -lRussian
...which, after being run through _splitpath or _wsplitpath, becomes
testcurs.exe" -lRussian
The .exe" is removed, and the command-line arguments shifted or removed,
depending on the value of include_args. Pretty strange stuff.
However, if one calls Xinitscr( ) and passed command-line arguments when
starting this library, those arguments will be stored in PDC_argc and
PDC_argv, and will be used instead of GetCommandLine.
*/
static void get_app_name( TCHAR *buff, const bool include_args)
{
int i;
int argc = (PDC_argc ? PDC_argc : __argc);
char **argv = (PDC_argc ? PDC_argv : __argv);
#ifdef PDC_WIDE
if( __wargv)
{
_wsplitpath( __wargv[0], NULL, NULL, buff, NULL);
if( include_args)
for( i = 1; i < __argc; i++)
{
wcscat( buff, L" ");
wcscat( buff, __wargv[i]);
}
}
else if( argv)
{
char tbuff[_MAX_PATH];
_splitpath( argv[0], NULL, NULL, tbuff, NULL);
if( include_args)
for( i = 1; i < argc; i++)
{
strcat( tbuff, " ");
strcat( tbuff, argv[i]);
}
mbstowcs( buff, tbuff, strlen( tbuff) + 1);
}
else /* no __argv or PDC_argv pointer available */
{
wchar_t *tptr;
_wsplitpath( GetCommandLine( ), NULL, NULL, buff, NULL);
_wcslwr( buff + 1);
tptr = wcsstr( buff, L".exe\"");
if( tptr)
{
if( include_args)
memmove( tptr, tptr + 5, wcslen( tptr + 4) * sizeof( wchar_t));
else
*tptr = '\0';
}
}
debug_printf( "(W) __argv: %p __wargv: %p Name out: '%ls'\n", __argv, __wargv, buff);
#else /* non-Unicode case */