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