1 /* vi:set ts=8 sts=4 sw=4 noet:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 * Photon GUI support by Julian Kinraid
5 *
6 * Do ":help uganda" in Vim to read copying and usage conditions.
7 * Do ":help credits" in Vim to see a list of people who contributed.
8 *
9 *
10 * Clipboard support is in os_qnx.c
11 * PhAttach() is called in os_qnx.c:qnx_init()
12 */
13
14 #include "vim.h"
15
16 // cproto fails on missing include files
17 #ifndef PROTO
18 # ifdef FEAT_TOOLBAR
19 # include <photon/PxImage.h>
20 # endif
21 #endif
22
23 #if !defined(__QNX__)
24 // Used when generating prototypes.
25 # define PgColor_t int
26 # define PhEvent_t int
27 # define PhPoint_t int
28 # define PtWidget_t int
29 # define Pg_BLACK 0
30 # define PtCallbackF_t int
31 # define PtCallbackInfo_t int
32 # define PhTile_t int
33 # define PtWidget_t int
34 # define PhImage_t int
35 #endif
36
37 #define RGB(r, g, b) PgRGB(r, g, b)
38
39 #define EVENT_BUFFER_SIZE sizeof(PhEvent_t) + 1000
40
41 // Some defines for gui_mch_mousehide()
42 #define MOUSE_HIDE TRUE
43 #define MOUSE_SHOW FALSE
44
45 // Optional support for using a PtPanelGroup widget, needs work
46 #undef USE_PANEL_GROUP
47
48 #ifdef USE_PANEL_GROUP
49 static char *empty_title = " ";
50 static char **panel_titles = NULL;
51 static ushort_t num_panels = 0;
52 static short pg_margin_left, pg_margin_right, pg_margin_top, pg_margin_bottom;
53 #endif
54
55 #define GUI_PH_MARGIN 4 // Size of the bevel
56
57 #define GUI_PH_MOUSE_TYPE Ph_CURSOR_INSERT
58 static PgColor_t gui_ph_mouse_color = Pg_BLACK;
59
60 static PhPoint_t gui_ph_raw_offset;
61 static PtWidget_t *gui_ph_timer_cursor; // handle cursor blinking
62 static PtWidget_t *gui_ph_timer_timeout; // used in gui_mch_wait_for_chars
63 static short is_timeout; // Has the timeout occurred?
64
65 /*
66 * This is set inside the mouse callback for a right mouse
67 * button click, and used for the popup menus
68 */
69 static PhPoint_t abs_mouse;
70
71 // Try and avoid redraws while a resize is in progress
72 static int is_ignore_draw = FALSE;
73
74 // Used for converting to/from utf-8 and other charsets
75 static struct PxTransCtrl *charset_translate;
76
77 /*
78 * Cursor blink functions.
79 *
80 * This is a simple state machine:
81 * BLINK_NONE not blinking at all
82 * BLINK_OFF blinking, cursor is not shown
83 * BLINK_ON blinking, cursor is shown
84 */
85 static enum {
86 BLINK_NONE,
87 BLINK_OFF,
88 BLINK_ON
89 } blink_state = BLINK_NONE;
90
91 static long_u blink_waittime = 700;
92 static long_u blink_ontime = 400;
93 static long_u blink_offtime = 250;
94
95 static struct
96 {
97 int key_sym;
98 char_u vim_code0;
99 char_u vim_code1;
100 } special_keys[] =
101 {
102 {Pk_Up, 'k', 'u'},
103 {Pk_Down, 'k', 'd'},
104 {Pk_Left, 'k', 'l'},
105 {Pk_Right, 'k', 'r'},
106
107 {Pk_F1, 'k', '1'},
108 {Pk_F2, 'k', '2'},
109 {Pk_F3, 'k', '3'},
110 {Pk_F4, 'k', '4'},
111 {Pk_F5, 'k', '5'},
112 {Pk_F6, 'k', '6'},
113 {Pk_F7, 'k', '7'},
114 {Pk_F8, 'k', '8'},
115 {Pk_F9, 'k', '9'},
116 {Pk_F10, 'k', ';'},
117
118 {Pk_F11, 'F', '1'},
119 {Pk_F12, 'F', '2'},
120 {Pk_F13, 'F', '3'},
121 {Pk_F14, 'F', '4'},
122 {Pk_F15, 'F', '5'},
123 {Pk_F16, 'F', '6'},
124 {Pk_F17, 'F', '7'},
125 {Pk_F18, 'F', '8'},
126 {Pk_F19, 'F', '9'},
127 {Pk_F20, 'F', 'A'},
128
129 {Pk_F21, 'F', 'B'},
130 {Pk_F22, 'F', 'C'},
131 {Pk_F23, 'F', 'D'},
132 {Pk_F24, 'F', 'E'},
133 {Pk_F25, 'F', 'F'},
134 {Pk_F26, 'F', 'G'},
135 {Pk_F27, 'F', 'H'},
136 {Pk_F28, 'F', 'I'},
137 {Pk_F29, 'F', 'J'},
138
139 {Pk_F30, 'F', 'K'},
140 {Pk_F31, 'F', 'L'},
141 {Pk_F32, 'F', 'M'},
142 {Pk_F33, 'F', 'N'},
143 {Pk_F34, 'F', 'O'},
144 {Pk_F35, 'F', 'P'},
145
146 {Pk_Help, '%', '1'},
147 {Pk_BackSpace, 'k', 'b'},
148 {Pk_Insert, 'k', 'I'},
149 {Pk_Delete, 'k', 'D'},
150 {Pk_Home, 'k', 'h'},
151 {Pk_End, '@', '7'},
152 {Pk_Prior, 'k', 'P'},
153 {Pk_Next, 'k', 'N'},
154 {Pk_Print, '%', '9'},
155
156 {Pk_KP_Add, 'K', '6'},
157 {Pk_KP_Subtract,'K', '7'},
158 {Pk_KP_Divide, 'K', '8'},
159 {Pk_KP_Multiply,'K', '9'},
160 {Pk_KP_Enter, 'K', 'A'},
161
162 {Pk_KP_0, KS_EXTRA, KE_KINS}, // Insert
163 {Pk_KP_Decimal, KS_EXTRA, KE_KDEL}, // Delete
164
165 {Pk_KP_4, 'k', 'l'}, // Left
166 {Pk_KP_6, 'k', 'r'}, // Right
167 {Pk_KP_8, 'k', 'u'}, // Up
168 {Pk_KP_2, 'k', 'd'}, // Down
169
170 {Pk_KP_7, 'K', '1'}, // Home
171 {Pk_KP_1, 'K', '4'}, // End
172
173 {Pk_KP_9, 'K', '3'}, // Page Up
174 {Pk_KP_3, 'K', '5'}, // Page Down
175
176 {Pk_KP_5, '&', '8'}, // Undo
177
178 // Keys that we want to be able to use any modifier with:
179 {Pk_Return, CAR, NUL},
180 {Pk_space, ' ', NUL},
181 {Pk_Tab, TAB, NUL},
182 {Pk_Escape, ESC, NUL},
183 {NL, NL, NUL},
184 {CAR, CAR, NUL},
185
186 // End of list marker:
187 {0, 0, 0}
188 };
189
190
191 ////////////////////////////////////////////////////////////////////////////
192
193 static PtCallbackF_t gui_ph_handle_timer_cursor;
194 static PtCallbackF_t gui_ph_handle_timer_timeout;
195
196 static PtCallbackF_t gui_ph_handle_window_cb;
197
198 static PtCallbackF_t gui_ph_handle_scrollbar;
199 static PtCallbackF_t gui_ph_handle_keyboard;
200 static PtCallbackF_t gui_ph_handle_mouse;
201 static PtCallbackF_t gui_ph_handle_pulldown_menu;
202 static PtCallbackF_t gui_ph_handle_menu;
203 static PtCallbackF_t gui_ph_handle_focus; // focus change of text area
204
205 static PtCallbackF_t gui_ph_handle_menu_resize;
206
207 // When a menu is unrealized, give focus back to vimTextArea
208 static PtCallbackF_t gui_ph_handle_menu_unrealized;
209
210 #ifdef USE_PANEL_GROUP
211 static void gui_ph_get_panelgroup_margins(short*, short*, short*, short*);
212 #endif
213
214 static void gui_ph_draw_start(void);
215 static void gui_ph_draw_end(void);
216
217 // Set the text for the balloon
218 static PtWidget_t * gui_ph_show_tooltip(PtWidget_t *window,
219 PtWidget_t *widget,
220 int position,
221 char *text,
222 char *font,
223 PgColor_t fill_color,
224 PgColor_t text_color);
225
226 ////////////////////////////////////////////////////////////////////////////
227
gui_ph_show_tooltip(PtWidget_t * window,PtWidget_t * widget,int position,char * text,char * font,PgColor_t fill_color,PgColor_t text_color)228 static PtWidget_t * gui_ph_show_tooltip(PtWidget_t *window,
229 PtWidget_t *widget,
230 int position,
231 char *text,
232 char *font,
233 PgColor_t fill_color,
234 PgColor_t text_color)
235 {
236 PtArg_t arg;
237 vimmenu_T *menu;
238 char_u *tooltip;
239
240 PtSetArg(&arg, Pt_ARG_POINTER, &menu, 0);
241 PtGetResources(widget, 1, &arg);
242
243 // Override the text and position
244
245 tooltip = text;
246 if (menu != NULL)
247 {
248 int index = MENU_INDEX_TIP;
249 if (menu->strings[ index ] != NULL)
250 tooltip = menu->strings[ index ];
251 }
252
253 return PtInflateBalloon(
254 window,
255 widget,
256 // Don't put the balloon at the bottom,
257 // it gets drawn over by gfx done in the PtRaw
258 Pt_BALLOON_TOP,
259 tooltip,
260 font,
261 fill_color,
262 text_color);
263 }
264
265 static void
gui_ph_resize_container(void)266 gui_ph_resize_container(void)
267 {
268 PhArea_t area;
269
270 PtWidgetArea(gui.vimWindow, &area);
271 PtWidgetPos (gui.vimContainer, &area.pos);
272
273 PtSetResource(gui.vimContainer, Pt_ARG_AREA, &area, 0);
274 }
275
276 static int
gui_ph_handle_menu_resize(PtWidget_t * widget,void * other,PtCallbackInfo_t * info)277 gui_ph_handle_menu_resize(
278 PtWidget_t *widget,
279 void *other,
280 PtCallbackInfo_t *info)
281 {
282 PtContainerCallback_t *sizes = info->cbdata;
283 PtWidget_t *container;
284 PhPoint_t below_menu;
285 int_u height;
286
287 height = sizes->new_dim.h;
288
289 // Because vim treats the toolbar and menubar separately,
290 // and here they're lumped together into a PtToolbarGroup,
291 // we only need either menu_height or toolbar_height set at once
292 if (gui.menu_is_active)
293 {
294 gui.menu_height = height;
295 gui.toolbar_height = 0;
296 }
297 #ifdef FEAT_TOOLBAR
298 else
299 gui.toolbar_height = height;
300 #endif
301
302 below_menu.x = 0;
303 below_menu.y = height;
304
305 #ifdef USE_PANEL_GROUP
306 container = gui.vimPanelGroup;
307 #else
308 container = gui.vimContainer;
309 #endif
310
311 PtSetResource(container, Pt_ARG_POS, &below_menu, 0);
312
313 gui_ph_resize_container();
314
315 #ifdef USE_PANEL_GROUP
316 gui_ph_get_panelgroup_margins(
317 &pg_margin_top, &pg_margin_bottom,
318 &pg_margin_left, &pg_margin_right);
319 #endif
320 return Pt_CONTINUE;
321 }
322
323 /*
324 * Pt_ARG_TIMER_REPEAT isn't used because the on & off times
325 * are different
326 */
327 static int
gui_ph_handle_timer_cursor(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)328 gui_ph_handle_timer_cursor(
329 PtWidget_t *widget,
330 void *data,
331 PtCallbackInfo_t *info)
332 {
333 if (blink_state == BLINK_ON)
334 {
335 gui_undraw_cursor();
336 blink_state = BLINK_OFF;
337 PtSetResource(gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL,
338 blink_offtime, 0);
339 }
340 else
341 {
342 gui_update_cursor(TRUE, FALSE);
343 blink_state = BLINK_ON;
344 PtSetResource(gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL,
345 blink_ontime, 0);
346 }
347 return Pt_CONTINUE;
348 }
349
350 static int
gui_ph_handle_timer_timeout(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)351 gui_ph_handle_timer_timeout(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
352 {
353 is_timeout = TRUE;
354
355 return Pt_CONTINUE;
356 }
357
358 static int
gui_ph_handle_window_cb(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)359 gui_ph_handle_window_cb(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
360 {
361 PhWindowEvent_t *we = info->cbdata;
362 ushort_t *width, *height;
363
364 switch (we->event_f) {
365 case Ph_WM_CLOSE:
366 gui_shell_closed();
367 break;
368
369 case Ph_WM_FOCUS:
370 // Just in case it's hidden and needs to be shown
371 gui_mch_mousehide(MOUSE_SHOW);
372
373 if (we->event_state == Ph_WM_EVSTATE_FOCUS)
374 {
375 gui_focus_change(TRUE);
376 gui_mch_start_blink();
377 }
378 else
379 {
380 gui_focus_change(FALSE);
381 gui_mch_stop_blink(TRUE);
382 }
383 break;
384
385 case Ph_WM_RESIZE:
386 PtGetResource(gui.vimWindow, Pt_ARG_WIDTH, &width, 0);
387 PtGetResource(gui.vimWindow, Pt_ARG_HEIGHT, &height, 0);
388 #ifdef USE_PANEL_GROUP
389 width -= (pg_margin_left + pg_margin_right);
390 height -= (pg_margin_top + pg_margin_bottom);
391 #endif
392 gui_resize_shell(*width, *height);
393 gui_set_shellsize(FALSE, FALSE, RESIZE_BOTH);
394 is_ignore_draw = FALSE;
395 PtEndFlux(gui.vimContainer);
396 PtContainerRelease(gui.vimContainer);
397 break;
398
399 default:
400 break;
401 }
402
403 return Pt_CONTINUE;
404 }
405
406 static int
gui_ph_handle_scrollbar(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)407 gui_ph_handle_scrollbar(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
408 {
409 PtScrollbarCallback_t *scroll;
410 scrollbar_T *sb;
411 int value, dragging = FALSE;
412
413 scroll = info->cbdata;
414
415 sb = (scrollbar_T *) data;
416 if (sb != NULL)
417 {
418 value = scroll->position;
419 switch (scroll->action)
420 {
421 case Pt_SCROLL_DRAGGED:
422 dragging = TRUE;
423 break;
424
425 case Pt_SCROLL_SET:
426 // FIXME: return straight away here?
427 return Pt_CONTINUE;
428 break;
429 }
430
431 gui_drag_scrollbar(sb, value, dragging);
432 }
433 return Pt_CONTINUE;
434 }
435
436 static int
gui_ph_handle_keyboard(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)437 gui_ph_handle_keyboard(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
438 {
439 PhKeyEvent_t *key;
440 unsigned char string[6];
441 int len, i;
442 int ch, modifiers;
443
444 key = PhGetData(info->event);
445
446 ch = modifiers = len = 0;
447
448 if (p_mh)
449 gui_mch_mousehide(MOUSE_HIDE);
450
451 // We're a good lil photon program, aren't we? yes we are, yeess wee arrr
452 if (key->key_flags & Pk_KF_Compose)
453 return Pt_CONTINUE;
454
455 if ((key->key_flags & Pk_KF_Cap_Valid) &&
456 PkIsKeyDown(key->key_flags))
457 {
458 #ifdef FEAT_MENU
459 /*
460 * Only show the menu if the Alt key is down, and the Shift & Ctrl
461 * keys aren't down, as well as the other conditions
462 */
463 if (((key->key_mods & Pk_KM_Alt) &&
464 !(key->key_mods & Pk_KM_Shift) &&
465 !(key->key_mods & Pk_KM_Ctrl)) &&
466 gui.menu_is_active &&
467 (*p_wak == 'y' ||
468 (*p_wak == 'm' &&
469 gui_is_menu_shortcut(key->key_cap))))
470 {
471 // Fallthrough and let photon look for the hotkey
472 return Pt_CONTINUE;
473 }
474 #endif
475
476 for (i = 0; special_keys[i].key_sym != 0; i++)
477 {
478 if (special_keys[i].key_sym == key->key_cap)
479 {
480 len = 0;
481 if (special_keys[i].vim_code1 == NUL)
482 ch = special_keys[i].vim_code0;
483 else
484 {
485 // Detect if a keypad number key has been pressed
486 // and change the key if Num Lock is on
487 if (key->key_cap >= Pk_KP_Enter && key->key_cap <= Pk_KP_9
488 && (key->key_mods & Pk_KM_Num_Lock))
489 {
490 // FIXME: For now, just map the key to a ascii value
491 // (see <photon/PkKeyDef.h>)
492 ch = key->key_cap - 0xf080;
493 }
494 else
495 ch = TO_SPECIAL(special_keys[i].vim_code0,
496 special_keys[i].vim_code1);
497 }
498 break;
499 }
500 }
501
502 if (key->key_mods & Pk_KM_Ctrl)
503 modifiers |= MOD_MASK_CTRL;
504 if (key->key_mods & Pk_KM_Alt)
505 modifiers |= MOD_MASK_ALT;
506 if (key->key_mods & Pk_KM_Shift)
507 modifiers |= MOD_MASK_SHIFT;
508
509 // Is this not a special key?
510 if (special_keys[i].key_sym == 0)
511 {
512 ch = PhTo8859_1(key);
513 if (ch == -1 || (enc_utf8 && ch > 127))
514 {
515 len = PhKeyToMb(string, key);
516 if (len > 0)
517 {
518 static char buf[6];
519 int src_taken, dst_made;
520 if (enc_utf8 != TRUE)
521 {
522 PxTranslateFromUTF(
523 charset_translate,
524 string,
525 len,
526 &src_taken,
527 buf,
528 6,
529 &dst_made);
530
531 add_to_input_buf(buf, dst_made);
532 }
533 else
534 {
535 add_to_input_buf(string, len);
536 }
537
538 return Pt_CONSUME;
539 }
540 len = 0;
541 ch = key->key_cap;
542 if (ch < 0xff)
543 {
544 // FIXME: is this the right thing to do?
545 if (modifiers & MOD_MASK_CTRL)
546 {
547 modifiers &= ~MOD_MASK_CTRL;
548
549 if ((ch >= 'a' && ch <= 'z') ||
550 ch == '[' ||
551 ch == ']' ||
552 ch == '\\')
553 ch = Ctrl_chr(ch);
554 else if (ch == '2')
555 ch = NUL;
556 else if (ch == '6')
557 ch = 0x1e;
558 else if (ch == '-')
559 ch = 0x1f;
560 else
561 modifiers |= MOD_MASK_CTRL;
562 }
563
564 if (modifiers & MOD_MASK_ALT)
565 {
566 ch = Meta(ch);
567 modifiers &= ~MOD_MASK_ALT;
568 }
569 }
570 else
571 {
572 return Pt_CONTINUE;
573 }
574 }
575 else
576 modifiers &= ~MOD_MASK_SHIFT;
577 }
578
579 ch = simplify_key(ch, &modifiers);
580 if (modifiers)
581 {
582 string[ len++ ] = CSI;
583 string[ len++ ] = KS_MODIFIER;
584 string[ len++ ] = modifiers;
585 }
586
587 if (IS_SPECIAL(ch))
588 {
589 string[ len++ ] = CSI;
590 string[ len++ ] = K_SECOND(ch);
591 string[ len++ ] = K_THIRD(ch);
592 }
593 else
594 {
595 string[ len++ ] = ch;
596 }
597
598 // Check if the key interrupts.
599 {
600 int int_ch = check_for_interrupt(ch, modifiers);
601
602 if (int_ch != NUL)
603 {
604 ch = int_ch;
605 string[0] = ch;
606 len = 1;
607 trash_input_buf();
608 }
609 }
610
611 if (len == 1 && string[0] == CSI)
612 {
613 // Turn CSI into K_CSI.
614 string[ len++ ] = KS_EXTRA;
615 string[ len++ ] = KE_CSI;
616 }
617
618 if (len > 0)
619 {
620 add_to_input_buf(string, len);
621 return Pt_CONSUME;
622 }
623 }
624
625 return Pt_CONTINUE;
626 }
627
628 static int
gui_ph_handle_mouse(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)629 gui_ph_handle_mouse(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
630 {
631 PhPointerEvent_t *pointer;
632 PhRect_t *pos;
633 int button = 0, repeated_click, modifiers = 0x0;
634 short mouse_x, mouse_y;
635
636 pointer = PhGetData(info->event);
637 pos = PhGetRects(info->event);
638
639 gui_mch_mousehide(MOUSE_SHOW);
640
641 /*
642 * Coordinates need to be relative to the base window,
643 * not relative to the vimTextArea widget
644 */
645 mouse_x = pos->ul.x + gui.border_width;
646 mouse_y = pos->ul.y + gui.border_width;
647
648 if (info->event->type == Ph_EV_PTR_MOTION_NOBUTTON)
649 {
650 gui_mouse_moved(mouse_x, mouse_y);
651 return Pt_CONTINUE;
652 }
653
654 if (pointer->key_mods & Pk_KM_Shift)
655 modifiers |= MOUSE_SHIFT;
656 if (pointer->key_mods & Pk_KM_Ctrl)
657 modifiers |= MOUSE_CTRL;
658 if (pointer->key_mods & Pk_KM_Alt)
659 modifiers |= MOUSE_ALT;
660
661 /*
662 * FIXME More than one button may be involved, but for
663 * now just deal with one
664 */
665 if (pointer->buttons & Ph_BUTTON_SELECT)
666 button = MOUSE_LEFT;
667
668 if (pointer->buttons & Ph_BUTTON_MENU)
669 {
670 button = MOUSE_RIGHT;
671 // Need the absolute coordinates for the popup menu
672 abs_mouse.x = pointer->pos.x;
673 abs_mouse.y = pointer->pos.y;
674 }
675
676 if (pointer->buttons & Ph_BUTTON_ADJUST)
677 button = MOUSE_MIDDLE;
678
679 // Catch a real release (not phantom or other releases
680 if (info->event->type == Ph_EV_BUT_RELEASE)
681 button = MOUSE_RELEASE;
682
683 if (info->event->type & Ph_EV_PTR_MOTION_BUTTON)
684 button = MOUSE_DRAG;
685
686 #if 0
687 // Vim doesn't use button repeats
688 if (info->event->type & Ph_EV_BUT_REPEAT)
689 button = MOUSE_DRAG;
690 #endif
691
692 // Don't do anything if it is one of the phantom mouse release events
693 if ((button != MOUSE_RELEASE) ||
694 (info->event->subtype == Ph_EV_RELEASE_REAL))
695 {
696 repeated_click = (pointer->click_count >= 2) ? TRUE : FALSE;
697
698 gui_send_mouse_event(button , mouse_x, mouse_y, repeated_click, modifiers);
699 }
700
701 return Pt_CONTINUE;
702 }
703
704 /*
705 * Handle a focus change of the PtRaw widget
706 */
707 static int
gui_ph_handle_focus(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)708 gui_ph_handle_focus(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
709 {
710 if (info->reason == Pt_CB_LOST_FOCUS)
711 {
712 PtRemoveEventHandler(gui.vimTextArea, Ph_EV_PTR_MOTION_NOBUTTON,
713 gui_ph_handle_mouse, NULL);
714
715 gui_mch_mousehide(MOUSE_SHOW);
716 }
717 else
718 {
719 PtAddEventHandler(gui.vimTextArea, Ph_EV_PTR_MOTION_NOBUTTON,
720 gui_ph_handle_mouse, NULL);
721 }
722 return Pt_CONTINUE;
723 }
724
725 static void
gui_ph_handle_raw_draw(PtWidget_t * widget,PhTile_t * damage)726 gui_ph_handle_raw_draw(PtWidget_t *widget, PhTile_t *damage)
727 {
728 PhRect_t *r;
729 PhPoint_t offset;
730 PhPoint_t translation;
731
732 if (is_ignore_draw == TRUE)
733 return;
734
735 PtSuperClassDraw(PtBasic, widget, damage);
736 PgGetTranslation(&translation);
737 PgClearTranslation();
738
739 #if 0
740 /*
741 * This causes some weird problems, with drawing being done from
742 * within this raw drawing function (rather than just simple clearing
743 * and text drawing done by gui_redraw)
744 *
745 * The main problem is when PhBlit is used, and the cursor appearing
746 * in places where it shouldn't
747 */
748 out_flush();
749 #endif
750
751 PtWidgetOffset(widget, &offset);
752 PhTranslatePoint(&offset, PtWidgetPos(gui.vimTextArea, NULL));
753
754 #if 1
755 // Redraw individual damage regions
756 if (damage->next != NULL)
757 damage = damage->next;
758
759 while (damage != NULL)
760 {
761 r = &damage->rect;
762 gui_redraw(
763 r->ul.x - offset.x, r->ul.y - offset.y,
764 r->lr.x - r->ul.x + 1,
765 r->lr.y - r->ul.y + 1);
766 damage = damage->next;
767 }
768 #else
769 // Redraw the rectangle that covers all the damaged regions
770 r = &damage->rect;
771 gui_redraw(
772 r->ul.x - offset.x, r->ul.y - offset.y,
773 r->lr.x - r->ul.x + 1,
774 r->lr.y - r->ul.y + 1);
775 #endif
776
777 PgSetTranslation(&translation, 0);
778 }
779
780 static int
gui_ph_handle_pulldown_menu(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)781 gui_ph_handle_pulldown_menu(
782 PtWidget_t *widget,
783 void *data,
784 PtCallbackInfo_t *info)
785 {
786 if (data != NULL)
787 {
788 vimmenu_T *menu = (vimmenu_T *) data;
789
790 PtPositionMenu(menu->submenu_id, NULL);
791 PtRealizeWidget(menu->submenu_id);
792 }
793
794 return Pt_CONTINUE;
795 }
796
797 /*
798 * This is used for pulldown/popup menus and also toolbar buttons
799 */
800 static int
gui_ph_handle_menu(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)801 gui_ph_handle_menu(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
802 {
803 if (data != NULL)
804 {
805 vimmenu_T *menu = (vimmenu_T *) data;
806 gui_menu_cb(menu);
807 }
808 return Pt_CONTINUE;
809 }
810
811 /*
812 * Stop focus from disappearing into the menubar...
813 */
814 static int
gui_ph_handle_menu_unrealized(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)815 gui_ph_handle_menu_unrealized(
816 PtWidget_t *widget,
817 void *data,
818 PtCallbackInfo_t *info)
819 {
820 PtGiveFocus(gui.vimTextArea, NULL);
821 return Pt_CONTINUE;
822 }
823
824 static int
gui_ph_handle_window_open(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)825 gui_ph_handle_window_open(
826 PtWidget_t *widget,
827 void *data,
828 PtCallbackInfo_t *info)
829 {
830 gui_set_shellsize(FALSE, TRUE, RESIZE_BOTH);
831 return Pt_CONTINUE;
832 }
833
834 ////////////////////////////////////////////////////////////////////////////
835
836 #define DRAW_START gui_ph_draw_start()
837 #define DRAW_END gui_ph_draw_end()
838
839 /*
840 * TODO: Set a clipping rect?
841 */
842 static void
gui_ph_draw_start(void)843 gui_ph_draw_start(void)
844 {
845 PhGC_t *gc;
846
847 gc = PgGetGC();
848 PgSetRegion(PtWidgetRid(PtFindDisjoint(gui.vimTextArea)));
849 PgClearClippingsCx(gc);
850 PgClearTranslationCx(gc);
851
852 PtWidgetOffset(gui.vimTextArea, &gui_ph_raw_offset);
853 PhTranslatePoint(&gui_ph_raw_offset, PtWidgetPos(gui.vimTextArea, NULL));
854
855 PgSetTranslation(&gui_ph_raw_offset, Pg_RELATIVE);
856 }
857
858 static void
gui_ph_draw_end(void)859 gui_ph_draw_end(void)
860 {
861 gui_ph_raw_offset.x = -gui_ph_raw_offset.x;
862 gui_ph_raw_offset.y = -gui_ph_raw_offset.y;
863 PgSetTranslation(&gui_ph_raw_offset, Pg_RELATIVE);
864 }
865
866 #ifdef USE_PANEL_GROUP
867 static vimmenu_T *
gui_ph_find_buffer_item(char_u * name)868 gui_ph_find_buffer_item(char_u *name)
869 {
870 vimmenu_T *top_level = root_menu;
871 vimmenu_T *items = NULL;
872
873 while (top_level != NULL &&
874 (STRCMP(top_level->dname, "Buffers") != 0))
875 top_level = top_level->next;
876
877 if (top_level != NULL)
878 {
879 items = top_level->children;
880
881 while (items != NULL &&
882 (STRCMP(items->dname, name) != 0))
883 items = items->next;
884 }
885 return items;
886 }
887
888 static void
gui_ph_pg_set_buffer_num(int_u buf_num)889 gui_ph_pg_set_buffer_num(int_u buf_num)
890 {
891 int i;
892 char search[16];
893 char *mark;
894
895 if (gui.vimTextArea == NULL || buf_num == 0)
896 return;
897
898 search[0] = '(';
899 ultoa(buf_num, &search[1], 10);
900 STRCAT(search, ")");
901
902 for (i = 0; i < num_panels; i++)
903 {
904 // find the last "(" in the panel title and see if the buffer
905 // number in the title matches the one we're looking for
906 mark = STRRCHR(panel_titles[ i ], '(');
907 if (mark != NULL && STRCMP(mark, search) == 0)
908 {
909 PtSetResource(gui.vimPanelGroup, Pt_ARG_PG_CURRENT_INDEX,
910 i, 0);
911 }
912 }
913 }
914
915 static int
gui_ph_handle_pg_change(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)916 gui_ph_handle_pg_change(
917 PtWidget_t *widget,
918 void *data,
919 PtCallbackInfo_t *info)
920 {
921 vimmenu_T *menu;
922 PtPanelGroupCallback_t *panel;
923
924 if (info->event != NULL)
925 {
926 panel = info->cbdata;
927 if (panel->new_panel != NULL)
928 {
929 menu = gui_ph_find_buffer_item(panel->new_panel);
930 if (menu)
931 gui_menu_cb(menu);
932 }
933 }
934 return Pt_CONTINUE;
935 }
936
937 static void
gui_ph_get_panelgroup_margins(short * top,short * bottom,short * left,short * right)938 gui_ph_get_panelgroup_margins(
939 short *top,
940 short *bottom,
941 short *left,
942 short *right)
943 {
944 unsigned short abs_raw_x, abs_raw_y, abs_panel_x, abs_panel_y;
945 const unsigned short *margin_top, *margin_bottom;
946 const unsigned short *margin_left, *margin_right;
947
948 PtGetAbsPosition(gui.vimTextArea, &abs_raw_x, &abs_raw_y);
949 PtGetAbsPosition(gui.vimPanelGroup, &abs_panel_x, &abs_panel_y);
950
951 PtGetResource(gui.vimPanelGroup, Pt_ARG_MARGIN_RIGHT, &margin_right, 0);
952 PtGetResource(gui.vimPanelGroup, Pt_ARG_MARGIN_BOTTOM, &margin_bottom, 0);
953
954 abs_raw_x -= abs_panel_x;
955 abs_raw_y -= abs_panel_y;
956
957 *top = abs_raw_y;
958 *bottom = *margin_bottom;
959
960 *left = abs_raw_x;
961 *right = *margin_right;
962 }
963
964 /*
965 * Used for the tabs for PtPanelGroup
966 */
967 static int
gui_ph_is_buffer_item(vimmenu_T * menu,vimmenu_T * parent)968 gui_ph_is_buffer_item(vimmenu_T *menu, vimmenu_T *parent)
969 {
970 char *mark;
971
972 if (STRCMP(parent->dname, "Buffers") == 0)
973 {
974 // Look for '(' digits ')'
975 mark = vim_strchr(menu->dname, '(');
976 if (mark != NULL)
977 {
978 mark++;
979 while (isdigit(*mark))
980 mark++;
981
982 if (*mark == ')')
983 return TRUE;
984 }
985 }
986 return FALSE;
987 }
988
989 static void
gui_ph_pg_add_buffer(char * name)990 gui_ph_pg_add_buffer(char *name)
991 {
992 char **new_titles = NULL;
993
994 new_titles = ALLOC_MULT(char *, (num_panels + 1));
995 if (new_titles != NULL)
996 {
997 if (num_panels > 0)
998 memcpy(new_titles, panel_titles, num_panels * sizeof(char **));
999
1000 new_titles[ num_panels++ ] = name;
1001
1002 PtSetResource(gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, new_titles,
1003 num_panels);
1004
1005 vim_free(panel_titles);
1006 panel_titles = new_titles;
1007 }
1008 }
1009
1010 static void
gui_ph_pg_remove_buffer(char * name)1011 gui_ph_pg_remove_buffer(char *name)
1012 {
1013 int i;
1014 char **new_titles = NULL;
1015
1016 // If there is only 1 panel, we just use the temporary place holder
1017 if (num_panels > 1)
1018 {
1019 new_titles = ALLOC_MULT(char *, num_panels - 1);
1020 if (new_titles != NULL)
1021 {
1022 char **s = new_titles;
1023 // Copy all the titles except the one we're removing
1024 for (i = 0; i < num_panels; i++)
1025 {
1026 if (STRCMP(panel_titles[ i ], name) != 0)
1027 *s++ = panel_titles[ i ];
1028 }
1029 num_panels--;
1030
1031 PtSetResource(gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, new_titles,
1032 num_panels);
1033
1034 vim_free(panel_titles);
1035 panel_titles = new_titles;
1036 }
1037 }
1038 else
1039 {
1040 num_panels--;
1041 PtSetResource(gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, &empty_title,
1042 1);
1043
1044 VIM_CLEAR(panel_titles);
1045 }
1046 }
1047
1048 /*
1049 * When a buffer item is deleted from the buffer menu
1050 */
1051 static int
gui_ph_handle_buffer_remove(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)1052 gui_ph_handle_buffer_remove(
1053 PtWidget_t *widget,
1054 void *data,
1055 PtCallbackInfo_t *info)
1056 {
1057 vimmenu_T *menu;
1058
1059 if (data != NULL)
1060 {
1061 menu = (vimmenu_T *) data;
1062 gui_ph_pg_remove_buffer(menu->dname);
1063 }
1064
1065 return Pt_CONTINUE;
1066 }
1067 #endif
1068
1069 static int
gui_ph_pane_resize(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)1070 gui_ph_pane_resize(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
1071 {
1072 if (PtWidgetIsRealized(widget))
1073 {
1074 is_ignore_draw = TRUE;
1075 PtStartFlux(gui.vimContainer);
1076 PtContainerHold(gui.vimContainer);
1077 }
1078
1079 return Pt_CONTINUE;
1080 }
1081
1082 ////////////////////////////////////////////////////////////////////////////
1083
1084 void
gui_ph_encoding_changed(int new_encoding)1085 gui_ph_encoding_changed(int new_encoding)
1086 {
1087 // Default encoding is latin1
1088 char *charset = "latin1";
1089 int i;
1090
1091 struct {
1092 int encoding;
1093 char *name;
1094 } charsets[] = {
1095 { DBCS_JPN, "SHIFT_JIS" },
1096 { DBCS_KOR, "csEUCKR" },
1097 { DBCS_CHT, "big5" },
1098 { DBCS_CHS, "gb" }
1099 };
1100
1101 for (i = 0; i < ARRAY_LENGTH(charsets); i++)
1102 {
1103 if (new_encoding == charsets[ i ].encoding)
1104 charset = charsets[ i ].name;
1105 }
1106
1107 charset_translate = PxTranslateSet(charset_translate, charset);
1108 }
1109
1110 ////////////////////////////////////////////////////////////////////////////
1111
1112 void
gui_mch_prepare(int * argc,char ** argv)1113 gui_mch_prepare(int *argc, char **argv)
1114 {
1115 PtInit(NULL);
1116 }
1117
1118 int
gui_mch_init(void)1119 gui_mch_init(void)
1120 {
1121 PtArg_t args[10];
1122 int flags = 0, n = 0;
1123
1124 PhDim_t window_size = {100, 100}; // Arbitrary values
1125 PhPoint_t pos = {0, 0};
1126
1127 gui.event_buffer = alloc(EVENT_BUFFER_SIZE);
1128 if (gui.event_buffer == NULL)
1129 return FAIL;
1130
1131 // Get a translation so we can convert from ISO Latin-1 to UTF
1132 charset_translate = PxTranslateSet(NULL, "latin1");
1133
1134 // The +2 is for the 1 pixel dark line on each side
1135 gui.border_offset = gui.border_width = GUI_PH_MARGIN + 2;
1136
1137 // Handle close events ourselves
1138 PtSetArg(&args[ n++ ], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_CLOSE);
1139 PtSetArg(&args[ n++ ], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
1140 Ph_WM_CLOSE | Ph_WM_RESIZE | Ph_WM_FOCUS);
1141 PtSetArg(&args[ n++ ], Pt_ARG_DIM, &window_size, 0);
1142 gui.vimWindow = PtCreateWidget(PtWindow, NULL, n, args);
1143 if (gui.vimWindow == NULL)
1144 return FAIL;
1145
1146 PtAddCallback(gui.vimWindow, Pt_CB_WINDOW, gui_ph_handle_window_cb, NULL);
1147 PtAddCallback(gui.vimWindow, Pt_CB_WINDOW_OPENING,
1148 gui_ph_handle_window_open, NULL);
1149
1150 n = 0;
1151 PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS, Pt_ANCHOR_ALL, Pt_IS_ANCHORED);
1152 PtSetArg(&args[ n++ ], Pt_ARG_DIM, &window_size, 0);
1153 PtSetArg(&args[ n++ ], Pt_ARG_POS, &pos, 0);
1154
1155 #ifdef USE_PANEL_GROUP
1156 // Put in a temporary place holder title
1157 PtSetArg(&args[ n++ ], Pt_ARG_PG_PANEL_TITLES, &empty_title, 1);
1158
1159 gui.vimPanelGroup = PtCreateWidget(PtPanelGroup, gui.vimWindow, n, args);
1160 if (gui.vimPanelGroup == NULL)
1161 return FAIL;
1162
1163 PtAddCallback(gui.vimPanelGroup, Pt_CB_PG_PANEL_SWITCHING,
1164 gui_ph_handle_pg_change, NULL);
1165 #else
1166 // Turn off all edge decorations
1167 PtSetArg(&args[ n++ ], Pt_ARG_BASIC_FLAGS, Pt_FALSE, Pt_ALL);
1168 PtSetArg(&args[ n++ ], Pt_ARG_BEVEL_WIDTH, 0, 0);
1169 PtSetArg(&args[ n++ ], Pt_ARG_MARGIN_WIDTH, 0, 0);
1170 PtSetArg(&args[ n++ ], Pt_ARG_MARGIN_HEIGHT, 0, 0);
1171 PtSetArg(&args[ n++ ], Pt_ARG_CONTAINER_FLAGS, Pt_TRUE, Pt_AUTO_EXTENT);
1172
1173 gui.vimContainer = PtCreateWidget(PtPane, gui.vimWindow, n, args);
1174 if (gui.vimContainer == NULL)
1175 return FAIL;
1176
1177 PtAddCallback(gui.vimContainer, Pt_CB_RESIZE, gui_ph_pane_resize, NULL);
1178 #endif
1179
1180 // Size for the text area is set in gui_mch_set_text_area_pos
1181 n = 0;
1182
1183 PtSetArg(&args[ n++ ], Pt_ARG_RAW_DRAW_F, gui_ph_handle_raw_draw, 1);
1184 PtSetArg(&args[ n++ ], Pt_ARG_BEVEL_WIDTH, GUI_PH_MARGIN, 0);
1185 /*
1186 * Using focus render also causes the whole widget to be redrawn
1187 * whenever it changes focus, which is very annoying :p
1188 */
1189 PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_TRUE,
1190 Pt_GETS_FOCUS | Pt_HIGHLIGHTED);
1191 #ifndef FEAT_MOUSESHAPE
1192 PtSetArg(&args[ n++ ], Pt_ARG_CURSOR_TYPE, GUI_PH_MOUSE_TYPE, 0);
1193 PtSetArg(&args[ n++ ], Pt_ARG_CURSOR_COLOR, gui_ph_mouse_color, 0);
1194 #endif
1195
1196 gui.vimTextArea = PtCreateWidget(PtRaw, Pt_DFLT_PARENT, n, args);
1197 if (gui.vimTextArea == NULL)
1198 return FAIL;
1199
1200 // TODO: use PtAddEventHandlers instead?
1201 // Not using Ph_EV_BUT_REPEAT because vim wouldn't use it anyway
1202 PtAddEventHandler(gui.vimTextArea,
1203 Ph_EV_BUT_PRESS | Ph_EV_BUT_RELEASE | Ph_EV_PTR_MOTION_BUTTON,
1204 gui_ph_handle_mouse, NULL);
1205 PtAddEventHandler(gui.vimTextArea, Ph_EV_KEY,
1206 gui_ph_handle_keyboard, NULL);
1207 PtAddCallback(gui.vimTextArea, Pt_CB_GOT_FOCUS,
1208 gui_ph_handle_focus, NULL);
1209 PtAddCallback(gui.vimTextArea, Pt_CB_LOST_FOCUS,
1210 gui_ph_handle_focus, NULL);
1211
1212 /*
1213 * Now that the text area widget has been created, set up the colours,
1214 * which will call PtSetResource from gui_mch_new_colors
1215 */
1216
1217 /*
1218 * Create the two timers, not as accurate as using the kernel timer
1219 * functions, but good enough
1220 */
1221 gui_ph_timer_cursor = PtCreateWidget(PtTimer, gui.vimWindow, 0, NULL);
1222 if (gui_ph_timer_cursor == NULL)
1223 return FAIL;
1224
1225 gui_ph_timer_timeout = PtCreateWidget(PtTimer, gui.vimWindow, 0, NULL);
1226 if (gui_ph_timer_timeout == NULL)
1227 return FAIL;
1228
1229 PtAddCallback(gui_ph_timer_cursor, Pt_CB_TIMER_ACTIVATE,
1230 gui_ph_handle_timer_cursor, NULL);
1231 PtAddCallback(gui_ph_timer_timeout, Pt_CB_TIMER_ACTIVATE,
1232 gui_ph_handle_timer_timeout, NULL);
1233
1234 #ifdef FEAT_MENU
1235 n = 0;
1236 PtSetArg(&args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0);
1237 PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS, Pt_ANCHOR_LEFT_RIGHT,
1238 Pt_IS_ANCHORED);
1239 gui.vimToolBarGroup = PtCreateWidget(PtToolbarGroup, gui.vimWindow,
1240 n, args);
1241 if (gui.vimToolBarGroup == NULL)
1242 return FAIL;
1243
1244 PtAddCallback(gui.vimToolBarGroup, Pt_CB_RESIZE,
1245 gui_ph_handle_menu_resize, NULL);
1246
1247 n = 0;
1248 flags = 0;
1249 PtSetArg(&args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0);
1250 if (! vim_strchr(p_go, GO_MENUS))
1251 {
1252 flags |= Pt_DELAY_REALIZE;
1253 PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_TRUE, flags);
1254 }
1255 gui.vimMenuBar = PtCreateWidget(PtMenuBar, gui.vimToolBarGroup, n, args);
1256 if (gui.vimMenuBar == NULL)
1257 return FAIL;
1258
1259 # ifdef FEAT_TOOLBAR
1260 n = 0;
1261
1262 PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS,
1263 Pt_ANCHOR_LEFT_RIGHT |Pt_TOP_ANCHORED_TOP, Pt_IS_ANCHORED);
1264 PtSetArg(&args[ n++ ], Pt_ARG_RESIZE_FLAGS, Pt_TRUE,
1265 Pt_RESIZE_Y_AS_REQUIRED);
1266 PtSetArg(&args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0);
1267
1268 flags = Pt_GETS_FOCUS;
1269 if (! vim_strchr(p_go, GO_TOOLBAR))
1270 flags |= Pt_DELAY_REALIZE;
1271
1272 PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_DELAY_REALIZE, flags);
1273
1274 gui.vimToolBar = PtCreateWidget(PtToolbar, gui.vimToolBarGroup, n, args);
1275 if (gui.vimToolBar == NULL)
1276 return FAIL;
1277
1278 /*
1279 * Size for the toolbar is fetched in gui_mch_show_toolbar, after
1280 * the buttons have been added and the toolbar has resized it's height
1281 * for the buttons to fit
1282 */
1283 # endif
1284
1285 #endif
1286
1287 return OK;
1288 }
1289
1290 int
gui_mch_init_check(void)1291 gui_mch_init_check(void)
1292 {
1293 return (is_photon_available == TRUE) ? OK : FAIL;
1294 }
1295
1296 int
gui_mch_open(void)1297 gui_mch_open(void)
1298 {
1299 gui.norm_pixel = Pg_BLACK;
1300 gui.back_pixel = Pg_WHITE;
1301
1302 set_normal_colors();
1303
1304 gui_check_colors();
1305 gui.def_norm_pixel = gui.norm_pixel;
1306 gui.def_back_pixel = gui.back_pixel;
1307
1308 highlight_gui_started();
1309
1310 if (gui_win_x != -1 && gui_win_y != -1)
1311 gui_mch_set_winpos(gui_win_x, gui_win_y);
1312
1313 return (PtRealizeWidget(gui.vimWindow) == 0) ? OK : FAIL;
1314 }
1315
1316 void
gui_mch_exit(int rc)1317 gui_mch_exit(int rc)
1318 {
1319 PtDestroyWidget(gui.vimWindow);
1320
1321 PxTranslateSet(charset_translate, NULL);
1322
1323 vim_free(gui.event_buffer);
1324
1325 #ifdef USE_PANEL_GROUPS
1326 vim_free(panel_titles);
1327 #endif
1328 }
1329
1330 ////////////////////////////////////////////////////////////////////////////
1331 // events
1332
1333 /*
1334 * When no events are available, photon will call this function, working is
1335 * set to FALSE, and the gui_mch_update loop will exit.
1336 */
1337 static int
exit_gui_mch_update(void * data)1338 exit_gui_mch_update(void *data)
1339 {
1340 *(int *)data = FALSE;
1341 return Pt_END;
1342 }
1343
1344 void
gui_mch_update(void)1345 gui_mch_update(void)
1346 {
1347 int working = TRUE;
1348
1349 PtAppAddWorkProc(NULL, exit_gui_mch_update, &working);
1350 while ((working == TRUE) && !vim_is_input_buf_full())
1351 PtProcessEvent();
1352 }
1353
1354 int
gui_mch_wait_for_chars(int wtime)1355 gui_mch_wait_for_chars(int wtime)
1356 {
1357 is_timeout = FALSE;
1358
1359 if (wtime >= 0)
1360 PtSetResource(gui_ph_timer_timeout, Pt_ARG_TIMER_INITIAL,
1361 wtime == 0 ? 1 : wtime, 0);
1362
1363 while (1)
1364 {
1365 PtProcessEvent();
1366 if (input_available())
1367 {
1368 PtSetResource(gui_ph_timer_timeout, Pt_ARG_TIMER_INITIAL, 0, 0);
1369 return OK;
1370 }
1371 else if (is_timeout == TRUE)
1372 return FAIL;
1373 }
1374 }
1375
1376 #if defined(FEAT_BROWSE) || defined(PROTO)
1377 /*
1378 * Put up a file requester.
1379 * Returns the selected name in allocated memory, or NULL for Cancel.
1380 * saving, select file to write
1381 * title title for the window
1382 * default_name default name (well duh!)
1383 * ext not used (extension added)
1384 * initdir initial directory, NULL for current dir
1385 * filter not used (file name filter)
1386 */
1387 char_u *
gui_mch_browse(int saving,char_u * title,char_u * default_name,char_u * ext,char_u * initdir,char_u * filter)1388 gui_mch_browse(
1389 int saving,
1390 char_u *title,
1391 char_u *default_name,
1392 char_u *ext,
1393 char_u *initdir,
1394 char_u *filter)
1395 {
1396 PtFileSelectionInfo_t file;
1397 int flags;
1398 char_u *default_path;
1399 char_u *open_text = NULL;
1400
1401 flags = 0;
1402 memset(&file, 0, sizeof(file));
1403
1404 default_path = alloc(MAXPATHL + 1 + NAME_MAX + 1);
1405 if (default_path != NULL)
1406 {
1407 if (saving == TRUE)
1408 {
1409 // Don't need Pt_FSR_CONFIRM_EXISTING, vim will ask anyway
1410 flags |= Pt_FSR_NO_FCHECK;
1411 open_text = "&Save";
1412 }
1413
1414 // combine the directory and filename into a single path
1415 if (initdir == NULL || *initdir == NUL)
1416 {
1417 mch_dirname(default_path, MAXPATHL);
1418 initdir = default_path;
1419 }
1420 else
1421 {
1422 STRCPY(default_path, initdir);
1423 initdir = default_path;
1424 }
1425
1426 if (default_name != NULL)
1427 {
1428 if (default_path[ STRLEN(default_path) - 1 ] != '/')
1429 STRCAT(default_path, "/");
1430
1431 STRCAT(default_path, default_name);
1432 }
1433
1434 // TODO: add a filter?
1435 PtFileSelection(
1436 gui.vimWindow,
1437 NULL,
1438 title,
1439 default_path,
1440 NULL,
1441 open_text,
1442 NULL,
1443 NULL,
1444 &file,
1445 flags);
1446
1447 vim_free(default_path);
1448
1449 if (file.ret == Pt_FSDIALOG_BTN1)
1450 return vim_strsave(file.path);
1451 }
1452 return NULL;
1453 }
1454 #endif
1455
1456 #if defined(FEAT_GUI_DIALOG) || defined(PROTO)
1457 static PtWidget_t *gui_ph_dialog_text = NULL;
1458
1459 static int
gui_ph_dialog_close(int button,void * data)1460 gui_ph_dialog_close(int button, void *data)
1461 {
1462 PtModalCtrl_t *modal_ctrl = data;
1463 char_u *dialog_text, *vim_text;
1464
1465 if (gui_ph_dialog_text != NULL)
1466 {
1467 PtGetResource(gui_ph_dialog_text, Pt_ARG_TEXT_STRING, &dialog_text, 0);
1468 PtGetResource(gui_ph_dialog_text, Pt_ARG_POINTER, &vim_text, 0);
1469 STRNCPY(vim_text, dialog_text, IOSIZE - 1);
1470 }
1471
1472 PtModalUnblock(modal_ctrl, (void *) button);
1473
1474 return Pt_TRUE;
1475 }
1476
1477 static int
gui_ph_dialog_text_enter(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)1478 gui_ph_dialog_text_enter(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
1479 {
1480 if (info->reason_subtype == Pt_EDIT_ACTIVATE)
1481 gui_ph_dialog_close(1, data);
1482 return Pt_CONTINUE;
1483 }
1484
1485 static int
gui_ph_dialog_esc(PtWidget_t * widget,void * data,PtCallbackInfo_t * info)1486 gui_ph_dialog_esc(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
1487 {
1488 PhKeyEvent_t *key;
1489
1490 key = PhGetData(info->event);
1491 if ((key->key_flags & Pk_KF_Cap_Valid) && (key->key_cap == Pk_Escape))
1492 {
1493 gui_ph_dialog_close(0, data);
1494 return Pt_CONSUME;
1495 }
1496 return Pt_PROCESS;
1497 }
1498
1499 int
gui_mch_dialog(int type,char_u * title,char_u * message,char_u * buttons,int default_button,char_u * textfield,int ex_cmd)1500 gui_mch_dialog(
1501 int type,
1502 char_u *title,
1503 char_u *message,
1504 char_u *buttons,
1505 int default_button,
1506 char_u *textfield,
1507 int ex_cmd)
1508 {
1509 char_u *str;
1510 char_u **button_array;
1511 char_u *buttons_copy;
1512
1513 int button_count;
1514 int i, len;
1515 int dialog_result = -1;
1516
1517 // FIXME: the vertical option in guioptions is blatantly ignored
1518 // FIXME: so is the type
1519
1520 button_count = len = i = 0;
1521
1522 if (buttons == NULL || *buttons == NUL)
1523 return -1;
1524
1525 // There is one less separator than buttons, so bump up the button count
1526 button_count = 1;
1527
1528 // Count string length and number of separators
1529 for (str = buttons; *str; str++)
1530 {
1531 len++;
1532 if (*str == DLG_BUTTON_SEP)
1533 button_count++;
1534 }
1535
1536 if (title == NULL)
1537 title = "Vim";
1538
1539 buttons_copy = alloc(len + 1);
1540 button_array = ALLOC_MULT(char_u *, button_count);
1541 if (buttons_copy != NULL && button_array != NULL)
1542 {
1543 STRCPY(buttons_copy, buttons);
1544
1545 /*
1546 * Convert DLG_BUTTON_SEP into NUL's and fill in
1547 * button_array with the pointer to each NUL terminated string
1548 */
1549 str = buttons_copy;
1550 for (i = 0; i < button_count; i++)
1551 {
1552 button_array[ i ] = str;
1553 for (; *str; str++)
1554 {
1555 if (*str == DLG_BUTTON_SEP)
1556 {
1557 *str++ = NUL;
1558 break;
1559 }
1560 }
1561 }
1562 #ifndef FEAT_GUI_TEXTDIALOG
1563 dialog_result = PtAlert(
1564 gui.vimWindow, NULL,
1565 title,
1566 NULL,
1567 message, NULL,
1568 button_count, (const char **) button_array, NULL,
1569 default_button, 0, Pt_MODAL);
1570 #else
1571 // Writing the dialog ourselves lets us add extra features, like
1572 // trapping the escape key and returning 0 to vim
1573 {
1574 int n;
1575 PtArg_t args[5];
1576 PtWidget_t *dialog, *pane;
1577 PtModalCtrl_t modal_ctrl;
1578 PtDialogInfo_t di;
1579
1580 memset(&di, 0, sizeof(di));
1581 memset(&modal_ctrl, 0, sizeof(modal_ctrl));
1582
1583 n = 0;
1584 PtSetArg(&args[n++], Pt_ARG_GROUP_ROWS_COLS, 0, 0);
1585 PtSetArg(&args[n++], Pt_ARG_WIDTH, 350, 0);
1586 PtSetArg(&args[n++], Pt_ARG_GROUP_ORIENTATION,
1587 Pt_GROUP_VERTICAL, 0);
1588 PtSetArg(&args[n++], Pt_ARG_GROUP_FLAGS,
1589 Pt_TRUE, Pt_GROUP_NO_KEYS | Pt_GROUP_STRETCH_HORIZONTAL);
1590 PtSetArg(&args[n++], Pt_ARG_CONTAINER_FLAGS, Pt_FALSE, Pt_TRUE);
1591 pane = PtCreateWidget(PtGroup, NULL, n, args);
1592
1593 n = 0;
1594 PtSetArg(&args[n++], Pt_ARG_TEXT_STRING, message, 0);
1595 PtCreateWidget(PtLabel, pane, n, args);
1596
1597 if (textfield != NULL)
1598 {
1599 n = 0;
1600 PtSetArg(&args[n++], Pt_ARG_MAX_LENGTH, IOSIZE - 1, 0);
1601 PtSetArg(&args[n++], Pt_ARG_TEXT_STRING, textfield, 0);
1602 PtSetArg(&args[n++], Pt_ARG_POINTER, textfield, 0);
1603 gui_ph_dialog_text = PtCreateWidget(PtText, pane, n, args);
1604 PtAddCallback(gui_ph_dialog_text, Pt_CB_ACTIVATE,
1605 gui_ph_dialog_text_enter, &modal_ctrl);
1606 }
1607
1608 di.parent = gui.vimWindow;
1609 di.pane = pane;
1610 di.title = title;
1611 di.buttons = (const char **) button_array;
1612 di.nbtns = button_count;
1613 di.def_btn = default_button;
1614 // This is just to give the dialog the close button.
1615 // We check for the Escape key ourselves and return 0
1616 di.esc_btn = button_count;
1617 di.callback = gui_ph_dialog_close;
1618 di.data = &modal_ctrl;
1619
1620 dialog = PtCreateDialog(&di);
1621 PtAddFilterCallback(dialog, Ph_EV_KEY,
1622 gui_ph_dialog_esc, &modal_ctrl);
1623
1624 if (gui_ph_dialog_text != NULL)
1625 PtGiveFocus(gui_ph_dialog_text, NULL);
1626
1627 // Open dialog, block the vim window and wait for the dialog to close
1628 PtRealizeWidget(dialog);
1629 PtMakeModal(dialog, Ph_CURSOR_NOINPUT, Ph_CURSOR_DEFAULT_COLOR);
1630 dialog_result = (int) PtModalBlock(&modal_ctrl, 0);
1631
1632 PtDestroyWidget(dialog);
1633 gui_ph_dialog_text = NULL;
1634 }
1635 #endif
1636 }
1637
1638 vim_free(button_array);
1639 vim_free(buttons_copy);
1640
1641 return dialog_result;
1642 }
1643 #endif
1644 ////////////////////////////////////////////////////////////////////////////
1645 // window size/position/state
1646
1647 int
gui_mch_get_winpos(int * x,int * y)1648 gui_mch_get_winpos(int *x, int *y)
1649 {
1650 PhPoint_t *pos;
1651
1652 pos = PtWidgetPos(gui.vimWindow, NULL);
1653
1654 *x = pos->x;
1655 *y = pos->y;
1656
1657 return OK;
1658 }
1659
1660 void
gui_mch_set_winpos(int x,int y)1661 gui_mch_set_winpos(int x, int y)
1662 {
1663 PhPoint_t pos = { x, y };
1664
1665 PtSetResource(gui.vimWindow, Pt_ARG_POS, &pos, 0);
1666 }
1667
1668 void
gui_mch_set_shellsize(int width,int height,int min_width,int min_height,int base_width,int base_height,int direction)1669 gui_mch_set_shellsize(int width, int height,
1670 int min_width, int min_height, int base_width, int base_height,
1671 int direction)
1672 {
1673 PhDim_t window_size = { width, height };
1674 PhDim_t min_size = { min_width, min_height };
1675
1676 #ifdef USE_PANEL_GROUP
1677 window_size.w += pg_margin_left + pg_margin_right;
1678 window_size.h += pg_margin_top + pg_margin_bottom;
1679 #endif
1680
1681 PtSetResource(gui.vimWindow, Pt_ARG_MINIMUM_DIM, &min_size, 0);
1682 PtSetResource(gui.vimWindow, Pt_ARG_DIM, &window_size, 0);
1683
1684 if (! PtWidgetIsRealized(gui.vimWindow))
1685 gui_ph_resize_container();
1686 }
1687
1688 /*
1689 * Return the amount of screen space that hasn't been allocated (such as
1690 * by the shelf).
1691 */
1692 void
gui_mch_get_screen_dimensions(int * screen_w,int * screen_h)1693 gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
1694 {
1695 PhRect_t console;
1696
1697 PhWindowQueryVisible(Ph_QUERY_WORKSPACE, 0,
1698 PhInputGroup(NULL), &console);
1699
1700 *screen_w = console.lr.x - console.ul.x + 1;
1701 *screen_h = console.lr.y - console.ul.y + 1;
1702 }
1703
1704 void
gui_mch_iconify(void)1705 gui_mch_iconify(void)
1706 {
1707 PhWindowEvent_t event;
1708
1709 memset(&event, 0, sizeof (event));
1710 event.event_f = Ph_WM_HIDE;
1711 event.event_state = Ph_WM_EVSTATE_HIDE;
1712 event.rid = PtWidgetRid(gui.vimWindow);
1713 PtForwardWindowEvent(&event);
1714 }
1715
1716 #if defined(FEAT_EVAL) || defined(PROTO)
1717 /*
1718 * Bring the Vim window to the foreground.
1719 */
1720 void
gui_mch_set_foreground(void)1721 gui_mch_set_foreground(void)
1722 {
1723 PhWindowEvent_t event;
1724
1725 memset(&event, 0, sizeof (event));
1726 event.event_f = Ph_WM_TOFRONT;
1727 event.event_state = Ph_WM_EVSTATE_FFRONT;
1728 event.rid = PtWidgetRid(gui.vimWindow);
1729 PtForwardWindowEvent(&event);
1730 }
1731 #endif
1732
1733 void
gui_mch_settitle(char_u * title,char_u * icon)1734 gui_mch_settitle(char_u *title, char_u *icon)
1735 {
1736 #ifdef USE_PANEL_GROUP
1737 gui_ph_pg_set_buffer_num(curwin->w_buffer->b_fnum);
1738 #endif
1739 PtSetResource(gui.vimWindow, Pt_ARG_WINDOW_TITLE, title, 0);
1740 // Not sure what to do with the icon text, set balloon text somehow?
1741 }
1742
1743 ////////////////////////////////////////////////////////////////////////////
1744 // Scrollbar
1745
1746 void
gui_mch_set_scrollbar_thumb(scrollbar_T * sb,int val,int size,int max)1747 gui_mch_set_scrollbar_thumb(scrollbar_T *sb, int val, int size, int max)
1748 {
1749 int n = 0;
1750 PtArg_t args[3];
1751
1752 PtSetArg(&args[ n++ ], Pt_ARG_MAXIMUM, max, 0);
1753 PtSetArg(&args[ n++ ], Pt_ARG_SLIDER_SIZE, size, 0);
1754 PtSetArg(&args[ n++ ], Pt_ARG_GAUGE_VALUE, val, 0);
1755 PtSetResources(sb->id, n, args);
1756 }
1757
1758 void
gui_mch_set_scrollbar_pos(scrollbar_T * sb,int x,int y,int w,int h)1759 gui_mch_set_scrollbar_pos(scrollbar_T *sb, int x, int y, int w, int h)
1760 {
1761 PhArea_t area = {{ x, y }, { w, h }};
1762
1763 PtSetResource(sb->id, Pt_ARG_AREA, &area, 0);
1764 }
1765
1766 int
gui_mch_get_scrollbar_xpadding(void)1767 gui_mch_get_scrollbar_xpadding(void)
1768 {
1769 // TODO: Calculate the padding for adjust scrollbar position when the
1770 // Window is maximized.
1771 return 0;
1772 }
1773
1774 int
gui_mch_get_scrollbar_ypadding(void)1775 gui_mch_get_scrollbar_ypadding(void)
1776 {
1777 // TODO: Calculate the padding for adjust scrollbar position when the
1778 // Window is maximized.
1779 return 0;
1780 }
1781
1782 void
gui_mch_create_scrollbar(scrollbar_T * sb,int orient)1783 gui_mch_create_scrollbar(scrollbar_T *sb, int orient)
1784 {
1785 int n = 0;
1786 // int anchor_flags = 0;
1787 PtArg_t args[4];
1788
1789 /*
1790 * Stop the scrollbar from being realized when the parent
1791 * is realized, so it can be explicitly realized by vim.
1792 *
1793 * Also, don't let the scrollbar get focus
1794 */
1795 PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_DELAY_REALIZE,
1796 Pt_DELAY_REALIZE | Pt_GETS_FOCUS);
1797 PtSetArg(&args[ n++ ], Pt_ARG_SCROLLBAR_FLAGS, Pt_SCROLLBAR_SHOW_ARROWS, 0);
1798 #if 0
1799 // Don't need this anchoring for the scrollbars
1800 if (orient == SBAR_HORIZ)
1801 {
1802 anchor_flags = Pt_BOTTOM_ANCHORED_BOTTOM |
1803 Pt_LEFT_ANCHORED_LEFT | Pt_RIGHT_ANCHORED_RIGHT;
1804 }
1805 else
1806 {
1807 anchor_flags = Pt_BOTTOM_ANCHORED_BOTTOM | Pt_TOP_ANCHORED_TOP;
1808 if (sb->wp != NULL)
1809 {
1810 if (sb == &sb->wp->w_scrollbars[ SBAR_LEFT ])
1811 anchor_flags |= Pt_LEFT_ANCHORED_LEFT;
1812 else
1813 anchor_flags |= Pt_RIGHT_ANCHORED_RIGHT;
1814 }
1815 }
1816 PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS, anchor_flags, Pt_IS_ANCHORED);
1817 #endif
1818 PtSetArg(&args[ n++ ], Pt_ARG_ORIENTATION,
1819 (orient == SBAR_HORIZ) ? Pt_HORIZONTAL : Pt_VERTICAL, 0);
1820 #ifdef USE_PANEL_GROUP
1821 sb->id = PtCreateWidget(PtScrollbar, gui.vimPanelGroup, n, args);
1822 #else
1823 sb->id = PtCreateWidget(PtScrollbar, gui.vimContainer, n, args);
1824 #endif
1825
1826 PtAddCallback(sb->id, Pt_CB_SCROLLBAR_MOVE, gui_ph_handle_scrollbar, sb);
1827 }
1828
1829 void
gui_mch_enable_scrollbar(scrollbar_T * sb,int flag)1830 gui_mch_enable_scrollbar(scrollbar_T *sb, int flag)
1831 {
1832 if (flag != 0)
1833 PtRealizeWidget(sb->id);
1834 else
1835 PtUnrealizeWidget(sb->id);
1836 }
1837
1838 void
gui_mch_destroy_scrollbar(scrollbar_T * sb)1839 gui_mch_destroy_scrollbar(scrollbar_T *sb)
1840 {
1841 PtDestroyWidget(sb->id);
1842 sb->id = NULL;
1843 }
1844
1845 ////////////////////////////////////////////////////////////////////////////
1846 // Mouse functions
1847
1848 #if defined(FEAT_MOUSESHAPE) || defined(PROTO)
1849 // The last set mouse pointer shape is remembered, to be used when it goes
1850 // from hidden to not hidden.
1851 static int last_shape = 0;
1852
1853 // Table for shape IDs. Keep in sync with the mshape_names[] table in
1854 // misc2.c!
1855 static int mshape_ids[] =
1856 {
1857 Ph_CURSOR_POINTER, // arrow
1858 Ph_CURSOR_NONE, // blank
1859 Ph_CURSOR_INSERT, // beam
1860 Ph_CURSOR_DRAG_VERTICAL, // updown
1861 Ph_CURSOR_DRAG_VERTICAL, // udsizing
1862 Ph_CURSOR_DRAG_HORIZONTAL, // leftright
1863 Ph_CURSOR_DRAG_HORIZONTAL, // lrsizing
1864 Ph_CURSOR_WAIT, // busy
1865 Ph_CURSOR_DONT, // no
1866 Ph_CURSOR_CROSSHAIR, // crosshair
1867 Ph_CURSOR_FINGER, // hand1
1868 Ph_CURSOR_FINGER, // hand2
1869 Ph_CURSOR_FINGER, // pencil
1870 Ph_CURSOR_QUESTION_POINT, // question
1871 Ph_CURSOR_POINTER, // right-arrow
1872 Ph_CURSOR_POINTER, // up-arrow
1873 Ph_CURSOR_POINTER // last one
1874 };
1875
1876 void
mch_set_mouse_shape(int shape)1877 mch_set_mouse_shape(int shape)
1878 {
1879 int id;
1880
1881 if (!gui.in_use)
1882 return;
1883
1884 if (shape == MSHAPE_HIDE || gui.pointer_hidden)
1885 PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_TYPE, Ph_CURSOR_NONE,
1886 0);
1887 else
1888 {
1889 if (shape >= MSHAPE_NUMBERED)
1890 id = Ph_CURSOR_POINTER;
1891 else
1892 id = mshape_ids[shape];
1893
1894 PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_TYPE, id, 0);
1895 }
1896 if (shape != MSHAPE_HIDE)
1897 last_shape = shape;
1898 }
1899 #endif
1900
1901 void
gui_mch_mousehide(int hide)1902 gui_mch_mousehide(int hide)
1903 {
1904 if (gui.pointer_hidden != hide)
1905 {
1906 gui.pointer_hidden = hide;
1907 #ifdef FEAT_MOUSESHAPE
1908 if (hide)
1909 PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_TYPE,
1910 Ph_CURSOR_NONE, 0);
1911 else
1912 mch_set_mouse_shape(last_shape);
1913 #else
1914 PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_TYPE,
1915 (hide == MOUSE_SHOW) ? GUI_PH_MOUSE_TYPE : Ph_CURSOR_NONE,
1916 0);
1917 #endif
1918 }
1919 }
1920
1921 void
gui_mch_getmouse(int * x,int * y)1922 gui_mch_getmouse(int *x, int *y)
1923 {
1924 PhCursorInfo_t info;
1925 short ix, iy;
1926
1927 // FIXME: does this return the correct position,
1928 // with respect to the border?
1929 PhQueryCursor(PhInputGroup(NULL), &info);
1930 PtGetAbsPosition(gui.vimTextArea , &ix, &iy);
1931
1932 *x = info.pos.x - ix;
1933 *y = info.pos.y - iy;
1934 }
1935
1936 void
gui_mch_setmouse(int x,int y)1937 gui_mch_setmouse(int x, int y)
1938 {
1939 short abs_x, abs_y;
1940
1941 PtGetAbsPosition(gui.vimTextArea, &abs_x, &abs_y);
1942 // Add the border offset?
1943 PhMoveCursorAbs(PhInputGroup(NULL), abs_x + x, abs_y + y);
1944 }
1945
1946 ////////////////////////////////////////////////////////////////////////////
1947 // Colours
1948
1949 /*
1950 * Return the RGB value of a pixel as a long.
1951 */
1952 guicolor_T
gui_mch_get_rgb(guicolor_T pixel)1953 gui_mch_get_rgb(guicolor_T pixel)
1954 {
1955 return (guicolor_T)(PgRGB(PgRedValue(pixel),
1956 PgGreenValue(pixel), PgBlueValue(pixel)));
1957 }
1958
1959 void
gui_mch_new_colors(void)1960 gui_mch_new_colors(void)
1961 {
1962 #if 0 // Don't bother changing the cursor colour
1963 short color_diff;
1964
1965 /*
1966 * If there isn't enough difference between the background colour and
1967 * the mouse pointer colour then change the mouse pointer colour
1968 */
1969 color_diff = gui_get_lightness(gui_ph_mouse_color)
1970 - gui_get_lightness(gui.back_pixel);
1971
1972 if (abs(color_diff) < 64)
1973 {
1974 short r, g, b;
1975 // not a great algorithm...
1976 r = PgRedValue(gui_ph_mouse_color) ^ 255;
1977 g = PgGreenValue(gui_ph_mouse_color) ^ 255;
1978 b = PgBlueValue(gui_ph_mouse_color) ^ 255;
1979
1980 #ifndef FEAT_MOUSESHAPE
1981 gui_ph_mouse_color = PgRGB(r, g, b);
1982 PtSetResource(gui.vimTextArea, Pt_ARG_CURSOR_COLOR,
1983 gui_ph_mouse_color, 0);
1984 #endif
1985 }
1986 #endif
1987
1988 PtSetResource(gui.vimTextArea, Pt_ARG_FILL_COLOR, gui.back_pixel, 0);
1989 }
1990
1991 /*
1992 * This should be split out into a separate file,
1993 * every port does basically the same thing.
1994 *
1995 * This is the gui_w32.c version (i think..)
1996 * Return INVALCOLOR when failed.
1997 */
1998
1999 guicolor_T
gui_mch_get_color(char_u * name)2000 gui_mch_get_color(char_u *name)
2001 {
2002 return gui_get_color_cmn(name);
2003 }
2004
2005 guicolor_T
gui_mch_get_rgb_color(int r,int g,int b)2006 gui_mch_get_rgb_color(int r, int g, int b)
2007 {
2008 return gui_get_rgb_color_cmn(r, g, b);
2009 }
2010
2011 void
gui_mch_set_fg_color(guicolor_T color)2012 gui_mch_set_fg_color(guicolor_T color)
2013 {
2014 PgSetTextColor(color);
2015 }
2016
2017 void
gui_mch_set_bg_color(guicolor_T color)2018 gui_mch_set_bg_color(guicolor_T color)
2019 {
2020 PgSetFillColor(color);
2021 }
2022
2023 void
gui_mch_set_sp_color(guicolor_T color)2024 gui_mch_set_sp_color(guicolor_T color)
2025 {
2026 }
2027
2028 void
gui_mch_invert_rectangle(int row,int col,int nr,int nc)2029 gui_mch_invert_rectangle(int row, int col, int nr, int nc)
2030 {
2031 PhRect_t rect;
2032
2033 rect.ul.x = FILL_X(col);
2034 rect.ul.y = FILL_Y(row);
2035
2036 // FIXME: This has an off by one pixel problem
2037 rect.lr.x = rect.ul.x + nc * gui.char_width;
2038 rect.lr.y = rect.ul.y + nr * gui.char_height;
2039 if (nc > 0)
2040 rect.lr.x -= 1;
2041 if (nr > 0)
2042 rect.lr.y -= 1;
2043
2044 DRAW_START;
2045 PgSetDrawMode(Pg_DrawModeDSTINVERT);
2046 PgDrawRect(&rect, Pg_DRAW_FILL);
2047 PgSetDrawMode(Pg_DrawModeSRCCOPY);
2048 DRAW_END;
2049 }
2050
2051 void
gui_mch_clear_block(int row1,int col1,int row2,int col2)2052 gui_mch_clear_block(int row1, int col1, int row2, int col2)
2053 {
2054 PhRect_t block = {
2055 { FILL_X(col1), FILL_Y(row1) },
2056 { FILL_X(col2 + 1) - 1, FILL_Y(row2 + 1) - 1}
2057 };
2058
2059 DRAW_START;
2060 gui_mch_set_bg_color(gui.back_pixel);
2061 PgDrawRect(&block, Pg_DRAW_FILL);
2062 DRAW_END;
2063 }
2064
2065 void
gui_mch_clear_all(void)2066 gui_mch_clear_all(void)
2067 {
2068 PhRect_t text_rect = {
2069 { gui.border_width, gui.border_width },
2070 { Columns * gui.char_width + gui.border_width - 1 ,
2071 Rows * gui.char_height + gui.border_width - 1 }
2072 };
2073
2074 if (is_ignore_draw == TRUE)
2075 return;
2076
2077 DRAW_START;
2078 gui_mch_set_bg_color(gui.back_pixel);
2079 PgDrawRect(&text_rect, Pg_DRAW_FILL);
2080 DRAW_END;
2081 }
2082
2083 void
gui_mch_delete_lines(int row,int num_lines)2084 gui_mch_delete_lines(int row, int num_lines)
2085 {
2086 PhRect_t rect;
2087 PhPoint_t delta;
2088
2089 rect.ul.x = FILL_X(gui.scroll_region_left);
2090 rect.ul.y = FILL_Y(row + num_lines);
2091
2092 rect.lr.x = FILL_X(gui.scroll_region_right + 1) - 1;
2093 rect.lr.y = FILL_Y(gui.scroll_region_bot + 1) - 1;
2094
2095 PtWidgetOffset(gui.vimTextArea, &gui_ph_raw_offset);
2096 PhTranslatePoint(&gui_ph_raw_offset, PtWidgetPos(gui.vimTextArea, NULL));
2097 PhTranslateRect(&rect, &gui_ph_raw_offset);
2098
2099 delta.x = 0;
2100 delta.y = -num_lines * gui.char_height;
2101
2102 PgFlush();
2103
2104 PhBlit(PtWidgetRid(PtFindDisjoint(gui.vimTextArea)), &rect, &delta);
2105
2106 gui_clear_block(
2107 gui.scroll_region_bot - num_lines + 1,
2108 gui.scroll_region_left,
2109 gui.scroll_region_bot,
2110 gui.scroll_region_right);
2111 }
2112
2113 void
gui_mch_insert_lines(int row,int num_lines)2114 gui_mch_insert_lines(int row, int num_lines)
2115 {
2116 PhRect_t rect;
2117 PhPoint_t delta;
2118
2119 rect.ul.x = FILL_X(gui.scroll_region_left);
2120 rect.ul.y = FILL_Y(row);
2121
2122 rect.lr.x = FILL_X(gui.scroll_region_right + 1) - 1;
2123 rect.lr.y = FILL_Y(gui.scroll_region_bot - num_lines + 1) - 1;
2124
2125 PtWidgetOffset(gui.vimTextArea, &gui_ph_raw_offset);
2126 PhTranslatePoint(&gui_ph_raw_offset, PtWidgetPos(gui.vimTextArea, NULL));
2127 PhTranslateRect(&rect, &gui_ph_raw_offset);
2128
2129 delta.x = 0;
2130 delta.y = num_lines * gui.char_height;
2131
2132 PgFlush();
2133
2134 PhBlit(PtWidgetRid(PtFindDisjoint(gui.vimTextArea)) , &rect, &delta);
2135
2136 gui_clear_block(row, gui.scroll_region_left,
2137 row + num_lines - 1, gui.scroll_region_right);
2138 }
2139
2140 void
gui_mch_draw_string(int row,int col,char_u * s,int len,int flags)2141 gui_mch_draw_string(int row, int col, char_u *s, int len, int flags)
2142 {
2143 static char *utf8_buffer = NULL;
2144 static int utf8_len = 0;
2145
2146 PhPoint_t pos = { TEXT_X(col), TEXT_Y(row) };
2147 PhRect_t rect;
2148
2149 if (is_ignore_draw == TRUE)
2150 return;
2151
2152 DRAW_START;
2153
2154 if (!(flags & DRAW_TRANSP))
2155 {
2156 PgDrawIRect(
2157 FILL_X(col), FILL_Y(row),
2158 FILL_X(col + len) - 1, FILL_Y(row + 1) - 1,
2159 Pg_DRAW_FILL);
2160 }
2161
2162 if (flags & DRAW_UNDERL)
2163 PgSetUnderline(gui.norm_pixel, Pg_TRANSPARENT, 0);
2164
2165 if (charset_translate != NULL && enc_utf8 == 0)
2166 {
2167 int src_taken, dst_made;
2168
2169 // Use a static buffer to avoid large amounts of de/allocations
2170 if (utf8_len < len)
2171 {
2172 utf8_buffer = realloc(utf8_buffer, len * MB_LEN_MAX);
2173 utf8_len = len;
2174 }
2175
2176 PxTranslateToUTF(
2177 charset_translate,
2178 s,
2179 len,
2180 &src_taken,
2181 utf8_buffer,
2182 utf8_len,
2183 &dst_made);
2184 s = utf8_buffer;
2185 len = dst_made;
2186 }
2187
2188 PgDrawText(s, len, &pos, 0);
2189
2190 if (flags & DRAW_BOLD)
2191 {
2192 // FIXME: try and only calculate these values once...
2193 rect.ul.x = FILL_X(col) + 1;
2194 rect.ul.y = FILL_Y(row);
2195 rect.lr.x = FILL_X(col + len) - 1;
2196 rect.lr.y = FILL_Y(row + 1) - 1;
2197 // PgSetUserClip(NULL) causes the scrollbar to not redraw...
2198 #if 0
2199 pos.x++;
2200
2201 PgSetUserClip(&rect);
2202 PgDrawText(s, len, &pos, 0);
2203 PgSetUserClip(NULL);
2204 #else
2205 rect.lr.y -= (p_linespace + 1) / 2;
2206 // XXX: DrawTextArea doesn't work with phditto
2207 PgDrawTextArea(s, len, &rect, Pg_TEXT_BOTTOM);
2208 #endif
2209 }
2210
2211 if (flags & DRAW_UNDERL)
2212 PgSetUnderline(Pg_TRANSPARENT, Pg_TRANSPARENT, 0);
2213
2214 DRAW_END;
2215 }
2216
2217 ////////////////////////////////////////////////////////////////////////////
2218 // Cursor
2219
2220 void
gui_mch_draw_hollow_cursor(guicolor_T color)2221 gui_mch_draw_hollow_cursor(guicolor_T color)
2222 {
2223 PhRect_t r;
2224
2225 // FIXME: Double width characters
2226
2227 r.ul.x = FILL_X(gui.col);
2228 r.ul.y = FILL_Y(gui.row);
2229 r.lr.x = r.ul.x + gui.char_width - 1;
2230 r.lr.y = r.ul.y + gui.char_height - 1;
2231
2232 DRAW_START;
2233 PgSetStrokeColor(color);
2234 PgDrawRect(&r, Pg_DRAW_STROKE);
2235 DRAW_END;
2236 }
2237
2238 void
gui_mch_draw_part_cursor(int w,int h,guicolor_T color)2239 gui_mch_draw_part_cursor(int w, int h, guicolor_T color)
2240 {
2241 PhRect_t r;
2242
2243 r.ul.x = FILL_X(gui.col);
2244 r.ul.y = FILL_Y(gui.row) + gui.char_height - h;
2245 r.lr.x = r.ul.x + w - 1;
2246 r.lr.y = r.ul.y + h - 1;
2247
2248 DRAW_START;
2249 gui_mch_set_bg_color(color);
2250 PgDrawRect(&r, Pg_DRAW_FILL);
2251 DRAW_END;
2252 }
2253
2254 int
gui_mch_is_blinking(void)2255 gui_mch_is_blinking(void)
2256 {
2257 return blink_state != BLINK_NONE;
2258 }
2259
2260 int
gui_mch_is_blink_off(void)2261 gui_mch_is_blink_off(void)
2262 {
2263 return blink_state == BLINK_OFF;
2264 }
2265
2266 void
gui_mch_set_blinking(long wait,long on,long off)2267 gui_mch_set_blinking(long wait, long on, long off)
2268 {
2269 blink_waittime = wait;
2270 blink_ontime = on;
2271 blink_offtime = off;
2272 }
2273
2274 void
gui_mch_start_blink(void)2275 gui_mch_start_blink(void)
2276 {
2277 // Only turn on the timer on if none of the times are zero
2278 if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
2279 {
2280 PtSetResource(gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL,
2281 blink_waittime, 0);
2282 blink_state = BLINK_ON;
2283 gui_update_cursor(TRUE, FALSE);
2284 }
2285 }
2286
2287 void
gui_mch_stop_blink(int may_call_gui_update_cursor)2288 gui_mch_stop_blink(int may_call_gui_update_cursor)
2289 {
2290 PtSetResource(gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL, 0, 0);
2291
2292 if (blink_state == BLINK_OFF && may_call_gui_update_cursor)
2293 gui_update_cursor(TRUE, FALSE);
2294
2295 blink_state = BLINK_NONE;
2296 }
2297
2298 ////////////////////////////////////////////////////////////////////////////
2299 // miscellaneous functions
2300
2301 void
gui_mch_beep(void)2302 gui_mch_beep(void)
2303 {
2304 PtBeep();
2305 }
2306
2307 void
gui_mch_flash(int msec)2308 gui_mch_flash(int msec)
2309 {
2310 PgSetFillXORColor(Pg_BLACK, Pg_WHITE);
2311 PgSetDrawMode(Pg_DRAWMODE_XOR);
2312 gui_mch_clear_all();
2313 gui_mch_flush();
2314
2315 ui_delay((long) msec, TRUE);
2316
2317 gui_mch_clear_all();
2318 PgSetDrawMode(Pg_DRAWMODE_OPAQUE);
2319 gui_mch_flush();
2320 }
2321
2322 void
gui_mch_flush(void)2323 gui_mch_flush(void)
2324 {
2325 PgFlush();
2326 }
2327
2328 void
gui_mch_set_text_area_pos(int x,int y,int w,int h)2329 gui_mch_set_text_area_pos(int x, int y, int w, int h)
2330 {
2331 PhArea_t area = {{x, y}, {w, h}};
2332
2333 PtSetResource(gui.vimTextArea, Pt_ARG_AREA, &area, 0);
2334 }
2335
2336 int
gui_mch_haskey(char_u * name)2337 gui_mch_haskey(char_u *name)
2338 {
2339 int i;
2340
2341 for (i = 0; special_keys[i].key_sym != 0; i++)
2342 if (name[0] == special_keys[i].vim_code0 &&
2343 name[1] == special_keys[i].vim_code1)
2344 return OK;
2345 return FAIL;
2346 }
2347
2348 ////////////////////////////////////////////////////////////////////////////
2349 // Menu
2350
2351 #ifdef FEAT_TOOLBAR
2352 #include "toolbar.phi"
2353
2354 static PhImage_t *gui_ph_toolbar_images[] = {
2355 &tb_new_phi,
2356 &tb_open_phi,
2357 &tb_save_phi,
2358 &tb_undo_phi,
2359 &tb_redo_phi,
2360 &tb_cut_phi,
2361 &tb_copy_phi,
2362 &tb_paste_phi,
2363 &tb_print_phi,
2364 &tb_help_phi,
2365 &tb_find_phi,
2366 &tb_save_all_phi,
2367 &tb_save_session_phi,
2368 &tb_new_session_phi,
2369 &tb_load_session_phi,
2370 &tb_macro_phi,
2371 &tb_replace_phi,
2372 &tb_close_phi,
2373 &tb_maximize_phi,
2374 &tb_minimize_phi,
2375 &tb_split_phi,
2376 &tb_shell_phi,
2377 &tb_find_prev_phi,
2378 &tb_find_next_phi,
2379 &tb_find_help_phi,
2380 &tb_make_phi,
2381 &tb_jump_phi,
2382 &tb_ctags_phi,
2383 &tb_vsplit_phi,
2384 &tb_maxwidth_phi,
2385 &tb_minwidth_phi
2386 };
2387
2388 static PhImage_t *
gui_ph_toolbar_load_icon(char_u * iconfile)2389 gui_ph_toolbar_load_icon(char_u *iconfile)
2390 {
2391 static PhImage_t external_icon;
2392 PhImage_t *temp_phi = NULL;
2393
2394 temp_phi = PxLoadImage(iconfile, NULL);
2395 if (temp_phi != NULL)
2396 {
2397 // The label widget will free the image/palette/etc. for us when
2398 // it's destroyed
2399 temp_phi->flags |= Ph_RELEASE_IMAGE_ALL;
2400 memcpy(&external_icon, temp_phi, sizeof(external_icon));
2401 free(temp_phi);
2402
2403 temp_phi = &external_icon;
2404 }
2405 return temp_phi;
2406 }
2407
2408 /*
2409 * This returns either a builtin icon image, an external image or NULL
2410 * if it can't find either. The caller can't and doesn't need to try and
2411 * free() the returned image, and it can't store the image pointer.
2412 * (When setting the Pt_ARG_LABEL_IMAGE resource, the contents of the
2413 * PhImage_t are copied, and the original PhImage_t aren't needed anymore).
2414 */
2415 static PhImage_t *
gui_ph_toolbar_find_icon(vimmenu_T * menu)2416 gui_ph_toolbar_find_icon(vimmenu_T *menu)
2417 {
2418 char_u full_pathname[ MAXPATHL + 1 ];
2419 PhImage_t *icon = NULL;
2420
2421 if (menu->icon_builtin == FALSE)
2422 {
2423 if (menu->iconfile != NULL)
2424 // TODO: use gui_find_iconfile()
2425 icon = gui_ph_toolbar_load_icon(menu->iconfile);
2426
2427 // TODO: Restrict loading to just .png? Search for any format?
2428 if ((icon == NULL) &&
2429 ((gui_find_bitmap(menu->name, full_pathname, "gif") == OK) ||
2430 (gui_find_bitmap(menu->name, full_pathname, "png") == OK)))
2431 icon = gui_ph_toolbar_load_icon(full_pathname);
2432
2433 if (icon != NULL)
2434 return icon;
2435 }
2436
2437 if (menu->iconidx >= 0 &&
2438 (menu->iconidx < ARRAY_LENGTH(gui_ph_toolbar_images)))
2439 return gui_ph_toolbar_images[menu->iconidx];
2440
2441 return NULL;
2442 }
2443 #endif
2444
2445 #if defined(FEAT_MENU) || defined(PROTO)
2446 void
gui_mch_enable_menu(int flag)2447 gui_mch_enable_menu(int flag)
2448 {
2449 if (flag != 0)
2450 PtRealizeWidget(gui.vimMenuBar);
2451 else
2452 PtUnrealizeWidget(gui.vimMenuBar);
2453 }
2454
2455 void
gui_mch_set_menu_pos(int x,int y,int w,int h)2456 gui_mch_set_menu_pos(int x, int y, int w, int h)
2457 {
2458 // Nothing
2459 }
2460
2461 /*
2462 * Change the position of a menu button in the parent
2463 */
2464 static void
gui_ph_position_menu(PtWidget_t * widget,int priority)2465 gui_ph_position_menu(PtWidget_t *widget, int priority)
2466 {
2467 PtWidget_t *traverse;
2468 vimmenu_T *menu;
2469
2470 traverse = PtWidgetChildBack(PtWidgetParent(widget));
2471
2472 // Iterate through the list of widgets in traverse, until
2473 // we find the position we want to insert our widget into
2474 // TODO: traverse from front to back, possible speedup?
2475 while (traverse != NULL)
2476 {
2477 PtGetResource(traverse, Pt_ARG_POINTER, &menu, 0);
2478
2479 if (menu != NULL &&
2480 priority < menu->priority &&
2481 widget != traverse)
2482 {
2483 // Insert the widget before the current traverse widget
2484 PtWidgetInsert(widget, traverse, 1);
2485 return;
2486 }
2487
2488 traverse = PtWidgetBrotherInFront(traverse);
2489 }
2490 }
2491
2492 /*
2493 * the index is ignored because it's not useful for our purposes
2494 */
2495 void
gui_mch_add_menu(vimmenu_T * menu,int index)2496 gui_mch_add_menu(vimmenu_T *menu, int index)
2497 {
2498 vimmenu_T *parent = menu->parent;
2499 char_u *accel_key;
2500 char_u mnemonic_str[MB_LEN_MAX];
2501 int n;
2502 PtArg_t args[5];
2503
2504 menu->submenu_id = menu->id = NULL;
2505
2506 if (menu_is_menubar(menu->name))
2507 {
2508
2509 accel_key = vim_strchr(menu->name, '&');
2510 if (accel_key != NULL)
2511 {
2512 mnemonic_str[0] = accel_key[1];
2513 mnemonic_str[1] = NUL;
2514 }
2515
2516 // Create the menu button
2517 n = 0;
2518 PtSetArg(&args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0);
2519 PtSetArg(&args[ n++ ], Pt_ARG_ACCEL_TEXT, menu->actext, 0);
2520 if (accel_key != NULL)
2521 PtSetArg(&args[ n++ ], Pt_ARG_ACCEL_KEY, mnemonic_str, 0);
2522 PtSetArg(&args[ n++ ], Pt_ARG_POINTER, menu, 0);
2523
2524 if (parent != NULL)
2525 PtSetArg(&args[ n++ ], Pt_ARG_BUTTON_TYPE, Pt_MENU_RIGHT, 0);
2526
2527 menu->id = PtCreateWidget(PtMenuButton,
2528 (parent == NULL) ? gui.vimMenuBar : parent->submenu_id,
2529 n, args);
2530
2531 PtAddCallback(menu->id, Pt_CB_ARM, gui_ph_handle_pulldown_menu, menu);
2532
2533 // Create the actual menu
2534 n = 0;
2535 if (parent != NULL)
2536 PtSetArg(&args[ n++ ], Pt_ARG_MENU_FLAGS, Pt_TRUE, Pt_MENU_CHILD);
2537
2538 menu->submenu_id = PtCreateWidget(PtMenu, menu->id, n, args);
2539
2540 if (parent == NULL)
2541 {
2542 PtAddCallback(menu->submenu_id, Pt_CB_UNREALIZED,
2543 gui_ph_handle_menu_unrealized, menu);
2544
2545 if (menu->mnemonic != 0)
2546 {
2547 PtAddHotkeyHandler(gui.vimWindow, tolower(menu->mnemonic),
2548 Pk_KM_Alt, 0, menu, gui_ph_handle_pulldown_menu);
2549 }
2550 }
2551
2552 gui_ph_position_menu(menu->id, menu->priority);
2553
2554 // Redraw menubar here instead of gui_mch_draw_menubar
2555 if (gui.menu_is_active)
2556 PtRealizeWidget(menu->id);
2557 }
2558 else if (menu_is_popup(menu->name))
2559 {
2560 menu->submenu_id = PtCreateWidget(PtMenu, gui.vimWindow, 0, NULL);
2561 PtAddCallback(menu->submenu_id, Pt_CB_UNREALIZED,
2562 gui_ph_handle_menu_unrealized, menu);
2563 }
2564 }
2565
2566 void
gui_mch_add_menu_item(vimmenu_T * menu,int index)2567 gui_mch_add_menu_item(vimmenu_T *menu, int index)
2568 {
2569 vimmenu_T *parent = menu->parent;
2570 char_u *accel_key;
2571 char_u mnemonic_str[MB_LEN_MAX];
2572 int n;
2573 PtArg_t args[13];
2574
2575 n = 0;
2576 PtSetArg(&args[ n++ ], Pt_ARG_POINTER, menu, 0);
2577
2578 #ifdef FEAT_TOOLBAR
2579 if (menu_is_toolbar(parent->name))
2580 {
2581 if (menu_is_separator(menu->name))
2582 {
2583 PtSetArg(&args[ n++ ], Pt_ARG_SEP_FLAGS,
2584 Pt_SEP_VERTICAL, Pt_SEP_ORIENTATION);
2585 PtSetArg(&args[ n++ ], Pt_ARG_SEP_TYPE, Pt_ETCHED_IN, 0);
2586 PtSetArg(&args[ n++ ], Pt_ARG_ANCHOR_FLAGS,
2587 Pt_TRUE, Pt_ANCHOR_TOP_BOTTOM);
2588 PtSetArg(&args[ n++ ], Pt_ARG_WIDTH, 2, 0);
2589 menu->id = PtCreateWidget(PtSeparator, gui.vimToolBar, n, args);
2590 }
2591 else
2592 {
2593 if (strstr((const char *) p_toolbar, "text") != NULL)
2594 {
2595 PtSetArg(&args[ n++ ], Pt_ARG_BALLOON_POSITION,
2596 Pt_BALLOON_BOTTOM, 0);
2597 PtSetArg(&args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0);
2598 PtSetArg(&args[ n++ ], Pt_ARG_TEXT_FONT, "TextFont08", 0);
2599 }
2600 if ((strstr((const char *) p_toolbar, "icons") != NULL) &&
2601 (gui_ph_toolbar_images != NULL))
2602 {
2603 PtSetArg(&args[ n++ ], Pt_ARG_LABEL_IMAGE,
2604 gui_ph_toolbar_find_icon(menu), 0);
2605 PtSetArg(&args[ n++ ], Pt_ARG_LABEL_TYPE, Pt_TEXT_IMAGE, 0);
2606 PtSetArg(&args[ n++ ], Pt_ARG_TEXT_IMAGE_SPACING, 0, 0);
2607 }
2608 if (strstr((const char *) p_toolbar, "tooltips") != NULL)
2609 {
2610 PtSetArg(&args[ n++ ], Pt_ARG_LABEL_BALLOON,
2611 gui_ph_show_tooltip, 0);
2612 PtSetArg(&args[ n++ ], Pt_ARG_LABEL_FLAGS,
2613 Pt_TRUE, Pt_SHOW_BALLOON);
2614 }
2615 PtSetArg(&args[ n++ ], Pt_ARG_MARGIN_HEIGHT, 1, 0);
2616 PtSetArg(&args[ n++ ], Pt_ARG_MARGIN_WIDTH, 1, 0);
2617 PtSetArg(&args[ n++ ], Pt_ARG_FLAGS, Pt_FALSE,
2618 Pt_HIGHLIGHTED | Pt_GETS_FOCUS);
2619 PtSetArg(&args[ n++ ], Pt_ARG_FILL_COLOR, Pg_TRANSPARENT, 0);
2620 menu->id = PtCreateWidget(PtButton, gui.vimToolBar, n, args);
2621
2622 PtAddCallback(menu->id, Pt_CB_ACTIVATE, gui_ph_handle_menu, menu);
2623 }
2624 // Update toolbar if it's open
2625 if (PtWidgetIsRealized(gui.vimToolBar))
2626 PtRealizeWidget(menu->id);
2627 }
2628 else
2629 #endif
2630 if (menu_is_separator(menu->name))
2631 {
2632 menu->id = PtCreateWidget(PtSeparator, parent->submenu_id, n, args);
2633 }
2634 else
2635 {
2636 accel_key = vim_strchr(menu->name, '&');
2637 if (accel_key != NULL)
2638 {
2639 mnemonic_str[0] = accel_key[1];
2640 mnemonic_str[1] = NUL;
2641 }
2642
2643 PtSetArg(&args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0);
2644 if (accel_key != NULL)
2645 PtSetArg(&args[ n++ ], Pt_ARG_ACCEL_KEY, mnemonic_str,
2646 0);
2647
2648 PtSetArg(&args[ n++ ], Pt_ARG_ACCEL_TEXT, menu->actext, 0);
2649
2650 menu->id = PtCreateWidget(PtMenuButton, parent->submenu_id, n, args);
2651
2652 PtAddCallback(menu->id, Pt_CB_ACTIVATE, gui_ph_handle_menu, menu);
2653
2654 #ifdef USE_PANEL_GROUP
2655 if (gui_ph_is_buffer_item(menu, parent) == TRUE)
2656 {
2657 PtAddCallback(menu->id, Pt_CB_DESTROYED,
2658 gui_ph_handle_buffer_remove, menu);
2659 gui_ph_pg_add_buffer(menu->dname);
2660 }
2661 #endif
2662 }
2663
2664 gui_ph_position_menu(menu->id, menu->priority);
2665 }
2666
2667 void
gui_mch_destroy_menu(vimmenu_T * menu)2668 gui_mch_destroy_menu(vimmenu_T *menu)
2669 {
2670 if (menu->submenu_id != NULL)
2671 PtDestroyWidget(menu->submenu_id);
2672 if (menu->id != NULL)
2673 PtDestroyWidget(menu->id);
2674
2675 menu->submenu_id = NULL;
2676 menu->id = NULL;
2677 }
2678
2679 void
gui_mch_menu_grey(vimmenu_T * menu,int grey)2680 gui_mch_menu_grey(vimmenu_T *menu, int grey)
2681 {
2682 long flags, mask, fields;
2683
2684 if (menu->id == NULL)
2685 return;
2686
2687 flags = PtWidgetFlags(menu->id);
2688 if (PtWidgetIsClass(menu->id, PtMenuButton) &&
2689 PtWidgetIsClass(PtWidgetParent(menu->id), PtMenu))
2690 {
2691 fields = Pt_FALSE;
2692 mask = Pt_SELECTABLE | Pt_HIGHLIGHTED;
2693 }
2694 else
2695 {
2696 fields = Pt_TRUE;
2697 mask = Pt_BLOCKED | Pt_GHOST;
2698 }
2699
2700 if (! grey)
2701 fields = ~fields;
2702
2703 PtSetResource(menu->id, Pt_ARG_FLAGS, fields,
2704 mask);
2705 }
2706
2707 void
gui_mch_menu_hidden(vimmenu_T * menu,int hidden)2708 gui_mch_menu_hidden(vimmenu_T *menu, int hidden)
2709 {
2710 // TODO: [un]realize the widget?
2711 }
2712
2713 void
gui_mch_draw_menubar(void)2714 gui_mch_draw_menubar(void)
2715 {
2716 // The only time a redraw is needed is when a menu button
2717 // is added to the menubar, and that is detected and the bar
2718 // redrawn in gui_mch_add_menu_item
2719 }
2720
2721 void
gui_mch_show_popupmenu(vimmenu_T * menu)2722 gui_mch_show_popupmenu(vimmenu_T *menu)
2723 {
2724 PtSetResource(menu->submenu_id, Pt_ARG_POS, &abs_mouse, 0);
2725 PtRealizeWidget(menu->submenu_id);
2726 }
2727
2728 void
gui_mch_toggle_tearoffs(int enable)2729 gui_mch_toggle_tearoffs(int enable)
2730 {
2731 // No tearoffs yet
2732 }
2733
2734 #endif
2735
2736 #if defined(FEAT_TOOLBAR) || defined(PROTO)
2737 void
gui_mch_show_toolbar(int showit)2738 gui_mch_show_toolbar(int showit)
2739 {
2740 if (showit)
2741 PtRealizeWidget(gui.vimToolBar);
2742 else
2743 PtUnrealizeWidget(gui.vimToolBar);
2744 }
2745 #endif
2746
2747 ////////////////////////////////////////////////////////////////////////////
2748 // Fonts
2749
2750 static GuiFont
gui_ph_get_font(char_u * font_name,int_u font_flags,int_u font_size,int_u enforce)2751 gui_ph_get_font(
2752 char_u *font_name,
2753 int_u font_flags,
2754 int_u font_size,
2755 // Check whether the resulting font has the font flags and size that
2756 // was asked for
2757 int_u enforce
2758 )
2759 {
2760 char_u *font_tag;
2761 FontQueryInfo info;
2762 int_u style;
2763
2764 font_tag = alloc(MAX_FONT_TAG);
2765 if (font_tag != NULL)
2766 {
2767 if (PfGenerateFontName(font_name, font_flags, font_size,
2768 font_tag) != NULL)
2769 {
2770 // Enforce some limits on the font used
2771 style = PHFONT_INFO_FIXED;
2772
2773 if (enforce & PF_STYLE_BOLD)
2774 style |= PHFONT_INFO_BOLD;
2775 if (enforce & PF_STYLE_ANTIALIAS)
2776 style |= PHFONT_INFO_ALIAS;
2777 if (enforce & PF_STYLE_ITALIC)
2778 style |= PHFONT_INFO_ITALIC;
2779
2780 PfQueryFontInfo(font_tag, &info);
2781
2782 if (info.size == 0)
2783 font_size = 0;
2784
2785 // Make sure font size matches, and that the font style
2786 // at least has the bits we're checking for
2787 if (font_size == info.size &&
2788 style == (info.style & style))
2789 return (GuiFont)font_tag;
2790 }
2791 vim_free(font_tag);
2792 }
2793 return NULL;
2794 }
2795
2796 /*
2797 * Split up the vim font name
2798 *
2799 * vim_font is in the form of
2800 * <name>:s<height>:a:b:i
2801 *
2802 * a = antialias
2803 * b = bold
2804 * i = italic
2805 *
2806 */
2807
2808 static int
gui_ph_parse_font_name(char_u * vim_font,char_u ** font_name,int_u * font_flags,int_u * font_size)2809 gui_ph_parse_font_name(
2810 char_u *vim_font,
2811 char_u **font_name,
2812 int_u *font_flags,
2813 int_u *font_size)
2814 {
2815 char_u *mark;
2816 int_u name_len, size;
2817
2818 mark = vim_strchr(vim_font, ':');
2819 if (mark == NULL)
2820 name_len = STRLEN(vim_font);
2821 else
2822 name_len = (int_u) (mark - vim_font);
2823
2824 *font_name = vim_strnsave(vim_font, name_len);
2825 if (*font_name != NULL)
2826 {
2827 if (mark != NULL)
2828 {
2829 while (*mark != NUL && *mark++ == ':')
2830 {
2831 switch (tolower(*mark++))
2832 {
2833 case 'a': *font_flags |= PF_STYLE_ANTIALIAS; break;
2834 case 'b': *font_flags |= PF_STYLE_BOLD; break;
2835 case 'i': *font_flags |= PF_STYLE_ITALIC; break;
2836
2837 case 's':
2838 size = getdigits(&mark);
2839 // Restrict the size to some vague limits
2840 if (size < 1 || size > 100)
2841 size = 8;
2842
2843 *font_size = size;
2844 break;
2845
2846 default:
2847 break;
2848 }
2849 }
2850 }
2851 return TRUE;
2852 }
2853 return FALSE;
2854 }
2855
2856 int
gui_mch_init_font(char_u * vim_font_name,int fontset)2857 gui_mch_init_font(char_u *vim_font_name, int fontset)
2858 {
2859 char_u *font_tag;
2860 char_u *font_name = NULL;
2861 int_u font_flags = 0;
2862 int_u font_size = 12;
2863
2864 FontQueryInfo info;
2865 PhRect_t extent;
2866
2867 if (vim_font_name == NULL)
2868 {
2869 // Default font
2870 vim_font_name = "PC Terminal";
2871 }
2872
2873 if (STRCMP(vim_font_name, "*") == 0)
2874 {
2875 font_tag = PtFontSelection(gui.vimWindow, NULL, NULL,
2876 "pcterm12", -1, PHFONT_FIXED, NULL);
2877
2878 if (font_tag == NULL)
2879 return FAIL;
2880
2881 gui_mch_free_font(gui.norm_font);
2882 gui.norm_font = font_tag;
2883
2884 PfQueryFontInfo(font_tag, &info);
2885 font_name = vim_strsave(info.font);
2886 }
2887 else
2888 {
2889 if (gui_ph_parse_font_name(vim_font_name, &font_name, &font_flags,
2890 &font_size) == FALSE)
2891 return FAIL;
2892
2893 font_tag = gui_ph_get_font(font_name, font_flags, font_size, 0);
2894 if (font_tag == NULL)
2895 {
2896 vim_free(font_name);
2897 return FAIL;
2898 }
2899
2900 gui_mch_free_font(gui.norm_font);
2901 gui.norm_font = font_tag;
2902 }
2903
2904 gui_mch_free_font(gui.bold_font);
2905 gui.bold_font = gui_ph_get_font(font_name, font_flags | PF_STYLE_BOLD,
2906 font_size, PF_STYLE_BOLD);
2907
2908 gui_mch_free_font(gui.ital_font);
2909 gui.ital_font = gui_ph_get_font(font_name, font_flags | PF_STYLE_ITALIC,
2910 font_size, PF_STYLE_ITALIC);
2911
2912 // This extent was brought to you by the letter 'g'
2913 PfExtentText(&extent, NULL, font_tag, "g", 1);
2914
2915 gui.char_width = extent.lr.x - extent.ul.x + 1;
2916 gui.char_height = (- extent.ul.y) + extent.lr.y + 1;
2917 gui.char_ascent = - extent.ul.y;
2918
2919 vim_free(font_name);
2920 return OK;
2921 }
2922
2923 /*
2924 * Adjust gui.char_height (after 'linespace' was changed).
2925 */
2926 int
gui_mch_adjust_charheight(void)2927 gui_mch_adjust_charheight(void)
2928 {
2929 FontQueryInfo info;
2930
2931 PfQueryFontInfo(gui.norm_font, &info);
2932
2933 gui.char_height = - info.ascender + info.descender + p_linespace;
2934 gui.char_ascent = - info.ascender + p_linespace / 2;
2935
2936 return OK;
2937 }
2938
2939 GuiFont
gui_mch_get_font(char_u * vim_font_name,int report_error)2940 gui_mch_get_font(char_u *vim_font_name, int report_error)
2941 {
2942 char_u *font_name;
2943 char_u *font_tag;
2944 int_u font_size = 12;
2945 int_u font_flags = 0;
2946
2947 if (gui_ph_parse_font_name(vim_font_name, &font_name, &font_flags,
2948 &font_size) != FALSE)
2949 {
2950 font_tag = gui_ph_get_font(font_name, font_flags, font_size, -1);
2951 vim_free(font_name);
2952
2953 if (font_tag != NULL)
2954 return (GuiFont)font_tag;
2955 }
2956
2957 if (report_error)
2958 semsg(e_font, vim_font_name);
2959
2960 return FAIL;
2961 }
2962
2963 #if defined(FEAT_EVAL) || defined(PROTO)
2964 /*
2965 * Return the name of font "font" in allocated memory.
2966 * Don't know how to get the actual name, thus use the provided name.
2967 */
2968 char_u *
gui_mch_get_fontname(GuiFont font,char_u * name)2969 gui_mch_get_fontname(GuiFont font, char_u *name)
2970 {
2971 if (name == NULL)
2972 return NULL;
2973 return vim_strsave(name);
2974 }
2975 #endif
2976
2977 void
gui_mch_set_font(GuiFont font)2978 gui_mch_set_font(GuiFont font)
2979 {
2980 PgSetFont(font);
2981 }
2982
2983 void
gui_mch_free_font(GuiFont font)2984 gui_mch_free_font(GuiFont font)
2985 {
2986 vim_free(font);
2987 }
2988
2989