]> git.pld-linux.org Git - packages/vim.git/blame - 7.3.310
projects / packages / vim.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- add patches 7.3.619-743
[packages/vim.git] / 7.3.310
CommitLineData
59ab3540
AM		 1To: vim_dev@googlegroups.com
2Subject: Patch 7.3.310
3Fcc: outbox
4From: Bram Moolenaar <Bram@moolenaar.net>
5Mime-Version: 1.0
6Content-Type: text/plain; charset=UTF-8
7Content-Transfer-Encoding: 8bit
8------------
9
10Patch 7.3.310
11Problem: Code not following Vim style.
12Solution: Fix the style. (Elias Diem)
13Files: src/gui_photon.c
14
15
16*** ../vim-7.3.309/src/gui_photon.c 2011-09-07 19:08:57.000000000 +0200
17--- src/gui_photon.c 2011-09-14 16:01:55.000000000 +0200
18***************
19*** 477,483 ****
20 }
21 #endif
22
23! for(i = 0; special_keys[i].key_sym != 0; i++)
24 {
25 if (special_keys[i].key_sym == key->key_cap)
26 {
27--- 477,483 ----
28 }
29 #endif
30
31! for (i = 0; special_keys[i].key_sym != 0; i++)
32 {
33 if (special_keys[i].key_sym == key->key_cap)
34 {
35***************
36*** 758,764 ****
37 if (damage->next != NULL)
38 damage = damage->next;
39
40! while(damage != NULL)
41 {
42 r = &damage->rect;
43 gui_redraw(
44--- 758,764 ----
45 if (damage->next != NULL)
46 damage = damage->next;
47
48! while (damage != NULL)
49 {
50 r = &damage->rect;
51 gui_redraw(
52***************
53*** 798,809 ****
54
55 /* This is used for pulldown/popup menus and also toolbar buttons */
56 static int
57! gui_ph_handle_menu( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
58 {
59! if( data != NULL )
60 {
61 vimmenu_T *menu = (vimmenu_T *) data;
62! gui_menu_cb( menu );
63 }
64 return Pt_CONTINUE;
65 }
66--- 798,809 ----
67
68 /* This is used for pulldown/popup menus and also toolbar buttons */
69 static int
70! gui_ph_handle_menu(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
71 {
72! if (data != NULL)
73 {
74 vimmenu_T *menu = (vimmenu_T *) data;
75! gui_menu_cb(menu);
76 }
77 return Pt_CONTINUE;
78 }
79***************
80*** 813,821 ****
81 gui_ph_handle_menu_unrealized(
82 PtWidget_t *widget,
83 void *data,
84! PtCallbackInfo_t *info )
85 {
86! PtGiveFocus( gui.vimTextArea, NULL );
87 return Pt_CONTINUE;
88 }
89
90--- 813,821 ----
91 gui_ph_handle_menu_unrealized(
92 PtWidget_t *widget,
93 void *data,
94! PtCallbackInfo_t *info)
95 {
96! PtGiveFocus(gui.vimTextArea, NULL);
97 return Pt_CONTINUE;
98 }
99
100***************
101*** 823,831 ****
102 gui_ph_handle_window_open(
103 PtWidget_t *widget,
104 void *data,
105! PtCallbackInfo_t *info )
106 {
107! gui_set_shellsize( FALSE, TRUE, RESIZE_BOTH );
108 return Pt_CONTINUE;
109 }
110
111--- 823,831 ----
112 gui_ph_handle_window_open(
113 PtWidget_t *widget,
114 void *data,
115! PtCallbackInfo_t *info)
116 {
117! gui_set_shellsize(FALSE, TRUE, RESIZE_BOTH);
118 return Pt_CONTINUE;
119 }
120
121***************
122*** 836,909 ****
123
124 /* TODO: Set a clipping rect? */
125 static void
126! gui_ph_draw_start( void )
127 {
128 PhGC_t *gc;
129
130 gc = PgGetGC();
131! PgSetRegion( PtWidgetRid( PtFindDisjoint( gui.vimTextArea ) ) );
132! PgClearClippingsCx( gc );
133! PgClearTranslationCx( gc );
134
135! PtWidgetOffset( gui.vimTextArea, &gui_ph_raw_offset );
136! PhTranslatePoint( &gui_ph_raw_offset, PtWidgetPos( gui.vimTextArea, NULL ) );
137
138! PgSetTranslation( &gui_ph_raw_offset, Pg_RELATIVE );
139 }
140
141 static void
142! gui_ph_draw_end( void )
143 {
144 gui_ph_raw_offset.x = -gui_ph_raw_offset.x;
145 gui_ph_raw_offset.y = -gui_ph_raw_offset.y;
146! PgSetTranslation( &gui_ph_raw_offset, Pg_RELATIVE );
147 }
148
149 #ifdef USE_PANEL_GROUP
150 static vimmenu_T *
151! gui_ph_find_buffer_item( char_u *name )
152 {
153 vimmenu_T *top_level = root_menu;
154 vimmenu_T *items = NULL;
155
156! while( top_level != NULL &&
157! ( STRCMP( top_level->dname, "Buffers" ) != 0 ) )
158 top_level = top_level->next;
159
160! if( top_level != NULL )
161 {
162 items = top_level->children;
163
164! while( items != NULL &&
165! ( STRCMP( items->dname, name ) != 0 ) )
166 items = items->next;
167 }
168 return items;
169 }
170
171 static void
172! gui_ph_pg_set_buffer_num( int_u buf_num )
173 {
174 int i;
175 char search[16];
176 char *mark;
177
178! if( gui.vimTextArea == NULL || buf_num == 0 )
179 return;
180
181 search[0] = '(';
182! ultoa( buf_num, &search[1], 10 );
183! STRCAT( search, ")" );
184
185! for( i = 0; i < num_panels; i++ )
186 {
187 /* find the last "(" in the panel title and see if the buffer
188 * number in the title matches the one we're looking for */
189! mark = STRRCHR( panel_titles[ i ], '(' );
190! if( mark != NULL && STRCMP( mark, search ) == 0 )
191 {
192! PtSetResource( gui.vimPanelGroup, Pt_ARG_PG_CURRENT_INDEX,
193! i, 0 );
194 }
195 }
196 }
197--- 836,909 ----
198
199 /* TODO: Set a clipping rect? */
200 static void
201! gui_ph_draw_start(void)
202 {
203 PhGC_t *gc;
204
205 gc = PgGetGC();
206! PgSetRegion(PtWidgetRid(PtFindDisjoint(gui.vimTextArea)));
207! PgClearClippingsCx(gc);
208! PgClearTranslationCx(gc);
209
210! PtWidgetOffset(gui.vimTextArea, &gui_ph_raw_offset);
211! PhTranslatePoint(&gui_ph_raw_offset, PtWidgetPos(gui.vimTextArea, NULL));
212
213! PgSetTranslation(&gui_ph_raw_offset, Pg_RELATIVE);
214 }
215
216 static void
217! gui_ph_draw_end(void)
218 {
219 gui_ph_raw_offset.x = -gui_ph_raw_offset.x;
220 gui_ph_raw_offset.y = -gui_ph_raw_offset.y;
221! PgSetTranslation(&gui_ph_raw_offset, Pg_RELATIVE);
222 }
223
224 #ifdef USE_PANEL_GROUP
225 static vimmenu_T *
226! gui_ph_find_buffer_item(char_u *name)
227 {
228 vimmenu_T *top_level = root_menu;
229 vimmenu_T *items = NULL;
230
231! while (top_level != NULL &&
232! (STRCMP(top_level->dname, "Buffers") != 0))
233 top_level = top_level->next;
234
235! if (top_level != NULL)
236 {
237 items = top_level->children;
238
239! while (items != NULL &&
240! (STRCMP(items->dname, name) != 0))
241 items = items->next;
242 }
243 return items;
244 }
245
246 static void
247! gui_ph_pg_set_buffer_num(int_u buf_num)
248 {
249 int i;
250 char search[16];
251 char *mark;
252
253! if (gui.vimTextArea == NULL || buf_num == 0)
254 return;
255
256 search[0] = '(';
257! ultoa(buf_num, &search[1], 10);
258! STRCAT(search, ")");
259
260! for (i = 0; i < num_panels; i++)
261 {
262 /* find the last "(" in the panel title and see if the buffer
263 * number in the title matches the one we're looking for */
264! mark = STRRCHR(panel_titles[ i ], '(');
265! if (mark != NULL && STRCMP(mark, search) == 0)
266 {
267! PtSetResource(gui.vimPanelGroup, Pt_ARG_PG_CURRENT_INDEX,
268! i, 0);
269 }
270 }
271 }
272***************
273*** 912,930 ****
274 gui_ph_handle_pg_change(
275 PtWidget_t *widget,
276 void *data,
277! PtCallbackInfo_t *info )
278 {
279 vimmenu_T *menu;
280 PtPanelGroupCallback_t *panel;
281
282! if( info->event != NULL )
283 {
284 panel = info->cbdata;
285! if( panel->new_panel != NULL )
286 {
287! menu = gui_ph_find_buffer_item( panel->new_panel );
288! if( menu )
289! gui_menu_cb( menu );
290 }
291 }
292 return Pt_CONTINUE;
293--- 912,930 ----
294 gui_ph_handle_pg_change(
295 PtWidget_t *widget,
296 void *data,
297! PtCallbackInfo_t *info)
298 {
299 vimmenu_T *menu;
300 PtPanelGroupCallback_t *panel;
301
302! if (info->event != NULL)
303 {
304 panel = info->cbdata;
305! if (panel->new_panel != NULL)
306 {
307! menu = gui_ph_find_buffer_item(panel->new_panel);
308! if (menu)
309! gui_menu_cb(menu);
310 }
311 }
312 return Pt_CONTINUE;
313***************
314*** 935,951 ****
315 short *top,
316 short *bottom,
317 short *left,
318! short *right )
319 {
320 unsigned short abs_raw_x, abs_raw_y, abs_panel_x, abs_panel_y;
321 const unsigned short *margin_top, *margin_bottom;
322 const unsigned short *margin_left, *margin_right;
323
324! PtGetAbsPosition( gui.vimTextArea, &abs_raw_x, &abs_raw_y );
325! PtGetAbsPosition( gui.vimPanelGroup, &abs_panel_x, &abs_panel_y );
326
327! PtGetResource( gui.vimPanelGroup, Pt_ARG_MARGIN_RIGHT, &margin_right, 0 );
328! PtGetResource( gui.vimPanelGroup, Pt_ARG_MARGIN_BOTTOM, &margin_bottom, 0 );
329
330 abs_raw_x -= abs_panel_x;
331 abs_raw_y -= abs_panel_y;
332--- 935,951 ----
333 short *top,
334 short *bottom,
335 short *left,
336! short *right)
337 {
338 unsigned short abs_raw_x, abs_raw_y, abs_panel_x, abs_panel_y;
339 const unsigned short *margin_top, *margin_bottom;
340 const unsigned short *margin_left, *margin_right;
341
342! PtGetAbsPosition(gui.vimTextArea, &abs_raw_x, &abs_raw_y);
343! PtGetAbsPosition(gui.vimPanelGroup, &abs_panel_x, &abs_panel_y);
344
345! PtGetResource(gui.vimPanelGroup, Pt_ARG_MARGIN_RIGHT, &margin_right, 0);
346! PtGetResource(gui.vimPanelGroup, Pt_ARG_MARGIN_BOTTOM, &margin_bottom, 0);
347
348 abs_raw_x -= abs_panel_x;
349 abs_raw_y -= abs_panel_y;
350***************
351*** 959,979 ****
352
353 /* Used for the tabs for PtPanelGroup */
354 static int
355! gui_ph_is_buffer_item( vimmenu_T *menu, vimmenu_T *parent )
356 {
357 char *mark;
358
359! if( STRCMP( parent->dname, "Buffers" ) == 0 )
360 {
361 /* Look for '(' digits ')' */
362! mark = vim_strchr( menu->dname, '(' );
363! if( mark != NULL )
364 {
365 mark++;
366! while( isdigit( *mark ) )
367 mark++;
368
369! if( *mark == ')' )
370 return TRUE;
371 }
372 }
373--- 959,979 ----
374
375 /* Used for the tabs for PtPanelGroup */
376 static int
377! gui_ph_is_buffer_item(vimmenu_T *menu, vimmenu_T *parent)
378 {
379 char *mark;
380
381! if (STRCMP(parent->dname, "Buffers") == 0)
382 {
383 /* Look for '(' digits ')' */
384! mark = vim_strchr(menu->dname, '(');
385! if (mark != NULL)
386 {
387 mark++;
388! while (isdigit(*mark))
389 mark++;
390
391! if (*mark == ')')
392 return TRUE;
393 }
394 }
395***************
396*** 981,1043 ****
397 }
398
399 static void
400! gui_ph_pg_add_buffer(char *name )
401 {
402 char **new_titles = NULL;
403
404! new_titles = (char **) alloc( ( num_panels + 1 ) * sizeof( char ** ) );
405! if( new_titles != NULL )
406 {
407! if( num_panels > 0 )
408! memcpy( new_titles, panel_titles, num_panels * sizeof( char ** ) );
409
410 new_titles[ num_panels++ ] = name;
411
412! PtSetResource( gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, new_titles,
413! num_panels );
414
415! vim_free( panel_titles );
416 panel_titles = new_titles;
417 }
418 }
419
420 static void
421! gui_ph_pg_remove_buffer( char *name )
422 {
423 int i;
424 char **new_titles = NULL;
425
426 /* If there is only 1 panel, we just use the temporary place holder */
427! if( num_panels > 1 )
428 {
429! new_titles = (char **) alloc( ( num_panels - 1 ) * sizeof( char ** ) );
430! if( new_titles != NULL )
431 {
432 char **s = new_titles;
433 /* Copy all the titles except the one we're removing */
434! for( i = 0; i < num_panels; i++ )
435 {
436! if( STRCMP( panel_titles[ i ], name ) != 0 )
437 {
438 *s++ = panel_titles[ i ];
439 }
440 }
441 num_panels--;
442
443! PtSetResource( gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, new_titles,
444! num_panels );
445
446! vim_free( panel_titles );
447 panel_titles = new_titles;
448 }
449 }
450 else
451 {
452 num_panels--;
453! PtSetResource( gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, &empty_title,
454! 1 );
455
456! vim_free( panel_titles );
457 panel_titles = NULL;
458 }
459 }
460--- 981,1043 ----
461 }
462
463 static void
464! gui_ph_pg_add_buffer(char *name)
465 {
466 char **new_titles = NULL;
467
468! new_titles = (char **) alloc((num_panels + 1) * sizeof(char **));
469! if (new_titles != NULL)
470 {
471! if (num_panels > 0)
472! memcpy(new_titles, panel_titles, num_panels * sizeof(char **));
473
474 new_titles[ num_panels++ ] = name;
475
476! PtSetResource(gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, new_titles,
477! num_panels);
478
479! vim_free(panel_titles);
480 panel_titles = new_titles;
481 }
482 }
483
484 static void
485! gui_ph_pg_remove_buffer(char *name)
486 {
487 int i;
488 char **new_titles = NULL;
489
490 /* If there is only 1 panel, we just use the temporary place holder */
491! if (num_panels > 1)
492 {
493! new_titles = (char **) alloc((num_panels - 1) * sizeof(char **));
494! if (new_titles != NULL)
495 {
496 char **s = new_titles;
497 /* Copy all the titles except the one we're removing */
498! for (i = 0; i < num_panels; i++)
499 {
500! if (STRCMP(panel_titles[ i ], name) != 0)
501 {
502 *s++ = panel_titles[ i ];
503 }
504 }
505 num_panels--;
506
507! PtSetResource(gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, new_titles,
508! num_panels);
509
510! vim_free(panel_titles);
511 panel_titles = new_titles;
512 }
513 }
514 else
515 {
516 num_panels--;
517! PtSetResource(gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, &empty_title,
518! 1);
519
520! vim_free(panel_titles);
521 panel_titles = NULL;
522 }
523 }
524***************
525*** 1047,1060 ****
526 gui_ph_handle_buffer_remove(
527 PtWidget_t *widget,
528 void *data,
529! PtCallbackInfo_t *info )
530 {
531 vimmenu_T *menu;
532
533! if( data != NULL )
534 {
535 menu = (vimmenu_T *) data;
536! gui_ph_pg_remove_buffer( menu->dname );
537 }
538
539 return Pt_CONTINUE;
540--- 1047,1060 ----
541 gui_ph_handle_buffer_remove(
542 PtWidget_t *widget,
543 void *data,
544! PtCallbackInfo_t *info)
545 {
546 vimmenu_T *menu;
547
548! if (data != NULL)
549 {
550 menu = (vimmenu_T *) data;
551! gui_ph_pg_remove_buffer(menu->dname);
552 }
553
554 return Pt_CONTINUE;
555***************
556*** 1062,1074 ****
557 #endif
558
559 static int
560! gui_ph_pane_resize( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
561 {
562! if( PtWidgetIsRealized( widget ) )
563 {
564 is_ignore_draw = TRUE;
565! PtStartFlux( gui.vimContainer );
566! PtContainerHold( gui.vimContainer );
567 }
568
569 return Pt_CONTINUE;
570--- 1062,1074 ----
571 #endif
572
573 static int
574! gui_ph_pane_resize(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
575 {
576! if (PtWidgetIsRealized(widget))
577 {
578 is_ignore_draw = TRUE;
579! PtStartFlux(gui.vimContainer);
580! PtContainerHold(gui.vimContainer);
581 }
582
583 return Pt_CONTINUE;
584***************
585*** 1078,1084 ****
586
587 #ifdef FEAT_MBYTE
588 void
589! gui_ph_encoding_changed( int new_encoding )
590 {
591 /* Default encoding is latin1 */
592 char *charset = "latin1";
593--- 1078,1084 ----
594
595 #ifdef FEAT_MBYTE
596 void
597! gui_ph_encoding_changed(int new_encoding)
598 {
599 /* Default encoding is latin1 */
600 char *charset = "latin1";
601***************
602*** 1094,1106 ****
603 { DBCS_CHS, "gb" }
604 };
605
606! for( i = 0; i < ARRAY_LENGTH( charsets ); i++ )
607 {
608! if( new_encoding == charsets[ i ].encoding )
609 charset = charsets[ i ].name;
610 }
611
612! charset_translate = PxTranslateSet( charset_translate, charset );
613 }
614 #endif
615
616--- 1094,1106 ----
617 { DBCS_CHS, "gb" }
618 };
619
620! for (i = 0; i < ARRAY_LENGTH(charsets); i++)
621 {
622! if (new_encoding == charsets[ i ].encoding)
623 charset = charsets[ i ].name;
624 }
625
626! charset_translate = PxTranslateSet(charset_translate, charset);
627 }
628 #endif
629
630***************
631*** 1112,1118 ****
632 int *argc;
633 char **argv;
634 {
635! PtInit( NULL );
636 }
637
638 int
639--- 1112,1118 ----
640 int *argc;
641 char **argv;
642 {
643! PtInit(NULL);
644 }
645
646 int
647***************
648*** 1124,1213 ****
649 PhDim_t window_size = {100, 100}; /* Arbitrary values */
650 PhPoint_t pos = {0, 0};
651
652! gui.event_buffer = (PhEvent_t *) alloc( EVENT_BUFFER_SIZE );
653! if( gui.event_buffer == NULL )
654 return FAIL;
655
656 /* Get a translation so we can convert from ISO Latin-1 to UTF */
657! charset_translate = PxTranslateSet( NULL, "latin1" );
658
659 /* The +2 is for the 1 pixel dark line on each side */
660 gui.border_offset = gui.border_width = GUI_PH_MARGIN + 2;
661
662 /* Handle close events ourselves */
663! PtSetArg( &args[ n++ ], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_CLOSE );
664! PtSetArg( &args[ n++ ], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
665! Ph_WM_CLOSE | Ph_WM_RESIZE | Ph_WM_FOCUS );
666! PtSetArg( &args[ n++ ], Pt_ARG_DIM, &window_size, 0 );
667! gui.vimWindow = PtCreateWidget( PtWindow, NULL, n, args );
668! if( gui.vimWindow == NULL )
669 return FAIL;
670
671! PtAddCallback( gui.vimWindow, Pt_CB_WINDOW, gui_ph_handle_window_cb, NULL );
672! PtAddCallback( gui.vimWindow, Pt_CB_WINDOW_OPENING,
673! gui_ph_handle_window_open, NULL );
674
675 n = 0;
676! PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS, Pt_ANCHOR_ALL, Pt_IS_ANCHORED );
677! PtSetArg( &args[ n++ ], Pt_ARG_DIM, &window_size, 0 );
678! PtSetArg( &args[ n++ ], Pt_ARG_POS, &pos, 0 );
679
680 #ifdef USE_PANEL_GROUP
681 /* Put in a temprary place holder title */
682! PtSetArg( &args[ n++ ], Pt_ARG_PG_PANEL_TITLES, &empty_title, 1 );
683
684! gui.vimPanelGroup = PtCreateWidget( PtPanelGroup, gui.vimWindow, n, args );
685! if( gui.vimPanelGroup == NULL )
686 return FAIL;
687
688! PtAddCallback( gui.vimPanelGroup, Pt_CB_PG_PANEL_SWITCHING,
689! gui_ph_handle_pg_change, NULL );
690 #else
691 /* Turn off all edge decorations */
692! PtSetArg( &args[ n++ ], Pt_ARG_BASIC_FLAGS, Pt_FALSE, Pt_ALL );
693! PtSetArg( &args[ n++ ], Pt_ARG_BEVEL_WIDTH, 0, 0 );
694! PtSetArg( &args[ n++ ], Pt_ARG_MARGIN_WIDTH, 0, 0 );
695! PtSetArg( &args[ n++ ], Pt_ARG_MARGIN_HEIGHT, 0, 0 );
696! PtSetArg( &args[ n++ ], Pt_ARG_CONTAINER_FLAGS, Pt_TRUE, Pt_AUTO_EXTENT );
697
698! gui.vimContainer = PtCreateWidget( PtPane, gui.vimWindow, n, args );
699! if( gui.vimContainer == NULL )
700 return FAIL;
701
702! PtAddCallback( gui.vimContainer, Pt_CB_RESIZE, gui_ph_pane_resize, NULL );
703 #endif
704
705 /* Size for the text area is set in gui_mch_set_text_area_pos */
706 n = 0;
707
708! PtSetArg( &args[ n++ ], Pt_ARG_RAW_DRAW_F, gui_ph_handle_raw_draw, 1 );
709! PtSetArg( &args[ n++ ], Pt_ARG_BEVEL_WIDTH, GUI_PH_MARGIN, 0 );
710 /*
711 * Using focus render also causes the whole widget to be redrawn
712 * whenever it changes focus, which is very annoying :p
713 */
714! PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_TRUE,
715! Pt_GETS_FOCUS | Pt_HIGHLIGHTED );
716 #ifndef FEAT_MOUSESHAPE
717! PtSetArg( &args[ n++ ], Pt_ARG_CURSOR_TYPE, GUI_PH_MOUSE_TYPE, 0 );
718! PtSetArg( &args[ n++ ], Pt_ARG_CURSOR_COLOR, gui_ph_mouse_color, 0 );
719 #endif
720
721! gui.vimTextArea = PtCreateWidget( PtRaw, Pt_DFLT_PARENT, n, args );
722! if( gui.vimTextArea == NULL)
723 return FAIL;
724
725 /* TODO: use PtAddEventHandlers instead? */
726 /* Not using Ph_EV_BUT_REPEAT because vim wouldn't use it anyway */
727! PtAddEventHandler( gui.vimTextArea,
728 Ph_EV_BUT_PRESS | Ph_EV_BUT_RELEASE | Ph_EV_PTR_MOTION_BUTTON,
729! gui_ph_handle_mouse, NULL );
730! PtAddEventHandler( gui.vimTextArea, Ph_EV_KEY,
731! gui_ph_handle_keyboard, NULL );
732! PtAddCallback( gui.vimTextArea, Pt_CB_GOT_FOCUS,
733! gui_ph_handle_focus, NULL );
734! PtAddCallback( gui.vimTextArea, Pt_CB_LOST_FOCUS,
735! gui_ph_handle_focus, NULL );
736
737 /*
738 * Now that the text area widget has been created, set up the colours,
739--- 1124,1213 ----
740 PhDim_t window_size = {100, 100}; /* Arbitrary values */
741 PhPoint_t pos = {0, 0};
742
743! gui.event_buffer = (PhEvent_t *) alloc(EVENT_BUFFER_SIZE);
744! if (gui.event_buffer == NULL)
745 return FAIL;
746
747 /* Get a translation so we can convert from ISO Latin-1 to UTF */
748! charset_translate = PxTranslateSet(NULL, "latin1");
749
750 /* The +2 is for the 1 pixel dark line on each side */
751 gui.border_offset = gui.border_width = GUI_PH_MARGIN + 2;
752
753 /* Handle close events ourselves */
754! PtSetArg(&args[ n++ ], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_CLOSE);
755! PtSetArg(&args[ n++ ], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
756! Ph_WM_CLOSE | Ph_WM_RESIZE | Ph_WM_FOCUS);
757! PtSetArg(&args[ n++ ], Pt_ARG_DIM, &window_size, 0);
758! gui.vimWindow = PtCreateWidget(PtWindow, NULL, n, args);
759! if (gui.vimWindow == NULL)
760 return FAIL;
761
762! PtAddCallback(gui.vimWindow, Pt_CB_WINDOW, gui_ph_handle_window_cb, NULL);
763! PtAddCallback(gui.vimWindow, Pt_CB_WINDOW_OPENING,
764! gui_ph_handle_window_open, NULL);
765
766 n = 0;
767! PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS, Pt_ANCHOR_ALL, Pt_IS_ANCHORED);
768! PtSetArg(&args[ n++ ], Pt_ARG_DIM, &window_size, 0);
769! PtSetArg(&args[ n++ ], Pt_ARG_POS, &pos, 0);
770
771 #ifdef USE_PANEL_GROUP
772 /* Put in a temprary place holder title */
773! PtSetArg(&args[ n++ ], Pt_ARG_PG_PANEL_TITLES, &empty_title, 1);
774
775! gui.vimPanelGroup = PtCreateWidget(PtPanelGroup, gui.vimWindow, n, args);
776! if (gui.vimPanelGroup == NULL)
777 return FAIL;
778
779! PtAddCallback(gui.vimPanelGroup, Pt_CB_PG_PANEL_SWITCHING,
780! gui_ph_handle_pg_change, NULL);
781 #else
782 /* Turn off all edge decorations */
783! PtSetArg(&args[ n++ ], Pt_ARG_BASIC_FLAGS, Pt_FALSE, Pt_ALL);
784! PtSetArg(&args[ n++ ], Pt_ARG_BEVEL_WIDTH, 0, 0);
785! PtSetArg(&args[ n++ ], Pt_ARG_MARGIN_WIDTH, 0, 0);
786! PtSetArg(&args[ n++ ], Pt_ARG_MARGIN_HEIGHT, 0, 0);
787! PtSetArg(&args[ n++ ], Pt_ARG_CONTAINER_FLAGS, Pt_TRUE, Pt_AUTO_EXTENT);
788
789! gui.vimContainer = PtCreateWidget(PtPane, gui.vimWindow, n, args);
790! if (gui.vimContainer == NULL)
791 return FAIL;
792
793! PtAddCallback(gui.vimContainer, Pt_CB_RESIZE, gui_ph_pane_resize, NULL);
794 #endif
795
796 /* Size for the text area is set in gui_mch_set_text_area_pos */
797 n = 0;
798
799! PtSetArg(&args[ n++ ], Pt_ARG_RAW_DRAW_F, gui_ph_handle_raw_draw, 1);
800! PtSetArg(&args[ n++ ], Pt_ARG_BEVEL_WIDTH, GUI_PH_MARGIN, 0);
801 /*
802 * Using focus render also causes the whole widget to be redrawn
803 * whenever it changes focus, which is very annoying :p
804 */
805! PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_TRUE,
806! Pt_GETS_FOCUS | Pt_HIGHLIGHTED);
807 #ifndef FEAT_MOUSESHAPE
808! PtSetArg(&args[ n++ ], Pt_ARG_CURSOR_TYPE, GUI_PH_MOUSE_TYPE, 0);
809! PtSetArg(&args[ n++ ], Pt_ARG_CURSOR_COLOR, gui_ph_mouse_color, 0);
810 #endif
811
812! gui.vimTextArea = PtCreateWidget(PtRaw, Pt_DFLT_PARENT, n, args);
813! if (gui.vimTextArea == NULL)
814 return FAIL;
815
816 /* TODO: use PtAddEventHandlers instead? */
817 /* Not using Ph_EV_BUT_REPEAT because vim wouldn't use it anyway */
818! PtAddEventHandler(gui.vimTextArea,
819 Ph_EV_BUT_PRESS | Ph_EV_BUT_RELEASE | Ph_EV_PTR_MOTION_BUTTON,
820! gui_ph_handle_mouse, NULL);
821! PtAddEventHandler(gui.vimTextArea, Ph_EV_KEY,
822! gui_ph_handle_keyboard, NULL);
823! PtAddCallback(gui.vimTextArea, Pt_CB_GOT_FOCUS,
824! gui_ph_handle_focus, NULL);
825! PtAddCallback(gui.vimTextArea, Pt_CB_LOST_FOCUS,
826! gui_ph_handle_focus, NULL);
827
828 /*
829 * Now that the text area widget has been created, set up the colours,
830***************
831*** 1218,1278 ****
832 * Create the two timers, not as accurate as using the kernel timer
833 * functions, but good enough
834 */
835! gui_ph_timer_cursor = PtCreateWidget( PtTimer, gui.vimWindow, 0, NULL );
836! if( gui_ph_timer_cursor == NULL )
837 return FAIL;
838
839! gui_ph_timer_timeout = PtCreateWidget( PtTimer, gui.vimWindow, 0, NULL );
840! if( gui_ph_timer_timeout == NULL )
841 return FAIL;
842
843! PtAddCallback( gui_ph_timer_cursor, Pt_CB_TIMER_ACTIVATE,
844 gui_ph_handle_timer_cursor, NULL);
845! PtAddCallback( gui_ph_timer_timeout, Pt_CB_TIMER_ACTIVATE,
846 gui_ph_handle_timer_timeout, NULL);
847
848 #ifdef FEAT_MENU
849 n = 0;
850! PtSetArg( &args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0 );
851! PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS, Pt_ANCHOR_LEFT_RIGHT,
852! Pt_IS_ANCHORED );
853! gui.vimToolBarGroup = PtCreateWidget( PtToolbarGroup, gui.vimWindow,
854! n, args );
855! if( gui.vimToolBarGroup == NULL )
856 return FAIL;
857
858! PtAddCallback( gui.vimToolBarGroup, Pt_CB_RESIZE,
859! gui_ph_handle_menu_resize, NULL );
860
861 n = 0;
862 flags = 0;
863! PtSetArg( &args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0 );
864! if( ! vim_strchr( p_go, GO_MENUS ) )
865 {
866 flags |= Pt_DELAY_REALIZE;
867! PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_TRUE, flags );
868 }
869! gui.vimMenuBar = PtCreateWidget( PtMenuBar, gui.vimToolBarGroup, n, args );
870! if( gui.vimMenuBar == NULL )
871 return FAIL;
872
873 # ifdef FEAT_TOOLBAR
874 n = 0;
875
876! PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS,
877! Pt_ANCHOR_LEFT_RIGHT |Pt_TOP_ANCHORED_TOP, Pt_IS_ANCHORED );
878! PtSetArg( &args[ n++ ], Pt_ARG_RESIZE_FLAGS, Pt_TRUE,
879! Pt_RESIZE_Y_AS_REQUIRED );
880! PtSetArg( &args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0 );
881
882 flags = Pt_GETS_FOCUS;
883! if( ! vim_strchr( p_go, GO_TOOLBAR ) )
884 flags |= Pt_DELAY_REALIZE;
885
886! PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_DELAY_REALIZE, flags );
887
888! gui.vimToolBar = PtCreateWidget( PtToolbar, gui.vimToolBarGroup, n, args );
889! if( gui.vimToolBar == NULL )
890 return FAIL;
891
892 /*
893--- 1218,1278 ----
894 * Create the two timers, not as accurate as using the kernel timer
895 * functions, but good enough
896 */
897! gui_ph_timer_cursor = PtCreateWidget(PtTimer, gui.vimWindow, 0, NULL);
898! if (gui_ph_timer_cursor == NULL)
899 return FAIL;
900
901! gui_ph_timer_timeout = PtCreateWidget(PtTimer, gui.vimWindow, 0, NULL);
902! if (gui_ph_timer_timeout == NULL)
903 return FAIL;
904
905! PtAddCallback(gui_ph_timer_cursor, Pt_CB_TIMER_ACTIVATE,
906 gui_ph_handle_timer_cursor, NULL);
907! PtAddCallback(gui_ph_timer_timeout, Pt_CB_TIMER_ACTIVATE,
908 gui_ph_handle_timer_timeout, NULL);
909
910 #ifdef FEAT_MENU
911 n = 0;
912! PtSetArg(&args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0);
913! PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS, Pt_ANCHOR_LEFT_RIGHT,
914! Pt_IS_ANCHORED);
915! gui.vimToolBarGroup = PtCreateWidget(PtToolbarGroup, gui.vimWindow,
916! n, args);
917! if (gui.vimToolBarGroup == NULL)
918 return FAIL;
919
920! PtAddCallback(gui.vimToolBarGroup, Pt_CB_RESIZE,
921! gui_ph_handle_menu_resize, NULL);
922
923 n = 0;
924 flags = 0;
925! PtSetArg(&args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0);
926! if (! vim_strchr(p_go, GO_MENUS))
927 {
928 flags |= Pt_DELAY_REALIZE;
929! PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_TRUE, flags);
930 }
931! gui.vimMenuBar = PtCreateWidget(PtMenuBar, gui.vimToolBarGroup, n, args);
932! if (gui.vimMenuBar == NULL)
933 return FAIL;
934
935 # ifdef FEAT_TOOLBAR
936 n = 0;
937
938! PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS,
939! Pt_ANCHOR_LEFT_RIGHT |Pt_TOP_ANCHORED_TOP, Pt_IS_ANCHORED);
940! PtSetArg(&args[ n++ ], Pt_ARG_RESIZE_FLAGS, Pt_TRUE,
941! Pt_RESIZE_Y_AS_REQUIRED);
942! PtSetArg(&args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0);
943
944 flags = Pt_GETS_FOCUS;
945! if (! vim_strchr(p_go, GO_TOOLBAR))
946 flags |= Pt_DELAY_REALIZE;
947
948! PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_DELAY_REALIZE, flags);
949
950! gui.vimToolBar = PtCreateWidget(PtToolbar, gui.vimToolBarGroup, n, args);
951! if (gui.vimToolBar == NULL)
952 return FAIL;
953
954 /*
955***************
956*** 1310,1329 ****
957 if (gui_win_x != -1 && gui_win_y != -1)
958 gui_mch_set_winpos(gui_win_x, gui_win_y);
959
960! return (PtRealizeWidget( gui.vimWindow ) == 0) ? OK : FAIL;
961 }
962
963 void
964 gui_mch_exit(int rc)
965 {
966! PtDestroyWidget( gui.vimWindow );
967
968! PxTranslateSet( charset_translate, NULL );
969
970! vim_free( gui.event_buffer );
971
972 #ifdef USE_PANEL_GROUPS
973! vim_free( panel_titles );
974 #endif
975 }
976
977--- 1310,1329 ----
978 if (gui_win_x != -1 && gui_win_y != -1)
979 gui_mch_set_winpos(gui_win_x, gui_win_y);
980
981! return (PtRealizeWidget(gui.vimWindow) == 0) ? OK : FAIL;
982 }
983
984 void
985 gui_mch_exit(int rc)
986 {
987! PtDestroyWidget(gui.vimWindow);
988
989! PxTranslateSet(charset_translate, NULL);
990
991! vim_free(gui.event_buffer);
992
993 #ifdef USE_PANEL_GROUPS
994! vim_free(panel_titles);
995 #endif
996 }
997
998***************
999*** 1333,1339 ****
1000 /* When no events are available, photon will call this function, working is
1001 * set to FALSE, and the gui_mch_update loop will exit. */
1002 static int
1003! exit_gui_mch_update( void *data )
1004 {
1005 *(int *)data = FALSE;
1006 return Pt_END;
1007--- 1333,1339 ----
1008 /* When no events are available, photon will call this function, working is
1009 * set to FALSE, and the gui_mch_update loop will exit. */
1010 static int
1011! exit_gui_mch_update(void *data)
1012 {
1013 *(int *)data = FALSE;
1014 return Pt_END;
1015***************
1016*** 1344,1351 ****
1017 {
1018 int working = TRUE;
1019
1020! PtAppAddWorkProc( NULL, exit_gui_mch_update, &working );
1021! while( ( working == TRUE ) && !vim_is_input_buf_full())
1022 {
1023 PtProcessEvent();
1024 }
1025--- 1344,1351 ----
1026 {
1027 int working = TRUE;
1028
1029! PtAppAddWorkProc(NULL, exit_gui_mch_update, &working);
1030! while ((working == TRUE) && !vim_is_input_buf_full())
1031 {
1032 PtProcessEvent();
1033 }
1034***************
1035*** 1356,1378 ****
1036 {
1037 is_timeout = FALSE;
1038
1039! if( wtime > 0 )
1040! PtSetResource( gui_ph_timer_timeout, Pt_ARG_TIMER_INITIAL, wtime, 0 );
1041
1042! while( 1 )
1043 {
1044 PtProcessEvent();
1045! if( input_available() )
1046 {
1047! PtSetResource( gui_ph_timer_timeout, Pt_ARG_TIMER_INITIAL, 0, 0 );
1048 return OK;
1049 }
1050! else if( is_timeout == TRUE )
1051 return FAIL;
1052 }
1053 }
1054
1055! #if defined( FEAT_BROWSE ) || defined( PROTO )
1056 /*
1057 * Put up a file requester.
1058 * Returns the selected name in allocated memory, or NULL for Cancel.
1059--- 1356,1378 ----
1060 {
1061 is_timeout = FALSE;
1062
1063! if (wtime > 0)
1064! PtSetResource(gui_ph_timer_timeout, Pt_ARG_TIMER_INITIAL, wtime, 0);
1065
1066! while (1)
1067 {
1068 PtProcessEvent();
1069! if (input_available())
1070 {
1071! PtSetResource(gui_ph_timer_timeout, Pt_ARG_TIMER_INITIAL, 0, 0);
1072 return OK;
1073 }
1074! else if (is_timeout == TRUE)
1075 return FAIL;
1076 }
1077 }
1078
1079! #if defined(FEAT_BROWSE) || defined(PROTO)
1080 /*
1081 * Put up a file requester.
1082 * Returns the selected name in allocated memory, or NULL for Cancel.
1083***************
1084*** 1398,1409 ****
1085 char_u *open_text = NULL;
1086
1087 flags = 0;
1088! memset( &file, 0, sizeof( file ) );
1089
1090! default_path = alloc( MAXPATHL + 1 + NAME_MAX + 1 );
1091! if( default_path != NULL )
1092 {
1093! if( saving == TRUE )
1094 {
1095 /* Don't need Pt_FSR_CONFIRM_EXISTING, vim will ask anyway */
1096 flags |= Pt_FSR_NO_FCHECK;
1097--- 1398,1409 ----
1098 char_u *open_text = NULL;
1099
1100 flags = 0;
1101! memset(&file, 0, sizeof(file));
1102
1103! default_path = alloc(MAXPATHL + 1 + NAME_MAX + 1);
1104! if (default_path != NULL)
1105 {
1106! if (saving == TRUE)
1107 {
1108 /* Don't need Pt_FSR_CONFIRM_EXISTING, vim will ask anyway */
1109 flags |= Pt_FSR_NO_FCHECK;
1110***************
1111*** 1411,1433 ****
1112 }
1113
1114 /* combine the directory and filename into a single path */
1115! if( initdir == NULL || *initdir == NUL )
1116 {
1117! mch_dirname( default_path, MAXPATHL );
1118 initdir = default_path;
1119 }
1120 else
1121 {
1122! STRCPY( default_path, initdir );
1123 initdir = default_path;
1124 }
1125
1126! if( default_name != NULL )
1127 {
1128! if( default_path[ STRLEN( default_path ) - 1 ] != '/' )
1129! STRCAT( default_path, "/" );
1130
1131! STRCAT( default_path, default_name );
1132 }
1133
1134 /* TODO: add a filter? */
1135--- 1411,1433 ----
1136 }
1137
1138 /* combine the directory and filename into a single path */
1139! if (initdir == NULL || *initdir == NUL)
1140 {
1141! mch_dirname(default_path, MAXPATHL);
1142 initdir = default_path;
1143 }
1144 else
1145 {
1146! STRCPY(default_path, initdir);
1147 initdir = default_path;
1148 }
1149
1150! if (default_name != NULL)
1151 {
1152! if (default_path[ STRLEN(default_path) - 1 ] != '/')
1153! STRCAT(default_path, "/");
1154
1155! STRCAT(default_path, default_name);
1156 }
1157
1158 /* TODO: add a filter? */
1159***************
1160*** 1441,1495 ****
1161 NULL,
1162 NULL,
1163 &file,
1164! flags );
1165
1166! vim_free( default_path );
1167
1168! if( file.ret == Pt_FSDIALOG_BTN1 )
1169 return vim_strsave(file.path);
1170 }
1171 return NULL;
1172 }
1173 #endif
1174
1175! #if defined( FEAT_GUI_DIALOG ) || defined( PROTO )
1176 static PtWidget_t *gui_ph_dialog_text = NULL;
1177
1178 static int
1179! gui_ph_dialog_close( int button, void *data )
1180 {
1181 PtModalCtrl_t *modal_ctrl = data;
1182 char_u *dialog_text, *vim_text;
1183
1184! if( gui_ph_dialog_text != NULL )
1185 {
1186! PtGetResource( gui_ph_dialog_text, Pt_ARG_TEXT_STRING, &dialog_text, 0 );
1187! PtGetResource( gui_ph_dialog_text, Pt_ARG_POINTER, &vim_text, 0 );
1188! STRNCPY( vim_text, dialog_text, IOSIZE - 1 );
1189 }
1190
1191! PtModalUnblock( modal_ctrl, (void *) button );
1192
1193 return Pt_TRUE;
1194 }
1195
1196 static int
1197! gui_ph_dialog_text_enter( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
1198 {
1199! if( info->reason_subtype == Pt_EDIT_ACTIVATE )
1200! gui_ph_dialog_close( 1, data );
1201 return Pt_CONTINUE;
1202 }
1203
1204 static int
1205! gui_ph_dialog_esc( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
1206 {
1207 PhKeyEvent_t *key;
1208
1209! key = PhGetData( info->event );
1210! if( ( key->key_flags & Pk_KF_Cap_Valid ) && ( key->key_cap == Pk_Escape ) )
1211 {
1212! gui_ph_dialog_close( 0, data );
1213 return Pt_CONSUME;
1214 }
1215 return Pt_PROCESS;
1216--- 1441,1495 ----
1217 NULL,
1218 NULL,
1219 &file,
1220! flags);
1221
1222! vim_free(default_path);
1223
1224! if (file.ret == Pt_FSDIALOG_BTN1)
1225 return vim_strsave(file.path);
1226 }
1227 return NULL;
1228 }
1229 #endif
1230
1231! #if defined(FEAT_GUI_DIALOG) || defined(PROTO)
1232 static PtWidget_t *gui_ph_dialog_text = NULL;
1233
1234 static int
1235! gui_ph_dialog_close(int button, void *data)
1236 {
1237 PtModalCtrl_t *modal_ctrl = data;
1238 char_u *dialog_text, *vim_text;
1239
1240! if (gui_ph_dialog_text != NULL)
1241 {
1242! PtGetResource(gui_ph_dialog_text, Pt_ARG_TEXT_STRING, &dialog_text, 0);
1243! PtGetResource(gui_ph_dialog_text, Pt_ARG_POINTER, &vim_text, 0);
1244! STRNCPY(vim_text, dialog_text, IOSIZE - 1);
1245 }
1246
1247! PtModalUnblock(modal_ctrl, (void *) button);
1248
1249 return Pt_TRUE;
1250 }
1251
1252 static int
1253! gui_ph_dialog_text_enter(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
1254 {
1255! if (info->reason_subtype == Pt_EDIT_ACTIVATE)
1256! gui_ph_dialog_close(1, data);
1257 return Pt_CONTINUE;
1258 }
1259
1260 static int
1261! gui_ph_dialog_esc(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
1262 {
1263 PhKeyEvent_t *key;
1264
1265! key = PhGetData(info->event);
1266! if ((key->key_flags & Pk_KF_Cap_Valid) && (key->key_cap == Pk_Escape))
1267 {
1268! gui_ph_dialog_close(0, data);
1269 return Pt_CONSUME;
1270 }
1271 return Pt_PROCESS;
1272***************
1273*** 1518,1557 ****
1274
1275 button_count = len = i = 0;
1276
1277! if( buttons == NULL || *buttons == NUL )
1278 return -1;
1279
1280 /* There is one less separator than buttons, so bump up the button count */
1281 button_count = 1;
1282
1283 /* Count string length and number of seperators */
1284! for( str = buttons; *str; str++ )
1285 {
1286 len++;
1287! if( *str == DLG_BUTTON_SEP )
1288 button_count++;
1289 }
1290
1291! if ( title == NULL )
1292 title = "Vim";
1293
1294! buttons_copy = alloc( len + 1 );
1295! button_array = (char_u **) alloc( button_count * sizeof( char_u * ) );
1296! if( buttons_copy != NULL && button_array != NULL )
1297 {
1298! STRCPY( buttons_copy, buttons );
1299
1300 /*
1301 * Convert DLG_BUTTON_SEP into NUL's and fill in
1302 * button_array with the pointer to each NUL terminated string
1303 */
1304 str = buttons_copy;
1305! for( i = 0; i < button_count; i++ )
1306 {
1307 button_array[ i ] = str;
1308! for( ; *str; str++ )
1309 {
1310! if( *str == DLG_BUTTON_SEP )
1311 {
1312 *str++ = NUL;
1313 break;
1314--- 1518,1557 ----
1315
1316 button_count = len = i = 0;
1317
1318! if (buttons == NULL || *buttons == NUL)
1319 return -1;
1320
1321 /* There is one less separator than buttons, so bump up the button count */
1322 button_count = 1;
1323
1324 /* Count string length and number of seperators */
1325! for (str = buttons; *str; str++)
1326 {
1327 len++;
1328! if (*str == DLG_BUTTON_SEP)
1329 button_count++;
1330 }
1331
1332! if (title == NULL)
1333 title = "Vim";
1334
1335! buttons_copy = alloc(len + 1);
1336! button_array = (char_u **) alloc(button_count * sizeof(char_u *));
1337! if (buttons_copy != NULL && button_array != NULL)
1338 {
1339! STRCPY(buttons_copy, buttons);
1340
1341 /*
1342 * Convert DLG_BUTTON_SEP into NUL's and fill in
1343 * button_array with the pointer to each NUL terminated string
1344 */
1345 str = buttons_copy;
1346! for (i = 0; i < button_count; i++)
1347 {
1348 button_array[ i ] = str;
1349! for (; *str; str++)
1350 {
1351! if (*str == DLG_BUTTON_SEP)
1352 {
1353 *str++ = NUL;
1354 break;
1355***************
1356*** 1565,1571 ****
1357 NULL,
1358 message, NULL,
1359 button_count, (const char **) button_array, NULL,
1360! default_button, 0, Pt_MODAL );
1361 #else
1362 /* Writing the dialog ourselves lets us add extra features, like
1363 * trapping the escape key and returning 0 to vim */
1364--- 1565,1571 ----
1365 NULL,
1366 message, NULL,
1367 button_count, (const char **) button_array, NULL,
1368! default_button, 0, Pt_MODAL);
1369 #else
1370 /* Writing the dialog ourselves lets us add extra features, like
1371 * trapping the escape key and returning 0 to vim */
1372***************
1373*** 1576,1607 ****
1374 PtModalCtrl_t modal_ctrl;
1375 PtDialogInfo_t di;
1376
1377! memset( &di, 0, sizeof( di ) );
1378! memset( &modal_ctrl, 0, sizeof( modal_ctrl ) );
1379
1380 n = 0;
1381! PtSetArg( &args[n++], Pt_ARG_GROUP_ROWS_COLS, 0, 0 );
1382! PtSetArg( &args[n++], Pt_ARG_WIDTH, 350, 0 );
1383! PtSetArg( &args[n++], Pt_ARG_GROUP_ORIENTATION,
1384! Pt_GROUP_VERTICAL, 0 );
1385! PtSetArg( &args[n++], Pt_ARG_GROUP_FLAGS,
1386! Pt_TRUE, Pt_GROUP_NO_KEYS | Pt_GROUP_STRETCH_HORIZONTAL );
1387! PtSetArg( &args[n++], Pt_ARG_CONTAINER_FLAGS, Pt_FALSE, Pt_TRUE );
1388! pane = PtCreateWidget( PtGroup, NULL, n, args );
1389
1390 n = 0;
1391! PtSetArg( &args[n++], Pt_ARG_TEXT_STRING, message, 0 );
1392! PtCreateWidget( PtLabel, pane, n, args );
1393
1394! if( textfield != NULL )
1395 {
1396 n = 0;
1397! PtSetArg( &args[n++], Pt_ARG_MAX_LENGTH, IOSIZE - 1, 0 );
1398! PtSetArg( &args[n++], Pt_ARG_TEXT_STRING, textfield, 0 );
1399! PtSetArg( &args[n++], Pt_ARG_POINTER, textfield, 0 );
1400! gui_ph_dialog_text = PtCreateWidget( PtText, pane, n, args );
1401! PtAddCallback( gui_ph_dialog_text, Pt_CB_ACTIVATE,
1402! gui_ph_dialog_text_enter, &modal_ctrl );
1403 }
1404
1405 di.parent = gui.vimWindow;
1406--- 1576,1607 ----
1407 PtModalCtrl_t modal_ctrl;
1408 PtDialogInfo_t di;
1409
1410! memset(&di, 0, sizeof(di));
1411! memset(&modal_ctrl, 0, sizeof(modal_ctrl));
1412
1413 n = 0;
1414! PtSetArg(&args[n++], Pt_ARG_GROUP_ROWS_COLS, 0, 0);
1415! PtSetArg(&args[n++], Pt_ARG_WIDTH, 350, 0);
1416! PtSetArg(&args[n++], Pt_ARG_GROUP_ORIENTATION,
1417! Pt_GROUP_VERTICAL, 0);
1418! PtSetArg(&args[n++], Pt_ARG_GROUP_FLAGS,
1419! Pt_TRUE, Pt_GROUP_NO_KEYS | Pt_GROUP_STRETCH_HORIZONTAL);
1420! PtSetArg(&args[n++], Pt_ARG_CONTAINER_FLAGS, Pt_FALSE, Pt_TRUE);
1421! pane = PtCreateWidget(PtGroup, NULL, n, args);
1422
1423 n = 0;
1424! PtSetArg(&args[n++], Pt_ARG_TEXT_STRING, message, 0);
1425! PtCreateWidget(PtLabel, pane, n, args);
1426
1427! if (textfield != NULL)
1428 {
1429 n = 0;
1430! PtSetArg(&args[n++], Pt_ARG_MAX_LENGTH, IOSIZE - 1, 0);
1431! PtSetArg(&args[n++], Pt_ARG_TEXT_STRING, textfield, 0);
1432! PtSetArg(&args[n++], Pt_ARG_POINTER, textfield, 0);
1433! gui_ph_dialog_text = PtCreateWidget(PtText, pane, n, args);
1434! PtAddCallback(gui_ph_dialog_text, Pt_CB_ACTIVATE,
1435! gui_ph_dialog_text_enter, &modal_ctrl);
1436 }
1437
1438 di.parent = gui.vimWindow;
1439***************
1440*** 1616,1641 ****
1441 di.callback = gui_ph_dialog_close;
1442 di.data = &modal_ctrl;
1443
1444! dialog = PtCreateDialog( &di );
1445! PtAddFilterCallback( dialog, Ph_EV_KEY,
1446! gui_ph_dialog_esc, &modal_ctrl );
1447
1448! if( gui_ph_dialog_text != NULL )
1449! PtGiveFocus( gui_ph_dialog_text, NULL );
1450
1451 /* Open dialog, block the vim window and wait for the dialog to close */
1452! PtRealizeWidget( dialog );
1453! PtMakeModal( dialog, Ph_CURSOR_NOINPUT, Ph_CURSOR_DEFAULT_COLOR );
1454! dialog_result = (int) PtModalBlock( &modal_ctrl, 0 );
1455
1456! PtDestroyWidget( dialog );
1457 gui_ph_dialog_text = NULL;
1458 }
1459 #endif
1460 }
1461
1462! vim_free( button_array );
1463! vim_free( buttons_copy );
1464
1465 return dialog_result;
1466 }
1467--- 1616,1641 ----
1468 di.callback = gui_ph_dialog_close;
1469 di.data = &modal_ctrl;
1470
1471! dialog = PtCreateDialog(&di);
1472! PtAddFilterCallback(dialog, Ph_EV_KEY,
1473! gui_ph_dialog_esc, &modal_ctrl);
1474
1475! if (gui_ph_dialog_text != NULL)
1476! PtGiveFocus(gui_ph_dialog_text, NULL);
1477
1478 /* Open dialog, block the vim window and wait for the dialog to close */
1479! PtRealizeWidget(dialog);
1480! PtMakeModal(dialog, Ph_CURSOR_NOINPUT, Ph_CURSOR_DEFAULT_COLOR);
1481! dialog_result = (int) PtModalBlock(&modal_ctrl, 0);
1482
1483! PtDestroyWidget(dialog);
1484 gui_ph_dialog_text = NULL;
1485 }
1486 #endif
1487 }
1488
1489! vim_free(button_array);
1490! vim_free(buttons_copy);
1491
1492 return dialog_result;
1493 }
1494***************
1495*** 1648,1654 ****
1496 {
1497 PhPoint_t *pos;
1498
1499! pos = PtWidgetPos( gui.vimWindow, NULL );
1500
1501 *x = pos->x;
1502 *y = pos->y;
1503--- 1648,1654 ----
1504 {
1505 PhPoint_t *pos;
1506
1507! pos = PtWidgetPos(gui.vimWindow, NULL);
1508
1509 *x = pos->x;
1510 *y = pos->y;
1511***************
1512*** 1661,1667 ****
1513 {
1514 PhPoint_t pos = { x, y };
1515
1516! PtSetResource( gui.vimWindow, Pt_ARG_POS, &pos, 0 );
1517 }
1518
1519 void
1520--- 1661,1667 ----
1521 {
1522 PhPoint_t pos = { x, y };
1523
1524! PtSetResource(gui.vimWindow, Pt_ARG_POS, &pos, 0);
1525 }
1526
1527 void
1528***************
1529*** 1677,1686 ****
1530 window_size.h += pg_margin_top + pg_margin_bottom;
1531 #endif
1532
1533! PtSetResource( gui.vimWindow, Pt_ARG_MINIMUM_DIM, &min_size, 0 );
1534! PtSetResource( gui.vimWindow, Pt_ARG_DIM, &window_size, 0 );
1535
1536! if( ! PtWidgetIsRealized( gui.vimWindow ) )
1537 gui_ph_resize_container();
1538 }
1539
1540--- 1677,1686 ----
1541 window_size.h += pg_margin_top + pg_margin_bottom;
1542 #endif
1543
1544! PtSetResource(gui.vimWindow, Pt_ARG_MINIMUM_DIM, &min_size, 0);
1545! PtSetResource(gui.vimWindow, Pt_ARG_DIM, &window_size, 0);
1546
1547! if (! PtWidgetIsRealized(gui.vimWindow))
1548 gui_ph_resize_container();
1549 }
1550
1551***************
1552*** 1693,1700 ****
1553 {
1554 PhRect_t console;
1555
1556! PhWindowQueryVisible( Ph_QUERY_WORKSPACE, 0,
1557! PhInputGroup( NULL ), &console );
1558
1559 *screen_w = console.lr.x - console.ul.x + 1;
1560 *screen_h = console.lr.y - console.ul.y + 1;
1561--- 1693,1700 ----
1562 {
1563 PhRect_t console;
1564
1565! PhWindowQueryVisible(Ph_QUERY_WORKSPACE, 0,
1566! PhInputGroup(NULL), &console);
1567
1568 *screen_w = console.lr.x - console.ul.x + 1;
1569 *screen_h = console.lr.y - console.ul.y + 1;
1570***************
1571*** 1705,1715 ****
1572 {
1573 PhWindowEvent_t event;
1574
1575! memset( &event, 0, sizeof (event) );
1576 event.event_f = Ph_WM_HIDE;
1577 event.event_state = Ph_WM_EVSTATE_HIDE;
1578! event.rid = PtWidgetRid( gui.vimWindow );
1579! PtForwardWindowEvent( &event );
1580 }
1581
1582 #if defined(FEAT_EVAL) || defined(PROTO)
1583--- 1705,1715 ----
1584 {
1585 PhWindowEvent_t event;
1586
1587! memset(&event, 0, sizeof (event));
1588 event.event_f = Ph_WM_HIDE;
1589 event.event_state = Ph_WM_EVSTATE_HIDE;
1590! event.rid = PtWidgetRid(gui.vimWindow);
1591! PtForwardWindowEvent(&event);
1592 }
1593
1594 #if defined(FEAT_EVAL) || defined(PROTO)
1595***************
1596*** 1721,1731 ****
1597 {
1598 PhWindowEvent_t event;
1599
1600! memset( &event, 0, sizeof (event) );
1601 event.event_f = Ph_WM_TOFRONT;
1602 event.event_state = Ph_WM_EVSTATE_FFRONT;
1603! event.rid = PtWidgetRid( gui.vimWindow );
1604! PtForwardWindowEvent( &event );
1605 }
1606 #endif
1607
1608--- 1721,1731 ----
1609 {
1610 PhWindowEvent_t event;
1611
1612! memset(&event, 0, sizeof (event));
1613 event.event_f = Ph_WM_TOFRONT;
1614 event.event_state = Ph_WM_EVSTATE_FFRONT;
1615! event.rid = PtWidgetRid(gui.vimWindow);
1616! PtForwardWindowEvent(&event);
1617 }
1618 #endif
1619
1620***************
1621*** 1733,1741 ****
1622 gui_mch_settitle(char_u *title, char_u *icon)
1623 {
1624 #ifdef USE_PANEL_GROUP
1625! gui_ph_pg_set_buffer_num( curwin->w_buffer->b_fnum );
1626 #endif
1627! PtSetResource( gui.vimWindow, Pt_ARG_WINDOW_TITLE, title, 0 );
1628 /* Not sure what to do with the icon text, set balloon text somehow? */
1629 }
1630
1631--- 1733,1741 ----
1632 gui_mch_settitle(char_u *title, char_u *icon)
1633 {
1634 #ifdef USE_PANEL_GROUP
1635! gui_ph_pg_set_buffer_num(curwin->w_buffer->b_fnum);
1636 #endif
1637! PtSetResource(gui.vimWindow, Pt_ARG_WINDOW_TITLE, title, 0);
1638 /* Not sure what to do with the icon text, set balloon text somehow? */
1639 }
1640
1641***************
1642*** 1748,1757 ****
1643 int n = 0;
1644 PtArg_t args[3];
1645
1646! PtSetArg( &args[ n++ ], Pt_ARG_MAXIMUM, max, 0 );
1647! PtSetArg( &args[ n++ ], Pt_ARG_SLIDER_SIZE, size, 0 );
1648! PtSetArg( &args[ n++ ], Pt_ARG_GAUGE_VALUE, val, 0 );
1649! PtSetResources( sb->id, n, args );
1650 }
1651
1652 void
1653--- 1748,1757 ----
1654 int n = 0;
1655 PtArg_t args[3];
1656
1657! PtSetArg(&args[ n++ ], Pt_ARG_MAXIMUM, max, 0);
1658! PtSetArg(&args[ n++ ], Pt_ARG_SLIDER_SIZE, size, 0);
1659! PtSetArg(&args[ n++ ], Pt_ARG_GAUGE_VALUE, val, 0);
1660! PtSetResources(sb->id, n, args);
1661 }
1662
1663 void
1664***************
1665*** 1759,1765 ****
1666 {
1667 PhArea_t area = {{ x, y }, { w, h }};
1668
1669! PtSetResource( sb->id, Pt_ARG_AREA, &area, 0 );
1670 }
1671
1672 void
1673--- 1759,1765 ----
1674 {
1675 PhArea_t area = {{ x, y }, { w, h }};
1676
1677! PtSetResource(sb->id, Pt_ARG_AREA, &area, 0);
1678 }
1679
1680 void
1681***************
1682*** 1775,1786 ****
1683 *
1684 * Also, don't let the scrollbar get focus
1685 */
1686! PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_DELAY_REALIZE,
1687! Pt_DELAY_REALIZE | Pt_GETS_FOCUS );
1688! PtSetArg( &args[ n++ ], Pt_ARG_SCROLLBAR_FLAGS, Pt_SCROLLBAR_SHOW_ARROWS, 0);
1689 #if 0
1690 /* Don't need this anchoring for the scrollbars */
1691! if( orient == SBAR_HORIZ )
1692 {
1693 anchor_flags = Pt_BOTTOM_ANCHORED_BOTTOM |
1694 Pt_LEFT_ANCHORED_LEFT | Pt_RIGHT_ANCHORED_RIGHT;
1695--- 1775,1786 ----
1696 *
1697 * Also, don't let the scrollbar get focus
1698 */
1699! PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_DELAY_REALIZE,
1700! Pt_DELAY_REALIZE | Pt_GETS_FOCUS);
1701! PtSetArg(&args[ n++ ], Pt_ARG_SCROLLBAR_FLAGS, Pt_SCROLLBAR_SHOW_ARROWS, 0);
1702 #if 0
1703 /* Don't need this anchoring for the scrollbars */
1704! if (orient == SBAR_HORIZ)
1705 {
1706 anchor_flags = Pt_BOTTOM_ANCHORED_BOTTOM |
1707 Pt_LEFT_ANCHORED_LEFT | Pt_RIGHT_ANCHORED_RIGHT;
1708***************
1709*** 1788,1827 ****
1710 else
1711 {
1712 anchor_flags = Pt_BOTTOM_ANCHORED_BOTTOM | Pt_TOP_ANCHORED_TOP;
1713! if( sb->wp != NULL )
1714 {
1715! if( sb == &sb->wp->w_scrollbars[ SBAR_LEFT ] )
1716 anchor_flags |= Pt_LEFT_ANCHORED_LEFT;
1717 else
1718 anchor_flags |= Pt_RIGHT_ANCHORED_RIGHT;
1719 }
1720 }
1721! PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS, anchor_flags, Pt_IS_ANCHORED );
1722 #endif
1723! PtSetArg( &args[ n++ ], Pt_ARG_ORIENTATION,
1724! (orient == SBAR_HORIZ) ? Pt_HORIZONTAL : Pt_VERTICAL, 0 );
1725 #ifdef USE_PANEL_GROUP
1726! sb->id = PtCreateWidget( PtScrollbar, gui.vimPanelGroup, n, args );
1727 #else
1728! sb->id = PtCreateWidget( PtScrollbar, gui.vimContainer, n, args );
1729 #endif
1730
1731! PtAddCallback( sb->id, Pt_CB_SCROLLBAR_MOVE, gui_ph_handle_scrollbar, sb );
1732 }
1733
1734 void
1735 gui_mch_enable_scrollbar(scrollbar_T *sb, int flag)
1736 {
1737! if( flag != 0 )
1738! PtRealizeWidget( sb->id );
1739 else
1740! PtUnrealizeWidget( sb->id );
1741 }
1742
1743 void
1744 gui_mch_destroy_scrollbar(scrollbar_T *sb)
1745 {
1746! PtDestroyWidget( sb->id );
1747 sb->id = NULL;
1748 }
1749
1750--- 1788,1827 ----
1751 else
1752 {
1753 anchor_flags = Pt_BOTTOM_ANCHORED_BOTTOM | Pt_TOP_ANCHORED_TOP;
1754! if (sb->wp != NULL)
1755 {
1756! if (sb == &sb->wp->w_scrollbars[ SBAR_LEFT ])
1757 anchor_flags |= Pt_LEFT_ANCHORED_LEFT;
1758 else
1759 anchor_flags |= Pt_RIGHT_ANCHORED_RIGHT;
1760 }
1761 }
1762! PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS, anchor_flags, Pt_IS_ANCHORED);
1763 #endif
1764! PtSetArg(&args[ n++ ], Pt_ARG_ORIENTATION,
1765! (orient == SBAR_HORIZ) ? Pt_HORIZONTAL : Pt_VERTICAL, 0);
1766 #ifdef USE_PANEL_GROUP
1767! sb->id = PtCreateWidget(PtScrollbar, gui.vimPanelGroup, n, args);
1768 #else
1769! sb->id = PtCreateWidget(PtScrollbar, gui.vimContainer, n, args);
1770 #endif
1771
1772! PtAddCallback(sb->id, Pt_CB_SCROLLBAR_MOVE, gui_ph_handle_scrollbar, sb);
1773 }
1774
1775 void
1776 gui_mch_enable_scrollbar(scrollbar_T *sb, int flag)
1777 {
1778! if (flag != 0)
1779! PtRealizeWidget(sb->id);
1780 else
1781! PtUnrealizeWidget(sb->id);
1782 }
1783
1784 void
1785 gui_mch_destroy_scrollbar(scrollbar_T *sb)
1786 {
1787! PtDestroyWidget(sb->id);
1788 sb->id = NULL;
1789 }
1790
1791***************
1792*** 1866,1873 ****
1793 return;
1794
1795 if (shape == MSHAPE_HIDE || gui.pointer_hidden)
1796! PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_TYPE, Ph_CURSOR_NONE,
1797! 0 );
1798 else
1799 {
1800 if (shape >= MSHAPE_NUMBERED)
1801--- 1866,1873 ----
1802 return;
1803
1804 if (shape == MSHAPE_HIDE || gui.pointer_hidden)
1805! PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_TYPE, Ph_CURSOR_NONE,
1806! 0);
1807 else
1808 {
1809 if (shape >= MSHAPE_NUMBERED)
1810***************
1811*** 1875,1881 ****
1812 else
1813 id = mshape_ids[shape];
1814
1815! PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_TYPE, id, 0 );
1816 }
1817 if (shape != MSHAPE_HIDE)
1818 last_shape = shape;
1819--- 1875,1881 ----
1820 else
1821 id = mshape_ids[shape];
1822
1823! PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_TYPE, id, 0);
1824 }
1825 if (shape != MSHAPE_HIDE)
1826 last_shape = shape;
1827***************
1828*** 1885,1903 ****
1829 void
1830 gui_mch_mousehide(int hide)
1831 {
1832! if( gui.pointer_hidden != hide )
1833 {
1834 gui.pointer_hidden = hide;
1835 #ifdef FEAT_MOUSESHAPE
1836! if( hide )
1837! PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_TYPE,
1838! Ph_CURSOR_NONE, 0 );
1839 else
1840! mch_set_mouse_shape( last_shape );
1841 #else
1842! PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_TYPE,
1843! ( hide == MOUSE_SHOW ) ? GUI_PH_MOUSE_TYPE : Ph_CURSOR_NONE,
1844! 0 );
1845 #endif
1846 }
1847 }
1848--- 1885,1903 ----
1849 void
1850 gui_mch_mousehide(int hide)
1851 {
1852! if (gui.pointer_hidden != hide)
1853 {
1854 gui.pointer_hidden = hide;
1855 #ifdef FEAT_MOUSESHAPE
1856! if (hide)
1857! PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_TYPE,
1858! Ph_CURSOR_NONE, 0);
1859 else
1860! mch_set_mouse_shape(last_shape);
1861 #else
1862! PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_TYPE,
1863! (hide == MOUSE_SHOW) ? GUI_PH_MOUSE_TYPE : Ph_CURSOR_NONE,
1864! 0);
1865 #endif
1866 }
1867 }
1868***************
1869*** 1910,1917 ****
1870
1871 /* FIXME: does this return the correct position,
1872 * with respect to the border? */
1873! PhQueryCursor( PhInputGroup( NULL ), &info );
1874! PtGetAbsPosition( gui.vimTextArea , &ix, &iy );
1875
1876 *x = info.pos.x - ix;
1877 *y = info.pos.y - iy;
1878--- 1910,1917 ----
1879
1880 /* FIXME: does this return the correct position,
1881 * with respect to the border? */
1882! PhQueryCursor(PhInputGroup(NULL), &info);
1883! PtGetAbsPosition(gui.vimTextArea , &ix, &iy);
1884
1885 *x = info.pos.x - ix;
1886 *y = info.pos.y - iy;
1887***************
1888*** 1922,1930 ****
1889 {
1890 short abs_x, abs_y;
1891
1892! PtGetAbsPosition( gui.vimTextArea, &abs_x, &abs_y );
1893 /* Add the border offset? */
1894! PhMoveCursorAbs( PhInputGroup( NULL ), abs_x + x, abs_y + y );
1895 }
1896
1897 /****************************************************************************/
1898--- 1922,1930 ----
1899 {
1900 short abs_x, abs_y;
1901
1902! PtGetAbsPosition(gui.vimTextArea, &abs_x, &abs_y);
1903 /* Add the border offset? */
1904! PhMoveCursorAbs(PhInputGroup(NULL), abs_x + x, abs_y + y);
1905 }
1906
1907 /****************************************************************************/
1908***************
1909*** 1952,1974 ****
1910 color_diff = gui_get_lightness(gui_ph_mouse_color)
1911 - gui_get_lightness(gui.back_pixel);
1912
1913! if( abs( color_diff ) < 64 )
1914 {
1915 short r, g, b;
1916 /* not a great algorithm... */
1917! r = PgRedValue( gui_ph_mouse_color ) ^ 255;
1918! g = PgGreenValue( gui_ph_mouse_color ) ^ 255;
1919! b = PgBlueValue( gui_ph_mouse_color ) ^ 255;
1920
1921 #ifndef FEAT_MOUSESHAPE
1922! gui_ph_mouse_color = PgRGB( r, g, b );
1923! PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_COLOR,
1924! gui_ph_mouse_color, 0 );
1925 #endif
1926 }
1927 #endif
1928
1929! PtSetResource( gui.vimTextArea, Pt_ARG_FILL_COLOR, gui.back_pixel, 0 );
1930 }
1931
1932 static int
1933--- 1952,1974 ----
1934 color_diff = gui_get_lightness(gui_ph_mouse_color)
1935 - gui_get_lightness(gui.back_pixel);
1936
1937! if (abs(color_diff) < 64)
1938 {
1939 short r, g, b;
1940 /* not a great algorithm... */
1941! r = PgRedValue(gui_ph_mouse_color) ^ 255;
1942! g = PgGreenValue(gui_ph_mouse_color) ^ 255;
1943! b = PgBlueValue(gui_ph_mouse_color) ^ 255;
1944
1945 #ifndef FEAT_MOUSESHAPE
1946! gui_ph_mouse_color = PgRGB(r, g, b);
1947! PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_COLOR,
1948! gui_ph_mouse_color, 0);
1949 #endif
1950 }
1951 #endif
1952
1953! PtSetResource(gui.vimTextArea, Pt_ARG_FILL_COLOR, gui.back_pixel, 0);
1954 }
1955
1956 static int
1957***************
1958*** 2058,2076 ****
1959 };
1960
1961 /* is name #rrggbb format? */
1962! if( name[0] == '#' && STRLEN( name ) == 7 )
1963 {
1964! r = hex_digit( name[1] ) * 16 + hex_digit( name[2] );
1965! g = hex_digit( name[3] ) * 16 + hex_digit( name[4] );
1966! b = hex_digit( name[5] ) * 16 + hex_digit( name[6] );
1967! if( r < 0 || g < 0 || b < 0 )
1968 return INVALCOLOR;
1969 return RGB(r, g, b);
1970 }
1971
1972! for( i = 0; i < ARRAY_LENGTH( table ); i++ )
1973 {
1974! if( STRICMP( name, table[i].name ) == 0 )
1975 return table[i].colour;
1976 }
1977
1978--- 2058,2076 ----
1979 };
1980
1981 /* is name #rrggbb format? */
1982! if (name[0] == '#' && STRLEN(name) == 7)
1983 {
1984! r = hex_digit(name[1]) * 16 + hex_digit(name[2]);
1985! g = hex_digit(name[3]) * 16 + hex_digit(name[4]);
1986! b = hex_digit(name[5]) * 16 + hex_digit(name[6]);
1987! if (r < 0 || g < 0 || b < 0)
1988 return INVALCOLOR;
1989 return RGB(r, g, b);
1990 }
1991
1992! for (i = 0; i < ARRAY_LENGTH(table); i++)
1993 {
1994! if (STRICMP(name, table[i].name) == 0)
1995 return table[i].colour;
1996 }
1997
1998***************
1999*** 2129,2141 ****
2000 void
2001 gui_mch_set_fg_color(guicolor_T color)
2002 {
2003! PgSetTextColor( color );
2004 }
2005
2006 void
2007 gui_mch_set_bg_color(guicolor_T color)
2008 {
2009! PgSetFillColor( color );
2010 }
2011
2012 void
2013--- 2129,2141 ----
2014 void
2015 gui_mch_set_fg_color(guicolor_T color)
2016 {
2017! PgSetTextColor(color);
2018 }
2019
2020 void
2021 gui_mch_set_bg_color(guicolor_T color)
2022 {
2023! PgSetFillColor(color);
2024 }
2025
2026 void
2027***************
2028*** 2148,2168 ****
2029 {
2030 PhRect_t rect;
2031
2032! rect.ul.x = FILL_X( col );
2033! rect.ul.y = FILL_Y( row );
2034
2035 /* FIXME: This has an off by one pixel problem */
2036 rect.lr.x = rect.ul.x + nc * gui.char_width;
2037 rect.lr.y = rect.ul.y + nr * gui.char_height;
2038! if( nc > 0 )
2039 rect.lr.x -= 1;
2040! if( nr > 0 )
2041 rect.lr.y -= 1;
2042
2043 DRAW_START;
2044! PgSetDrawMode( Pg_DrawModeDSTINVERT );
2045! PgDrawRect( &rect, Pg_DRAW_FILL );
2046! PgSetDrawMode( Pg_DrawModeSRCCOPY );
2047 DRAW_END;
2048 }
2049
2050--- 2148,2168 ----
2051 {
2052 PhRect_t rect;
2053
2054! rect.ul.x = FILL_X(col);
2055! rect.ul.y = FILL_Y(row);
2056
2057 /* FIXME: This has an off by one pixel problem */
2058 rect.lr.x = rect.ul.x + nc * gui.char_width;
2059 rect.lr.y = rect.ul.y + nr * gui.char_height;
2060! if (nc > 0)
2061 rect.lr.x -= 1;
2062! if (nr > 0)
2063 rect.lr.y -= 1;
2064
2065 DRAW_START;
2066! PgSetDrawMode(Pg_DrawModeDSTINVERT);
2067! PgDrawRect(&rect, Pg_DRAW_FILL);
2068! PgSetDrawMode(Pg_DrawModeSRCCOPY);
2069 DRAW_END;
2070 }
2071
2072***************
2073*** 2170,2182 ****
2074 gui_mch_clear_block(int row1, int col1, int row2, int col2)
2075 {
2076 PhRect_t block = {
2077! { FILL_X( col1 ), FILL_Y( row1 ) },
2078! { FILL_X( col2 + 1 ) - 1, FILL_Y( row2 + 1 ) - 1}
2079 };
2080
2081 DRAW_START;
2082! gui_mch_set_bg_color( gui.back_pixel );
2083! PgDrawRect( &block, Pg_DRAW_FILL );
2084 DRAW_END;
2085 }
2086
2087--- 2170,2182 ----
2088 gui_mch_clear_block(int row1, int col1, int row2, int col2)
2089 {
2090 PhRect_t block = {
2091! { FILL_X(col1), FILL_Y(row1) },
2092! { FILL_X(col2 + 1) - 1, FILL_Y(row2 + 1) - 1}
2093 };
2094
2095 DRAW_START;
2096! gui_mch_set_bg_color(gui.back_pixel);
2097! PgDrawRect(&block, Pg_DRAW_FILL);
2098 DRAW_END;
2099 }
2100
2101***************
2102*** 2189,2200 ****
2103 Rows * gui.char_height + gui.border_width - 1 }
2104 };
2105
2106! if( is_ignore_draw == TRUE )
2107 return;
2108
2109 DRAW_START;
2110! gui_mch_set_bg_color( gui.back_pixel );
2111! PgDrawRect( &text_rect, Pg_DRAW_FILL );
2112 DRAW_END;
2113 }
2114
2115--- 2189,2200 ----
2116 Rows * gui.char_height + gui.border_width - 1 }
2117 };
2118
2119! if (is_ignore_draw == TRUE)
2120 return;
2121
2122 DRAW_START;
2123! gui_mch_set_bg_color(gui.back_pixel);
2124! PgDrawRect(&text_rect, Pg_DRAW_FILL);
2125 DRAW_END;
2126 }
2127
2128***************
2129*** 2204,2231 ****
2130 PhRect_t rect;
2131 PhPoint_t delta;
2132
2133! rect.ul.x = FILL_X( gui.scroll_region_left );
2134! rect.ul.y = FILL_Y( row + num_lines );
2135
2136! rect.lr.x = FILL_X( gui.scroll_region_right + 1 ) - 1;
2137! rect.lr.y = FILL_Y( gui.scroll_region_bot + 1) - 1;
2138
2139! PtWidgetOffset( gui.vimTextArea, &gui_ph_raw_offset );
2140! PhTranslatePoint( &gui_ph_raw_offset, PtWidgetPos(gui.vimTextArea, NULL));
2141! PhTranslateRect( &rect, &gui_ph_raw_offset );
2142
2143 delta.x = 0;
2144 delta.y = -num_lines * gui.char_height;
2145
2146 PgFlush();
2147
2148! PhBlit( PtWidgetRid( PtFindDisjoint( gui.vimTextArea ) ), &rect, &delta );
2149
2150 gui_clear_block(
2151 gui.scroll_region_bot - num_lines + 1,
2152 gui.scroll_region_left,
2153 gui.scroll_region_bot,
2154! gui.scroll_region_right );
2155 }
2156
2157 void
2158--- 2204,2231 ----
2159 PhRect_t rect;
2160 PhPoint_t delta;
2161
2162! rect.ul.x = FILL_X(gui.scroll_region_left);
2163! rect.ul.y = FILL_Y(row + num_lines);
2164
2165! rect.lr.x = FILL_X(gui.scroll_region_right + 1) - 1;
2166! rect.lr.y = FILL_Y(gui.scroll_region_bot + 1) - 1;
2167
2168! PtWidgetOffset(gui.vimTextArea, &gui_ph_raw_offset);
2169! PhTranslatePoint(&gui_ph_raw_offset, PtWidgetPos(gui.vimTextArea, NULL));
2170! PhTranslateRect(&rect, &gui_ph_raw_offset);
2171
2172 delta.x = 0;
2173 delta.y = -num_lines * gui.char_height;
2174
2175 PgFlush();
2176
2177! PhBlit(PtWidgetRid(PtFindDisjoint(gui.vimTextArea)), &rect, &delta);
2178
2179 gui_clear_block(
2180 gui.scroll_region_bot - num_lines + 1,
2181 gui.scroll_region_left,
2182 gui.scroll_region_bot,
2183! gui.scroll_region_right);
2184 }
2185
2186 void
2187***************
2188*** 2234,2258 ****
2189 PhRect_t rect;
2190 PhPoint_t delta;
2191
2192! rect.ul.x = FILL_X( gui.scroll_region_left );
2193! rect.ul.y = FILL_Y( row );
2194
2195! rect.lr.x = FILL_X( gui.scroll_region_right + 1 ) - 1;
2196! rect.lr.y = FILL_Y( gui.scroll_region_bot - num_lines + 1 ) - 1;
2197
2198! PtWidgetOffset( gui.vimTextArea, &gui_ph_raw_offset );
2199! PhTranslatePoint( &gui_ph_raw_offset, PtWidgetPos( gui.vimTextArea, NULL ) );
2200! PhTranslateRect( &rect, &gui_ph_raw_offset );
2201
2202 delta.x = 0;
2203 delta.y = num_lines * gui.char_height;
2204
2205 PgFlush();
2206
2207! PhBlit( PtWidgetRid( PtFindDisjoint( gui.vimTextArea ) ) , &rect, &delta );
2208
2209! gui_clear_block( row, gui.scroll_region_left,
2210! row + num_lines - 1, gui.scroll_region_right );
2211 }
2212
2213 void
2214--- 2234,2258 ----
2215 PhRect_t rect;
2216 PhPoint_t delta;
2217
2218! rect.ul.x = FILL_X(gui.scroll_region_left);
2219! rect.ul.y = FILL_Y(row);
2220
2221! rect.lr.x = FILL_X(gui.scroll_region_right + 1) - 1;
2222! rect.lr.y = FILL_Y(gui.scroll_region_bot - num_lines + 1) - 1;
2223
2224! PtWidgetOffset(gui.vimTextArea, &gui_ph_raw_offset);
2225! PhTranslatePoint(&gui_ph_raw_offset, PtWidgetPos(gui.vimTextArea, NULL));
2226! PhTranslateRect(&rect, &gui_ph_raw_offset);
2227
2228 delta.x = 0;
2229 delta.y = num_lines * gui.char_height;
2230
2231 PgFlush();
2232
2233! PhBlit(PtWidgetRid(PtFindDisjoint(gui.vimTextArea)) , &rect, &delta);
2234
2235! gui_clear_block(row, gui.scroll_region_left,
2236! row + num_lines - 1, gui.scroll_region_right);
2237 }
2238
2239 void
2240***************
2241*** 2261,2297 ****
2242 static char *utf8_buffer = NULL;
2243 static int utf8_len = 0;
2244
2245! PhPoint_t pos = { TEXT_X( col ), TEXT_Y( row ) };
2246 PhRect_t rect;
2247
2248! if( is_ignore_draw == TRUE )
2249 return;
2250
2251 DRAW_START;
2252
2253! if( !( flags & DRAW_TRANSP ) )
2254 {
2255 PgDrawIRect(
2256! FILL_X( col ), FILL_Y( row ),
2257! FILL_X( col + len ) - 1, FILL_Y( row + 1 ) - 1,
2258! Pg_DRAW_FILL );
2259 }
2260
2261! if( flags & DRAW_UNDERL )
2262! PgSetUnderline( gui.norm_pixel, Pg_TRANSPARENT, 0 );
2263
2264! if( charset_translate != NULL
2265 #ifdef FEAT_MBYTE
2266 && enc_utf8 == 0
2267 #endif
2268! )
2269 {
2270 int src_taken, dst_made;
2271
2272 /* Use a static buffer to avoid large amounts of de/allocations */
2273! if( utf8_len < len )
2274 {
2275! utf8_buffer = realloc( utf8_buffer, len * MB_LEN_MAX );
2276 utf8_len = len;
2277 }
2278
2279--- 2261,2297 ----
2280 static char *utf8_buffer = NULL;
2281 static int utf8_len = 0;
2282
2283! PhPoint_t pos = { TEXT_X(col), TEXT_Y(row) };
2284 PhRect_t rect;
2285
2286! if (is_ignore_draw == TRUE)
2287 return;
2288
2289 DRAW_START;
2290
2291! if (!(flags & DRAW_TRANSP))
2292 {
2293 PgDrawIRect(
2294! FILL_X(col), FILL_Y(row),
2295! FILL_X(col + len) - 1, FILL_Y(row + 1) - 1,
2296! Pg_DRAW_FILL);
2297 }
2298
2299! if (flags & DRAW_UNDERL)
2300! PgSetUnderline(gui.norm_pixel, Pg_TRANSPARENT, 0);
2301
2302! if (charset_translate != NULL
2303 #ifdef FEAT_MBYTE
2304 && enc_utf8 == 0
2305 #endif
2306! )
2307 {
2308 int src_taken, dst_made;
2309
2310 /* Use a static buffer to avoid large amounts of de/allocations */
2311! if (utf8_len < len)
2312 {
2313! utf8_buffer = realloc(utf8_buffer, len * MB_LEN_MAX);
2314 utf8_len = len;
2315 }
2316
2317***************
2318*** 2302,2337 ****
2319 &src_taken,
2320 utf8_buffer,
2321 utf8_len,
2322! &dst_made );
2323 s = utf8_buffer;
2324 len = dst_made;
2325 }
2326
2327! PgDrawText( s, len, &pos, 0 );
2328
2329! if( flags & DRAW_BOLD )
2330 {
2331 /* FIXME: try and only calculate these values once... */
2332! rect.ul.x = FILL_X( col ) + 1;
2333! rect.ul.y = FILL_Y( row );
2334! rect.lr.x = FILL_X( col + len ) - 1;
2335! rect.lr.y = FILL_Y( row + 1) - 1;
2336! /* PgSetUserClip( NULL ) causes the scrollbar to not redraw... */
2337 #if 0
2338 pos.x++;
2339
2340! PgSetUserClip( &rect );
2341! PgDrawText( s, len, &pos, 0 );
2342! PgSetUserClip( NULL );
2343 #else
2344! rect.lr.y -= ( p_linespace + 1 ) / 2;
2345 /* XXX: DrawTextArea doesn't work with phditto */
2346! PgDrawTextArea( s, len, &rect, Pg_TEXT_BOTTOM );
2347 #endif
2348 }
2349
2350! if( flags & DRAW_UNDERL )
2351! PgSetUnderline( Pg_TRANSPARENT, Pg_TRANSPARENT, 0 );
2352
2353 DRAW_END;
2354 }
2355--- 2302,2337 ----
2356 &src_taken,
2357 utf8_buffer,
2358 utf8_len,
2359! &dst_made);
2360 s = utf8_buffer;
2361 len = dst_made;
2362 }
2363
2364! PgDrawText(s, len, &pos, 0);
2365
2366! if (flags & DRAW_BOLD)
2367 {
2368 /* FIXME: try and only calculate these values once... */
2369! rect.ul.x = FILL_X(col) + 1;
2370! rect.ul.y = FILL_Y(row);
2371! rect.lr.x = FILL_X(col + len) - 1;
2372! rect.lr.y = FILL_Y(row + 1) - 1;
2373! /* PgSetUserClip(NULL) causes the scrollbar to not redraw... */
2374 #if 0
2375 pos.x++;
2376
2377! PgSetUserClip(&rect);
2378! PgDrawText(s, len, &pos, 0);
2379! PgSetUserClip(NULL);
2380 #else
2381! rect.lr.y -= (p_linespace + 1) / 2;
2382 /* XXX: DrawTextArea doesn't work with phditto */
2383! PgDrawTextArea(s, len, &rect, Pg_TEXT_BOTTOM);
2384 #endif
2385 }
2386
2387! if (flags & DRAW_UNDERL)
2388! PgSetUnderline(Pg_TRANSPARENT, Pg_TRANSPARENT, 0);
2389
2390 DRAW_END;
2391 }
2392***************
2393*** 2346,2359 ****
2394
2395 /* FIXME: Double width characters */
2396
2397! r.ul.x = FILL_X( gui.col );
2398! r.ul.y = FILL_Y( gui.row );
2399 r.lr.x = r.ul.x + gui.char_width - 1;
2400 r.lr.y = r.ul.y + gui.char_height - 1;
2401
2402 DRAW_START;
2403! PgSetStrokeColor( color );
2404! PgDrawRect( &r, Pg_DRAW_STROKE );
2405 DRAW_END;
2406 }
2407
2408--- 2346,2359 ----
2409
2410 /* FIXME: Double width characters */
2411
2412! r.ul.x = FILL_X(gui.col);
2413! r.ul.y = FILL_Y(gui.row);
2414 r.lr.x = r.ul.x + gui.char_width - 1;
2415 r.lr.y = r.ul.y + gui.char_height - 1;
2416
2417 DRAW_START;
2418! PgSetStrokeColor(color);
2419! PgDrawRect(&r, Pg_DRAW_STROKE);
2420 DRAW_END;
2421 }
2422
2423***************
2424*** 2362,2375 ****
2425 {
2426 PhRect_t r;
2427
2428! r.ul.x = FILL_X( gui.col );
2429! r.ul.y = FILL_Y( gui.row ) + gui.char_height - h;
2430 r.lr.x = r.ul.x + w - 1;
2431 r.lr.y = r.ul.y + h - 1;
2432
2433 DRAW_START;
2434! gui_mch_set_bg_color( color );
2435! PgDrawRect( &r, Pg_DRAW_FILL );
2436 DRAW_END;
2437 }
2438
2439--- 2362,2375 ----
2440 {
2441 PhRect_t r;
2442
2443! r.ul.x = FILL_X(gui.col);
2444! r.ul.y = FILL_Y(gui.row) + gui.char_height - h;
2445 r.lr.x = r.ul.x + w - 1;
2446 r.lr.y = r.ul.y + h - 1;
2447
2448 DRAW_START;
2449! gui_mch_set_bg_color(color);
2450! PgDrawRect(&r, Pg_DRAW_FILL);
2451 DRAW_END;
2452 }
2453
2454***************
2455*** 2385,2394 ****
2456 gui_mch_start_blink(void)
2457 {
2458 /* Only turn on the timer on if none of the times are zero */
2459! if( blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
2460 {
2461! PtSetResource( gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL,
2462! blink_waittime, 0 );
2463 blink_state = BLINK_ON;
2464 gui_update_cursor(TRUE, FALSE);
2465 }
2466--- 2385,2394 ----
2467 gui_mch_start_blink(void)
2468 {
2469 /* Only turn on the timer on if none of the times are zero */
2470! if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
2471 {
2472! PtSetResource(gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL,
2473! blink_waittime, 0);
2474 blink_state = BLINK_ON;
2475 gui_update_cursor(TRUE, FALSE);
2476 }
2477***************
2478*** 2397,2405 ****
2479 void
2480 gui_mch_stop_blink(void)
2481 {
2482! PtSetResource( gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL, 0, 0 );
2483
2484! if( blink_state == BLINK_OFF )
2485 gui_update_cursor(TRUE, FALSE);
2486
2487 blink_state = BLINK_NONE;
2488--- 2397,2405 ----
2489 void
2490 gui_mch_stop_blink(void)
2491 {
2492! PtSetResource(gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL, 0, 0);
2493
2494! if (blink_state == BLINK_OFF)
2495 gui_update_cursor(TRUE, FALSE);
2496
2497 blink_state = BLINK_NONE;
2498***************
2499*** 2417,2431 ****
2500 void
2501 gui_mch_flash(int msec)
2502 {
2503! PgSetFillXORColor( Pg_BLACK, Pg_WHITE );
2504! PgSetDrawMode( Pg_DRAWMODE_XOR );
2505 gui_mch_clear_all();
2506 gui_mch_flush();
2507
2508! ui_delay( (long) msec, TRUE );
2509
2510 gui_mch_clear_all();
2511! PgSetDrawMode( Pg_DRAWMODE_OPAQUE );
2512 gui_mch_flush();
2513 }
2514
2515--- 2417,2431 ----
2516 void
2517 gui_mch_flash(int msec)
2518 {
2519! PgSetFillXORColor(Pg_BLACK, Pg_WHITE);
2520! PgSetDrawMode(Pg_DRAWMODE_XOR);
2521 gui_mch_clear_all();
2522 gui_mch_flush();
2523
2524! ui_delay((long) msec, TRUE);
2525
2526 gui_mch_clear_all();
2527! PgSetDrawMode(Pg_DRAWMODE_OPAQUE);
2528 gui_mch_flush();
2529 }
2530
2531***************
2532*** 2440,2446 ****
2533 {
2534 PhArea_t area = {{x, y}, {w, h}};
2535
2536! PtSetResource( gui.vimTextArea, Pt_ARG_AREA, &area, 0 );
2537 }
2538
2539 int
2540--- 2440,2446 ----
2541 {
2542 PhArea_t area = {{x, y}, {w, h}};
2543
2544! PtSetResource(gui.vimTextArea, Pt_ARG_AREA, &area, 0);
2545 }
2546
2547 int
2548***************
2549*** 2496,2514 ****
2550 };
2551
2552 static PhImage_t *
2553! gui_ph_toolbar_load_icon( char_u *iconfile )
2554 {
2555 static PhImage_t external_icon;
2556 PhImage_t *temp_phi = NULL;
2557
2558! temp_phi = PxLoadImage( iconfile, NULL );
2559! if( temp_phi != NULL )
2560 {
2561 /* The label widget will free the image/palette/etc. for us when
2562 * it's destroyed */
2563 temp_phi->flags |= Ph_RELEASE_IMAGE_ALL;
2564! memcpy( &external_icon, temp_phi, sizeof( external_icon ) );
2565! free( temp_phi );
2566
2567 temp_phi = &external_icon;
2568 }
2569--- 2496,2514 ----
2570 };
2571
2572 static PhImage_t *
2573! gui_ph_toolbar_load_icon(char_u *iconfile)
2574 {
2575 static PhImage_t external_icon;
2576 PhImage_t *temp_phi = NULL;
2577
2578! temp_phi = PxLoadImage(iconfile, NULL);
2579! if (temp_phi != NULL)
2580 {
2581 /* The label widget will free the image/palette/etc. for us when
2582 * it's destroyed */
2583 temp_phi->flags |= Ph_RELEASE_IMAGE_ALL;
2584! memcpy(&external_icon, temp_phi, sizeof(external_icon));
2585! free(temp_phi);
2586
2587 temp_phi = &external_icon;
2588 }
2589***************
2590*** 2523,2551 ****
2591 * PhImage_t are copied, and the original PhImage_t aren't needed anymore).
2592 */
2593 static PhImage_t *
2594! gui_ph_toolbar_find_icon( vimmenu_T *menu )
2595 {
2596 char_u full_pathname[ MAXPATHL + 1 ];
2597 PhImage_t *icon = NULL;
2598
2599! if( menu->icon_builtin == FALSE )
2600 {
2601! if( menu->iconfile != NULL )
2602 /* TODO: use gui_find_iconfile() */
2603! icon = gui_ph_toolbar_load_icon( menu->iconfile );
2604
2605 /* TODO: Restrict loading to just .png? Search for any format? */
2606! if( ( icon == NULL ) &&
2607! ( ( gui_find_bitmap( menu->name, full_pathname, "gif" ) == OK ) ||
2608! ( gui_find_bitmap( menu->name, full_pathname, "png" ) == OK ) ) )
2609! icon = gui_ph_toolbar_load_icon( full_pathname );
2610
2611! if( icon != NULL )
2612 return icon;
2613 }
2614
2615! if( menu->iconidx >= 0 &&
2616! ( menu->iconidx < ARRAY_LENGTH( gui_ph_toolbar_images ) ) )
2617 {
2618 return gui_ph_toolbar_images[menu->iconidx];
2619 }
2620--- 2523,2551 ----
2621 * PhImage_t are copied, and the original PhImage_t aren't needed anymore).
2622 */
2623 static PhImage_t *
2624! gui_ph_toolbar_find_icon(vimmenu_T *menu)
2625 {
2626 char_u full_pathname[ MAXPATHL + 1 ];
2627 PhImage_t *icon = NULL;
2628
2629! if (menu->icon_builtin == FALSE)
2630 {
2631! if (menu->iconfile != NULL)
2632 /* TODO: use gui_find_iconfile() */
2633! icon = gui_ph_toolbar_load_icon(menu->iconfile);
2634
2635 /* TODO: Restrict loading to just .png? Search for any format? */
2636! if ((icon == NULL) &&
2637! ((gui_find_bitmap(menu->name, full_pathname, "gif") == OK) ||
2638! (gui_find_bitmap(menu->name, full_pathname, "png") == OK)))
2639! icon = gui_ph_toolbar_load_icon(full_pathname);
2640
2641! if (icon != NULL)
2642 return icon;
2643 }
2644
2645! if (menu->iconidx >= 0 &&
2646! (menu->iconidx < ARRAY_LENGTH(gui_ph_toolbar_images)))
2647 {
2648 return gui_ph_toolbar_images[menu->iconidx];
2649 }
2650***************
2651*** 2554,2567 ****
2652 }
2653 #endif
2654
2655! #if defined( FEAT_MENU ) || defined( PROTO )
2656 void
2657 gui_mch_enable_menu(int flag)
2658 {
2659! if( flag != 0 )
2660! PtRealizeWidget( gui.vimMenuBar );
2661 else
2662! PtUnrealizeWidget( gui.vimMenuBar );
2663 }
2664
2665 void
2666--- 2554,2567 ----
2667 }
2668 #endif
2669
2670! #if defined(FEAT_MENU) || defined(PROTO)
2671 void
2672 gui_mch_enable_menu(int flag)
2673 {
2674! if (flag != 0)
2675! PtRealizeWidget(gui.vimMenuBar);
2676 else
2677! PtUnrealizeWidget(gui.vimMenuBar);
2678 }
2679
2680 void
2681***************
2682*** 2572,2601 ****
2683
2684 /* Change the position of a menu button in the parent */
2685 static void
2686! gui_ph_position_menu( PtWidget_t *widget, int priority )
2687 {
2688 PtWidget_t *traverse;
2689 vimmenu_T *menu;
2690
2691! traverse = PtWidgetChildBack( PtWidgetParent( widget ) );
2692
2693 /* Iterate through the list of widgets in traverse, until
2694 * we find the position we want to insert our widget into */
2695 /* TODO: traverse from front to back, possible speedup? */
2696! while( traverse != NULL )
2697 {
2698! PtGetResource( traverse, Pt_ARG_POINTER, &menu, 0 );
2699
2700! if( menu != NULL &&
2701 priority < menu->priority &&
2702! widget != traverse )
2703 {
2704 /* Insert the widget before the current traverse widget */
2705! PtWidgetInsert( widget, traverse, 1 );
2706 return;
2707 }
2708
2709! traverse = PtWidgetBrotherInFront( traverse );
2710 }
2711 }
2712
2713--- 2572,2601 ----
2714
2715 /* Change the position of a menu button in the parent */
2716 static void
2717! gui_ph_position_menu(PtWidget_t *widget, int priority)
2718 {
2719 PtWidget_t *traverse;
2720 vimmenu_T *menu;
2721
2722! traverse = PtWidgetChildBack(PtWidgetParent(widget));
2723
2724 /* Iterate through the list of widgets in traverse, until
2725 * we find the position we want to insert our widget into */
2726 /* TODO: traverse from front to back, possible speedup? */
2727! while (traverse != NULL)
2728 {
2729! PtGetResource(traverse, Pt_ARG_POINTER, &menu, 0);
2730
2731! if (menu != NULL &&
2732 priority < menu->priority &&
2733! widget != traverse)
2734 {
2735 /* Insert the widget before the current traverse widget */
2736! PtWidgetInsert(widget, traverse, 1);
2737 return;
2738 }
2739
2740! traverse = PtWidgetBrotherInFront(traverse);
2741 }
2742 }
2743
2744***************
2745*** 2611,2621 ****
2746
2747 menu->submenu_id = menu->id = NULL;
2748
2749! if( menu_is_menubar( menu->name ) )
2750 {
2751
2752! accel_key = vim_strchr( menu->name, '&' );
2753! if( accel_key != NULL )
2754 {
2755 mnemonic_str[0] = accel_key[1];
2756 mnemonic_str[1] = NUL;
2757--- 2611,2621 ----
2758
2759 menu->submenu_id = menu->id = NULL;
2760
2761! if (menu_is_menubar(menu->name))
2762 {
2763
2764! accel_key = vim_strchr(menu->name, '&');
2765! if (accel_key != NULL)
2766 {
2767 mnemonic_str[0] = accel_key[1];
2768 mnemonic_str[1] = NUL;
2769***************
2770*** 2623,2673 ****
2771
2772 /* Create the menu button */
2773 n = 0;
2774! PtSetArg( &args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0 );
2775! PtSetArg( &args[ n++ ], Pt_ARG_ACCEL_TEXT, menu->actext, 0 );
2776! if( accel_key != NULL )
2777! PtSetArg( &args[ n++ ], Pt_ARG_ACCEL_KEY, mnemonic_str, 0 );
2778! PtSetArg( &args[ n++ ], Pt_ARG_POINTER, menu, 0 );
2779
2780! if( parent != NULL )
2781! PtSetArg( &args[ n++ ], Pt_ARG_BUTTON_TYPE, Pt_MENU_RIGHT, 0 );
2782
2783! menu->id = PtCreateWidget( PtMenuButton,
2784 (parent == NULL) ? gui.vimMenuBar : parent->submenu_id,
2785! n, args );
2786
2787! PtAddCallback( menu->id, Pt_CB_ARM, gui_ph_handle_pulldown_menu, menu );
2788
2789 /* Create the actual menu */
2790 n = 0;
2791! if( parent != NULL )
2792! PtSetArg( &args[ n++ ], Pt_ARG_MENU_FLAGS, Pt_TRUE, Pt_MENU_CHILD );
2793
2794! menu->submenu_id = PtCreateWidget( PtMenu, menu->id, n, args );
2795
2796! if( parent == NULL )
2797 {
2798! PtAddCallback( menu->submenu_id, Pt_CB_UNREALIZED,
2799! gui_ph_handle_menu_unrealized, menu );
2800
2801! if( menu->mnemonic != 0 )
2802 {
2803! PtAddHotkeyHandler( gui.vimWindow, tolower( menu->mnemonic ),
2804! Pk_KM_Alt, 0, menu, gui_ph_handle_pulldown_menu );
2805 }
2806 }
2807
2808! gui_ph_position_menu( menu->id, menu->priority );
2809
2810 /* Redraw menubar here instead of gui_mch_draw_menubar */
2811! if( gui.menu_is_active )
2812! PtRealizeWidget( menu->id );
2813 }
2814! else if( menu_is_popup( menu->name ) )
2815 {
2816! menu->submenu_id = PtCreateWidget( PtMenu, gui.vimWindow, 0, NULL );
2817! PtAddCallback( menu->submenu_id, Pt_CB_UNREALIZED,
2818! gui_ph_handle_menu_unrealized, menu );
2819 }
2820 }
2821
2822--- 2623,2673 ----
2823
2824 /* Create the menu button */
2825 n = 0;
2826! PtSetArg(&args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0);
2827! PtSetArg(&args[ n++ ], Pt_ARG_ACCEL_TEXT, menu->actext, 0);
2828! if (accel_key != NULL)
2829! PtSetArg(&args[ n++ ], Pt_ARG_ACCEL_KEY, mnemonic_str, 0);
2830! PtSetArg(&args[ n++ ], Pt_ARG_POINTER, menu, 0);
2831
2832! if (parent != NULL)
2833! PtSetArg(&args[ n++ ], Pt_ARG_BUTTON_TYPE, Pt_MENU_RIGHT, 0);
2834
2835! menu->id = PtCreateWidget(PtMenuButton,
2836 (parent == NULL) ? gui.vimMenuBar : parent->submenu_id,
2837! n, args);
2838
2839! PtAddCallback(menu->id, Pt_CB_ARM, gui_ph_handle_pulldown_menu, menu);
2840
2841 /* Create the actual menu */
2842 n = 0;
2843! if (parent != NULL)
2844! PtSetArg(&args[ n++ ], Pt_ARG_MENU_FLAGS, Pt_TRUE, Pt_MENU_CHILD);
2845
2846! menu->submenu_id = PtCreateWidget(PtMenu, menu->id, n, args);
2847
2848! if (parent == NULL)
2849 {
2850! PtAddCallback(menu->submenu_id, Pt_CB_UNREALIZED,
2851! gui_ph_handle_menu_unrealized, menu);
2852
2853! if (menu->mnemonic != 0)
2854 {
2855! PtAddHotkeyHandler(gui.vimWindow, tolower(menu->mnemonic),
2856! Pk_KM_Alt, 0, menu, gui_ph_handle_pulldown_menu);
2857 }
2858 }
2859
2860! gui_ph_position_menu(menu->id, menu->priority);
2861
2862 /* Redraw menubar here instead of gui_mch_draw_menubar */
2863! if (gui.menu_is_active)
2864! PtRealizeWidget(menu->id);
2865 }
2866! else if (menu_is_popup(menu->name))
2867 {
2868! menu->submenu_id = PtCreateWidget(PtMenu, gui.vimWindow, 0, NULL);
2869! PtAddCallback(menu->submenu_id, Pt_CB_UNREALIZED,
2870! gui_ph_handle_menu_unrealized, menu);
2871 }
2872 }
2873
2874***************
2875*** 2681,2784 ****
2876 PtArg_t args[13];
2877
2878 n = 0;
2879! PtSetArg( &args[ n++ ], Pt_ARG_POINTER, menu, 0 );
2880
2881 #ifdef FEAT_TOOLBAR
2882! if( menu_is_toolbar( parent->name ) )
2883 {
2884! if( menu_is_separator( menu->name ) )
2885 {
2886! PtSetArg( &args[ n++ ], Pt_ARG_SEP_FLAGS,
2887! Pt_SEP_VERTICAL, Pt_SEP_ORIENTATION );
2888! PtSetArg( &args[ n++ ], Pt_ARG_SEP_TYPE, Pt_ETCHED_IN, 0 );
2889! PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS,
2890! Pt_TRUE, Pt_ANCHOR_TOP_BOTTOM );
2891! PtSetArg( &args[ n++ ], Pt_ARG_WIDTH, 2, 0 );
2892! menu->id = PtCreateWidget( PtSeparator, gui.vimToolBar, n, args );
2893 }
2894 else
2895 {
2896! if( strstr( (const char *) p_toolbar, "text" ) != NULL )
2897 {
2898! PtSetArg( &args[ n++ ], Pt_ARG_BALLOON_POSITION,
2899! Pt_BALLOON_BOTTOM, 0 );
2900! PtSetArg( &args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0 );
2901! PtSetArg( &args[ n++ ], Pt_ARG_TEXT_FONT, "TextFont08", 0 );
2902 }
2903! if( ( strstr( (const char *) p_toolbar, "icons" ) != NULL ) &&
2904! ( gui_ph_toolbar_images != NULL ) )
2905 {
2906! PtSetArg( &args[ n++ ], Pt_ARG_LABEL_IMAGE,
2907! gui_ph_toolbar_find_icon( menu ), 0 );
2908! PtSetArg( &args[ n++ ], Pt_ARG_LABEL_TYPE, Pt_TEXT_IMAGE, 0 );
2909! PtSetArg( &args[ n++ ], Pt_ARG_TEXT_IMAGE_SPACING, 0, 0 );
2910 }
2911! if( strstr( (const char *) p_toolbar, "tooltips" ) != NULL )
2912 {
2913! PtSetArg( &args[ n++ ], Pt_ARG_LABEL_BALLOON,
2914! gui_ph_show_tooltip, 0 );
2915! PtSetArg( &args[ n++ ], Pt_ARG_LABEL_FLAGS,
2916! Pt_TRUE, Pt_SHOW_BALLOON );
2917 }
2918! PtSetArg( &args[ n++ ], Pt_ARG_MARGIN_HEIGHT, 1, 0 );
2919! PtSetArg( &args[ n++ ], Pt_ARG_MARGIN_WIDTH, 1, 0 );
2920! PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_FALSE,
2921! Pt_HIGHLIGHTED | Pt_GETS_FOCUS );
2922! PtSetArg( &args[ n++ ], Pt_ARG_FILL_COLOR, Pg_TRANSPARENT, 0 );
2923! menu->id = PtCreateWidget( PtButton, gui.vimToolBar, n, args );
2924
2925! PtAddCallback( menu->id, Pt_CB_ACTIVATE, gui_ph_handle_menu, menu );
2926 }
2927 /* Update toolbar if it's open */
2928! if( PtWidgetIsRealized( gui.vimToolBar ) )
2929! PtRealizeWidget( menu->id );
2930 }
2931 else
2932 #endif
2933! if( menu_is_separator( menu->name ) )
2934 {
2935! menu->id = PtCreateWidget( PtSeparator, parent->submenu_id, n, args );
2936 }
2937 else
2938 {
2939! accel_key = vim_strchr( menu->name, '&' );
2940! if( accel_key != NULL )
2941 {
2942 mnemonic_str[0] = accel_key[1];
2943 mnemonic_str[1] = NUL;
2944 }
2945
2946! PtSetArg( &args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0 );
2947! if( accel_key != NULL )
2948! PtSetArg( &args[ n++ ], Pt_ARG_ACCEL_KEY, mnemonic_str,
2949! 0 );
2950
2951! PtSetArg( &args[ n++ ], Pt_ARG_ACCEL_TEXT, menu->actext, 0 );
2952
2953! menu->id = PtCreateWidget( PtMenuButton, parent->submenu_id, n, args );
2954
2955! PtAddCallback( menu->id, Pt_CB_ACTIVATE, gui_ph_handle_menu, menu );
2956
2957 #ifdef USE_PANEL_GROUP
2958! if( gui_ph_is_buffer_item( menu, parent ) == TRUE )
2959 {
2960! PtAddCallback( menu->id, Pt_CB_DESTROYED,
2961! gui_ph_handle_buffer_remove, menu );
2962! gui_ph_pg_add_buffer( menu->dname );
2963 }
2964 #endif
2965 }
2966
2967! gui_ph_position_menu( menu->id, menu->priority );
2968 }
2969
2970 void
2971 gui_mch_destroy_menu(vimmenu_T *menu)
2972 {
2973! if( menu->submenu_id != NULL )
2974! PtDestroyWidget( menu->submenu_id );
2975! if( menu->id != NULL )
2976! PtDestroyWidget( menu->id );
2977
2978 menu->submenu_id = NULL;
2979 menu->id = NULL;
2980--- 2681,2784 ----
2981 PtArg_t args[13];
2982
2983 n = 0;
2984! PtSetArg(&args[ n++ ], Pt_ARG_POINTER, menu, 0);
2985
2986 #ifdef FEAT_TOOLBAR
2987! if (menu_is_toolbar(parent->name))
2988 {
2989! if (menu_is_separator(menu->name))
2990 {
2991! PtSetArg(&args[ n++ ], Pt_ARG_SEP_FLAGS,
2992! Pt_SEP_VERTICAL, Pt_SEP_ORIENTATION);
2993! PtSetArg(&args[ n++ ], Pt_ARG_SEP_TYPE, Pt_ETCHED_IN, 0);
2994! PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS,
2995! Pt_TRUE, Pt_ANCHOR_TOP_BOTTOM);
2996! PtSetArg(&args[ n++ ], Pt_ARG_WIDTH, 2, 0);
2997! menu->id = PtCreateWidget(PtSeparator, gui.vimToolBar, n, args);
2998 }
2999 else
3000 {
3001! if (strstr((const char *) p_toolbar, "text") != NULL)
3002 {
3003! PtSetArg(&args[ n++ ], Pt_ARG_BALLOON_POSITION,
3004! Pt_BALLOON_BOTTOM, 0);
3005! PtSetArg(&args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0);
3006! PtSetArg(&args[ n++ ], Pt_ARG_TEXT_FONT, "TextFont08", 0);
3007 }
3008! if ((strstr((const char *) p_toolbar, "icons") != NULL) &&
3009! (gui_ph_toolbar_images != NULL))
3010 {
3011! PtSetArg(&args[ n++ ], Pt_ARG_LABEL_IMAGE,
3012! gui_ph_toolbar_find_icon(menu), 0);
3013! PtSetArg(&args[ n++ ], Pt_ARG_LABEL_TYPE, Pt_TEXT_IMAGE, 0);
3014! PtSetArg(&args[ n++ ], Pt_ARG_TEXT_IMAGE_SPACING, 0, 0);
3015 }
3016! if (strstr((const char *) p_toolbar, "tooltips") != NULL)
3017 {
3018! PtSetArg(&args[ n++ ], Pt_ARG_LABEL_BALLOON,
3019! gui_ph_show_tooltip, 0);
3020! PtSetArg(&args[ n++ ], Pt_ARG_LABEL_FLAGS,
3021! Pt_TRUE, Pt_SHOW_BALLOON);
3022 }
3023! PtSetArg(&args[ n++ ], Pt_ARG_MARGIN_HEIGHT, 1, 0);
3024! PtSetArg(&args[ n++ ], Pt_ARG_MARGIN_WIDTH, 1, 0);
3025! PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_FALSE,
3026! Pt_HIGHLIGHTED | Pt_GETS_FOCUS);
3027! PtSetArg(&args[ n++ ], Pt_ARG_FILL_COLOR, Pg_TRANSPARENT, 0);
3028! menu->id = PtCreateWidget(PtButton, gui.vimToolBar, n, args);
3029
3030! PtAddCallback(menu->id, Pt_CB_ACTIVATE, gui_ph_handle_menu, menu);
3031 }
3032 /* Update toolbar if it's open */
3033! if (PtWidgetIsRealized(gui.vimToolBar))
3034! PtRealizeWidget(menu->id);
3035 }
3036 else
3037 #endif
3038! if (menu_is_separator(menu->name))
3039 {
3040! menu->id = PtCreateWidget(PtSeparator, parent->submenu_id, n, args);
3041 }
3042 else
3043 {
3044! accel_key = vim_strchr(menu->name, '&');
3045! if (accel_key != NULL)
3046 {
3047 mnemonic_str[0] = accel_key[1];
3048 mnemonic_str[1] = NUL;
3049 }
3050
3051! PtSetArg(&args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0);
3052! if (accel_key != NULL)
3053! PtSetArg(&args[ n++ ], Pt_ARG_ACCEL_KEY, mnemonic_str,
3054! 0);
3055
3056! PtSetArg(&args[ n++ ], Pt_ARG_ACCEL_TEXT, menu->actext, 0);
3057
3058! menu->id = PtCreateWidget(PtMenuButton, parent->submenu_id, n, args);
3059
3060! PtAddCallback(menu->id, Pt_CB_ACTIVATE, gui_ph_handle_menu, menu);
3061
3062 #ifdef USE_PANEL_GROUP
3063! if (gui_ph_is_buffer_item(menu, parent) == TRUE)
3064 {
3065! PtAddCallback(menu->id, Pt_CB_DESTROYED,
3066! gui_ph_handle_buffer_remove, menu);
3067! gui_ph_pg_add_buffer(menu->dname);
3068 }
3069 #endif
3070 }
3071
3072! gui_ph_position_menu(menu->id, menu->priority);
3073 }
3074
3075 void
3076 gui_mch_destroy_menu(vimmenu_T *menu)
3077 {
3078! if (menu->submenu_id != NULL)
3079! PtDestroyWidget(menu->submenu_id);
3080! if (menu->id != NULL)
3081! PtDestroyWidget(menu->id);
3082
3083 menu->submenu_id = NULL;
3084 menu->id = NULL;
3085***************
3086*** 2789,2800 ****
3087 {
3088 long flags, mask, fields;
3089
3090! if( menu->id == NULL )
3091 return;
3092
3093! flags = PtWidgetFlags( menu->id );
3094! if( PtWidgetIsClass( menu->id, PtMenuButton ) &&
3095! PtWidgetIsClass( PtWidgetParent( menu->id ), PtMenu ) )
3096 {
3097 fields = Pt_FALSE;
3098 mask = Pt_SELECTABLE | Pt_HIGHLIGHTED;
3099--- 2789,2800 ----
3100 {
3101 long flags, mask, fields;
3102
3103! if (menu->id == NULL)
3104 return;
3105
3106! flags = PtWidgetFlags(menu->id);
3107! if (PtWidgetIsClass(menu->id, PtMenuButton) &&
3108! PtWidgetIsClass(PtWidgetParent(menu->id), PtMenu))
3109 {
3110 fields = Pt_FALSE;
3111 mask = Pt_SELECTABLE | Pt_HIGHLIGHTED;
3112***************
3113*** 2805,2815 ****
3114 mask = Pt_BLOCKED | Pt_GHOST;
3115 }
3116
3117! if( ! grey )
3118 fields = ~fields;
3119
3120! PtSetResource( menu->id, Pt_ARG_FLAGS, fields,
3121! mask );
3122 }
3123
3124 void
3125--- 2805,2815 ----
3126 mask = Pt_BLOCKED | Pt_GHOST;
3127 }
3128
3129! if (! grey)
3130 fields = ~fields;
3131
3132! PtSetResource(menu->id, Pt_ARG_FLAGS, fields,
3133! mask);
3134 }
3135
3136 void
3137***************
3138*** 2830,2837 ****
3139 void
3140 gui_mch_show_popupmenu(vimmenu_T *menu)
3141 {
3142! PtSetResource( menu->submenu_id, Pt_ARG_POS, &abs_mouse, 0 );
3143! PtRealizeWidget( menu->submenu_id );
3144 }
3145
3146 void
3147--- 2830,2837 ----
3148 void
3149 gui_mch_show_popupmenu(vimmenu_T *menu)
3150 {
3151! PtSetResource(menu->submenu_id, Pt_ARG_POS, &abs_mouse, 0);
3152! PtRealizeWidget(menu->submenu_id);
3153 }
3154
3155 void
3156***************
3157*** 2842,2855 ****
3158
3159 #endif
3160
3161! #if defined( FEAT_TOOLBAR ) || defined( PROTO )
3162 void
3163 gui_mch_show_toolbar(int showit)
3164 {
3165! if( showit )
3166! PtRealizeWidget( gui.vimToolBar );
3167 else
3168! PtUnrealizeWidget( gui.vimToolBar );
3169 }
3170 #endif
3171
3172--- 2842,2855 ----
3173
3174 #endif
3175
3176! #if defined(FEAT_TOOLBAR) || defined(PROTO)
3177 void
3178 gui_mch_show_toolbar(int showit)
3179 {
3180! if (showit)
3181! PtRealizeWidget(gui.vimToolBar);
3182 else
3183! PtUnrealizeWidget(gui.vimToolBar);
3184 }
3185 #endif
3186
3187***************
3188*** 2870,2903 ****
3189 FontQueryInfo info;
3190 int_u style;
3191
3192! font_tag = alloc( MAX_FONT_TAG );
3193! if( font_tag != NULL )
3194 {
3195! if( PfGenerateFontName( font_name, font_flags, font_size,
3196! font_tag ) != NULL )
3197 {
3198 /* Enforce some limits on the font used */
3199 style = PHFONT_INFO_FIXED;
3200
3201! if( enforce & PF_STYLE_BOLD )
3202 style |= PHFONT_INFO_BOLD;
3203! if( enforce & PF_STYLE_ANTIALIAS )
3204 style |= PHFONT_INFO_ALIAS;
3205! if( enforce & PF_STYLE_ITALIC )
3206 style |= PHFONT_INFO_ITALIC;
3207
3208! PfQueryFontInfo( font_tag, &info );
3209
3210! if( info.size == 0 )
3211 font_size = 0;
3212
3213 /* Make sure font size matches, and that the font style
3214 * at least has the bits we're checking for */
3215! if( font_size == info.size &&
3216! style == (info.style & style) )
3217 return (GuiFont)font_tag;
3218 }
3219! vim_free( font_tag );
3220 }
3221 return NULL;
3222 }
3223--- 2870,2903 ----
3224 FontQueryInfo info;
3225 int_u style;
3226
3227! font_tag = alloc(MAX_FONT_TAG);
3228! if (font_tag != NULL)
3229 {
3230! if (PfGenerateFontName(font_name, font_flags, font_size,
3231! font_tag) != NULL)
3232 {
3233 /* Enforce some limits on the font used */
3234 style = PHFONT_INFO_FIXED;
3235
3236! if (enforce & PF_STYLE_BOLD)
3237 style |= PHFONT_INFO_BOLD;
3238! if (enforce & PF_STYLE_ANTIALIAS)
3239 style |= PHFONT_INFO_ALIAS;
3240! if (enforce & PF_STYLE_ITALIC)
3241 style |= PHFONT_INFO_ITALIC;
3242
3243! PfQueryFontInfo(font_tag, &info);
3244
3245! if (info.size == 0)
3246 font_size = 0;
3247
3248 /* Make sure font size matches, and that the font style
3249 * at least has the bits we're checking for */
3250! if (font_size == info.size &&
3251! style == (info.style & style))
3252 return (GuiFont)font_tag;
3253 }
3254! vim_free(font_tag);
3255 }
3256 return NULL;
3257 }
3258***************
3259*** 2919,2936 ****
3260 char_u *vim_font,
3261 char_u **font_name,
3262 int_u *font_flags,
3263! int_u *font_size )
3264 {
3265 char_u *mark;
3266 int_u name_len, size;
3267
3268! mark = vim_strchr( vim_font, ':' );
3269! if( mark == NULL )
3270! name_len = STRLEN( vim_font );
3271 else
3272! name_len = (int_u) ( mark - vim_font );
3273
3274! *font_name = vim_strnsave( vim_font, name_len );
3275 if (*font_name != NULL)
3276 {
3277 if (mark != NULL)
3278--- 2919,2936 ----
3279 char_u *vim_font,
3280 char_u **font_name,
3281 int_u *font_flags,
3282! int_u *font_size)
3283 {
3284 char_u *mark;
3285 int_u name_len, size;
3286
3287! mark = vim_strchr(vim_font, ':');
3288! if (mark == NULL)
3289! name_len = STRLEN(vim_font);
3290 else
3291! name_len = (int_u) (mark - vim_font);
3292
3293! *font_name = vim_strnsave(vim_font, name_len);
3294 if (*font_name != NULL)
3295 {
3296 if (mark != NULL)
3297***************
3298*** 2944,2950 ****
3299 case 'i': *font_flags |= PF_STYLE_ITALIC; break;
3300
3301 case 's':
3302! size = getdigits( &mark );
3303 /* Restrict the size to some vague limits */
3304 if (size < 1 || size > 100)
3305 size = 8;
3306--- 2944,2950 ----
3307 case 'i': *font_flags |= PF_STYLE_ITALIC; break;
3308
3309 case 's':
3310! size = getdigits(&mark);
3311 /* Restrict the size to some vague limits */
3312 if (size < 1 || size > 100)
3313 size = 8;
3314***************
3315*** 2979,3031 ****
3316 vim_font_name = "PC Terminal";
3317 }
3318
3319! if (STRCMP( vim_font_name, "*" ) == 0)
3320 {
3321! font_tag = PtFontSelection( gui.vimWindow, NULL, NULL,
3322! "pcterm12", -1, PHFONT_FIXED, NULL );
3323
3324 if (font_tag == NULL)
3325 return FAIL;
3326
3327! gui_mch_free_font( gui.norm_font );
3328 gui.norm_font = font_tag;
3329
3330! PfQueryFontInfo( font_tag, &info );
3331! font_name = vim_strsave( info.font );
3332 }
3333 else
3334 {
3335! if (gui_ph_parse_font_name( vim_font_name, &font_name, &font_flags,
3336! &font_size ) == FALSE)
3337 return FAIL;
3338
3339! font_tag = gui_ph_get_font( font_name, font_flags, font_size, 0 );
3340 if (font_tag == NULL)
3341 {
3342! vim_free( font_name );
3343 return FAIL;
3344 }
3345
3346! gui_mch_free_font( gui.norm_font );
3347 gui.norm_font = font_tag;
3348 }
3349
3350! gui_mch_free_font( gui.bold_font );
3351! gui.bold_font = gui_ph_get_font( font_name, font_flags | PF_STYLE_BOLD,
3352! font_size, PF_STYLE_BOLD );
3353!
3354! gui_mch_free_font( gui.ital_font );
3355! gui.ital_font = gui_ph_get_font( font_name, font_flags | PF_STYLE_ITALIC,
3356! font_size, PF_STYLE_ITALIC );
3357
3358 /* This extent was brought to you by the letter 'g' */
3359! PfExtentText( &extent, NULL, font_tag, "g", 1 );
3360
3361 gui.char_width = extent.lr.x - extent.ul.x + 1;
3362 gui.char_height = (- extent.ul.y) + extent.lr.y + 1;
3363 gui.char_ascent = - extent.ul.y;
3364
3365! vim_free( font_name );
3366 return OK;
3367 }
3368
3369--- 2979,3031 ----
3370 vim_font_name = "PC Terminal";
3371 }
3372
3373! if (STRCMP(vim_font_name, "*") == 0)
3374 {
3375! font_tag = PtFontSelection(gui.vimWindow, NULL, NULL,
3376! "pcterm12", -1, PHFONT_FIXED, NULL);
3377
3378 if (font_tag == NULL)
3379 return FAIL;
3380
3381! gui_mch_free_font(gui.norm_font);
3382 gui.norm_font = font_tag;
3383
3384! PfQueryFontInfo(font_tag, &info);
3385! font_name = vim_strsave(info.font);
3386 }
3387 else
3388 {
3389! if (gui_ph_parse_font_name(vim_font_name, &font_name, &font_flags,
3390! &font_size) == FALSE)
3391 return FAIL;
3392
3393! font_tag = gui_ph_get_font(font_name, font_flags, font_size, 0);
3394 if (font_tag == NULL)
3395 {
3396! vim_free(font_name);
3397 return FAIL;
3398 }
3399
3400! gui_mch_free_font(gui.norm_font);
3401 gui.norm_font = font_tag;
3402 }
3403
3404! gui_mch_free_font(gui.bold_font);
3405! gui.bold_font = gui_ph_get_font(font_name, font_flags | PF_STYLE_BOLD,
3406! font_size, PF_STYLE_BOLD);
3407!
3408! gui_mch_free_font(gui.ital_font);
3409! gui.ital_font = gui_ph_get_font(font_name, font_flags | PF_STYLE_ITALIC,
3410! font_size, PF_STYLE_ITALIC);
3411
3412 /* This extent was brought to you by the letter 'g' */
3413! PfExtentText(&extent, NULL, font_tag, "g", 1);
3414
3415 gui.char_width = extent.lr.x - extent.ul.x + 1;
3416 gui.char_height = (- extent.ul.y) + extent.lr.y + 1;
3417 gui.char_ascent = - extent.ul.y;
3418
3419! vim_free(font_name);
3420 return OK;
3421 }
3422
3423***************
3424*** 3037,3043 ****
3425 {
3426 FontQueryInfo info;
3427
3428! PfQueryFontInfo( gui.norm_font, &info );
3429
3430 gui.char_height = - info.ascender + info.descender + p_linespace;
3431 gui.char_ascent = - info.ascender + p_linespace / 2;
3432--- 3037,3043 ----
3433 {
3434 FontQueryInfo info;
3435
3436! PfQueryFontInfo(gui.norm_font, &info);
3437
3438 gui.char_height = - info.ascender + info.descender + p_linespace;
3439 gui.char_ascent = - info.ascender + p_linespace / 2;
3440***************
3441*** 3053,3070 ****
3442 int_u font_size = 12;
3443 int_u font_flags = 0;
3444
3445! if (gui_ph_parse_font_name( vim_font_name, &font_name, &font_flags,
3446! &font_size ) != FALSE)
3447 {
3448! font_tag = gui_ph_get_font( font_name, font_flags, font_size, -1 );
3449! vim_free( font_name );
3450
3451 if (font_tag != NULL)
3452 return (GuiFont)font_tag;
3453 }
3454
3455 if (report_error)
3456! EMSG2(e_font, vim_font_name );
3457
3458 return FAIL;
3459 }
3460--- 3053,3070 ----
3461 int_u font_size = 12;
3462 int_u font_flags = 0;
3463
3464! if (gui_ph_parse_font_name(vim_font_name, &font_name, &font_flags,
3465! &font_size) != FALSE)
3466 {
3467! font_tag = gui_ph_get_font(font_name, font_flags, font_size, -1);
3468! vim_free(font_name);
3469
3470 if (font_tag != NULL)
3471 return (GuiFont)font_tag;
3472 }
3473
3474 if (report_error)
3475! EMSG2(e_font, vim_font_name);
3476
3477 return FAIL;
3478 }
3479***************
3480*** 3088,3099 ****
3481 void
3482 gui_mch_set_font(GuiFont font)
3483 {
3484! PgSetFont( font );
3485 }
3486
3487 void
3488 gui_mch_free_font(GuiFont font)
3489 {
3490! vim_free( font );
3491 }
3492
3493--- 3088,3099 ----
3494 void
3495 gui_mch_set_font(GuiFont font)
3496 {
3497! PgSetFont(font);
3498 }
3499
3500 void
3501 gui_mch_free_font(GuiFont font)
3502 {
3503! vim_free(font);
3504 }
3505
3506*** ../vim-7.3.309/src/version.c 2011-09-14 15:41:54.000000000 +0200
3507--- src/version.c 2011-09-14 16:01:50.000000000 +0200
3508***************
3509*** 711,712 ****
3510--- 711,714 ----
3511 { /* Add new patch number below this line */
3512+ /**/
3513+ 310,
3514 /**/
3515
3516--
3517An operatingsystem is just a name you give to the rest of bloating
3518idiosyncratic machine-based-features you left out of your editor.
3519 (author unknown)
3520
3521 /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\
3522/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
3523\\\ an exciting new programming language -- http://www.Zimbu.org ///
3524 \\\ help me help AIDS victims -- http://ICCF-Holland.org ///
Vi IMproved - a Vi clone
This page took 2.751087 seconds and 4 git commands to generate.