]>
Commit | Line | Data |
---|---|---|
bb987377 ER |
1 | To: vim_dev@googlegroups.com |
2 | Subject: Patch 7.3.187 | |
3 | Fcc: outbox | |
4 | From: Bram Moolenaar <Bram@moolenaar.net> | |
5 | Mime-Version: 1.0 | |
6 | Content-Type: text/plain; charset=UTF-8 | |
7 | Content-Transfer-Encoding: 8bit | |
8 | ------------ | |
9 | ||
10 | Patch 7.3.187 | |
11 | Problem: The RISC OS port has obvious errors and is not being maintained. | |
12 | Solution: Remove the RISC OS files and code. | |
13 | Files: src/ascii.h, src/eval.c, src/ex_cmds.c, src/ex_cmds2.c, | |
14 | src/ex_docmd.c, src/fileio.c, src/globals.h, src/gui.c, src/gui.h, | |
15 | src/main.c, src/memfile.c, src/memline.c, src/misc1.c, | |
16 | src/proto.h, src/quickfix.c, src/search.c, src/structs.h, | |
17 | src/term.c, src/termlib.c, src/version.c, src/vim.h, | |
18 | src/gui_riscos.h, src/os_riscos.h, src/gui_riscos.c, | |
19 | src/os_riscos.c, runtime/doc/os_risc.txt | |
20 | ||
21 | ||
22 | *** ../vim-7.3.186/src/ascii.h 2010-08-15 21:57:25.000000000 +0200 | |
23 | --- src/ascii.h 2011-05-10 16:22:08.000000000 +0200 | |
24 | *************** | |
25 | *** 183,193 **** | |
26 | # define PATHSEP psepc | |
27 | # define PATHSEPSTR pseps | |
28 | #else | |
29 | ! # ifdef RISCOS | |
30 | ! # define PATHSEP '.' | |
31 | ! # define PATHSEPSTR "." | |
32 | ! # else | |
33 | ! # define PATHSEP '/' | |
34 | ! # define PATHSEPSTR "/" | |
35 | ! # endif | |
36 | #endif | |
37 | --- 183,188 ---- | |
38 | # define PATHSEP psepc | |
39 | # define PATHSEPSTR pseps | |
40 | #else | |
41 | ! # define PATHSEP '/' | |
42 | ! # define PATHSEPSTR "/" | |
43 | #endif | |
44 | *** ../vim-7.3.186/src/eval.c 2011-04-21 14:27:21.000000000 +0200 | |
45 | --- src/eval.c 2011-05-10 16:22:21.000000000 +0200 | |
46 | *************** | |
47 | *** 11818,11826 **** | |
48 | #ifdef __QNX__ | |
49 | "qnx", | |
50 | #endif | |
51 | - #ifdef RISCOS | |
52 | - "riscos", | |
53 | - #endif | |
54 | #ifdef UNIX | |
55 | "unix", | |
56 | #endif | |
57 | --- 11818,11823 ---- | |
58 | *** ../vim-7.3.186/src/ex_cmds.c 2011-05-10 16:00:43.000000000 +0200 | |
59 | --- src/ex_cmds.c 2011-05-10 16:23:22.000000000 +0200 | |
60 | *************** | |
61 | *** 899,907 **** | |
62 | * Handle the ":!cmd" command. Also for ":r !cmd" and ":w !cmd" | |
63 | * Bangs in the argument are replaced with the previously entered command. | |
64 | * Remember the argument. | |
65 | - * | |
66 | - * RISCOS: Bangs only replaced when followed by a space, since many | |
67 | - * pathnames contain one. | |
68 | */ | |
69 | void | |
70 | do_bang(addr_count, eap, forceit, do_in, do_out) | |
71 | --- 899,904 ---- | |
72 | *************** | |
73 | *** 980,990 **** | |
74 | trailarg = NULL; | |
75 | while (*p) | |
76 | { | |
77 | ! if (*p == '!' | |
78 | ! #ifdef RISCOS | |
79 | ! && (p[1] == ' ' || p[1] == NUL) | |
80 | ! #endif | |
81 | ! ) | |
82 | { | |
83 | if (p > newcmd && p[-1] == '\\') | |
84 | STRMOVE(p - 1, p); | |
85 | --- 977,983 ---- | |
86 | trailarg = NULL; | |
87 | while (*p) | |
88 | { | |
89 | ! if (*p == '!') | |
90 | { | |
91 | if (p > newcmd && p[-1] == '\\') | |
92 | STRMOVE(p - 1, p); | |
93 | *************** | |
94 | *** 1578,1591 **** | |
95 | if (p != NULL) | |
96 | *p = NUL; | |
97 | } | |
98 | - # ifdef RISCOS | |
99 | - STRCAT(buf, " { < "); /* Use RISC OS notation for input. */ | |
100 | - STRCAT(buf, itmp); | |
101 | - STRCAT(buf, " } "); | |
102 | - # else | |
103 | STRCAT(buf, " <"); /* " < " causes problems on Amiga */ | |
104 | STRCAT(buf, itmp); | |
105 | - # endif | |
106 | if (*p_shq == NUL) | |
107 | { | |
108 | p = vim_strchr(cmd, '|'); | |
109 | --- 1571,1578 ---- | |
110 | *************** | |
111 | *** 1634,1649 **** | |
112 | else | |
113 | vim_snprintf((char *)end, (size_t)(buflen - (end - buf)), | |
114 | #ifdef FEAT_QUICKFIX | |
115 | - # ifndef RISCOS | |
116 | - opt != p_sp ? " %s%s" : | |
117 | - # endif | |
118 | " %s %s", | |
119 | #else | |
120 | - # ifndef RISCOS | |
121 | " %s%s", /* " > %s" causes problems on Amiga */ | |
122 | - # else | |
123 | - " %s %s", /* But is needed for 'shellpipe' and RISC OS */ | |
124 | - # endif | |
125 | #endif | |
126 | (char *)opt, (char *)fname); | |
127 | } | |
128 | --- 1621,1629 ---- | |
129 | *************** | |
130 | *** 1844,1854 **** | |
131 | #ifdef VMS | |
132 | (char_u *)"-tmp", | |
133 | #else | |
134 | - # ifdef RISCOS | |
135 | - (char_u *)"/tmp", | |
136 | - # else | |
137 | (char_u *)".tmp", | |
138 | - # endif | |
139 | #endif | |
140 | FALSE); | |
141 | if (tempname == NULL) /* out of memory */ | |
142 | --- 1824,1830 ---- | |
143 | *** ../vim-7.3.186/src/ex_cmds2.c 2011-04-11 21:35:03.000000000 +0200 | |
144 | --- src/ex_cmds2.c 2011-05-10 16:23:47.000000000 +0200 | |
145 | *************** | |
146 | *** 500,517 **** | |
147 | /* Expand the file name in the same way as do_source(). This means | |
148 | * doing it twice, so that $DIR/file gets expanded when $DIR is | |
149 | * "~/dir". */ | |
150 | - #ifdef RISCOS | |
151 | - q = mch_munge_fname(p); | |
152 | - #else | |
153 | q = expand_env_save(p); | |
154 | - #endif | |
155 | if (q == NULL) | |
156 | return FAIL; | |
157 | - #ifdef RISCOS | |
158 | - p = mch_munge_fname(q); | |
159 | - #else | |
160 | p = expand_env_save(q); | |
161 | - #endif | |
162 | vim_free(q); | |
163 | if (p == NULL) | |
164 | return FAIL; | |
165 | --- 500,509 ---- | |
166 | *************** | |
167 | *** 2940,2950 **** | |
168 | proftime_T wait_start; | |
169 | #endif | |
170 | ||
171 | - #ifdef RISCOS | |
172 | - p = mch_munge_fname(fname); | |
173 | - #else | |
174 | p = expand_env_save(fname); | |
175 | - #endif | |
176 | if (p == NULL) | |
177 | return retval; | |
178 | fname_exp = fix_fname(p); | |
179 | --- 2932,2938 ---- | |
180 | *** ../vim-7.3.186/src/ex_docmd.c 2011-05-05 14:26:37.000000000 +0200 | |
181 | --- src/ex_docmd.c 2011-05-10 16:24:18.000000000 +0200 | |
182 | *************** | |
183 | *** 9702,9715 **** | |
184 | valid = 0; /* Must have ":p:h" to be valid */ | |
185 | } | |
186 | else | |
187 | - #ifdef RISCOS | |
188 | - /* Always use the full path for RISC OS if possible. */ | |
189 | - result = curbuf->b_ffname; | |
190 | - if (result == NULL) | |
191 | - result = curbuf->b_fname; | |
192 | - #else | |
193 | result = curbuf->b_fname; | |
194 | - #endif | |
195 | break; | |
196 | ||
197 | case SPEC_HASH: /* '#' or "#99": alternate file */ | |
198 | --- 9702,9708 ---- | |
199 | *************** | |
200 | *** 9854,9864 **** | |
201 | if (src[*usedlen] == '<') /* remove the file name extension */ | |
202 | { | |
203 | ++*usedlen; | |
204 | - #ifdef RISCOS | |
205 | - if ((s = vim_strrchr(result, '/')) != NULL && s >= gettail(result)) | |
206 | - #else | |
207 | if ((s = vim_strrchr(result, '.')) != NULL && s >= gettail(result)) | |
208 | - #endif | |
209 | resultlen = (int)(s - result); | |
210 | } | |
211 | #ifdef FEAT_MODIFY_FNAME | |
212 | --- 9847,9853 ---- | |
213 | *************** | |
214 | *** 10875,10882 **** | |
215 | else if (vim_ispathsep(*p)) | |
216 | { | |
217 | *s++ = '='; | |
218 | ! #if defined(BACKSLASH_IN_FILENAME) || defined(AMIGA) || defined(RISCOS) \ | |
219 | ! || defined(VMS) | |
220 | if (*p == ':') | |
221 | *s++ = '-'; | |
222 | else | |
223 | --- 10864,10870 ---- | |
224 | else if (vim_ispathsep(*p)) | |
225 | { | |
226 | *s++ = '='; | |
227 | ! #if defined(BACKSLASH_IN_FILENAME) || defined(AMIGA) || defined(VMS) | |
228 | if (*p == ':') | |
229 | *s++ = '-'; | |
230 | else | |
231 | *** ../vim-7.3.186/src/fileio.c 2011-05-05 16:41:19.000000000 +0200 | |
232 | --- src/fileio.c 2011-05-10 16:26:06.000000000 +0200 | |
233 | *************** | |
234 | *** 504,521 **** | |
235 | ||
236 | if (newfile && !read_stdin && !read_buffer) | |
237 | { | |
238 | ! /* Remember time of file. | |
239 | ! * For RISCOS, also remember the filetype. | |
240 | ! */ | |
241 | if (mch_stat((char *)fname, &st) >= 0) | |
242 | { | |
243 | buf_store_time(curbuf, &st, fname); | |
244 | curbuf->b_mtime_read = curbuf->b_mtime; | |
245 | - | |
246 | - #if defined(RISCOS) && defined(FEAT_OSFILETYPE) | |
247 | - /* Read the filetype into the buffer local filetype option. */ | |
248 | - mch_read_filetype(fname); | |
249 | - #endif | |
250 | #ifdef UNIX | |
251 | /* | |
252 | * Use the protection bits of the original file for the swap file. | |
253 | --- 504,514 ---- | |
254 | ||
255 | if (newfile && !read_stdin && !read_buffer) | |
256 | { | |
257 | ! /* Remember time of file. */ | |
258 | if (mch_stat((char *)fname, &st) >= 0) | |
259 | { | |
260 | buf_store_time(curbuf, &st, fname); | |
261 | curbuf->b_mtime_read = curbuf->b_mtime; | |
262 | #ifdef UNIX | |
263 | /* | |
264 | * Use the protection bits of the original file for the swap file. | |
265 | *************** | |
266 | *** 557,563 **** | |
267 | ||
268 | /* | |
269 | * for UNIX: check readonly with perm and mch_access() | |
270 | - * for RISCOS: same as Unix, otherwise file gets re-datestamped! | |
271 | * for MSDOS and Amiga: check readonly by trying to open the file for writing | |
272 | */ | |
273 | file_readonly = FALSE; | |
274 | --- 550,555 ---- | |
275 | *************** | |
276 | *** 3804,3816 **** | |
277 | ||
278 | /* make sure we have a valid backup extension to use */ | |
279 | if (*p_bex == NUL) | |
280 | - { | |
281 | - #ifdef RISCOS | |
282 | - backup_ext = (char_u *)"/bak"; | |
283 | - #else | |
284 | backup_ext = (char_u *)".bak"; | |
285 | - #endif | |
286 | - } | |
287 | else | |
288 | backup_ext = p_bex; | |
289 | ||
290 | --- 3796,3802 ---- | |
291 | *************** | |
292 | *** 4724,4734 **** | |
293 | #endif | |
294 | if (perm >= 0) /* set perm. of new file same as old file */ | |
295 | (void)mch_setperm(wfname, perm); | |
296 | - #ifdef RISCOS | |
297 | - if (!append && !filtering) | |
298 | - /* Set the filetype after writing the file. */ | |
299 | - mch_set_filetype(wfname, buf->b_p_oft); | |
300 | - #endif | |
301 | #ifdef HAVE_ACL | |
302 | /* Probably need to set the ACL before changing the user (can't set the | |
303 | * ACL on a file the user doesn't own). */ | |
304 | --- 4710,4715 ---- | |
305 | *************** | |
306 | *** 6262,6280 **** | |
307 | */ | |
308 | for (ptr = retval + fnamelen; ptr > retval; mb_ptr_back(retval, ptr)) | |
309 | { | |
310 | - #ifndef RISCOS | |
311 | if (*ext == '.' | |
312 | ! # ifdef USE_LONG_FNAME | |
313 | && (!USE_LONG_FNAME || shortname) | |
314 | ! # else | |
315 | ! # ifndef SHORT_FNAME | |
316 | && shortname | |
317 | - # endif | |
318 | # endif | |
319 | ) | |
320 | if (*ptr == '.') /* replace '.' by '_' */ | |
321 | *ptr = '_'; | |
322 | - #endif | |
323 | if (vim_ispathsep(*ptr)) | |
324 | { | |
325 | ++ptr; | |
326 | --- 6243,6259 ---- | |
327 | */ | |
328 | for (ptr = retval + fnamelen; ptr > retval; mb_ptr_back(retval, ptr)) | |
329 | { | |
330 | if (*ext == '.' | |
331 | ! #ifdef USE_LONG_FNAME | |
332 | && (!USE_LONG_FNAME || shortname) | |
333 | ! #else | |
334 | ! # ifndef SHORT_FNAME | |
335 | && shortname | |
336 | # endif | |
337 | + #endif | |
338 | ) | |
339 | if (*ptr == '.') /* replace '.' by '_' */ | |
340 | *ptr = '_'; | |
341 | if (vim_ispathsep(*ptr)) | |
342 | { | |
343 | ++ptr; | |
344 | *************** | |
345 | *** 6309,6331 **** | |
346 | if (fname == NULL || *fname == NUL | |
347 | || vim_ispathsep(fname[STRLEN(fname) - 1])) | |
348 | { | |
349 | - #ifdef RISCOS | |
350 | - if (*ext == '/') | |
351 | - #else | |
352 | if (*ext == '.') | |
353 | - #endif | |
354 | *s++ = '_'; | |
355 | } | |
356 | /* | |
357 | * If the extension starts with '.', truncate the base name at 8 | |
358 | * characters | |
359 | */ | |
360 | - #ifdef RISCOS | |
361 | - /* We normally use '/', but swap files are '_' */ | |
362 | - else if (*ext == '/' || *ext == '_') | |
363 | - #else | |
364 | else if (*ext == '.') | |
365 | - #endif | |
366 | { | |
367 | if ((size_t)(s - ptr) > (size_t)8) | |
368 | { | |
369 | --- 6288,6301 ---- | |
370 | *************** | |
371 | *** 6337,6349 **** | |
372 | * If the extension doesn't start with '.', and the file name | |
373 | * doesn't have an extension yet, append a '.' | |
374 | */ | |
375 | - #ifdef RISCOS | |
376 | - else if ((e = vim_strchr(ptr, '/')) == NULL) | |
377 | - *s++ = '/'; | |
378 | - #else | |
379 | else if ((e = vim_strchr(ptr, '.')) == NULL) | |
380 | *s++ = '.'; | |
381 | - #endif | |
382 | /* | |
383 | * If the extension doesn't start with '.', and there already is an | |
384 | * extension, it may need to be truncated | |
385 | --- 6307,6314 ---- | |
386 | *************** | |
387 | *** 6371,6393 **** | |
388 | /* | |
389 | * Prepend the dot. | |
390 | */ | |
391 | ! if (prepend_dot && !shortname && *(e = gettail(retval)) != | |
392 | ! #ifdef RISCOS | |
393 | ! '/' | |
394 | ! #else | |
395 | ! '.' | |
396 | ! #endif | |
397 | #ifdef USE_LONG_FNAME | |
398 | && USE_LONG_FNAME | |
399 | #endif | |
400 | ) | |
401 | { | |
402 | STRMOVE(e + 1, e); | |
403 | - #ifdef RISCOS | |
404 | - *e = '/'; | |
405 | - #else | |
406 | *e = '.'; | |
407 | - #endif | |
408 | } | |
409 | #endif | |
410 | ||
411 | --- 6336,6349 ---- | |
412 | /* | |
413 | * Prepend the dot. | |
414 | */ | |
415 | ! if (prepend_dot && !shortname && *(e = gettail(retval)) != '.' | |
416 | #ifdef USE_LONG_FNAME | |
417 | && USE_LONG_FNAME | |
418 | #endif | |
419 | ) | |
420 | { | |
421 | STRMOVE(e + 1, e); | |
422 | *e = '.'; | |
423 | } | |
424 | #endif | |
425 | ||
426 | *************** | |
427 | *** 10205,10223 **** | |
428 | ++p; | |
429 | break; | |
430 | case '.': | |
431 | - #ifdef RISCOS | |
432 | - if (allow_dirs != NULL) | |
433 | - *allow_dirs = TRUE; | |
434 | - /* FALLTHROUGH */ | |
435 | - #endif | |
436 | case '~': | |
437 | reg_pat[i++] = '\\'; | |
438 | reg_pat[i++] = *p; | |
439 | break; | |
440 | case '?': | |
441 | - #ifdef RISCOS | |
442 | - case '#': | |
443 | - #endif | |
444 | reg_pat[i++] = '.'; | |
445 | break; | |
446 | case '\\': | |
447 | --- 10161,10171 ---- | |
448 | *** ../vim-7.3.186/src/globals.h 2011-05-05 14:26:37.000000000 +0200 | |
449 | --- src/globals.h 2011-05-10 16:26:13.000000000 +0200 | |
450 | *************** | |
451 | *** 1513,1519 **** | |
452 | EXTERN char_u e_sandbox[] INIT(= N_("E48: Not allowed in sandbox")); | |
453 | #endif | |
454 | EXTERN char_u e_secure[] INIT(= N_("E523: Not allowed here")); | |
455 | ! #if defined(AMIGA) || defined(MACOS) || defined(MSWIN) || defined(RISCOS) \ | |
456 | || defined(UNIX) || defined(VMS) || defined(OS2) | |
457 | EXTERN char_u e_screenmode[] INIT(= N_("E359: Screen mode setting not supported")); | |
458 | #endif | |
459 | --- 1513,1519 ---- | |
460 | EXTERN char_u e_sandbox[] INIT(= N_("E48: Not allowed in sandbox")); | |
461 | #endif | |
462 | EXTERN char_u e_secure[] INIT(= N_("E523: Not allowed here")); | |
463 | ! #if defined(AMIGA) || defined(MACOS) || defined(MSWIN) \ | |
464 | || defined(UNIX) || defined(VMS) || defined(OS2) | |
465 | EXTERN char_u e_screenmode[] INIT(= N_("E359: Screen mode setting not supported")); | |
466 | #endif | |
467 | *** ../vim-7.3.186/src/gui.c 2011-01-17 20:08:03.000000000 +0100 | |
468 | --- src/gui.c 2011-05-10 16:26:53.000000000 +0200 | |
469 | *************** | |
470 | *** 2156,2162 **** | |
471 | ||
472 | if (highlight_mask & (HL_INVERSE | HL_STANDOUT)) | |
473 | { | |
474 | ! #if defined(AMIGA) || defined(RISCOS) | |
475 | gui_mch_set_colors(bg_color, fg_color); | |
476 | #else | |
477 | gui_mch_set_fg_color(bg_color); | |
478 | --- 2156,2162 ---- | |
479 | ||
480 | if (highlight_mask & (HL_INVERSE | HL_STANDOUT)) | |
481 | { | |
482 | ! #if defined(AMIGA) | |
483 | gui_mch_set_colors(bg_color, fg_color); | |
484 | #else | |
485 | gui_mch_set_fg_color(bg_color); | |
486 | *************** | |
487 | *** 2165,2171 **** | |
488 | } | |
489 | else | |
490 | { | |
491 | ! #if defined(AMIGA) || defined(RISCOS) | |
492 | gui_mch_set_colors(fg_color, bg_color); | |
493 | #else | |
494 | gui_mch_set_fg_color(fg_color); | |
495 | --- 2165,2171 ---- | |
496 | } | |
497 | else | |
498 | { | |
499 | ! #if defined(AMIGA) | |
500 | gui_mch_set_colors(fg_color, bg_color); | |
501 | #else | |
502 | gui_mch_set_fg_color(fg_color); | |
503 | *************** | |
504 | *** 2193,2199 **** | |
505 | if (back != 0 && ((draw_flags & DRAW_BOLD) || (highlight_mask & HL_ITALIC))) | |
506 | return FAIL; | |
507 | ||
508 | ! #if defined(RISCOS) || defined(FEAT_GUI_GTK) | |
509 | /* If there's no italic font, then fake it. | |
510 | * For GTK2, we don't need a different font for italic style. */ | |
511 | if (hl_mask_todo & HL_ITALIC) | |
512 | --- 2193,2199 ---- | |
513 | if (back != 0 && ((draw_flags & DRAW_BOLD) || (highlight_mask & HL_ITALIC))) | |
514 | return FAIL; | |
515 | ||
516 | ! #if defined(FEAT_GUI_GTK) | |
517 | /* If there's no italic font, then fake it. | |
518 | * For GTK2, we don't need a different font for italic style. */ | |
519 | if (hl_mask_todo & HL_ITALIC) | |
520 | *************** | |
521 | *** 2985,3010 **** | |
522 | did_clip = TRUE; | |
523 | } | |
524 | /* Allow the left button to start the selection */ | |
525 | - else if (button == | |
526 | - # ifdef RISCOS | |
527 | - /* Only start a drag on a drag event. Otherwise | |
528 | - * we don't get a release event. */ | |
529 | - MOUSE_DRAG | |
530 | - # else | |
531 | - MOUSE_LEFT | |
532 | - # endif | |
533 | - ) | |
534 | - { | |
535 | - clip_start_selection(X_2_COL(x), Y_2_ROW(y), repeated_click); | |
536 | - did_clip = TRUE; | |
537 | - } | |
538 | - # ifdef RISCOS | |
539 | else if (button == MOUSE_LEFT) | |
540 | { | |
541 | ! clip_clear_selection(); | |
542 | did_clip = TRUE; | |
543 | } | |
544 | - # endif | |
545 | ||
546 | /* Always allow pasting */ | |
547 | if (button != MOUSE_MIDDLE) | |
548 | --- 2985,2995 ---- | |
549 | did_clip = TRUE; | |
550 | } | |
551 | /* Allow the left button to start the selection */ | |
552 | else if (button == MOUSE_LEFT) | |
553 | { | |
554 | ! clip_start_selection(X_2_COL(x), Y_2_ROW(y), repeated_click); | |
555 | did_clip = TRUE; | |
556 | } | |
557 | ||
558 | /* Always allow pasting */ | |
559 | if (button != MOUSE_MIDDLE) | |
560 | *** ../vim-7.3.186/src/gui.h 2010-08-15 21:57:25.000000000 +0200 | |
561 | --- src/gui.h 2011-05-10 16:27:19.000000000 +0200 | |
562 | *************** | |
563 | *** 52,61 **** | |
564 | # include <SegLoad.h>*/ | |
565 | #endif | |
566 | ||
567 | - #ifdef RISCOS | |
568 | - # include "gui_riscos.h" | |
569 | - #endif | |
570 | - | |
571 | #ifdef FEAT_GUI_PHOTON | |
572 | # include <Ph.h> | |
573 | # include <Pt.h> | |
574 | --- 52,57 ---- | |
575 | *************** | |
576 | *** 151,157 **** | |
577 | #define DRAW_BOLD 0x02 /* draw bold text */ | |
578 | #define DRAW_UNDERL 0x04 /* draw underline text */ | |
579 | #define DRAW_UNDERC 0x08 /* draw undercurl text */ | |
580 | ! #if defined(RISCOS) || defined(FEAT_GUI_GTK) | |
581 | # define DRAW_ITALIC 0x10 /* draw italic text */ | |
582 | #endif | |
583 | #define DRAW_CURSOR 0x20 /* drawing block cursor (win32) */ | |
584 | --- 147,153 ---- | |
585 | #define DRAW_BOLD 0x02 /* draw bold text */ | |
586 | #define DRAW_UNDERL 0x04 /* draw underline text */ | |
587 | #define DRAW_UNDERC 0x08 /* draw undercurl text */ | |
588 | ! #if defined(FEAT_GUI_GTK) | |
589 | # define DRAW_ITALIC 0x10 /* draw italic text */ | |
590 | #endif | |
591 | #define DRAW_CURSOR 0x20 /* drawing block cursor (win32) */ | |
592 | *************** | |
593 | *** 219,227 **** | |
594 | #ifdef FEAT_GUI_MAC | |
595 | ControlHandle id; /* A handle to the scrollbar */ | |
596 | #endif | |
597 | - #ifdef RISCOS | |
598 | - int id; /* Window handle of scrollbar window */ | |
599 | - #endif | |
600 | #ifdef FEAT_GUI_PHOTON | |
601 | PtWidget_t *id; | |
602 | #endif | |
603 | --- 215,220 ---- | |
604 | *************** | |
605 | *** 450,463 **** | |
606 | int visibility; /* Is window partially/fully obscured? */ | |
607 | #endif | |
608 | ||
609 | - #ifdef RISCOS | |
610 | - int window_handle; | |
611 | - char_u *window_title; | |
612 | - int window_title_size; | |
613 | - int fg_colour; /* in 0xBBGGRR format */ | |
614 | - int bg_colour; | |
615 | - #endif | |
616 | - | |
617 | #ifdef FEAT_GUI_PHOTON | |
618 | PtWidget_t *vimWindow; /* PtWindow */ | |
619 | PtWidget_t *vimTextArea; /* PtRaw */ | |
620 | --- 443,448 ---- | |
621 | *** ../vim-7.3.186/src/main.c 2011-04-11 21:35:03.000000000 +0200 | |
622 | --- src/main.c 2011-05-10 16:27:33.000000000 +0200 | |
623 | *************** | |
624 | *** 3276,3286 **** | |
625 | main_msg(_("+reverse\t\tDon't use reverse video (also: +rv)")); | |
626 | main_msg(_("-xrm <resource>\tSet the specified resource")); | |
627 | #endif /* FEAT_GUI_X11 */ | |
628 | - #if defined(FEAT_GUI) && defined(RISCOS) | |
629 | - mch_msg(_("\nArguments recognised by gvim (RISC OS version):\n")); | |
630 | - main_msg(_("--columns <number>\tInitial width of window in columns")); | |
631 | - main_msg(_("--rows <number>\tInitial height of window in rows")); | |
632 | - #endif | |
633 | #ifdef FEAT_GUI_GTK | |
634 | mch_msg(_("\nArguments recognised by gvim (GTK+ version):\n")); | |
635 | main_msg(_("-font <font>\t\tUse <font> for normal text (also: -fn)")); | |
636 | --- 3276,3281 ---- | |
637 | *** ../vim-7.3.186/src/memfile.c 2011-03-22 18:10:34.000000000 +0100 | |
638 | --- src/memfile.c 2011-05-10 16:27:38.000000000 +0200 | |
639 | *************** | |
640 | *** 1307,1313 **** | |
641 | * fname cannot be NameBuff, because it must have been allocated. | |
642 | */ | |
643 | mf_set_ffname(mfp); | |
644 | ! #if defined(MSDOS) || defined(MSWIN) || defined(RISCOS) | |
645 | /* | |
646 | * A ":!cd e:xxx" may change the directory without us knowning, use the | |
647 | * full pathname always. Careful: This frees fname! | |
648 | --- 1307,1313 ---- | |
649 | * fname cannot be NameBuff, because it must have been allocated. | |
650 | */ | |
651 | mf_set_ffname(mfp); | |
652 | ! #if defined(MSDOS) || defined(MSWIN) | |
653 | /* | |
654 | * A ":!cd e:xxx" may change the directory without us knowning, use the | |
655 | * full pathname always. Careful: This frees fname! | |
656 | *** ../vim-7.3.186/src/memline.c 2011-02-15 11:56:56.000000000 +0100 | |
657 | --- src/memline.c 2011-05-10 16:28:40.000000000 +0200 | |
658 | *************** | |
659 | *** 748,754 **** | |
660 | continue; | |
661 | if (mf_open_file(mfp, fname) == OK) /* consumes fname! */ | |
662 | { | |
663 | ! #if defined(MSDOS) || defined(MSWIN) || defined(RISCOS) | |
664 | /* | |
665 | * set full pathname for swap file now, because a ":!cd dir" may | |
666 | * change directory without us knowing it. | |
667 | --- 748,754 ---- | |
668 | continue; | |
669 | if (mf_open_file(mfp, fname) == OK) /* consumes fname! */ | |
670 | { | |
671 | ! #if defined(MSDOS) || defined(MSWIN) | |
672 | /* | |
673 | * set full pathname for swap file now, because a ":!cd dir" may | |
674 | * change directory without us knowing it. | |
675 | *************** | |
676 | *** 933,939 **** | |
677 | b0p->b0_fname[0] = NUL; | |
678 | else | |
679 | { | |
680 | ! #if defined(MSDOS) || defined(MSWIN) || defined(AMIGA) || defined(RISCOS) | |
681 | /* Systems that cannot translate "~user" back into a path: copy the | |
682 | * file name unmodified. Do use slashes instead of backslashes for | |
683 | * portability. */ | |
684 | --- 933,939 ---- | |
685 | b0p->b0_fname[0] = NUL; | |
686 | else | |
687 | { | |
688 | ! #if defined(MSDOS) || defined(MSWIN) || defined(AMIGA) | |
689 | /* Systems that cannot translate "~user" back into a path: copy the | |
690 | * file name unmodified. Do use slashes instead of backslashes for | |
691 | * portability. */ | |
692 | *************** | |
693 | *** 1103,1109 **** | |
694 | fname = (char_u *)""; | |
695 | len = (int)STRLEN(fname); | |
696 | if (len >= 4 && | |
697 | ! #if defined(VMS) || defined(RISCOS) | |
698 | STRNICMP(fname + len - 4, "_s" , 2) | |
699 | #else | |
700 | STRNICMP(fname + len - 4, ".s" , 2) | |
701 | --- 1103,1109 ---- | |
702 | fname = (char_u *)""; | |
703 | len = (int)STRLEN(fname); | |
704 | if (len >= 4 && | |
705 | ! #if defined(VMS) | |
706 | STRNICMP(fname + len - 4, "_s" , 2) | |
707 | #else | |
708 | STRNICMP(fname + len - 4, ".s" , 2) | |
709 | *************** | |
710 | *** 1773,1783 **** | |
711 | #ifdef VMS | |
712 | names[0] = vim_strsave((char_u *)"*_sw%"); | |
713 | #else | |
714 | - # ifdef RISCOS | |
715 | - names[0] = vim_strsave((char_u *)"*_sw#"); | |
716 | - # else | |
717 | names[0] = vim_strsave((char_u *)"*.sw?"); | |
718 | - # endif | |
719 | #endif | |
720 | #if defined(UNIX) || defined(WIN3264) | |
721 | /* For Unix names starting with a dot are special. MS-Windows | |
722 | --- 1773,1779 ---- | |
723 | *************** | |
724 | *** 1804,1814 **** | |
725 | #ifdef VMS | |
726 | names[0] = concat_fnames(dir_name, (char_u *)"*_sw%", TRUE); | |
727 | #else | |
728 | - # ifdef RISCOS | |
729 | - names[0] = concat_fnames(dir_name, (char_u *)"*_sw#", TRUE); | |
730 | - # else | |
731 | names[0] = concat_fnames(dir_name, (char_u *)"*.sw?", TRUE); | |
732 | - # endif | |
733 | #endif | |
734 | #if defined(UNIX) || defined(WIN3264) | |
735 | /* For Unix names starting with a dot are special. MS-Windows | |
736 | --- 1800,1806 ---- | |
737 | *************** | |
738 | *** 1877,1883 **** | |
739 | char_u *swapname; | |
740 | ||
741 | swapname = modname(fname_res, | |
742 | ! #if defined(VMS) || defined(RISCOS) | |
743 | (char_u *)"_swp", FALSE | |
744 | #else | |
745 | (char_u *)".swp", TRUE | |
746 | --- 1869,1875 ---- | |
747 | char_u *swapname; | |
748 | ||
749 | swapname = modname(fname_res, | |
750 | ! #if defined(VMS) | |
751 | (char_u *)"_swp", FALSE | |
752 | #else | |
753 | (char_u *)".swp", TRUE | |
754 | *************** | |
755 | *** 2176,2186 **** | |
756 | #ifdef VMS | |
757 | names[num_names] = concat_fnames(path, (char_u *)"_sw%", FALSE); | |
758 | #else | |
759 | - # ifdef RISCOS | |
760 | - names[num_names] = concat_fnames(path, (char_u *)"_sw#", FALSE); | |
761 | - # else | |
762 | names[num_names] = concat_fnames(path, (char_u *)".sw?", FALSE); | |
763 | - # endif | |
764 | #endif | |
765 | if (names[num_names] == NULL) | |
766 | goto end; | |
767 | --- 2168,2174 ---- | |
768 | *************** | |
769 | *** 2207,2217 **** | |
770 | #ifdef VMS | |
771 | names[num_names] = modname(path, (char_u *)"_sw%", FALSE); | |
772 | #else | |
773 | - # ifdef RISCOS | |
774 | - names[num_names] = modname(path, (char_u *)"_sw#", FALSE); | |
775 | - # else | |
776 | names[num_names] = modname(path, (char_u *)".sw?", FALSE); | |
777 | - # endif | |
778 | #endif | |
779 | if (names[num_names] == NULL) | |
780 | goto end; | |
781 | --- 2195,2201 ---- | |
782 | *************** | |
783 | *** 3205,3211 **** | |
784 | mf_free(mfp, hp); /* free the data block */ | |
785 | buf->b_ml.ml_locked = NULL; | |
786 | ||
787 | ! for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0; --stack_idx) | |
788 | { | |
789 | buf->b_ml.ml_stack_top = 0; /* stack is invalid when failing */ | |
790 | ip = &(buf->b_ml.ml_stack[stack_idx]); | |
791 | --- 3189,3196 ---- | |
792 | mf_free(mfp, hp); /* free the data block */ | |
793 | buf->b_ml.ml_locked = NULL; | |
794 | ||
795 | ! for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0; | |
796 | ! --stack_idx) | |
797 | { | |
798 | buf->b_ml.ml_stack_top = 0; /* stack is invalid when failing */ | |
799 | ip = &(buf->b_ml.ml_stack[stack_idx]); | |
800 | *************** | |
801 | *** 3956,3969 **** | |
802 | #else | |
803 | (buf->b_p_sn || buf->b_shortname), | |
804 | #endif | |
805 | - #ifdef RISCOS | |
806 | - /* Avoid problems if fname has special chars, eg <Wimp$Scrap> */ | |
807 | - ffname, | |
808 | - #else | |
809 | fname_res, | |
810 | - #endif | |
811 | (char_u *) | |
812 | ! #if defined(VMS) || defined(RISCOS) | |
813 | "_swp", | |
814 | #else | |
815 | ".swp", | |
816 | --- 3941,3949 ---- | |
817 | #else | |
818 | (buf->b_p_sn || buf->b_shortname), | |
819 | #endif | |
820 | fname_res, | |
821 | (char_u *) | |
822 | ! #if defined(VMS) | |
823 | "_swp", | |
824 | #else | |
825 | ".swp", | |
826 | *************** | |
827 | *** 4427,4440 **** | |
828 | } | |
829 | close(fd); | |
830 | } | |
831 | - #ifdef RISCOS | |
832 | - else | |
833 | - /* Can't open swap file, though it does exist. | |
834 | - * Assume that the user is editing two files with | |
835 | - * the same name in different directories. No error. | |
836 | - */ | |
837 | - differ = TRUE; | |
838 | - #endif | |
839 | ||
840 | /* give the ATTENTION message when there is an old swap file | |
841 | * for the current file, and the buffer was not recovered. */ | |
842 | --- 4407,4412 ---- | |
843 | *** ../vim-7.3.186/src/misc1.c 2011-05-10 14:44:07.000000000 +0200 | |
844 | --- src/misc1.c 2011-05-10 16:29:29.000000000 +0200 | |
845 | *************** | |
846 | *** 4589,4613 **** | |
847 | vim_ispathsep(c) | |
848 | int c; | |
849 | { | |
850 | ! #ifdef RISCOS | |
851 | ! return (c == '.' || c == ':'); | |
852 | ! #else | |
853 | ! # ifdef UNIX | |
854 | return (c == '/'); /* UNIX has ':' inside file names */ | |
855 | ! # else | |
856 | ! # ifdef BACKSLASH_IN_FILENAME | |
857 | return (c == ':' || c == '/' || c == '\\'); | |
858 | ! # else | |
859 | ! # ifdef VMS | |
860 | /* server"user passwd"::device:[full.path.name]fname.extension;version" */ | |
861 | return (c == ':' || c == '[' || c == ']' || c == '/' | |
862 | || c == '<' || c == '>' || c == '"' ); | |
863 | ! # else /* Amiga */ | |
864 | return (c == ':' || c == '/'); | |
865 | ! # endif /* VMS */ | |
866 | ! # endif | |
867 | # endif | |
868 | ! #endif /* RISC OS */ | |
869 | } | |
870 | ||
871 | #if defined(FEAT_SEARCHPATH) || defined(PROTO) | |
872 | --- 4589,4609 ---- | |
873 | vim_ispathsep(c) | |
874 | int c; | |
875 | { | |
876 | ! #ifdef UNIX | |
877 | return (c == '/'); /* UNIX has ':' inside file names */ | |
878 | ! #else | |
879 | ! # ifdef BACKSLASH_IN_FILENAME | |
880 | return (c == ':' || c == '/' || c == '\\'); | |
881 | ! # else | |
882 | ! # ifdef VMS | |
883 | /* server"user passwd"::device:[full.path.name]fname.extension;version" */ | |
884 | return (c == ':' || c == '[' || c == ']' || c == '/' | |
885 | || c == '<' || c == '>' || c == '"' ); | |
886 | ! # else | |
887 | return (c == ':' || c == '/'); | |
888 | ! # endif /* VMS */ | |
889 | # endif | |
890 | ! #endif | |
891 | } | |
892 | ||
893 | #if defined(FEAT_SEARCHPATH) || defined(PROTO) | |
894 | *** ../vim-7.3.186/src/proto.h 2010-08-15 21:57:29.000000000 +0200 | |
895 | --- src/proto.h 2011-05-10 16:29:45.000000000 +0200 | |
896 | *************** | |
897 | *** 62,70 **** | |
898 | # ifdef __BEOS__ | |
899 | # include "os_beos.pro" | |
900 | # endif | |
901 | - # ifdef RISCOS | |
902 | - # include "os_riscos.pro" | |
903 | - # endif | |
904 | # ifdef __QNX__ | |
905 | # include "os_qnx.pro" | |
906 | # endif | |
907 | --- 62,67 ---- | |
908 | *************** | |
909 | *** 245,253 **** | |
910 | # ifdef FEAT_GUI_X11 | |
911 | # include "gui_x11.pro" | |
912 | # endif | |
913 | - # ifdef RISCOS | |
914 | - # include "gui_riscos.pro" | |
915 | - # endif | |
916 | # ifdef FEAT_GUI_PHOTON | |
917 | # include "gui_photon.pro" | |
918 | # endif | |
919 | --- 242,247 ---- | |
920 | *** ../vim-7.3.186/src/quickfix.c 2011-05-05 17:14:07.000000000 +0200 | |
921 | --- src/quickfix.c 2011-05-10 16:30:18.000000000 +0200 | |
922 | *************** | |
923 | *** 1182,1202 **** | |
924 | if (fname == NULL || *fname == NUL) /* no file name */ | |
925 | return 0; | |
926 | { | |
927 | - #ifdef RISCOS | |
928 | - /* Name is reported as `main.c', but file is `c.main' */ | |
929 | - return ro_buflist_add(fname); | |
930 | - #else | |
931 | char_u *ptr; | |
932 | int fnum; | |
933 | ||
934 | ! # ifdef VMS | |
935 | vms_remove_version(fname); | |
936 | ! # endif | |
937 | ! # ifdef BACKSLASH_IN_FILENAME | |
938 | if (directory != NULL) | |
939 | slash_adjust(directory); | |
940 | slash_adjust(fname); | |
941 | ! # endif | |
942 | if (directory != NULL && !vim_isAbsName(fname) | |
943 | && (ptr = concat_fnames(directory, fname, TRUE)) != NULL) | |
944 | { | |
945 | --- 1182,1198 ---- | |
946 | if (fname == NULL || *fname == NUL) /* no file name */ | |
947 | return 0; | |
948 | { | |
949 | char_u *ptr; | |
950 | int fnum; | |
951 | ||
952 | ! #ifdef VMS | |
953 | vms_remove_version(fname); | |
954 | ! #endif | |
955 | ! #ifdef BACKSLASH_IN_FILENAME | |
956 | if (directory != NULL) | |
957 | slash_adjust(directory); | |
958 | slash_adjust(fname); | |
959 | ! #endif | |
960 | if (directory != NULL && !vim_isAbsName(fname) | |
961 | && (ptr = concat_fnames(directory, fname, TRUE)) != NULL) | |
962 | { | |
963 | *************** | |
964 | *** 1221,1227 **** | |
965 | return fnum; | |
966 | } | |
967 | return buflist_add(fname, 0); | |
968 | - #endif | |
969 | } | |
970 | } | |
971 | ||
972 | --- 1217,1222 ---- | |
973 | *** ../vim-7.3.186/src/search.c 2011-02-25 18:38:29.000000000 +0100 | |
974 | --- src/search.c 2011-05-10 16:30:38.000000000 +0200 | |
975 | *************** | |
976 | *** 4581,4589 **** | |
977 | char_u *already = NULL; | |
978 | char_u *startp = NULL; | |
979 | char_u *inc_opt = NULL; | |
980 | - #ifdef RISCOS | |
981 | - int previous_munging = __riscosify_control; | |
982 | - #endif | |
983 | #if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX) | |
984 | win_T *curwin_save = NULL; | |
985 | #endif | |
986 | --- 4581,4586 ---- | |
987 | *************** | |
988 | *** 4596,4606 **** | |
989 | if (file_line == NULL) | |
990 | return; | |
991 | ||
992 | - #ifdef RISCOS | |
993 | - /* UnixLib knows best how to munge c file names - turn munging back on. */ | |
994 | - int __riscosify_control = 0; | |
995 | - #endif | |
996 | - | |
997 | if (type != CHECK_PATH && type != FIND_DEFINE | |
998 | #ifdef FEAT_INS_EXPAND | |
999 | /* when CONT_SOL is set compare "ptr" with the beginning of the line | |
1000 | --- 4593,4598 ---- | |
1001 | *************** | |
1002 | *** 5228,5238 **** | |
1003 | vim_free(regmatch.regprog); | |
1004 | vim_free(incl_regmatch.regprog); | |
1005 | vim_free(def_regmatch.regprog); | |
1006 | - | |
1007 | - #ifdef RISCOS | |
1008 | - /* Restore previous file munging state. */ | |
1009 | - __riscosify_control = previous_munging; | |
1010 | - #endif | |
1011 | } | |
1012 | ||
1013 | static void | |
1014 | --- 5220,5225 ---- | |
1015 | *** ../vim-7.3.186/src/structs.h 2011-03-22 18:10:34.000000000 +0100 | |
1016 | --- src/structs.h 2011-05-10 16:30:49.000000000 +0200 | |
1017 | *************** | |
1018 | *** 2366,2376 **** | |
1019 | MenuHandle menu_handle; | |
1020 | MenuHandle submenu_handle; | |
1021 | #endif | |
1022 | - #ifdef RISCOS | |
1023 | - int *id; /* Not used, but gui.c needs it */ | |
1024 | - int greyed_out; /* Flag */ | |
1025 | - int hidden; | |
1026 | - #endif | |
1027 | #ifdef FEAT_GUI_PHOTON | |
1028 | PtWidget_t *id; | |
1029 | PtWidget_t *submenu_id; | |
1030 | --- 2366,2371 ---- | |
1031 | *** ../vim-7.3.186/src/term.c 2010-12-30 14:47:32.000000000 +0100 | |
1032 | --- src/term.c 2011-05-10 16:31:41.000000000 +0200 | |
1033 | *************** | |
1034 | *** 52,58 **** | |
1035 | ||
1036 | /* | |
1037 | * Here are the builtin termcap entries. They are not stored as complete | |
1038 | ! * Tcarr structures, as such a structure is too big. | |
1039 | * | |
1040 | * The entries are compact, therefore they normally are included even when | |
1041 | * HAVE_TGETENT is defined. When HAVE_TGETENT is defined, the builtin entries | |
1042 | --- 52,58 ---- | |
1043 | ||
1044 | /* | |
1045 | * Here are the builtin termcap entries. They are not stored as complete | |
1046 | ! * structures with all entries, as such a structure is too big. | |
1047 | * | |
1048 | * The entries are compact, therefore they normally are included even when | |
1049 | * HAVE_TGETENT is defined. When HAVE_TGETENT is defined, the builtin entries | |
1050 | *************** | |
1051 | *** 199,269 **** | |
1052 | #endif | |
1053 | ||
1054 | #ifndef NO_BUILTIN_TCAPS | |
1055 | - # if defined(RISCOS) || defined(ALL_BUILTIN_TCAPS) | |
1056 | - /* | |
1057 | - * Default for the Acorn. | |
1058 | - */ | |
1059 | - {(int)KS_NAME, "riscos"}, | |
1060 | - {(int)KS_CL, "\014"}, /* Cls and Home Cursor */ | |
1061 | - {(int)KS_CM, "\001%d\001%d\002"}, /* Position cursor */ | |
1062 | - | |
1063 | - {(int)KS_CCO, "16"}, /* Allow 16 colors */ | |
1064 | - | |
1065 | - {(int)KS_CAF, "\001%d\021"}, /* Set foreground colour */ | |
1066 | - {(int)KS_CAB, "\001%d\022"}, /* Set background colour */ | |
1067 | - | |
1068 | - | |
1069 | - {(int)KS_ME, "\004"}, /* Normal mode */ | |
1070 | - {(int)KS_MR, "\005"}, /* Reverse */ | |
1071 | - | |
1072 | - {(int)KS_VI, "\016"}, /* Cursor invisible */ | |
1073 | - {(int)KS_VE, "\017"}, /* Cursor visible */ | |
1074 | - {(int)KS_VS, "\020"}, /* Cursor very visible */ | |
1075 | - | |
1076 | - {(int)KS_CS, "\001%d\001%d\003"}, /* Set scroll region */ | |
1077 | - {(int)KS_SR, "\023"}, /* Scroll text down */ | |
1078 | - {K_UP, "\217"}, | |
1079 | - {K_DOWN, "\216"}, | |
1080 | - {K_LEFT, "\214"}, | |
1081 | - {K_RIGHT, "\215"}, | |
1082 | - {K_S_UP, "\237"}, | |
1083 | - {K_S_DOWN, "\236"}, | |
1084 | - {K_S_LEFT, "\234"}, | |
1085 | - {K_S_RIGHT, "\235"}, | |
1086 | - | |
1087 | - {K_F1, "\201"}, | |
1088 | - {K_F2, "\202"}, | |
1089 | - {K_F3, "\203"}, | |
1090 | - {K_F4, "\204"}, | |
1091 | - {K_F5, "\205"}, | |
1092 | - {K_F6, "\206"}, | |
1093 | - {K_F7, "\207"}, | |
1094 | - {K_F8, "\210"}, | |
1095 | - {K_F9, "\211"}, | |
1096 | - {K_F10, "\312"}, | |
1097 | - {K_F11, "\313"}, | |
1098 | - {K_F12, "\314"}, | |
1099 | - {K_S_F1, "\221"}, | |
1100 | - {K_S_F2, "\222"}, | |
1101 | - {K_S_F3, "\223"}, | |
1102 | - {K_S_F4, "\224"}, | |
1103 | - {K_S_F5, "\225"}, | |
1104 | - {K_S_F6, "\226"}, | |
1105 | - {K_S_F7, "\227"}, | |
1106 | - {K_S_F8, "\230"}, | |
1107 | - {K_S_F9, "\231"}, | |
1108 | - {K_S_F10, "\332"}, | |
1109 | - {K_S_F11, "\333"}, | |
1110 | - {K_S_F12, "\334"}, | |
1111 | - {K_BS, "\010"}, | |
1112 | - {K_INS, "\315"}, | |
1113 | - {K_DEL, "\177"}, | |
1114 | - {K_HOME, "\036"}, | |
1115 | - {K_END, "\213"}, | |
1116 | - {K_PAGEUP, "\237"}, | |
1117 | - {K_PAGEDOWN, "\236"}, | |
1118 | - # endif /* Acorn terminal */ | |
1119 | - | |
1120 | ||
1121 | # if defined(AMIGA) || defined(ALL_BUILTIN_TCAPS) | |
1122 | /* | |
1123 | --- 199,204 ---- | |
1124 | *************** | |
1125 | *** 1399,1408 **** | |
1126 | /* | |
1127 | * DEFAULT_TERM is used, when no terminal is specified with -T option or $TERM. | |
1128 | */ | |
1129 | - #ifdef RISCOS | |
1130 | - # define DEFAULT_TERM (char_u *)"riscos" | |
1131 | - #endif | |
1132 | - | |
1133 | #ifdef AMIGA | |
1134 | # define DEFAULT_TERM (char_u *)"amiga" | |
1135 | #endif | |
1136 | --- 1334,1339 ---- | |
1137 | *** ../vim-7.3.186/src/termlib.c 2010-08-15 21:57:30.000000000 +0200 | |
1138 | --- src/termlib.c 2011-05-10 16:31:58.000000000 +0200 | |
1139 | *************** | |
1140 | *** 13,19 **** | |
1141 | #include "vim.h" | |
1142 | #include "termlib.pro" | |
1143 | ||
1144 | ! #if !defined(AMIGA) && !defined(VMS) && !defined(MACOS) && !defined(RISCOS) | |
1145 | # include <sgtty.h> | |
1146 | #endif | |
1147 | ||
1148 | --- 13,19 ---- | |
1149 | #include "vim.h" | |
1150 | #include "termlib.pro" | |
1151 | ||
1152 | ! #if !defined(AMIGA) && !defined(VMS) && !defined(MACOS) | |
1153 | # include <sgtty.h> | |
1154 | #endif | |
1155 | ||
1156 | *** ../vim-7.3.186/src/version.c 2011-05-10 16:12:40.000000000 +0200 | |
1157 | --- src/version.c 2011-05-10 16:37:20.000000000 +0200 | |
1158 | *************** | |
1159 | *** 1205,1213 **** | |
1160 | # endif | |
1161 | #endif | |
1162 | ||
1163 | - #ifdef RISCOS | |
1164 | - MSG_PUTS(_("\nRISC OS version")); | |
1165 | - #endif | |
1166 | #ifdef VMS | |
1167 | MSG_PUTS(_("\nOpenVMS version")); | |
1168 | # ifdef HAVE_PATHDEF | |
1169 | --- 1207,1212 ---- | |
1170 | *** ../vim-7.3.186/src/vim.h 2011-05-05 16:41:19.000000000 +0200 | |
1171 | --- src/vim.h 2011-05-10 16:32:40.000000000 +0200 | |
1172 | *************** | |
1173 | *** 184,192 **** | |
1174 | # define SIZEOF_INT 2 | |
1175 | # endif | |
1176 | #endif | |
1177 | - #ifdef RISCOS | |
1178 | - # define SIZEOF_INT 4 | |
1179 | - #endif | |
1180 | ||
1181 | ||
1182 | #include "feature.h" /* #defines for optionals and features */ | |
1183 | --- 184,189 ---- | |
1184 | *************** | |
1185 | *** 340,349 **** | |
1186 | # include "os_mac.h" | |
1187 | #endif | |
1188 | ||
1189 | - #ifdef RISCOS | |
1190 | - # include "os_riscos.h" | |
1191 | - #endif | |
1192 | - | |
1193 | #ifdef __QNX__ | |
1194 | # include "os_qnx.h" | |
1195 | #endif | |
1196 | --- 337,342 ---- | |
1197 | *** ../vim-7.3.186/src/gui_riscos.h 2010-08-15 21:57:28.000000000 +0200 | |
1198 | --- src/gui_riscos.h 1970-01-01 01:00:00.000000000 +0100 | |
1199 | *************** | |
1200 | *** 1,32 **** | |
1201 | - /* vi:set ts=8 sts=4 sw=4: | |
1202 | - * | |
1203 | - * VIM - Vi IMproved by Bram Moolenaar | |
1204 | - * | |
1205 | - * Do ":help uganda" in Vim to read copying and usage conditions. | |
1206 | - * Do ":help credits" in Vim to see a list of people who contributed. | |
1207 | - */ | |
1208 | - | |
1209 | - #define FEAT_BROWSE | |
1210 | - | |
1211 | - #define TASK 0x4b534154 | |
1212 | - | |
1213 | - /* Nested wimp flags: */ | |
1214 | - #define CHILD_FIX_TO_WORKAREA 0 | |
1215 | - #define CHILD_FIX_TO_LEFT 1 | |
1216 | - #define CHILD_FIX_TO_BOTTOM 1 | |
1217 | - #define CHILD_FIX_TO_RIGHT 2 | |
1218 | - #define CHILD_FIX_TO_TOP 2 | |
1219 | - | |
1220 | - #define CHILD_SELF_SCROLL 0 | |
1221 | - #define CHILD_PARENT_SCROLL 1 | |
1222 | - | |
1223 | - #define CHILD_LEFT 16 | |
1224 | - #define CHILD_BOTTOM 18 | |
1225 | - #define CHILD_RIGHT 20 | |
1226 | - #define CHILD_TOP 22 | |
1227 | - #define CHILD_SCROLL_X 24 | |
1228 | - #define CHILD_SCROLL_Y 26 | |
1229 | - | |
1230 | - int wimp_poll(int mask, int *block); | |
1231 | - int wimp_poll_idle(int mask, int *block, int end_time); | |
1232 | - void ro_open_main(int *block); | |
1233 | --- 0 ---- | |
1234 | *** ../vim-7.3.186/src/os_riscos.h 2010-08-15 21:57:30.000000000 +0200 | |
1235 | --- src/os_riscos.h 1970-01-01 01:00:00.000000000 +0100 | |
1236 | *************** | |
1237 | *** 1,166 **** | |
1238 | - /* vi:set ts=8 sts=4 sw=4: | |
1239 | - * | |
1240 | - * VIM - Vi IMproved by Bram Moolenaar | |
1241 | - * | |
1242 | - * Do ":help uganda" in Vim to read copying and usage conditions. | |
1243 | - * Do ":help credits" in Vim to see a list of people who contributed. | |
1244 | - */ | |
1245 | - | |
1246 | - #include <sys/types.h> | |
1247 | - #include <sys/stat.h> | |
1248 | - #include <sys/ioctl.h> | |
1249 | - #include <termios.h> | |
1250 | - #include <stdlib.h> | |
1251 | - #include <unixlib/local.h> | |
1252 | - #include <errno.h> | |
1253 | - #include <fcntl.h> | |
1254 | - | |
1255 | - #define CASE_INSENSITIVE_FILENAME | |
1256 | - #define FEAT_MODIFY_FNAME | |
1257 | - #define FEAT_OSFILETYPE | |
1258 | - #define DFLT_OFT "Text" | |
1259 | - #define USE_TERM_CONSOLE | |
1260 | - #define HAVE_AVAIL_MEM | |
1261 | - | |
1262 | - /* Longer filenames now accessible to all */ | |
1263 | - #ifndef BASENAMELEN | |
1264 | - # define BASENAMELEN 64 /* Same length as unzip */ | |
1265 | - #endif | |
1266 | - | |
1267 | - #ifndef TEMNAME | |
1268 | - # define TEMPNAME "<Wimp$ScrapDir>.v?XXXXXX" | |
1269 | - # define TEMPNAMELEN 25 | |
1270 | - #endif | |
1271 | - | |
1272 | - #ifndef DFLT_HELPFILE | |
1273 | - # define DFLT_HELPFILE "Vim:doc.help" | |
1274 | - #endif | |
1275 | - | |
1276 | - #ifndef DFLT_BDIR | |
1277 | - # define DFLT_BDIR ".,<Wimp$ScrapDir>." /* default for 'backupdir' */ | |
1278 | - #endif | |
1279 | - | |
1280 | - /* Paths to try putting swap file in. */ | |
1281 | - #ifndef DFLT_DIR | |
1282 | - # define DFLT_DIR "<Wimp$ScrapDir>.,." /* default for 'directory' */ | |
1283 | - #endif | |
1284 | - | |
1285 | - #ifndef DFLT_VDIR | |
1286 | - # define DFLT_VDIR "Choices:Vim.view" /* default for 'viewdir' */ | |
1287 | - #endif | |
1288 | - | |
1289 | - #ifndef TERMCAPFILE | |
1290 | - # define TERMCAPFILE "Vim:TermCap" | |
1291 | - #endif | |
1292 | - #define HAVE_TGETENT | |
1293 | - | |
1294 | - #ifndef SYNTAX_FNAME | |
1295 | - # define SYNTAX_FNAME "Vim:Syntax.%s" | |
1296 | - #endif | |
1297 | - | |
1298 | - #ifndef EVIM_FILE | |
1299 | - # define EVIM_FILE "Vim:Evim" | |
1300 | - #endif | |
1301 | - | |
1302 | - #define FEAT_VIMINFO | |
1303 | - | |
1304 | - #ifndef VIMINFO_FILE | |
1305 | - # define VIMINFO_FILE "<Choices$Write>.Vim.VimInfo" | |
1306 | - #endif | |
1307 | - #ifndef VIMINFO_FILE2 | |
1308 | - # define VIMINFO_FILE2 "Choices:Vim.VimInfo" | |
1309 | - #endif | |
1310 | - | |
1311 | - #ifndef VIMRC_FILE | |
1312 | - # define VIMRC_FILE "/vimrc" | |
1313 | - #endif | |
1314 | - #ifndef EXRC_FILE | |
1315 | - # define EXRC_FILE "/exrc" | |
1316 | - #endif | |
1317 | - #ifndef GVIMRC_FILE | |
1318 | - # define GVIMRC_FILE "/gvimrc" | |
1319 | - #endif | |
1320 | - #ifndef USR_VIMRC_FILE | |
1321 | - # define USR_VIMRC_FILE "Vim:Evim" | |
1322 | - #endif | |
1323 | - #ifndef SESSION_FILE | |
1324 | - # define SESSION_FILE "/Session.vim" | |
1325 | - #endif | |
1326 | - #ifndef USR_VIMRC_FILE | |
1327 | - # define USR_VIMRC_FILE "Choices:Vim.VimRC" | |
1328 | - #endif | |
1329 | - #ifndef USR_GVIMRC_FILE | |
1330 | - # define USR_GVIMRC_FILE "Choices:Vim.GVimRC" | |
1331 | - #endif | |
1332 | - #ifndef USR_EXRC_FILE | |
1333 | - # define USR_EXRC_FILE "Choices:Vim.ExRC" | |
1334 | - #endif | |
1335 | - #ifndef SYS_VIMRC_FILE | |
1336 | - # define SYS_VIMRC_FILE "Vim:VimRC" | |
1337 | - #endif | |
1338 | - #ifndef SYS_GVIMRC_FILE | |
1339 | - # define SYS_GVIMRC_FILE "Vim:GVimRC" | |
1340 | - #endif | |
1341 | - #ifndef SYS_MENU_FILE | |
1342 | - # define SYS_MENU_FILE "Vim:Menu" | |
1343 | - #endif | |
1344 | - #ifndef SYS_OPTWIN_FILE | |
1345 | - # define SYS_OPTWIN_FILE "Vim:Optwin" | |
1346 | - #endif | |
1347 | - #ifndef FILETYPE_FILE | |
1348 | - # define FILETYPE_FILE "Vim:Filetype" | |
1349 | - #endif | |
1350 | - #ifndef FTPLUGIN_FILE | |
1351 | - # define FTPLUGIN_FILE "Vim:Ftplugin/vim" | |
1352 | - #endif | |
1353 | - #ifndef INDENT_FILE | |
1354 | - # define INDENT_FILE "Vim:Indent/vim" | |
1355 | - #endif | |
1356 | - #ifndef FTOFF_FILE | |
1357 | - # define FTOFF_FILE "Vim:Ftoff" | |
1358 | - #endif | |
1359 | - #ifndef FTPLUGOF_FILE | |
1360 | - # define FTPLUGOF_FILE "Vim:Ftplugof" | |
1361 | - #endif | |
1362 | - #ifndef INDOFF_FILE | |
1363 | - # define INDOFF_FILE "Vim:Indoff" | |
1364 | - #endif | |
1365 | - | |
1366 | - #define DFLT_ERRORFILE "errors/vim" | |
1367 | - #define DFLT_RUNTIMEPATH "Choices:Vim,Vim:,Choices:Vim.after" | |
1368 | - | |
1369 | - /* | |
1370 | - * RISC PCs have plenty of memory, use large buffers | |
1371 | - */ | |
1372 | - #define CMDBUFFSIZE 1024 /* size of the command processing buffer */ | |
1373 | - #define MAXPATHL 256 /* paths are always quite short though */ | |
1374 | - | |
1375 | - #ifndef DFLT_MAXMEM | |
1376 | - # define DFLT_MAXMEM (5*1024) /* use up to 5 Mbyte for a buffer */ | |
1377 | - #endif | |
1378 | - | |
1379 | - #ifndef DFLT_MAXMEMTOT | |
1380 | - # define DFLT_MAXMEMTOT (10*1024) /* use up to 10 Mbyte for Vim */ | |
1381 | - #endif | |
1382 | - | |
1383 | - #ifdef HAVE_SIGSET | |
1384 | - # define signal sigset | |
1385 | - #endif | |
1386 | - | |
1387 | - #define n_flag (1<<31) | |
1388 | - #define z_flag (1<<30) | |
1389 | - #define c_flag (1<<29) | |
1390 | - #define v_flag (1<<28) | |
1391 | - | |
1392 | - /* These take r0-r7 as inputs, returns r0-r7 in global variables. */ | |
1393 | - void swi(int swinum, ...); /* Handles errors itself */ | |
1394 | - int xswi(int swinum, ...); /* Returns errors using v flag */ | |
1395 | - extern int r0, r1, r2, r3, r4, r5, r6, r7; /* For return values */ | |
1396 | - | |
1397 | - #include <kernel.h> | |
1398 | - #include <swis.h> | |
1399 | - | |
1400 | - #define mch_memmove(to, from, len) memmove((char *)(to), (char *)(from), len) | |
1401 | - #define mch_rename(src, dst) rename(src, dst) | |
1402 | - #define mch_getenv(x) (char_u *)getenv((char *)x) | |
1403 | - #define mch_setenv(name, val, x) setenv(name, val, x) | |
1404 | --- 0 ---- | |
1405 | *** ../vim-7.3.186/src/gui_riscos.c 2011-05-10 15:52:10.000000000 +0200 | |
1406 | --- src/gui_riscos.c 1970-01-01 01:00:00.000000000 +0100 | |
1407 | *************** | |
1408 | *** 1,3558 **** | |
1409 | - /* vi:set ts=8 sts=4 sw=4: | |
1410 | - * | |
1411 | - * VIM - Vi IMproved by Bram Moolenaar | |
1412 | - * | |
1413 | - * Do ":help uganda" in Vim to read copying and usage conditions. | |
1414 | - * Do ":help credits" in Vim to see a list of people who contributed. | |
1415 | - * See README.txt for an overview of the Vim source code. | |
1416 | - */ | |
1417 | - | |
1418 | - #include "vim.h" | |
1419 | - #include <string.h> | |
1420 | - | |
1421 | - /* | |
1422 | - * gui_riscos.c | |
1423 | - * | |
1424 | - * Thomas Leonard <tal197@ecs.soton.ac.uk> | |
1425 | - * Updated by Andy Wingate <andy@sparse.net> | |
1426 | - */ | |
1427 | - | |
1428 | - extern int time_of_last_poll; | |
1429 | - | |
1430 | - int task_handle = 0; /* Zero means we are not yet a Wimp task */ | |
1431 | - int child_handle = 0; /* Task handle of our child process (zero if none). */ | |
1432 | - int *wimp_menu = (int *) -1; /* Pointer to a Wimp menu structure (or -1) */ | |
1433 | - int save_window = -1; /* Save As window handle */ | |
1434 | - | |
1435 | - int *redraw_block = NULL; /* NULL means not in a redraw loop. */ | |
1436 | - int ro_return_early = FALSE; /* Break out of gui_mch_wait_for_chars() */ | |
1437 | - | |
1438 | - int leaf_ref = 0; /* Wimp message number - send via Wimp$Scrap */ | |
1439 | - char_u *leaf_name = NULL; /* Leaf name from DataSave */ | |
1440 | - | |
1441 | - int default_columns = 120; /* These values are used if the --rows and --columns */ | |
1442 | - int default_rows = 32; /* options aren't used on startup. */ | |
1443 | - | |
1444 | - #define DRAG_FALSE 0 | |
1445 | - #define DRAG_SELECTION 1 | |
1446 | - #define DRAG_RESIZE_WINDOW 2 | |
1447 | - int ro_dragging = DRAG_FALSE; | |
1448 | - int drag_button; | |
1449 | - int drag_modifiers; | |
1450 | - int drag_x_offset; | |
1451 | - int drag_y_offset; | |
1452 | - | |
1453 | - int nested_wimp = FALSE; /* Bool - can we use the new wimp? */ | |
1454 | - | |
1455 | - int changed_mode = FALSE; | |
1456 | - int x_eigen_factor; | |
1457 | - int y_eigen_factor; | |
1458 | - | |
1459 | - /* If ro_current_font is non-zero then use the outline font with that handle, | |
1460 | - * otherwise, if zap_redraw is TRUE then use ZapRedraw, otherwise use the | |
1461 | - * system font. | |
1462 | - * | |
1463 | - * If zap_redraw is TRUE then zap_file[] contains valid Zap font file | |
1464 | - * pointers (or NULLs). | |
1465 | - */ | |
1466 | - int ro_current_font = 0; /* 0 is system font, or ZapRedraw */ | |
1467 | - int font_x_offset = 0; /* Where to position each char in its box */ | |
1468 | - int font_y_offset = 0; | |
1469 | - | |
1470 | - int zap_redraw = FALSE; | |
1471 | - int double_height = FALSE; /* Plot each line twice? */ | |
1472 | - | |
1473 | - #define grgb(r,g,b) ((b<<16) + (g<<8) + (r)) | |
1474 | - #define UNUSED_COLOUR (gui.back_pixel) | |
1475 | - | |
1476 | - #define RO_LOAD_CLIPBOARD -2 /* Internal handle for DataSave message. */ | |
1477 | - | |
1478 | - /* Changes by John Kortink, 22-23 July 1998 | |
1479 | - * | |
1480 | - * Stuff to make redraw a lot faster. Almost all of it is right here below, | |
1481 | - * elsewhere changes are marked with 'JK230798'. Apart from a small change in | |
1482 | - * 'gui.c' all changes are limited to this file, 'gui_riscos.c'. The change in | |
1483 | - * 'gui.c' is to make Vim stop being 'smart' not redrawing characters that are | |
1484 | - * 'already there' (i.e. from the previous line, by coincidence). This caused a | |
1485 | - * lot more calls to the redraw code, which we want to avoid because a few nice | |
1486 | - * big strings at a time is a lot faster than a truckload of small ones. ('Dear | |
1487 | - * Bram ...'). | |
1488 | - */ | |
1489 | - | |
1490 | - /* The ZapRedraw structure */ | |
1491 | - | |
1492 | - static struct | |
1493 | - { | |
1494 | - int r_flags; | |
1495 | - int r_minx; | |
1496 | - int r_miny; | |
1497 | - int r_maxx; | |
1498 | - int r_maxy; | |
1499 | - int r_screen; | |
1500 | - int r_bpl; | |
1501 | - int r_bpp; | |
1502 | - int r_charw; | |
1503 | - int r_charh; | |
1504 | - char *r_caddr; | |
1505 | - int r_cbpl; | |
1506 | - int r_cbpc; | |
1507 | - int r_linesp; | |
1508 | - int r_data; | |
1509 | - int r_scrollx; | |
1510 | - int r_scrolly; | |
1511 | - int *r_palette; | |
1512 | - int r_for; | |
1513 | - int r_bac; | |
1514 | - char *r_workarea; | |
1515 | - int r_magx; | |
1516 | - int r_magy; | |
1517 | - int r_xsize; | |
1518 | - int r_ysize; | |
1519 | - int r_mode; | |
1520 | - } | |
1521 | - zap_redraw_block; | |
1522 | - | |
1523 | - /* Other globals */ | |
1524 | - | |
1525 | - static int zap_redraw_initialised = FALSE; | |
1526 | - static int zap_redraw_update_colours; | |
1527 | - static int zap_redraw_colours[2]; | |
1528 | - static int zap_redraw_palette[16]; | |
1529 | - | |
1530 | - /* Holds the current Zap font file(s). | |
1531 | - * The font is recreated from this block on a mode change. | |
1532 | - * When using zap, element ZAP_NORMAL is always valid, but | |
1533 | - * the others can be NULL. | |
1534 | - */ | |
1535 | - | |
1536 | - #define ZAP_NORMAL 0 | |
1537 | - #define ZAP_BOLD 1 | |
1538 | - #define ZAP_ITALIC 2 | |
1539 | - #define ZAP_BITALIC 3 | |
1540 | - #define ZAP_STYLES 4 | |
1541 | - | |
1542 | - /* Zap font file format data */ | |
1543 | - static char *zap_file[ZAP_STYLES] = {NULL, NULL, NULL, NULL}; | |
1544 | - | |
1545 | - /* r_caddr format for current mode */ | |
1546 | - static char *zap_caddr[ZAP_STYLES] = {NULL, NULL, NULL, NULL}; | |
1547 | - | |
1548 | - static void ro_remove_menu(int *menu); | |
1549 | - | |
1550 | - /* | |
1551 | - * Initialise all the ZapRedraw stuff. | |
1552 | - * Call this when changing font and after each mode change. | |
1553 | - * zap_redraw_bitmap must contain a valid Zap font file (possibly | |
1554 | - * created from the system font). | |
1555 | - * | |
1556 | - * Return FAIL to revert to system font (if we can't use ZapRedraw). | |
1557 | - */ | |
1558 | - int | |
1559 | - ro_zap_redraw_initialise() | |
1560 | - { | |
1561 | - int bytes_per_bitmap_char; | |
1562 | - int first, last; | |
1563 | - int i; | |
1564 | - | |
1565 | - /* Can't have initialisers for struct members :-(, ok, this way then ... */ | |
1566 | - if (!zap_redraw_initialised) | |
1567 | - { | |
1568 | - zap_redraw_block.r_workarea = NULL; | |
1569 | - zap_redraw_initialised = TRUE; | |
1570 | - } | |
1571 | - | |
1572 | - /* We redraw in DSA mode */ | |
1573 | - zap_redraw_block.r_flags = 0x0; | |
1574 | - | |
1575 | - /* Let ZapRedraw get the screen address for us */ | |
1576 | - zap_redraw_block.r_screen = 0; | |
1577 | - | |
1578 | - /* Read the font width and height from the font file header. | |
1579 | - * Assume that all styles are the same size. | |
1580 | - * ZAP_NORMAL is always present. | |
1581 | - */ | |
1582 | - zap_redraw_block.r_charw = ((int *) zap_file[ZAP_NORMAL])[2]; | |
1583 | - zap_redraw_block.r_charh = ((int *) zap_file[ZAP_NORMAL])[3]; | |
1584 | - | |
1585 | - /* We have no linespacing */ | |
1586 | - zap_redraw_block.r_linesp = 0; | |
1587 | - | |
1588 | - /* Fix foreground = colour 1 */ | |
1589 | - zap_redraw_block.r_for = 1; | |
1590 | - | |
1591 | - /* Fix background = colour 0 */ | |
1592 | - zap_redraw_block.r_bac = 0; | |
1593 | - | |
1594 | - /* Colour mask buffer */ | |
1595 | - zap_redraw_block.r_palette = zap_redraw_palette; | |
1596 | - | |
1597 | - /* Allocate local workspace (for the few calls following here) */ | |
1598 | - if (zap_redraw_block.r_workarea != NULL) | |
1599 | - free(zap_redraw_block.r_workarea); | |
1600 | - zap_redraw_block.r_workarea = (char*) malloc(128); | |
1601 | - if (!zap_redraw_block.r_workarea) | |
1602 | - return FAIL; /* Out of memory */ | |
1603 | - | |
1604 | - /* Fill in VDU variables */ | |
1605 | - if (xswi(ZapRedraw_ReadVduVars, 0, &zap_redraw_block) & v_flag) | |
1606 | - return FAIL; /* Can't find ZapRedraw module - use VDU instead */ | |
1607 | - | |
1608 | - /* Determine cbpl and cbpc */ | |
1609 | - swi(ZapRedraw_CachedCharSize, zap_redraw_block.r_bpp, 0, | |
1610 | - zap_redraw_block.r_charw, zap_redraw_block.r_charh); | |
1611 | - zap_redraw_block.r_cbpl = r2; | |
1612 | - zap_redraw_block.r_cbpc = r3; | |
1613 | - | |
1614 | - /* Allocate general workspace (for the calls outside) */ | |
1615 | - if (zap_redraw_block.r_workarea != NULL) | |
1616 | - free(zap_redraw_block.r_workarea); | |
1617 | - zap_redraw_block.r_workarea = (char*) malloc(128 + zap_redraw_block.r_cbpl); | |
1618 | - if (!zap_redraw_block.r_workarea) | |
1619 | - return FAIL; /* Out of memory */ | |
1620 | - | |
1621 | - /* Now convert the 1 bpp character data ready for the current mode */ | |
1622 | - | |
1623 | - bytes_per_bitmap_char = (zap_redraw_block.r_charw * zap_redraw_block.r_charh + 7) / 8; | |
1624 | - | |
1625 | - /* Convert the fonts from 1bpp to a format suitable for the | |
1626 | - * current mode. | |
1627 | - */ | |
1628 | - for (i = 0; i < ZAP_STYLES; i++) | |
1629 | - { | |
1630 | - first = ((int *) zap_file[i])[4]; | |
1631 | - last = ((int *) zap_file[i])[5]; | |
1632 | - | |
1633 | - if (last > 255) | |
1634 | - last = 255; /* Don't convert cursors (overwrites memory!) */ | |
1635 | - | |
1636 | - /* Allocate the font cache */ | |
1637 | - vim_free(zap_caddr[i]); | |
1638 | - if (zap_file[i]) | |
1639 | - zap_caddr[i] = (char*) malloc(zap_redraw_block.r_cbpc * 256); | |
1640 | - else | |
1641 | - zap_caddr[i] = NULL; /* No file for this style */ | |
1642 | - | |
1643 | - if (zap_caddr[i]) | |
1644 | - { | |
1645 | - zap_redraw_block.r_caddr = zap_caddr[i]; | |
1646 | - | |
1647 | - swi(ZapRedraw_ConvertBitmap, 0, &zap_redraw_block, | |
1648 | - first, last, /* Range of characters to convert */ | |
1649 | - zap_file[i] + 0x20 /* Addr of first char provided by font */ | |
1650 | - - first * bytes_per_bitmap_char); | |
1651 | - } | |
1652 | - } | |
1653 | - | |
1654 | - if (!zap_caddr[ZAP_NORMAL]) | |
1655 | - { | |
1656 | - zap_redraw = FALSE; /* Out of memory */ | |
1657 | - return FAIL; | |
1658 | - } | |
1659 | - | |
1660 | - /* Next time we need them, we have to update the colour masks */ | |
1661 | - zap_redraw_update_colours = TRUE; | |
1662 | - | |
1663 | - return OK; | |
1664 | - } | |
1665 | - | |
1666 | - /* | |
1667 | - * Redraw a string at OS coordinates <x,y> (top-left, x inclusive, y exclusive). | |
1668 | - * Graphics clip window is window[0..3] as in R1+28..40 of Wimp_RedrawWindow. | |
1669 | - * Returns (possibly modified) flags. | |
1670 | - */ | |
1671 | - int | |
1672 | - ro_zap_redraw_draw_string(x, y, string, length, flags, clip) | |
1673 | - int x; | |
1674 | - int y; | |
1675 | - char *string; | |
1676 | - int length; | |
1677 | - int flags; /* DRAW_TRANSP, DRAW_BOLD, DRAW_UNDERL, DRAW_ITALIC */ | |
1678 | - int *clip; | |
1679 | - { | |
1680 | - char redraw_data[1024]; | |
1681 | - int clip_minx; | |
1682 | - int clip_miny; | |
1683 | - int clip_maxx; | |
1684 | - int clip_maxy; | |
1685 | - int os_xshift = zap_redraw_block.r_magx; | |
1686 | - int os_yshift = zap_redraw_block.r_magy; | |
1687 | - | |
1688 | - if (flags & DRAW_TRANSP) | |
1689 | - return flags; /* We don't do transparent plotting yet. */ | |
1690 | - | |
1691 | - if (flags & DRAW_BOLD) | |
1692 | - { | |
1693 | - if (flags & DRAW_ITALIC && zap_caddr[ZAP_BITALIC]) | |
1694 | - zap_redraw_block.r_caddr = zap_caddr[ZAP_BITALIC]; | |
1695 | - else | |
1696 | - zap_redraw_block.r_caddr = zap_caddr[ZAP_BOLD]; | |
1697 | - } | |
1698 | - else | |
1699 | - { | |
1700 | - if (flags & DRAW_ITALIC) | |
1701 | - zap_redraw_block.r_caddr = zap_caddr[ZAP_ITALIC]; | |
1702 | - else | |
1703 | - zap_redraw_block.r_caddr = zap_caddr[ZAP_NORMAL]; | |
1704 | - } | |
1705 | - if (!zap_redraw_block.r_caddr) | |
1706 | - { | |
1707 | - zap_redraw_block.r_caddr = zap_caddr[ZAP_NORMAL]; | |
1708 | - flags |= DRAW_UNDERL; /* Style missing - we can always underline */ | |
1709 | - } | |
1710 | - | |
1711 | - /* Set the vertical scaling flag */ | |
1712 | - if (double_height) | |
1713 | - zap_redraw_block.r_flags = 1 << 1; | |
1714 | - else | |
1715 | - zap_redraw_block.r_flags = 0; | |
1716 | - | |
1717 | - /* Update the colour masks (if needed) */ | |
1718 | - if (zap_redraw_update_colours) | |
1719 | - { | |
1720 | - swi(ZapRedraw_CreatePalette, 2, | |
1721 | - &zap_redraw_block, | |
1722 | - zap_redraw_colours, | |
1723 | - zap_redraw_block.r_palette, 2); | |
1724 | - zap_redraw_update_colours = FALSE; | |
1725 | - } | |
1726 | - | |
1727 | - /* Target rectangle in ZapRedraw rectangle coordinates (pixels, Y-min/max reversed !!!) */ | |
1728 | - zap_redraw_block.r_minx = x >> os_xshift; /* inclusive */ | |
1729 | - zap_redraw_block.r_miny = zap_redraw_block.r_ysize - (y >> os_yshift); /* inclusive */ | |
1730 | - zap_redraw_block.r_maxx = (x + length * gui.char_width) >> os_xshift; /* exclusive */ | |
1731 | - zap_redraw_block.r_maxy = zap_redraw_block.r_ysize - ((y - gui.char_height) >> os_yshift); | |
1732 | - /* exclusive */ | |
1733 | - | |
1734 | - /* Clip rectangle in ZapRedraw rectangle coordinates (pixels, Y-min/max reversed !!!) */ | |
1735 | - clip_minx = clip[0] >> os_xshift; /* inclusive */ | |
1736 | - clip_miny = zap_redraw_block.r_ysize - (clip[3] >> os_yshift); /* inclusive */ | |
1737 | - clip_maxx = clip[2] >> os_xshift; /* exclusive */ | |
1738 | - clip_maxy = zap_redraw_block.r_ysize - (clip[1] >> os_yshift); /* exclusive */ | |
1739 | - | |
1740 | - /* Clip target rectangle against the current graphics window */ | |
1741 | - if (zap_redraw_block.r_minx < clip_minx) | |
1742 | - { | |
1743 | - zap_redraw_block.r_scrollx = clip_minx - zap_redraw_block.r_minx; | |
1744 | - zap_redraw_block.r_minx = clip_minx; | |
1745 | - } | |
1746 | - else | |
1747 | - zap_redraw_block.r_scrollx = 0; | |
1748 | - if (zap_redraw_block.r_miny < clip_miny) | |
1749 | - { | |
1750 | - zap_redraw_block.r_scrolly = clip_miny - zap_redraw_block.r_miny; | |
1751 | - zap_redraw_block.r_miny = clip_miny; | |
1752 | - } | |
1753 | - else | |
1754 | - zap_redraw_block.r_scrolly = 0; | |
1755 | - if (zap_redraw_block.r_maxx > clip_maxx) | |
1756 | - zap_redraw_block.r_maxx = clip_maxx; | |
1757 | - if (zap_redraw_block.r_maxy > clip_maxy) | |
1758 | - zap_redraw_block.r_maxy = clip_maxy; | |
1759 | - | |
1760 | - /* Fill in the character data structure */ | |
1761 | - if (length > (sizeof(redraw_data) - 2 * 4 - 2)) | |
1762 | - length = sizeof(redraw_data) - 2 * 4 - 2; | |
1763 | - ((int*) redraw_data)[0] = 2 * 4; | |
1764 | - ((int*) redraw_data)[1] = 0; | |
1765 | - strncpy(redraw_data + 2 * 4, string, length); | |
1766 | - redraw_data[2 * 4 + length + 0] = '\0'; | |
1767 | - redraw_data[2 * 4 + length + 1] = '\x2'; | |
1768 | - zap_redraw_block.r_data = (int) redraw_data; | |
1769 | - | |
1770 | - /* Perform the draw */ | |
1771 | - swi(ZapRedraw_RedrawArea, 0, &zap_redraw_block); | |
1772 | - | |
1773 | - return flags; | |
1774 | - } | |
1775 | - | |
1776 | - /* | |
1777 | - * Okay that was it from me, back to Thomas ... | |
1778 | - */ | |
1779 | - | |
1780 | - /* | |
1781 | - * Parse the GUI related command-line arguments. Any arguments used are | |
1782 | - * deleted from argv, and *argc is decremented accordingly. This is called | |
1783 | - * when vim is started, whether or not the GUI has been started. | |
1784 | - */ | |
1785 | - void | |
1786 | - gui_mch_prepare(int *argc, char **argv) | |
1787 | - { | |
1788 | - int arg = 1; | |
1789 | - | |
1790 | - while (arg < *argc - 1) | |
1791 | - { | |
1792 | - if (strcmp(argv[arg], "--rows") == 0 || strcmp(argv[arg], "--columns") == 0) | |
1793 | - { | |
1794 | - int value; | |
1795 | - | |
1796 | - value = atoi(argv[arg + 1]); | |
1797 | - | |
1798 | - if (argv[arg][2] == 'r') | |
1799 | - default_rows = value; | |
1800 | - else | |
1801 | - default_columns = value; | |
1802 | - | |
1803 | - /* Delete argument from argv[]. (hope this is read/write!) */ | |
1804 | - | |
1805 | - *argc -= 2; | |
1806 | - if (*argc > arg) | |
1807 | - mch_memmove(&argv[arg], &argv[arg + 2], (*argc - arg) | |
1808 | - * sizeof(char *)); | |
1809 | - } | |
1810 | - else | |
1811 | - arg++; | |
1812 | - } | |
1813 | - } | |
1814 | - | |
1815 | - /* Fatal error on initialisation - report it and die. */ | |
1816 | - void | |
1817 | - ro_die(error) | |
1818 | - char_u *error; /* RISC OS error block */ | |
1819 | - { | |
1820 | - swi(Wimp_ReportError, error, 5, "GVim"); | |
1821 | - exit(EXIT_FAILURE); | |
1822 | - } | |
1823 | - | |
1824 | - /* Find the sizes of the window tools: | |
1825 | - * | |
1826 | - * Create a test window. | |
1827 | - * Find inner and outer sizes. | |
1828 | - * Find the difference. | |
1829 | - * Delete window. | |
1830 | - * | |
1831 | - * While we're here, find the eigen values too. | |
1832 | - */ | |
1833 | - void | |
1834 | - ro_measure_tools() | |
1835 | - { | |
1836 | - int block[10]; | |
1837 | - int vdu[] = { 4, 5, -1}; | |
1838 | - int test_window[] = | |
1839 | - { | |
1840 | - -100, -100, /* Visible area : min X,Y */ | |
1841 | - -50, -50, /* max X,Y */ | |
1842 | - 0, 0, /* Scroll offsets */ | |
1843 | - -1, /* Window in front */ | |
1844 | - 0xd0800150, /* Window flags */ | |
1845 | - 0xff070207, /* Colours */ | |
1846 | - 0x000c0103, /* More colours */ | |
1847 | - 0, -0x4000, /* Workarea extent */ | |
1848 | - 0x4000, 0, /* max X,Y */ | |
1849 | - 0x00000000, /* No title */ | |
1850 | - 0 << 12, /* No workarea button type */ | |
1851 | - 1, /* Wimp sprite area */ | |
1852 | - 0x00010001, /* Minimum width, height */ | |
1853 | - 0, 0, 0, /* Title data (none) */ | |
1854 | - 0 /* No icons */ | |
1855 | - }; | |
1856 | - int inner_max_x, inner_min_y; | |
1857 | - | |
1858 | - swi(Wimp_CreateWindow, 0, test_window); | |
1859 | - | |
1860 | - block[0] = r0; | |
1861 | - /* Open the window (and read state). | |
1862 | - * GetWindowOutline needs it too if the wimp isn't nested. | |
1863 | - */ | |
1864 | - swi(Wimp_OpenWindow, 0, block); | |
1865 | - inner_max_x = block[3]; | |
1866 | - inner_min_y = block[2]; | |
1867 | - | |
1868 | - swi(Wimp_GetWindowOutline, 0, block); | |
1869 | - | |
1870 | - gui.scrollbar_width = block[3] - inner_max_x; | |
1871 | - gui.scrollbar_height = inner_min_y - block[2]; | |
1872 | - | |
1873 | - swi(Wimp_DeleteWindow, 0, block); | |
1874 | - | |
1875 | - /* Read the size of one pixel. */ | |
1876 | - swi(OS_ReadVduVariables, vdu, vdu); | |
1877 | - x_eigen_factor = vdu[0]; | |
1878 | - y_eigen_factor = vdu[1]; | |
1879 | - } | |
1880 | - | |
1881 | - /* Load a template from the current templates file. | |
1882 | - * Create the window and return its handle. | |
1883 | - */ | |
1884 | - int | |
1885 | - ro_load_template(str_name, title, title_size) | |
1886 | - char_u *str_name; /* Identifier of window in file (max 12 chars) */ | |
1887 | - char_u **title; /* If not NULL then return pointer to title here */ | |
1888 | - int *title_size; /* If not NULL then return the title length here */ | |
1889 | - { | |
1890 | - int *window; | |
1891 | - char *data; | |
1892 | - int name[4]; | |
1893 | - | |
1894 | - strcpy( (char *) name, str_name); | |
1895 | - | |
1896 | - /* Find how big we must make the buffers */ | |
1897 | - | |
1898 | - if (xswi(Wimp_LoadTemplate, 0, 0, 0, 0, -1, name, 0) & v_flag) | |
1899 | - ro_die( (char *) r0); | |
1900 | - | |
1901 | - window = malloc(r1); /* Don't print text messages from alloc() */ | |
1902 | - data = malloc(r2); | |
1903 | - if (window == NULL || data == NULL) | |
1904 | - ro_die("\0\0\0\0Out of memory - Can't load templates"); | |
1905 | - | |
1906 | - /* Load the template into the buffers */ | |
1907 | - | |
1908 | - swi(Wimp_LoadTemplate, 0, | |
1909 | - window, /* Temp block */ | |
1910 | - data, /* Icon data */ | |
1911 | - data + r2 + 1, /* End of icon data */ | |
1912 | - -1, /* No fonts */ | |
1913 | - name, 0); /* First match */ | |
1914 | - if (r6 == 0) | |
1915 | - ro_die("\0\0\0\0Can't find window in Templates file"); | |
1916 | - | |
1917 | - /* Create the window */ | |
1918 | - | |
1919 | - if (xswi(Wimp_CreateWindow, 0, window) & v_flag) | |
1920 | - ro_die( (char *) r0); | |
1921 | - | |
1922 | - if (title) | |
1923 | - *title = (char_u *) window[18]; | |
1924 | - if (title_size) | |
1925 | - *title_size = window[20]; | |
1926 | - | |
1927 | - free(window); /* Free temp block */ | |
1928 | - return r0; /* Return the window handle */ | |
1929 | - } | |
1930 | - | |
1931 | - /* | |
1932 | - * Check if the GUI can be started. Called before gvimrc is sourced. | |
1933 | - * Return OK or FAIL. | |
1934 | - */ | |
1935 | - int | |
1936 | - gui_mch_init_check() | |
1937 | - { | |
1938 | - return OK; /* TODO: GUI can always be started? */ | |
1939 | - } | |
1940 | - | |
1941 | - /* | |
1942 | - * Initialise the RISC OS GUI. | |
1943 | - * Create all the windows. | |
1944 | - * Returns OK for success, FAIL when the GUI can't be started. | |
1945 | - */ | |
1946 | - int | |
1947 | - gui_mch_init() | |
1948 | - { | |
1949 | - int messages[] = { | |
1950 | - 1, 2, 3, 4, /* DataSave, DataSaveAck, DataLoad, DataLoadAck */ | |
1951 | - 8, /* PreQuit */ | |
1952 | - 0xf, /* ClaimEntity (for clipboard) */ | |
1953 | - 0x10, /* DataRequest (for clipboard) */ | |
1954 | - 0x400c1, /* Mode change */ | |
1955 | - 0x400c3, /* TaskCloseDown */ | |
1956 | - 0x400c9, /* MenusDeleted */ | |
1957 | - 0x808c1, /* TW_Output */ | |
1958 | - 0x808c2, /* TW_Ego */ | |
1959 | - 0x808c3, /* TW_Morio */ | |
1960 | - 0x808c4, /* TW_Morite */ | |
1961 | - 0}; /* End-of-list. */ | |
1962 | - | |
1963 | - | |
1964 | - /* There may have been some errors reported in the | |
1965 | - * command window before we get here. Wait if so. | |
1966 | - */ | |
1967 | - swi(Wimp_ReadSysInfo, 3); | |
1968 | - if (r0 == 0) | |
1969 | - swi(Wimp_CommandWindow, 0); /* Window opened - close with prompt */ | |
1970 | - | |
1971 | - if (xswi(Wimp_Initialise, 310, 0x4b534154, "GVim", messages) & v_flag) | |
1972 | - return FAIL; | |
1973 | - nested_wimp = r0 >= 397; | |
1974 | - task_handle = r1; | |
1975 | - | |
1976 | - /* Load the templates. */ | |
1977 | - | |
1978 | - if (xswi(Wimp_OpenTemplate, 0, "Vim:Templates") & v_flag) | |
1979 | - ro_die( (char *) r0); | |
1980 | - | |
1981 | - gui.window_handle = ro_load_template("editor", | |
1982 | - &gui.window_title, | |
1983 | - &gui.window_title_size); | |
1984 | - | |
1985 | - save_window = ro_load_template("save", NULL, NULL); | |
1986 | - | |
1987 | - swi(Wimp_CloseTemplate); | |
1988 | - | |
1989 | - /* Set default foreground and background colours. */ | |
1990 | - | |
1991 | - gui.norm_pixel = gui.def_norm_pixel; | |
1992 | - gui.back_pixel = gui.def_back_pixel; | |
1993 | - | |
1994 | - /* Get the colours from the "Normal" and "Menu" group (set in syntax.c or | |
1995 | - * in a vimrc file) */ | |
1996 | - | |
1997 | - set_normal_colors(); | |
1998 | - | |
1999 | - /* | |
2000 | - * Check that none of the colors are the same as the background color | |
2001 | - */ | |
2002 | - | |
2003 | - gui_check_colors(); | |
2004 | - | |
2005 | - /* Get the colours for the highlight groups (gui_check_colors() might have | |
2006 | - * changed them) */ | |
2007 | - | |
2008 | - highlight_gui_started(); /* re-init colours and fonts */ | |
2009 | - | |
2010 | - /* Set geometry based on values read on initialisation. */ | |
2011 | - | |
2012 | - gui.num_cols = Columns = default_columns; | |
2013 | - gui.num_rows = Rows = default_rows; | |
2014 | - | |
2015 | - /* Get some information about our environment. */ | |
2016 | - | |
2017 | - ro_measure_tools(); | |
2018 | - | |
2019 | - return OK; | |
2020 | - } | |
2021 | - | |
2022 | - /* | |
2023 | - * Called when the foreground or background colour has been changed. | |
2024 | - */ | |
2025 | - void | |
2026 | - gui_mch_new_colors() | |
2027 | - { | |
2028 | - } | |
2029 | - | |
2030 | - /* | |
2031 | - * Open the GUI window which was created by a call to gui_mch_init(). | |
2032 | - */ | |
2033 | - int | |
2034 | - gui_mch_open(void) | |
2035 | - { | |
2036 | - int block[10]; | |
2037 | - | |
2038 | - block[0] = gui.window_handle; | |
2039 | - swi(Wimp_GetWindowState, 0, block); | |
2040 | - block[7] = -1; /* Open at the top of the stack */ | |
2041 | - swi(Wimp_OpenWindow, 0, block); | |
2042 | - | |
2043 | - /* Give the new window the input focus */ | |
2044 | - swi(Wimp_SetCaretPosition, gui.window_handle, -1, 0, 0, -1, -1); | |
2045 | - | |
2046 | - if (gui_win_x != -1 && gui_win_y != -1) | |
2047 | - gui_mch_set_winpos(gui_win_x, gui_win_y); | |
2048 | - | |
2049 | - return OK; | |
2050 | - } | |
2051 | - | |
2052 | - void | |
2053 | - gui_mch_exit(int rc) | |
2054 | - { | |
2055 | - int block[64]; | |
2056 | - | |
2057 | - /* Close window. Stops us from getting troublesome events | |
2058 | - * if we take a while to die. | |
2059 | - */ | |
2060 | - block[0] = gui.window_handle; | |
2061 | - swi(Wimp_CloseWindow, 0, block); | |
2062 | - | |
2063 | - if (child_handle) | |
2064 | - { | |
2065 | - /* We still have a sub-task running - kill it */ | |
2066 | - block[0] = 20; | |
2067 | - block[3] = 0; | |
2068 | - block[4] = 0; /* Quit */ | |
2069 | - if ((xswi(Wimp_SendMessage, 17, block, child_handle) & v_flag) == 0) | |
2070 | - { | |
2071 | - /* Idle until child dies. */ | |
2072 | - while (child_handle) | |
2073 | - { | |
2074 | - process_event(wimp_poll(1, block), block); | |
2075 | - } | |
2076 | - } | |
2077 | - } | |
2078 | - | |
2079 | - exit(rc); | |
2080 | - } | |
2081 | - | |
2082 | - /* | |
2083 | - * Get the position of the top left corner of the window. | |
2084 | - */ | |
2085 | - int | |
2086 | - gui_mch_get_winpos(int *x, int *y) | |
2087 | - { | |
2088 | - /* TODO */ | |
2089 | - return FAIL; | |
2090 | - } | |
2091 | - | |
2092 | - /* | |
2093 | - * Set the position of the top left corner of the window to the given | |
2094 | - * coordinates. | |
2095 | - */ | |
2096 | - void | |
2097 | - gui_mch_set_winpos(int x, int y) | |
2098 | - { | |
2099 | - /* TODO */ | |
2100 | - } | |
2101 | - | |
2102 | - void | |
2103 | - gui_mch_set_shellsize(width, height, min_width, min_height, base_width, base_height, direction) | |
2104 | - int width; /* In OS units */ | |
2105 | - int height; | |
2106 | - int min_width; /* Smallest permissible window size (ignored) */ | |
2107 | - int min_height; | |
2108 | - int base_width; /* Space for scroll bars, etc */ | |
2109 | - int base_height; | |
2110 | - int direction; | |
2111 | - { | |
2112 | - int s_width, s_height; | |
2113 | - int block[] = { | |
2114 | - gui.window_handle, | |
2115 | - 0, | |
2116 | - -height + 1, | |
2117 | - width, | |
2118 | - 1}; | |
2119 | - | |
2120 | - gui_mch_get_screen_dimensions(&s_width, &s_height); | |
2121 | - s_width -= base_width; | |
2122 | - s_height -= base_height; /* Underestimate - ignores titlebar */ | |
2123 | - | |
2124 | - swi(Wimp_GetWindowState, 0, block); | |
2125 | - block[3] = block[1] + width; | |
2126 | - block[2] = block[4] - height; | |
2127 | - if (block[3] > s_width) | |
2128 | - { | |
2129 | - block[3] = s_width; | |
2130 | - block[1] = block[3] - width; | |
2131 | - } | |
2132 | - if (block[2] < gui.scrollbar_height) | |
2133 | - { | |
2134 | - block[2] = gui.scrollbar_height; | |
2135 | - block[4] = block[2] + height; | |
2136 | - } | |
2137 | - swi(Wimp_OpenWindow, 0, block); | |
2138 | - swi(Wimp_ForceRedraw, gui.window_handle, 0, -height, width, 0); | |
2139 | - } | |
2140 | - | |
2141 | - void | |
2142 | - gui_mch_get_screen_dimensions(int *screen_w, int *screen_h) | |
2143 | - { | |
2144 | - int block[] = {4, 5, 11, 12, -1}; | |
2145 | - | |
2146 | - swi(OS_ReadVduVariables, block, block); | |
2147 | - *screen_w = (block[2] + 1) << block[0]; | |
2148 | - *screen_h = (block[3] + 1) << block[1]; | |
2149 | - } | |
2150 | - | |
2151 | - /* Take a font name with options and return a font handle, or | |
2152 | - * zero for failure. | |
2153 | - * Replace extension with 'Bold' or 'Italic' depending on modifiers. | |
2154 | - */ | |
2155 | - int | |
2156 | - ro_get_font(fullname, weight) | |
2157 | - char_u *fullname; | |
2158 | - int weight; /* Initial weights: | |
2159 | - * BIT MEANING | |
2160 | - * 0 bold | |
2161 | - * 1 italic | |
2162 | - */ | |
2163 | - { | |
2164 | - char_u *arg; | |
2165 | - char_u font[41]; | |
2166 | - int width = -1; | |
2167 | - int height = -1; | |
2168 | - int name_len; | |
2169 | - int i; | |
2170 | - char_u c; | |
2171 | - | |
2172 | - for (i = 0; i < 39;) | |
2173 | - { | |
2174 | - c = fullname[i]; | |
2175 | - if (c == ':' || c == NUL || c == '.') | |
2176 | - break; | |
2177 | - font[i++] = c; | |
2178 | - } | |
2179 | - | |
2180 | - /* find the first modifier, NULL if none */ | |
2181 | - arg = strchr(fullname + i, ':'); | |
2182 | - | |
2183 | - while (arg) | |
2184 | - { | |
2185 | - switch (*++arg) | |
2186 | - { | |
2187 | - case 'h': | |
2188 | - height = strtol(arg + 1, (char **) &arg, 10); | |
2189 | - break; | |
2190 | - case 'w': | |
2191 | - width = strtol(arg + 1, (char **) &arg, 10); | |
2192 | - break; | |
2193 | - case 'b': | |
2194 | - weight |= 1; | |
2195 | - break; | |
2196 | - case 'i': | |
2197 | - weight |= 2; | |
2198 | - break; | |
2199 | - default: | |
2200 | - return 0; | |
2201 | - } | |
2202 | - arg = strchr(arg, ':'); | |
2203 | - } | |
2204 | - | |
2205 | - if ((weight & 1) && i < 35) | |
2206 | - { | |
2207 | - /* Bold goes instead of given suffix */ | |
2208 | - strncpy(font + i, ".Bold", 5); | |
2209 | - i += 5; | |
2210 | - } | |
2211 | - else | |
2212 | - { | |
2213 | - /* Copy rest of name unless we are using Bold */ | |
2214 | - while (i < 39) | |
2215 | - { | |
2216 | - c = fullname[i]; | |
2217 | - if (c == ':' || c == NUL) | |
2218 | - break; | |
2219 | - font[i++] = c; | |
2220 | - } | |
2221 | - } | |
2222 | - if ((weight & 2) && i < 32) | |
2223 | - { | |
2224 | - strncpy(font + i, ".Oblique", 8); | |
2225 | - i += 8; | |
2226 | - } | |
2227 | - | |
2228 | - font[i] = 0; | |
2229 | - | |
2230 | - if (height < 1 && width < 1) | |
2231 | - height = width = 10; /* Default to 10pt */ | |
2232 | - else if (height < 1) | |
2233 | - height = width; | |
2234 | - else if (width < 1) | |
2235 | - width = height; | |
2236 | - | |
2237 | - if (xswi(Font_FindFont, 0, font, width << 4, height << 4, 0, 0) & v_flag) | |
2238 | - return NOFONT; /* Can't find font */ | |
2239 | - | |
2240 | - return r0; | |
2241 | - } | |
2242 | - | |
2243 | - /* Load a file into allocated memory and check it is valid. | |
2244 | - * Return a pointer to the allocated block on success. | |
2245 | - */ | |
2246 | - char * | |
2247 | - zap_load_file(name, style) | |
2248 | - char_u *name; /* Name of directory containing styles */ | |
2249 | - char_u *style; /* Name of style within directory */ | |
2250 | - { | |
2251 | - char_u fname[256]; | |
2252 | - char_u *file; | |
2253 | - | |
2254 | - if (strlen(name) + strlen(style) > 254) | |
2255 | - return NULL; /* Names too long */ | |
2256 | - | |
2257 | - sprintf(fname, "%s.%s", name, style); | |
2258 | - | |
2259 | - /* Load the named font in 1bpp format. */ | |
2260 | - if (xswi(OS_File, 13, fname, 0, 0, "VimFonts:") & v_flag || r0 != 1) | |
2261 | - return NULL; /* Error reading file info, or not a file */ | |
2262 | - | |
2263 | - /* Allocate enough memory to load the whole file */ | |
2264 | - file = (char *) alloc(r4); | |
2265 | - if (!file) | |
2266 | - return NULL; /* Out of memory */ | |
2267 | - | |
2268 | - if (xswi(OS_File, 12, fname, file, 0, "VimFonts:") & v_flag) | |
2269 | - return NULL; /* Unable to load file */ | |
2270 | - | |
2271 | - if (strncmp(file, "ZapFont\015", 8) == 0) | |
2272 | - return file; /* Loaded OK! */ | |
2273 | - | |
2274 | - vim_free(file); | |
2275 | - return NULL; /* Not a valid font file */ | |
2276 | - } | |
2277 | - | |
2278 | - /* Load and convert the named font. | |
2279 | - * If name is NULL or a null string then convert the system font. | |
2280 | - * Return OK on success; FAIL and we revert to using the VDU drivers. | |
2281 | - * | |
2282 | - * 'name' is the name of a directory. | |
2283 | - * Tries to load 'name.0', 'name.B', 'name.I' and 'name.IB'. | |
2284 | - */ | |
2285 | - int | |
2286 | - zap_load_font(name) | |
2287 | - char_u *name; | |
2288 | - { | |
2289 | - int i; | |
2290 | - | |
2291 | - /* Free the existing font files, if any */ | |
2292 | - for (i = 0; i < ZAP_STYLES; i++) | |
2293 | - { | |
2294 | - vim_free(zap_file[i]); | |
2295 | - zap_file[i] = NULL; | |
2296 | - } | |
2297 | - | |
2298 | - if (name && *name == '!') | |
2299 | - { | |
2300 | - name++; | |
2301 | - double_height = TRUE; | |
2302 | - } | |
2303 | - else | |
2304 | - double_height = FALSE; | |
2305 | - | |
2306 | - if (name && *name) | |
2307 | - { | |
2308 | - zap_file[ZAP_NORMAL] = zap_load_file(name, "0"); | |
2309 | - if (!zap_file[ZAP_NORMAL]) | |
2310 | - return FAIL; /* Can't load the 'normal' style - error */ | |
2311 | - | |
2312 | - zap_file[ZAP_BOLD] = zap_load_file(name, "B"); | |
2313 | - zap_file[ZAP_ITALIC] = zap_load_file(name, "I"); | |
2314 | - zap_file[ZAP_BITALIC] = zap_load_file(name, "IB"); | |
2315 | - } | |
2316 | - else | |
2317 | - { | |
2318 | - int *header; | |
2319 | - char workarea[16]; | |
2320 | - char *old_wa; | |
2321 | - | |
2322 | - /* Allocate memory for system font (8 x 8 x 256 bits, plus header) */ | |
2323 | - header = (int *) alloc(0x20 + 8 * 256); | |
2324 | - if (header == NULL) | |
2325 | - return FAIL; | |
2326 | - zap_file[ZAP_NORMAL] = (char *) header; | |
2327 | - | |
2328 | - /* Store details about the system font */ | |
2329 | - header[2] = 8; /* Width */ | |
2330 | - header[3] = 8; /* Height */ | |
2331 | - header[4] = 0; /* First char */ | |
2332 | - header[5] = 255; /* Last char */ | |
2333 | - header[6] = header[7] = 0; /* Reserved */ | |
2334 | - | |
2335 | - /* Get system font bitmap */ | |
2336 | - old_wa = zap_redraw_block.r_workarea; | |
2337 | - zap_redraw_block.r_workarea = workarea; | |
2338 | - swi(ZapRedraw_ReadSystemChars, zap_file[ZAP_NORMAL] + 0x20, &zap_redraw_block); | |
2339 | - zap_redraw_block.r_workarea = old_wa; | |
2340 | - } | |
2341 | - | |
2342 | - return ro_zap_redraw_initialise(); | |
2343 | - } | |
2344 | - | |
2345 | - /* | |
2346 | - * Initialise vim to use the font with the given name. | |
2347 | - * Return FAIL if the font could not be loaded, OK otherwise. | |
2348 | - */ | |
2349 | - int | |
2350 | - gui_mch_init_font(char_u *font_name, int fontset) | |
2351 | - { | |
2352 | - int new_handle = 0; /* Use the system font by default */ | |
2353 | - | |
2354 | - if (font_name[0] == '!') | |
2355 | - { | |
2356 | - /* Select a ZapRedraw font */ | |
2357 | - if (zap_load_font(font_name + 1)) | |
2358 | - zap_redraw = TRUE; | |
2359 | - else | |
2360 | - { | |
2361 | - EMSG2(_("E610: Can't load Zap font '%s'"), font_name); | |
2362 | - font_name = "System"; /* Error - use system font */ | |
2363 | - zap_redraw = FALSE; | |
2364 | - } | |
2365 | - } | |
2366 | - else | |
2367 | - { | |
2368 | - zap_redraw = FALSE; | |
2369 | - | |
2370 | - if (font_name) | |
2371 | - { | |
2372 | - /* Extract any extra details about the font */ | |
2373 | - new_handle = ro_get_font(font_name, 0); | |
2374 | - if (!new_handle) | |
2375 | - return FAIL; | |
2376 | - } | |
2377 | - else | |
2378 | - font_name = "System"; | |
2379 | - } | |
2380 | - | |
2381 | - /* Free the previous font, if any */ | |
2382 | - gui_mch_free_font(gui.norm_font); | |
2383 | - gui.norm_font = new_handle; | |
2384 | - gui.char_ascent = 0; | |
2385 | - | |
2386 | - if (new_handle) | |
2387 | - { | |
2388 | - /* Read details about the chosen font */ | |
2389 | - swi(Font_ReadInfo, new_handle); | |
2390 | - | |
2391 | - gui.char_width = r3 - r1; | |
2392 | - gui.char_height = r4 - r2; | |
2393 | - | |
2394 | - font_x_offset = -r1; /* Where to position each char in its box */ | |
2395 | - font_y_offset = -r4; | |
2396 | - | |
2397 | - /* Try to load other fonts for bold, italic, and bold-italic */ | |
2398 | - gui_mch_free_font(gui.bold_font); | |
2399 | - gui.bold_font = ro_get_font(font_name, 1); | |
2400 | - gui_mch_free_font(gui.ital_font); | |
2401 | - gui.ital_font = ro_get_font(font_name, 2); | |
2402 | - gui_mch_free_font(gui.boldital_font); | |
2403 | - gui.boldital_font = ro_get_font(font_name, 3); | |
2404 | - } | |
2405 | - else | |
2406 | - { | |
2407 | - /* Use the system font or ZapRedraw. */ | |
2408 | - if (zap_redraw) | |
2409 | - { | |
2410 | - gui.char_width = zap_redraw_block.r_charw << zap_redraw_block.r_magx; | |
2411 | - gui.char_height = zap_redraw_block.r_charh << zap_redraw_block.r_magy; | |
2412 | - if (double_height) | |
2413 | - gui.char_height <<= 1; | |
2414 | - } | |
2415 | - else | |
2416 | - { | |
2417 | - gui.char_width = 16; | |
2418 | - gui.char_height = 32; | |
2419 | - } | |
2420 | - | |
2421 | - gui_mch_free_font(gui.bold_font); | |
2422 | - gui.bold_font = 0; | |
2423 | - gui_mch_free_font(gui.ital_font); | |
2424 | - gui.ital_font = 0; | |
2425 | - gui_mch_free_font(gui.boldital_font); | |
2426 | - gui.boldital_font = 0; | |
2427 | - } | |
2428 | - hl_set_font_name(font_name); | |
2429 | - | |
2430 | - must_redraw = CLEAR; | |
2431 | - return OK; | |
2432 | - } | |
2433 | - | |
2434 | - /* | |
2435 | - * Adjust gui.char_height (after 'linespace' was changed). | |
2436 | - */ | |
2437 | - int | |
2438 | - gui_mch_adjust_charheight() | |
2439 | - { | |
2440 | - return FAIL; | |
2441 | - } | |
2442 | - | |
2443 | - /* | |
2444 | - * Get a font structure for highlighting. | |
2445 | - */ | |
2446 | - GuiFont | |
2447 | - gui_mch_get_font(name, giveErrorIfMissing) | |
2448 | - char_u *name; | |
2449 | - int giveErrorIfMissing; | |
2450 | - { | |
2451 | - int handle; | |
2452 | - | |
2453 | - if (!name) | |
2454 | - return NOFONT; /* System font if no name */ | |
2455 | - | |
2456 | - handle = ro_get_font(name, 0); | |
2457 | - if (!handle) | |
2458 | - { | |
2459 | - if (giveErrorIfMissing) | |
2460 | - EMSG2(_("E611: Can't use font %s"), name); | |
2461 | - return NOFONT; | |
2462 | - } | |
2463 | - | |
2464 | - return handle; | |
2465 | - } | |
2466 | - | |
2467 | - #if defined(FEAT_EVAL) || defined(PROTO) | |
2468 | - /* | |
2469 | - * Return the name of font "font" in allocated memory. | |
2470 | - * Don't know how to get the actual name, thus use the provided name. | |
2471 | - */ | |
2472 | - char_u * | |
2473 | - gui_mch_get_fontname(font, name) | |
2474 | - GuiFont font; | |
2475 | - char_u *name; | |
2476 | - { | |
2477 | - if (name == NULL) | |
2478 | - return NULL; | |
2479 | - return vim_strsave(name); | |
2480 | - } | |
2481 | - #endif | |
2482 | - | |
2483 | - /* | |
2484 | - * Set the current text font. | |
2485 | - */ | |
2486 | - void | |
2487 | - gui_mch_set_font(GuiFont font) | |
2488 | - { | |
2489 | - ro_current_font = font; | |
2490 | - | |
2491 | - if (font) | |
2492 | - { | |
2493 | - /* Not the system font or ZapRedraw font - select it */ | |
2494 | - swi(Font_SetFont, font); | |
2495 | - } | |
2496 | - } | |
2497 | - | |
2498 | - /* | |
2499 | - * If a font is not going to be used, free its structure. | |
2500 | - */ | |
2501 | - void | |
2502 | - gui_mch_free_font(GuiFont font) | |
2503 | - { | |
2504 | - if (font) | |
2505 | - swi(Font_LoseFont, font); | |
2506 | - } | |
2507 | - | |
2508 | - /* | |
2509 | - * Return the Pixel value (colour) for the given colour name. | |
2510 | - * Return INVALCOLOR for error. | |
2511 | - * NB: I've changed Green for now, since it looked really sick | |
2512 | - */ | |
2513 | - guicolor_T | |
2514 | - gui_mch_get_color(char_u *name) | |
2515 | - { | |
2516 | - int i; | |
2517 | - struct colour | |
2518 | - { | |
2519 | - char_u *name; | |
2520 | - guicolor_T value; | |
2521 | - } colours[] = | |
2522 | - { | |
2523 | - { "Red", grgb(255, 0, 0) }, | |
2524 | - { "LightRed", grgb(255, 0, 0) }, | |
2525 | - { "DarkRed", grgb(139, 0, 0) }, | |
2526 | - | |
2527 | - { "Green", grgb(50, 200, 50) }, | |
2528 | - { "LightGreen", grgb(144, 238, 144) }, | |
2529 | - { "DarkGreen", grgb(0, 100, 0) }, | |
2530 | - { "SeaGreen", grgb(46, 139, 87) }, | |
2531 | - | |
2532 | - { "Blue", grgb(0, 0, 255) }, | |
2533 | - { "LightBlue", grgb(173, 216, 230) }, | |
2534 | - { "DarkBlue", grgb(0, 0, 139) }, | |
2535 | - { "SlateBlue", grgb(160, 90, 205) }, | |
2536 | - | |
2537 | - { "Cyan", grgb(0, 255, 255) }, | |
2538 | - { "LightCyan", grgb(224, 255, 255) }, | |
2539 | - { "DarkCyan", grgb(0, 139, 139) }, | |
2540 | - | |
2541 | - { "Magenta", grgb(255, 0, 255) }, | |
2542 | - { "LightMagenta", grgb(255, 224, 255) }, | |
2543 | - { "DarkMagenta", grgb(139, 0, 139) }, | |
2544 | - | |
2545 | - { "Yellow", grgb(255, 255, 0) }, | |
2546 | - { "LightYellow", grgb(255, 255, 224) }, | |
2547 | - { "DarkYellow", grgb(139, 139, 0) }, | |
2548 | - { "Brown", grgb(165, 42, 42) }, | |
2549 | - | |
2550 | - { "Gray", grgb(190, 190, 190) }, | |
2551 | - { "Grey", grgb(190, 190, 190) }, | |
2552 | - { "LightGray", grgb(211, 211, 211) }, | |
2553 | - { "LightGrey", grgb(211, 211, 211) }, | |
2554 | - { "DarkGray", grgb(169, 169, 169) }, | |
2555 | - { "DarkGrey", grgb(169, 169, 169) }, | |
2556 | - { "Gray10", grgb(26, 26, 26) }, | |
2557 | - { "Grey10", grgb(26, 26, 26) }, | |
2558 | - { "Gray20", grgb(51, 51, 51) }, | |
2559 | - { "Grey20", grgb(51, 51, 51) }, | |
2560 | - { "Gray30", grgb(77, 77, 77) }, | |
2561 | - { "Grey30", grgb(77, 77, 77) }, | |
2562 | - { "Gray40", grgb(102, 102, 102) }, | |
2563 | - { "Grey40", grgb(102, 102, 102) }, | |
2564 | - { "Gray50", grgb(127, 127, 127) }, | |
2565 | - { "Grey50", grgb(127, 127, 127) }, | |
2566 | - { "Gray60", grgb(153, 153, 153) }, | |
2567 | - { "Grey60", grgb(153, 153, 153) }, | |
2568 | - { "Gray70", grgb(179, 179, 179) }, | |
2569 | - { "Grey70", grgb(179, 179, 179) }, | |
2570 | - { "Gray80", grgb(204, 204, 204) }, | |
2571 | - { "Grey80", grgb(204, 204, 204) }, | |
2572 | - { "Gray90", grgb(229, 229, 229) }, | |
2573 | - { "Grey90", grgb(229, 229, 229) }, | |
2574 | - | |
2575 | - { "Black", grgb(0, 0, 0) }, | |
2576 | - { "White", grgb(255, 255, 255) }, | |
2577 | - | |
2578 | - { "Orange", grgb(255, 165, 0) }, | |
2579 | - { "Purple", grgb(160, 32, 240) }, | |
2580 | - { "Violet", grgb(238, 130, 238) }, | |
2581 | - {NULL, 0} | |
2582 | - }; | |
2583 | - | |
2584 | - if (name[0] == '#') | |
2585 | - { | |
2586 | - char *end; | |
2587 | - int c; | |
2588 | - | |
2589 | - c = strtol(name + 1, &end, 16); | |
2590 | - return (guicolor_T) ((c >> 16) & 0xff) | (c & 0xff00) | ((c & 0xff) << 16); | |
2591 | - } | |
2592 | - | |
2593 | - for (i = 0; colours[i].name != NULL; i++) | |
2594 | - { | |
2595 | - if (STRICMP(name, colours[i].name) == 0) | |
2596 | - return colours[i].value; | |
2597 | - } | |
2598 | - if (strnicmp(name, "grey", 4) == 0 || strnicmp(name, "gray", 4) == 0) | |
2599 | - { | |
2600 | - int level = (255 * atoi(name + 4)) / 100; | |
2601 | - return (guicolor_T) grgb(level, level, level); | |
2602 | - } | |
2603 | - return INVALCOLOR; | |
2604 | - } | |
2605 | - | |
2606 | - /* | |
2607 | - * Set the current text colours. | |
2608 | - * If we are using fonts then set the antialiasing colours too. | |
2609 | - */ | |
2610 | - void | |
2611 | - gui_mch_set_colors(guicolor_T fg, guicolor_T bg) | |
2612 | - { | |
2613 | - zap_redraw_colours[0] = bg << 8; /* JK230798, register new background colour */ | |
2614 | - zap_redraw_colours[1] = fg << 8; /* JK230798, register new foreground colour */ | |
2615 | - zap_redraw_update_colours = TRUE; /* JK230798, need update of colour masks */ | |
2616 | - | |
2617 | - swi(ColourTrans_ReturnGCOL, fg << 8); | |
2618 | - gui.fg_colour = r0; | |
2619 | - swi(ColourTrans_ReturnGCOL, bg << 8); | |
2620 | - gui.bg_colour = r0; | |
2621 | - | |
2622 | - if (ro_current_font) | |
2623 | - swi(ColourTrans_SetFontColours, 0, bg << 8, fg << 8, 14); | |
2624 | - } | |
2625 | - | |
2626 | - void | |
2627 | - ro_draw_string(x, y, s, len, flags, clip) | |
2628 | - int x; /* Top-left coord to plot at (x incl, y excl) */ | |
2629 | - int y; /* (screen coords) */ | |
2630 | - char_u *s; /* String to plot */ | |
2631 | - int len; /* Length of string */ | |
2632 | - int flags; /* DRAW_TRANSP, DRAW_BOLD, DRAW_UNDERL */ | |
2633 | - int* clip; /* JK230798, added clip window */ | |
2634 | - { | |
2635 | - if (ro_current_font) | |
2636 | - { | |
2637 | - int fx; | |
2638 | - int flen = len; /* Preserve for underline */ | |
2639 | - | |
2640 | - /* Use the Font manager to paint the string. | |
2641 | - * Must do one char at a time to get monospacing. | |
2642 | - */ | |
2643 | - | |
2644 | - if (flags & DRAW_ITALIC && !gui.ital_font) | |
2645 | - flags |= DRAW_UNDERL; /* No italic - underline instead */ | |
2646 | - | |
2647 | - if ((flags & DRAW_TRANSP) == 0) | |
2648 | - { | |
2649 | - swi(ColourTrans_SetColour, gui.bg_colour, 0, 0, 0, 0); | |
2650 | - swi(OS_Plot, 4, x, y - gui.char_height); | |
2651 | - swi(OS_Plot, 96 + 5, x + len * gui.char_width - 1, y - 1); | |
2652 | - } | |
2653 | - | |
2654 | - fx = x + font_x_offset; | |
2655 | - while (flen--) | |
2656 | - { | |
2657 | - swi(Font_Paint, 0, s++, 0x90, fx, y + font_y_offset, 0, 0, 1); | |
2658 | - fx += gui.char_width; | |
2659 | - } | |
2660 | - } | |
2661 | - else | |
2662 | - { | |
2663 | - if (zap_redraw) | |
2664 | - { | |
2665 | - /* Using fast Zap redraw. */ | |
2666 | - flags = ro_zap_redraw_draw_string(x, y, s, len, flags, clip); | |
2667 | - } | |
2668 | - else | |
2669 | - { | |
2670 | - /* Using the system font */ | |
2671 | - if (flags & DRAW_ITALIC) | |
2672 | - flags |= DRAW_UNDERL; | |
2673 | - | |
2674 | - if ((flags & DRAW_TRANSP) == 0) | |
2675 | - { | |
2676 | - swi(ColourTrans_SetColour, gui.bg_colour, 0, 0, 0, 0); | |
2677 | - swi(OS_Plot, 4, x, y - gui.char_height); | |
2678 | - swi(OS_Plot, 96 + 5, x + len * gui.char_width - 1, y - 1); | |
2679 | - } | |
2680 | - swi(OS_Plot, 4, /* Move the drawing cursor */ | |
2681 | - x, | |
2682 | - y - 1); | |
2683 | - swi(ColourTrans_SetColour, gui.fg_colour, 0, 0, 0, 0); | |
2684 | - swi(OS_WriteN, s, len); | |
2685 | - | |
2686 | - if (flags & DRAW_BOLD) | |
2687 | - { | |
2688 | - swi(OS_Plot, 4, x + (1 << x_eigen_factor), y - 1); | |
2689 | - swi(OS_WriteN, s, len); | |
2690 | - } | |
2691 | - } | |
2692 | - } | |
2693 | - | |
2694 | - if (flags & DRAW_UNDERL) | |
2695 | - { | |
2696 | - if (ro_current_font || zap_redraw) | |
2697 | - swi(ColourTrans_SetColour, gui.fg_colour, 0, 0, 0, 0); | |
2698 | - /* Underlined is the same with all plotting methods */ | |
2699 | - swi(OS_Plot, 4, x, y - gui.char_height); | |
2700 | - swi(OS_Plot, 1, gui.char_width * len, 0); | |
2701 | - } | |
2702 | - } | |
2703 | - | |
2704 | - void | |
2705 | - gui_mch_draw_string(int row, int col, char_u *s, int len, int flags) | |
2706 | - { | |
2707 | - int x, y; /* Workarea x,y */ | |
2708 | - x = col * gui.char_width; | |
2709 | - y = -row * gui.char_height; | |
2710 | - | |
2711 | - if (redraw_block) | |
2712 | - { | |
2713 | - ro_draw_string(x + redraw_block[1], y + redraw_block[4], | |
2714 | - s, len, flags, &redraw_block[7]); /* JK230798, added clip window */ | |
2715 | - } | |
2716 | - else | |
2717 | - { | |
2718 | - int block[44]; | |
2719 | - block[0] = gui.window_handle; | |
2720 | - block[1] = x; | |
2721 | - block[2] = y - gui.char_height; | |
2722 | - block[3] = (col + len) * gui.char_width; | |
2723 | - block[4] = y; | |
2724 | - swi(Wimp_UpdateWindow, 0, block); | |
2725 | - while (r0) | |
2726 | - { | |
2727 | - ro_draw_string(x + block[1], y + block[4], | |
2728 | - s, len, flags, &block[7]); /* JK230798, added clip window */ | |
2729 | - swi(Wimp_GetRectangle, 0, block); | |
2730 | - } | |
2731 | - } | |
2732 | - } | |
2733 | - | |
2734 | - /* | |
2735 | - * Return OK if the key with the termcap name "name" is supported. | |
2736 | - */ | |
2737 | - int | |
2738 | - gui_mch_haskey(char_u *name) | |
2739 | - { | |
2740 | - return FAIL; | |
2741 | - } | |
2742 | - | |
2743 | - void | |
2744 | - gui_mch_beep(void) | |
2745 | - { | |
2746 | - swi(OS_WriteI + 7); | |
2747 | - } | |
2748 | - | |
2749 | - /* | |
2750 | - * Visual bell. | |
2751 | - */ | |
2752 | - void | |
2753 | - gui_mch_flash(int msec) | |
2754 | - { | |
2755 | - /* TODO */ | |
2756 | - } | |
2757 | - | |
2758 | - | |
2759 | - /* | |
2760 | - * Plot a solid rectangle using the given plot action and colour. | |
2761 | - * Coordinates are inclusive and window-relative. | |
2762 | - */ | |
2763 | - void | |
2764 | - plot_rectangle(plot, colour, minx, miny, maxx, maxy) | |
2765 | - int plot; /* OS_Plot action */ | |
2766 | - int colour; | |
2767 | - int minx; | |
2768 | - int miny; | |
2769 | - int maxx; | |
2770 | - int maxy; | |
2771 | - { | |
2772 | - if (redraw_block) | |
2773 | - { | |
2774 | - swi(ColourTrans_SetColour, colour, 0, 0, 0, 0); | |
2775 | - swi(OS_Plot, 4, minx + redraw_block[1], miny + redraw_block[4]); | |
2776 | - swi(OS_Plot, plot, maxx + redraw_block[1], maxy + redraw_block[4]); | |
2777 | - } | |
2778 | - else | |
2779 | - { | |
2780 | - int block[44]; | |
2781 | - block[0] = gui.window_handle; | |
2782 | - block[1] = minx; | |
2783 | - block[2] = miny; | |
2784 | - block[3] = maxx + 1; | |
2785 | - block[4] = maxy + 1; | |
2786 | - swi(Wimp_UpdateWindow, 0, block); | |
2787 | - while (r0) | |
2788 | - { | |
2789 | - swi(ColourTrans_SetColour, colour, 0, 0, 0, 0); | |
2790 | - swi(OS_Plot, 4, minx + block[1], miny + block[4]); | |
2791 | - swi(OS_Plot, plot, maxx + block[1], maxy + block[4]); | |
2792 | - swi(Wimp_GetRectangle, 0, block); | |
2793 | - } | |
2794 | - } | |
2795 | - } | |
2796 | - | |
2797 | - /* | |
2798 | - * Invert a rectangle from row r, column c, for nr rows and nc columns. | |
2799 | - */ | |
2800 | - void | |
2801 | - gui_mch_invert_rectangle(int r, int c, int nr, int nc) | |
2802 | - { | |
2803 | - plot_rectangle(96 + 6, 0, FILL_X(c), -FILL_Y(r + nr), FILL_X(c + nc), -FILL_Y(r)); | |
2804 | - } | |
2805 | - | |
2806 | - /* | |
2807 | - * Iconify the GUI window. | |
2808 | - */ | |
2809 | - void | |
2810 | - gui_mch_iconify(void) | |
2811 | - { | |
2812 | - } | |
2813 | - | |
2814 | - #if defined(FEAT_EVAL) || defined(PROTO) | |
2815 | - /* | |
2816 | - * Bring the Vim window to the foreground. | |
2817 | - */ | |
2818 | - void | |
2819 | - gui_mch_set_foreground() | |
2820 | - { | |
2821 | - /* TODO */ | |
2822 | - } | |
2823 | - #endif | |
2824 | - | |
2825 | - /* Draw a hollow rectangle relative to the current | |
2826 | - * graphics cursor position, with the given width | |
2827 | - * and height. Start position is top-left. | |
2828 | - */ | |
2829 | - void | |
2830 | - draw_hollow(w, h) | |
2831 | - int w; | |
2832 | - int h; | |
2833 | - { | |
2834 | - swi(OS_Plot, 1, w - 1, 0); | |
2835 | - swi(OS_Plot, 1, 0, 1 - h); | |
2836 | - swi(OS_Plot, 1, 1 - w, 0); | |
2837 | - swi(OS_Plot, 1, 0, h - 1); | |
2838 | - } | |
2839 | - | |
2840 | - /* | |
2841 | - * Draw a cursor without focus. | |
2842 | - */ | |
2843 | - void | |
2844 | - gui_mch_draw_hollow_cursor(guicolor_T colour) | |
2845 | - { | |
2846 | - int x = FILL_X(gui.cursor_col); /* Window relative, top-left */ | |
2847 | - int y = -FILL_Y(gui.cursor_row); | |
2848 | - if (redraw_block == NULL) | |
2849 | - { | |
2850 | - int block[11]; | |
2851 | - | |
2852 | - block[0] = gui.window_handle; | |
2853 | - block[1] = x; | |
2854 | - block[2] = y - gui.char_height; | |
2855 | - block[3] = x + gui.char_width; | |
2856 | - block[4] = y; | |
2857 | - swi(Wimp_UpdateWindow, 0, block); | |
2858 | - while (r0) | |
2859 | - { | |
2860 | - swi(ColourTrans_SetGCOL, colour << 8, 0, 0, 0, 0); | |
2861 | - | |
2862 | - swi(OS_Plot, 4, x + block[1], y + block[4] - 1); | |
2863 | - draw_hollow(gui.char_width, gui.char_height); | |
2864 | - | |
2865 | - swi(Wimp_GetRectangle, 0, block); | |
2866 | - } | |
2867 | - } | |
2868 | - else | |
2869 | - { | |
2870 | - swi(ColourTrans_SetGCOL, colour << 8, 0, 0, 0, 0); | |
2871 | - | |
2872 | - swi(OS_Plot, 4, x + redraw_block[1], y + redraw_block[4] - 1); | |
2873 | - draw_hollow(gui.char_width, gui.char_height); | |
2874 | - } | |
2875 | - } | |
2876 | - | |
2877 | - /* | |
2878 | - * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using | |
2879 | - * color "color". | |
2880 | - */ | |
2881 | - void | |
2882 | - gui_mch_draw_part_cursor(w, h, colour) | |
2883 | - int w; | |
2884 | - int h; | |
2885 | - guicolor_T colour; | |
2886 | - { | |
2887 | - int x = FILL_X(gui.cursor_col); | |
2888 | - int y = -FILL_Y(gui.cursor_row); | |
2889 | - swi(ColourTrans_ReturnGCOL, colour << 8); | |
2890 | - plot_rectangle(96 + 5, r0, x, y - h, x + w - 1, y - 1); | |
2891 | - } | |
2892 | - | |
2893 | - /* | |
2894 | - * Catch up with any queued events. This may put keyboard input into the | |
2895 | - * input buffer, call resize call-backs, trigger timers etc. | |
2896 | - * If there is nothing in the event queue(& no timers pending), then we return | |
2897 | - * immediately (well, after a Wimp_Poll). | |
2898 | - */ | |
2899 | - void | |
2900 | - gui_mch_update(void) | |
2901 | - { | |
2902 | - int block[64]; | |
2903 | - int reason; | |
2904 | - | |
2905 | - swi(OS_ReadMonotonicTime); | |
2906 | - if ((r0 - time_of_last_poll) < 50) | |
2907 | - return; /* Don't return too often */ | |
2908 | - | |
2909 | - reason = wimp_poll(0, block); | |
2910 | - if (reason) | |
2911 | - process_event(reason, block); | |
2912 | - ro_return_early = FALSE; /* We're returning anyway. */ | |
2913 | - } | |
2914 | - | |
2915 | - void | |
2916 | - redraw_window(block) | |
2917 | - int *block; | |
2918 | - { | |
2919 | - int x, y; /* Vim workarea coords */ | |
2920 | - int width, height; | |
2921 | - int blank_col; | |
2922 | - | |
2923 | - swi(ColourTrans_ReturnGCOL, UNUSED_COLOUR << 8, 0, 0, 1<<7, 0); | |
2924 | - blank_col = r0; | |
2925 | - | |
2926 | - swi(Wimp_RedrawWindow, 0, block); | |
2927 | - redraw_block = block; | |
2928 | - while (r0) | |
2929 | - { | |
2930 | - x = block[7] - block[1]; | |
2931 | - y = block[4] - block[10]; | |
2932 | - width = block[9] - block[7]; | |
2933 | - height = block[10] - block[8]; | |
2934 | - | |
2935 | - if (height + y > Rows * gui.char_height) | |
2936 | - { | |
2937 | - /* Blank everything off the bottom. */ | |
2938 | - plot_rectangle(96 + 5, blank_col, | |
2939 | - 0, block[8] - block[4], | |
2940 | - block[9] - block[1], -FILL_Y(Rows) - 1); | |
2941 | - height = Rows * gui.char_height; | |
2942 | - } | |
2943 | - if (width + x> Columns * gui.char_width) | |
2944 | - { | |
2945 | - /* Blank everything off to the right. */ | |
2946 | - plot_rectangle(96 + 5, blank_col, | |
2947 | - FILL_X(Columns), block[8] - block[4], | |
2948 | - block[9] - block[1], 0); | |
2949 | - width = Columns * gui.char_width; | |
2950 | - } | |
2951 | - gui_redraw(x , y, width, height); | |
2952 | - swi(Wimp_GetRectangle, 0, block); | |
2953 | - } | |
2954 | - redraw_block = NULL; | |
2955 | - } | |
2956 | - | |
2957 | - /* Check if we have modified data. | |
2958 | - * If we do then ack the message to stop the shutdown. | |
2959 | - * Otherwise, ignore the message. | |
2960 | - */ | |
2961 | - void | |
2962 | - ro_prequit(block) | |
2963 | - int *block; | |
2964 | - { | |
2965 | - if (!ro_ok_to_quit()) | |
2966 | - { | |
2967 | - /* Not OK to quit - stop shutdown */ | |
2968 | - block[3] = block[2]; | |
2969 | - swi(Wimp_SendMessage, 19, block, block[1]); | |
2970 | - } | |
2971 | - /* Do nothing. We may get a Message_Quit later. */ | |
2972 | - } | |
2973 | - | |
2974 | - /* If there is unsaved data then ask the user if they mind losing it. | |
2975 | - * Return TRUE if we can quit without saving, FALSE to halt the | |
2976 | - * shutdown. | |
2977 | - */ | |
2978 | - int | |
2979 | - ro_ok_to_quit() | |
2980 | - { | |
2981 | - int old_confirm = cmdmod.confirm; | |
2982 | - | |
2983 | - cmdmod.confirm = FALSE; /* Use our own, single tasking, box */ | |
2984 | - | |
2985 | - if (check_changed_any(FALSE)) | |
2986 | - { | |
2987 | - swi(Wimp_ReportError, | |
2988 | - "\0\0\0\0Vim contains unsaved data - quit anyway?", | |
2989 | - 0x17, | |
2990 | - "Vim"); | |
2991 | - cmdmod.confirm = old_confirm; | |
2992 | - if (r1 != 1) | |
2993 | - return FALSE; | |
2994 | - } | |
2995 | - cmdmod.confirm = old_confirm; | |
2996 | - return TRUE; | |
2997 | - } | |
2998 | - | |
2999 | - /* Quit without checking for unsaved data. */ | |
3000 | - void | |
3001 | - ro_quit() | |
3002 | - { | |
3003 | - exiting = TRUE; | |
3004 | - getout(0); | |
3005 | - | |
3006 | - exiting = FALSE; /* probably can't get here */ | |
3007 | - setcursor(); /* position cursor */ | |
3008 | - out_flush(); | |
3009 | - } | |
3010 | - | |
3011 | - /* Insent the given vim special code into the input buffer */ | |
3012 | - void | |
3013 | - ro_press(a, b, modifier) | |
3014 | - char a; | |
3015 | - char b; | |
3016 | - int modifier; /* %<Ctrl><Shift> 0000 0000 */ | |
3017 | - { | |
3018 | - char_u buf[6]; | |
3019 | - int vim_mod; | |
3020 | - int key; | |
3021 | - | |
3022 | - | |
3023 | - /* Convert RISC OS modifier to Vim modifier. */ | |
3024 | - vim_mod = ((modifier & 0x10) ? MOD_MASK_SHIFT : 0) | |
3025 | - | ((modifier & 0x20) ? MOD_MASK_CTRL : 0); | |
3026 | - key = simplify_key(TERMCAP2KEY(a, b), &vim_mod); | |
3027 | - | |
3028 | - buf[3] = CSI; | |
3029 | - buf[4] = KEY2TERMCAP0(key); | |
3030 | - buf[5] = KEY2TERMCAP1(key); | |
3031 | - if (vim_mod) | |
3032 | - { | |
3033 | - buf[0] = CSI; | |
3034 | - buf[1] = KS_MODIFIER; | |
3035 | - buf[2] = vim_mod; | |
3036 | - add_to_input_buf(buf, 6); | |
3037 | - } | |
3038 | - else | |
3039 | - add_to_input_buf(buf + 3, 3); | |
3040 | - } | |
3041 | - | |
3042 | - /* Take a wimp key code and insert the vim equivalent | |
3043 | - * into vim's input buffer. | |
3044 | - * CTRL-C also sets got_int. | |
3045 | - */ | |
3046 | - void | |
3047 | - ro_insert_key(code) | |
3048 | - char_u *code; /* Wimp_ProcessKey code (4 bytes) */ | |
3049 | - { | |
3050 | - char a = code[0]; | |
3051 | - char b = code[1]; | |
3052 | - int base, modifier; | |
3053 | - | |
3054 | - if (a == 3 && ctrl_c_interrupts) | |
3055 | - got_int = TRUE; | |
3056 | - | |
3057 | - /* Is it a normal key? */ | |
3058 | - if (a > 31 && a < 127) | |
3059 | - { | |
3060 | - add_to_input_buf(code, 1); | |
3061 | - return; | |
3062 | - } | |
3063 | - | |
3064 | - /* We should pass any unrecognised keys on, but | |
3065 | - * for now just pass on F12 combinations. | |
3066 | - */ | |
3067 | - switch (b) | |
3068 | - { | |
3069 | - case 0: | |
3070 | - /* Home and Delete are the only special cases */ | |
3071 | - switch (a) | |
3072 | - { | |
3073 | - case 0x1e: | |
3074 | - ro_press('k','h', 0); /* Home */ | |
3075 | - return; | |
3076 | - case 0x7f: | |
3077 | - ro_press('k','D', 0); /* Delete */ | |
3078 | - return; | |
3079 | - case CSI: | |
3080 | - { | |
3081 | - /* Turn CSI into K_CSI. Untested! */ | |
3082 | - char_u string[3] = {CSI, KS_EXTRA, KE_CSI}; | |
3083 | - | |
3084 | - add_to_input_buf(string, 3); | |
3085 | - return; | |
3086 | - } | |
3087 | - default: | |
3088 | - add_to_input_buf(code, 1); | |
3089 | - return; | |
3090 | - } | |
3091 | - case 1: | |
3092 | - if ((a & 0xcf) == 0xcc) | |
3093 | - { | |
3094 | - /* F12 pressed - pass it on (quick hack) */ | |
3095 | - swi(Wimp_ProcessKey, a | 0x100); | |
3096 | - return; | |
3097 | - } | |
3098 | - base = a & 0xcf; | |
3099 | - modifier = a & 0x30; | |
3100 | - switch (base) | |
3101 | - { | |
3102 | - case 0x8a: /* Tab */ | |
3103 | - add_to_input_buf("\011", 1); | |
3104 | - return; | |
3105 | - case 0x8b: /* Copy (End) */ | |
3106 | - return ro_press('@', '7', modifier); | |
3107 | - case 0x8c: /* Left */ | |
3108 | - return ro_press('k', 'l', modifier); | |
3109 | - case 0x8d: /* Right */ | |
3110 | - return ro_press('k', 'r', modifier); | |
3111 | - case 0x8e: /* Down */ | |
3112 | - if (modifier & 0x10) | |
3113 | - return ro_press('k', 'N', modifier ^ 0x10); | |
3114 | - else | |
3115 | - return ro_press('k', 'd', modifier); | |
3116 | - case 0x8f: /* Up */ | |
3117 | - if (modifier & 0x10) | |
3118 | - return ro_press('k', 'P', modifier ^ 0x10); | |
3119 | - else | |
3120 | - return ro_press('k', 'u', modifier); | |
3121 | - case 0xca: /* F10 */ | |
3122 | - return ro_press('k', ';', modifier); | |
3123 | - case 0xcb: /* F11 */ | |
3124 | - return ro_press('F', '1', modifier); | |
3125 | - case 0xcd: /* Insert */ | |
3126 | - return ro_press('k', 'I', modifier); | |
3127 | - default: | |
3128 | - if (base > 0x80 && base < 0x18a) | |
3129 | - { | |
3130 | - /* One of the other function keys */ | |
3131 | - return ro_press('k', '0' + (base & 15), modifier); | |
3132 | - } | |
3133 | - } | |
3134 | - } | |
3135 | - } | |
3136 | - | |
3137 | - /* Process a mouse event. */ | |
3138 | - void | |
3139 | - ro_mouse(block) | |
3140 | - int *block; | |
3141 | - { | |
3142 | - int x, y, button, vim_button; | |
3143 | - int modifiers = 0; | |
3144 | - int min_x, min_y; /* Visible area of editor window */ | |
3145 | - int max_x, max_y; | |
3146 | - | |
3147 | - if (block[3] != gui.window_handle || ro_dragging) | |
3148 | - return; /* Not our window or ignoring clicks*/ | |
3149 | - | |
3150 | - x = block[0]; /* Click position - screen coords */ | |
3151 | - y = block[1]; | |
3152 | - button = block[2]; | |
3153 | - | |
3154 | - block[0] = gui.window_handle; | |
3155 | - swi(Wimp_GetWindowState, 0, block); | |
3156 | - min_x = block[1]; | |
3157 | - min_y = block[2]; | |
3158 | - max_x = block[3]; | |
3159 | - max_y = block[4]; | |
3160 | - | |
3161 | - if (block[3] - x < gui.scrollbar_width) | |
3162 | - { | |
3163 | - /* Click in that blank area under the scrollbars */ | |
3164 | - | |
3165 | - if (button & 0x444) | |
3166 | - { | |
3167 | - int front_block[64]; | |
3168 | - /* Dragging with Select - bring window to front first */ | |
3169 | - front_block[0] = gui.window_handle; | |
3170 | - swi(Wimp_GetWindowState, 0, front_block); | |
3171 | - front_block[7] = -1; | |
3172 | - ro_open_main(front_block); | |
3173 | - } | |
3174 | - | |
3175 | - block[0] = gui.window_handle; | |
3176 | - block[1] = 7; /* Drag point */ | |
3177 | - block[2] = block[4] = 0; /* Coords of point. */ | |
3178 | - block[3] = block[5] = 0; | |
3179 | - drag_x_offset = max_x - x; | |
3180 | - drag_y_offset = min_y - y; | |
3181 | - | |
3182 | - /* Parent box. */ | |
3183 | - block[6] = min_x + | |
3184 | - gui.scrollbar_width * 2 + | |
3185 | - MIN_COLUMNS * gui.char_width; | |
3186 | - block[7] = 0; | |
3187 | - gui_mch_get_screen_dimensions(&block[8], &block[9]); | |
3188 | - block[9] = max_y - | |
3189 | - 4 * gui.char_height - | |
3190 | - gui.scrollbar_height; | |
3191 | - | |
3192 | - swi(Wimp_DragBox, 0, block); | |
3193 | - ro_dragging = DRAG_RESIZE_WINDOW; | |
3194 | - drag_button = vim_button; | |
3195 | - drag_modifiers = modifiers; | |
3196 | - return; | |
3197 | - } | |
3198 | - | |
3199 | - if (button & 0x111) | |
3200 | - vim_button = MOUSE_RIGHT; | |
3201 | - else if (button & 0x222) | |
3202 | - vim_button = MOUSE_MIDDLE; | |
3203 | - else | |
3204 | - vim_button = MOUSE_LEFT; | |
3205 | - | |
3206 | - swi(OS_Byte, 121, 0x80); | |
3207 | - if (r1 == 0xff) | |
3208 | - modifiers |= MOUSE_SHIFT; | |
3209 | - swi(OS_Byte, 121, 0x81); | |
3210 | - if (r1 == 0xff) | |
3211 | - modifiers |= MOUSE_CTRL; | |
3212 | - swi(OS_Byte, 121, 0x82); | |
3213 | - if (r1 == 0xff) | |
3214 | - modifiers |= MOUSE_ALT; | |
3215 | - | |
3216 | - if (button == 2) | |
3217 | - { | |
3218 | - /* Menu click: | |
3219 | - * If shift was pressed then do the paste action. | |
3220 | - * If not, then open the pop-up menu. | |
3221 | - */ | |
3222 | - modifiers ^= MOUSE_SHIFT; | |
3223 | - if (modifiers && MOUSE_SHIFT) | |
3224 | - { | |
3225 | - vimmenu_T main; | |
3226 | - /* Shift was NOT pressed - show menu */ | |
3227 | - main.dname = (char_u *) "Vim"; | |
3228 | - main.children = root_menu; | |
3229 | - gui_mch_show_popupmenu(&main); | |
3230 | - return; | |
3231 | - } | |
3232 | - } | |
3233 | - | |
3234 | - /* Gain the input focus */ | |
3235 | - swi(Wimp_SetCaretPosition, gui.window_handle, -1, 0, 0, -1, -1); | |
3236 | - | |
3237 | - if (button & 0xf0) | |
3238 | - { | |
3239 | - /* Drag operation: | |
3240 | - * | |
3241 | - * Tell the Wimp to start a drag. | |
3242 | - * Monitor null events. | |
3243 | - */ | |
3244 | - block[1] = 7; /* Drag a point. */ | |
3245 | - block[2] = block[4] = x; /* Coords of point. */ | |
3246 | - block[3] = block[5] = y; | |
3247 | - block[6] = 0; /* Coords of bounding box. */ | |
3248 | - block[7] = 0; | |
3249 | - gui_mch_get_screen_dimensions(&block[8], &block[9]); | |
3250 | - | |
3251 | - drag_x_offset = drag_y_offset = 0; | |
3252 | - | |
3253 | - swi(Wimp_DragBox, 0, block); | |
3254 | - ro_dragging = DRAG_SELECTION; | |
3255 | - drag_button = vim_button; | |
3256 | - drag_modifiers = modifiers; | |
3257 | - | |
3258 | - vim_button |= MOUSE_DRAG; | |
3259 | - } | |
3260 | - | |
3261 | - gui_send_mouse_event( | |
3262 | - vim_button, | |
3263 | - x - min_x, | |
3264 | - max_y - y, | |
3265 | - button & 0xf ? TRUE : FALSE, /* dclick */ | |
3266 | - modifiers); | |
3267 | - } | |
3268 | - | |
3269 | - void | |
3270 | - ro_continue_drag(block) | |
3271 | - int *block; /* Just used as scrap. */ | |
3272 | - { | |
3273 | - int x, y; | |
3274 | - | |
3275 | - /* Get screen coords of pointer. */ | |
3276 | - swi(Wimp_GetPointerInfo, 0, block); | |
3277 | - x = block[0] + drag_x_offset; | |
3278 | - y = block[1] + drag_y_offset; | |
3279 | - | |
3280 | - block[0] = gui.window_handle; | |
3281 | - swi(Wimp_GetWindowState, 0, block); | |
3282 | - | |
3283 | - if (ro_dragging == DRAG_RESIZE_WINDOW) | |
3284 | - { | |
3285 | - /* Resizing the main window. */ | |
3286 | - block[2] = y; | |
3287 | - block[3] = x; | |
3288 | - ro_open_main(block); | |
3289 | - } | |
3290 | - else | |
3291 | - { | |
3292 | - /* Selecting some text. */ | |
3293 | - gui_send_mouse_event( | |
3294 | - drag_button | MOUSE_DRAG, /* Always report the same button */ | |
3295 | - x - block[1], | |
3296 | - block[4] - y, | |
3297 | - FALSE, /* Not a double click. */ | |
3298 | - drag_modifiers); | |
3299 | - } | |
3300 | - } | |
3301 | - | |
3302 | - /* User has released all mouse buttons, marking the end of a drag. */ | |
3303 | - void | |
3304 | - ro_drag_finished(block) | |
3305 | - int *block; | |
3306 | - { | |
3307 | - int x; | |
3308 | - int y; | |
3309 | - int width, height; | |
3310 | - | |
3311 | - /* I don't trust the box returned by Wimp_Poll; look at the pointer | |
3312 | - * ourselves. | |
3313 | - */ | |
3314 | - swi(Wimp_GetPointerInfo, 0, block); | |
3315 | - x = block[0] + drag_x_offset; | |
3316 | - y = block[1] + drag_y_offset; | |
3317 | - | |
3318 | - if (ro_dragging == DRAG_RESIZE_WINDOW) | |
3319 | - { | |
3320 | - block[0] = gui.window_handle; | |
3321 | - swi(Wimp_GetWindowState, 0, block); | |
3322 | - block[2] = y; | |
3323 | - block[3] = x; | |
3324 | - ro_open_main(block); | |
3325 | - | |
3326 | - width = (block[3] - block[1]); | |
3327 | - height = (block[4] - block[2]); | |
3328 | - | |
3329 | - swi(Wimp_ForceRedraw, gui.window_handle, 0, -height, width, 0); | |
3330 | - gui_resize_shell(width, height); | |
3331 | - } | |
3332 | - else | |
3333 | - { | |
3334 | - block[0] = gui.window_handle; | |
3335 | - swi(Wimp_GetWindowState, 0, block); | |
3336 | - gui_send_mouse_event( | |
3337 | - MOUSE_RELEASE, | |
3338 | - x - block[1], | |
3339 | - block[4] - y, | |
3340 | - FALSE, /* not a double click */ | |
3341 | - drag_modifiers); | |
3342 | - } | |
3343 | - ro_dragging = DRAG_FALSE; | |
3344 | - } | |
3345 | - | |
3346 | - /* Load the file/pathname given in block into a [new] buffer. | |
3347 | - * | |
3348 | - * Modifier Action | |
3349 | - * | |
3350 | - * None :confirm e <file> | |
3351 | - * Ctrl :sp <file> | |
3352 | - * Shift <file> | |
3353 | - * | |
3354 | - * Insert into typebuf, at the start. | |
3355 | - * If loading from !Scrap then use saved leafname instead, and | |
3356 | - * delete the scrap file. Also, ignore shift key. | |
3357 | - * | |
3358 | - * NB: Doesn't send DataLoadAck (other app might delete temp file?). | |
3359 | - */ | |
3360 | - void | |
3361 | - ro_dataload(block) | |
3362 | - int *block; | |
3363 | - { | |
3364 | - char_u new_path[MAXPATHL]; | |
3365 | - char_u *path = ((char_u *) block) + 44; | |
3366 | - int scrap = FALSE; | |
3367 | - | |
3368 | - if (block[3] == leaf_ref && leaf_name) | |
3369 | - scrap = TRUE; | |
3370 | - | |
3371 | - switch (get_real_state() & 0xff) | |
3372 | - { | |
3373 | - case INSERT: | |
3374 | - case CMDLINE: | |
3375 | - case CMDLINE+LANGMAP: | |
3376 | - /* For insert mode we can only insert the pathname (currently) | |
3377 | - * Make sure Shift is pressed. | |
3378 | - */ | |
3379 | - swi(OS_Byte, 121, 0x80); /* Is Shift pressed? */ | |
3380 | - if (r1 == 0xff) | |
3381 | - { | |
3382 | - ins_typebuf(" ", REMAP_NONE, 0, TRUE, FALSE); | |
3383 | - ins_typebuf(path, REMAP_NONE, 0, TRUE, FALSE); | |
3384 | - ro_return_early = TRUE; /* Return even though nothing was typed. */ | |
3385 | - } | |
3386 | - else | |
3387 | - swi(Wimp_ReportError, | |
3388 | - "\0\0\0\0Sorry, you can only load text in normal mode", 5, "Vim"); | |
3389 | - break; | |
3390 | - | |
3391 | - case NORMAL: | |
3392 | - ro_return_early = TRUE; /* Return even though nothing was typed. */ | |
3393 | - | |
3394 | - if (scrap) /* Remove <Wimp$Scrap>. Later. */ | |
3395 | - ins_typebuf(":!~remove <Wimp$Scrap>\r", REMAP_NONE, 0, TRUE, FALSE); | |
3396 | - | |
3397 | - /* Insert {:sp ,:confirm e }[+f\ <leaf> ]<file><CR> */ | |
3398 | - ins_typebuf("\r", REMAP_NONE, 0, TRUE, FALSE); | |
3399 | - ins_typebuf(path, REMAP_NONE, 0, TRUE, FALSE); | |
3400 | - ins_typebuf(" ", REMAP_NONE, 0, TRUE, FALSE); | |
3401 | - | |
3402 | - if (scrap) | |
3403 | - { | |
3404 | - /* Loading via !Scrap - change pathname to stored leafname */ | |
3405 | - ins_typebuf(leaf_name, REMAP_NONE, 0, TRUE, FALSE); | |
3406 | - ins_typebuf(" +f\\ ", REMAP_NONE, 0, TRUE, FALSE); | |
3407 | - leaf_ref = 0; | |
3408 | - vim_free(leaf_name); | |
3409 | - leaf_name = NULL; | |
3410 | - } | |
3411 | - | |
3412 | - swi(OS_Byte, 121, 0x81); /* Is Ctrl pressed? */ | |
3413 | - if (r1 == 0xff) | |
3414 | - /* Yes, split window */ | |
3415 | - ins_typebuf(":sp", REMAP_NONE, 0, TRUE, FALSE); | |
3416 | - else | |
3417 | - ins_typebuf(":confirm e", REMAP_NONE, 0, TRUE, FALSE); | |
3418 | - break; | |
3419 | - | |
3420 | - default: | |
3421 | - swi(Wimp_ReportError, "\0\0\0\0You can only load text in normal mode.", 5, "Vim"); | |
3422 | - } | |
3423 | - /* Send DataSaveAck so other program doesn't think we died | |
3424 | - * and delete <Wimp$Scrap>. | |
3425 | - */ | |
3426 | - block[3] = block[2]; | |
3427 | - block[4] = 4; | |
3428 | - swi(Wimp_SendMessage, 17, block, block[1]); | |
3429 | - } | |
3430 | - | |
3431 | - void | |
3432 | - ro_datasave(block) | |
3433 | - int *block; | |
3434 | - { | |
3435 | - char_u *path = ((char_u *) block) + 44; | |
3436 | - | |
3437 | - /* Preserve the name given so we can use it, not <Wimp$Scrap> */ | |
3438 | - if (leaf_name) | |
3439 | - vim_free(leaf_name); | |
3440 | - leaf_name = vim_strsave(path); | |
3441 | - | |
3442 | - block[9] = -1; /* File is unsafe. */ | |
3443 | - strcpy(path, "<Wimp$Scrap>"); | |
3444 | - block[0] = 60; | |
3445 | - block[3] = block[2]; | |
3446 | - block[4] = 2; | |
3447 | - swi(Wimp_SendMessage, 17, block, block[1]); | |
3448 | - | |
3449 | - leaf_ref = block[2]; | |
3450 | - } | |
3451 | - | |
3452 | - void | |
3453 | - ro_message(block) | |
3454 | - int *block; | |
3455 | - { | |
3456 | - char_u *buffer; | |
3457 | - long_u len; | |
3458 | - | |
3459 | - if (block[1] == task_handle) | |
3460 | - return; /* Don't talk to ourself! */ | |
3461 | - switch (block[4]) | |
3462 | - { | |
3463 | - case 0: /* Quit. */ | |
3464 | - if (block[4] == 0) | |
3465 | - ro_quit(); | |
3466 | - break; | |
3467 | - case 1: /* DataSave */ | |
3468 | - ro_datasave(block); | |
3469 | - break; | |
3470 | - case 2: /* DataSaveAck. */ | |
3471 | - if (clip_convert_selection(&buffer, &len, &clip_star) == -1) | |
3472 | - return; | |
3473 | - | |
3474 | - /* Save the clipboard contents to a file. */ | |
3475 | - swi(OS_File, 10, ((char_u *) block) + 44, 0xfff, 0, buffer, buffer + len); | |
3476 | - | |
3477 | - /* Ack with DataLoad message. */ | |
3478 | - block[3] = block[2]; | |
3479 | - block[4] = 3; | |
3480 | - block[9] = len; | |
3481 | - swi(Wimp_SendMessage, 17, block, block[1]); | |
3482 | - | |
3483 | - vim_free(buffer); | |
3484 | - break; | |
3485 | - case 3: /* DataLoad */ | |
3486 | - ro_dataload(block); | |
3487 | - break; | |
3488 | - case 8: /* PreQuit */ | |
3489 | - ro_prequit(block); | |
3490 | - break; | |
3491 | - case 0xf: /* Lose clipboard. */ | |
3492 | - if (block[5] & 4) | |
3493 | - { | |
3494 | - clip_free_selection(&clip_star); | |
3495 | - clip_star.owned = FALSE; | |
3496 | - } | |
3497 | - break; | |
3498 | - case 0x10: /* DataRequest (clip_star) */ | |
3499 | - if (clip_star.owned) | |
3500 | - { | |
3501 | - int rows; | |
3502 | - | |
3503 | - /* Tell other program that we have the clipboard. */ | |
3504 | - block[0] = 52; | |
3505 | - block[3] = block[2]; /* Copy myref to yourref. */ | |
3506 | - block[4] = 1; /* DataSave message. */ | |
3507 | - /* Create an estimate for the size (larger or same as true | |
3508 | - * value) */ | |
3509 | - rows = clip_star.end.lnum - clip_star.start.lnum; | |
3510 | - if (rows < 0) | |
3511 | - rows = -rows; | |
3512 | - block[9] = (rows + 1) * Columns + 1; /* Add one for possible | |
3513 | - final newline. */ | |
3514 | - block[10] = 0xfff; /* Clipboard is text. */ | |
3515 | - strcpy( ((char_u *) block) + 44, "VimClip"); | |
3516 | - swi(Wimp_SendMessage, 17, block, block[1]); | |
3517 | - } | |
3518 | - break; | |
3519 | - case 0x400c1: /* Mode change */ | |
3520 | - changed_mode = TRUE; /* Flag - update on next OpenWindow */ | |
3521 | - if (zap_redraw) | |
3522 | - { | |
3523 | - /* JK230798, re-initialise ZapRedraw stuff */ | |
3524 | - if (ro_zap_redraw_initialise() == FAIL) | |
3525 | - zap_redraw = FALSE; | |
3526 | - } | |
3527 | - break; | |
3528 | - case 0x400c3: /* TaskCloseDown */ | |
3529 | - if (block[1] == child_handle) | |
3530 | - child_handle = 0; | |
3531 | - break; | |
3532 | - } | |
3533 | - } | |
3534 | - | |
3535 | - /* | |
3536 | - * Converts a scrollbar's window handle into a scrollbar pointer. | |
3537 | - * NULL on failure. | |
3538 | - */ | |
3539 | - scrollbar_T * | |
3540 | - ro_find_sbar(id) | |
3541 | - int id; | |
3542 | - { | |
3543 | - win_T *wp; | |
3544 | - | |
3545 | - if (gui.bottom_sbar.id == id) | |
3546 | - return &gui.bottom_sbar; | |
3547 | - FOR_ALL_WINDOWS(wp) | |
3548 | - { | |
3549 | - if (wp->w_scrollbars[SBAR_LEFT].id == id) | |
3550 | - return &wp->w_scrollbars[SBAR_LEFT]; | |
3551 | - if (wp->w_scrollbars[SBAR_RIGHT].id == id) | |
3552 | - return &wp->w_scrollbars[SBAR_RIGHT]; | |
3553 | - } | |
3554 | - return NULL; | |
3555 | - } | |
3556 | - | |
3557 | - void | |
3558 | - scroll_to(line, sb) | |
3559 | - int sb; /* Scrollbar number */ | |
3560 | - int line; | |
3561 | - { | |
3562 | - char_u code[8]; | |
3563 | - | |
3564 | - /* Don't put events in the input queue now. */ | |
3565 | - if (hold_gui_events) | |
3566 | - return; | |
3567 | - | |
3568 | - /* Send a scroll event: | |
3569 | - * | |
3570 | - * A scrollbar event is CSI (NOT K_SPECIAL), KS_VER_SCROLLBAR, | |
3571 | - * KE_FILLER followed by: | |
3572 | - * one byte representing the scrollbar number, and then four bytes | |
3573 | - * representing a long_u which is the new value of the scrollbar. | |
3574 | - */ | |
3575 | - code[0] = CSI; | |
3576 | - code[1] = KS_VER_SCROLLBAR; | |
3577 | - code[2] = KE_FILLER; | |
3578 | - code[3] = sb; | |
3579 | - code[4] = line >> 24; | |
3580 | - code[5] = line >> 16; | |
3581 | - code[6] = line >> 8; | |
3582 | - code[7] = line; | |
3583 | - add_to_input_buf(code, 8); | |
3584 | - } | |
3585 | - | |
3586 | - void | |
3587 | - h_scroll_to(col) | |
3588 | - int col; | |
3589 | - { | |
3590 | - char_u code[8]; | |
3591 | - | |
3592 | - /* Don't put events in the input queue now. */ | |
3593 | - if (hold_gui_events) | |
3594 | - return; | |
3595 | - | |
3596 | - /* Send a scroll event: | |
3597 | - * | |
3598 | - * A scrollbar event is CSI (NOT K_SPECIAL) | |
3599 | - * | |
3600 | - * A horizontal scrollbar event is K_SPECIAL, KS_HOR_SCROLLBAR, | |
3601 | - * KE_FILLER followed by four bytes representing a long_u which is the | |
3602 | - * new value of the scrollbar. | |
3603 | - */ | |
3604 | - code[0] = CSI; | |
3605 | - code[1] = KS_HOR_SCROLLBAR; | |
3606 | - code[2] = KE_FILLER; | |
3607 | - code[4] = col >> 24; | |
3608 | - code[5] = col >> 16; | |
3609 | - code[6] = col >> 8; | |
3610 | - code[7] = col; | |
3611 | - add_to_input_buf(code, 8); | |
3612 | - } | |
3613 | - | |
3614 | - void | |
3615 | - ro_scroll(block) | |
3616 | - int *block; | |
3617 | - { | |
3618 | - scrollbar_T *sb; | |
3619 | - int offset; | |
3620 | - win_T *wp; | |
3621 | - | |
3622 | - /* Block is ready for Wimp_OpenWindow, and also contains: | |
3623 | - * | |
3624 | - * +32 = scroll X direction (-2 .. +2) | |
3625 | - * +36 = scroll Y direction (-2 .. +2) | |
3626 | - */ | |
3627 | - | |
3628 | - sb = ro_find_sbar(block[0]); | |
3629 | - if (!sb) | |
3630 | - return; /* Window not found (error). */ | |
3631 | - | |
3632 | - wp = sb-> wp; | |
3633 | - | |
3634 | - if (wp == NULL) | |
3635 | - { | |
3636 | - /* Horizontal bar. */ | |
3637 | - offset = block[8]; | |
3638 | - if (offset == -2) | |
3639 | - offset = (block[1] - block[3]) / gui.char_width; | |
3640 | - else if (offset == 2) | |
3641 | - offset = (block[3] - block[1]) / gui.char_width; | |
3642 | - | |
3643 | - block[5] += offset * gui.char_width; | |
3644 | - | |
3645 | - gui_drag_scrollbar(sb, block[5] / gui.char_width, FALSE); | |
3646 | - | |
3647 | - swi(Wimp_OpenWindow, 0, block); | |
3648 | - } | |
3649 | - else | |
3650 | - { | |
3651 | - offset = -block[9]; | |
3652 | - if (offset == -2) | |
3653 | - offset = -(wp -> w_height - 1); | |
3654 | - else if (offset == 2) | |
3655 | - offset = wp -> w_height - 1; | |
3656 | - | |
3657 | - /* Possibly we should reposition the scrollbar? | |
3658 | - * Vim seems to update the bar anyway... | |
3659 | - */ | |
3660 | - gui_drag_scrollbar(sb, offset - (block[6] / gui.char_height), FALSE); | |
3661 | - } | |
3662 | - } | |
3663 | - | |
3664 | - /* Move a window by a given offset. Used to simulate the function of the | |
3665 | - * nested wimp. | |
3666 | - */ | |
3667 | - void | |
3668 | - ro_move_child(window, x, y, pos_wanted, pos_got) | |
3669 | - int window; | |
3670 | - int x,y; /* offset to move by */ | |
3671 | - int pos_wanted, pos_got; | |
3672 | - { | |
3673 | - int block[10]; | |
3674 | - | |
3675 | - block[0] = window; | |
3676 | - swi(Wimp_GetWindowState, 0, block); | |
3677 | - block[1] += x; | |
3678 | - block[2] += y; | |
3679 | - block[3] += x; | |
3680 | - block[4] += y; | |
3681 | - if (pos_wanted == -1) | |
3682 | - block[7] = -1; | |
3683 | - else if (pos_wanted == -2) | |
3684 | - block[7] = pos_got; | |
3685 | - swi(Wimp_OpenWindow, 0, block); | |
3686 | - } | |
3687 | - | |
3688 | - /* Open the main window. Also updates scrollbars if we are not | |
3689 | - * using the nested Wimp. | |
3690 | - * If we have just changed mode then re-read all values. | |
3691 | - */ | |
3692 | - void | |
3693 | - ro_open_main(block) | |
3694 | - int *block; | |
3695 | - { | |
3696 | - int toggle_size; | |
3697 | - | |
3698 | - /* Find out if the user clicked on the toggle size icon. */ | |
3699 | - block[20] = block[0]; | |
3700 | - swi(Wimp_GetWindowState, 0, block + 20); | |
3701 | - toggle_size = block[28] & (1 << 19); | |
3702 | - | |
3703 | - if (nested_wimp) | |
3704 | - { | |
3705 | - swi(Wimp_OpenWindow, 0, block); | |
3706 | - } | |
3707 | - else | |
3708 | - { | |
3709 | - int old[10]; | |
3710 | - int x_offset, y_offset; /* Move children same as parent. */ | |
3711 | - int pos_wanted, pos_got; | |
3712 | - int left_bar = gui.which_scrollbars[SBAR_LEFT]; | |
3713 | - int right_bar = gui.which_scrollbars[SBAR_RIGHT]; | |
3714 | - win_T *wp; | |
3715 | - | |
3716 | - /* Three cases to think about: | |
3717 | - * 1) Move to top. Open each window at the top. | |
3718 | - * 2) Same stack position. Open each with same position. | |
3719 | - * 3) Open at bottom. Open children with parent's new position. | |
3720 | - */ | |
3721 | - | |
3722 | - old[0] = block[0]; | |
3723 | - swi(Wimp_GetWindowState, 0, old); | |
3724 | - pos_wanted = block[7]; | |
3725 | - swi(Wimp_OpenWindow, 0, block); | |
3726 | - /* Block updated by OpenWindow? I don't think so! */ | |
3727 | - swi(Wimp_GetWindowState, 0, block); | |
3728 | - pos_got = block[7]; | |
3729 | - | |
3730 | - x_offset = block[1] - old[1]; | |
3731 | - y_offset = block[4] - old[4]; | |
3732 | - if (x_offset || y_offset || pos_wanted == -1 || pos_wanted == -2) | |
3733 | - { | |
3734 | - /* If parent has moved, re-open all the child windows. */ | |
3735 | - FOR_ALL_WINDOWS(wp) | |
3736 | - { | |
3737 | - /* Reopen scrollbars for this window. */ | |
3738 | - if (left_bar) | |
3739 | - ro_move_child(wp -> w_scrollbars[SBAR_LEFT].id, | |
3740 | - x_offset, y_offset, | |
3741 | - pos_wanted, pos_got); | |
3742 | - if (right_bar) | |
3743 | - ro_move_child(wp -> w_scrollbars[SBAR_RIGHT].id, | |
3744 | - x_offset, y_offset, | |
3745 | - pos_wanted, pos_got); | |
3746 | - } | |
3747 | - } | |
3748 | - } | |
3749 | - if (changed_mode || toggle_size) | |
3750 | - { | |
3751 | - int width, height; | |
3752 | - | |
3753 | - if (changed_mode) | |
3754 | - ro_measure_tools(); | |
3755 | - block[0] = gui.window_handle; | |
3756 | - swi(Wimp_GetWindowState, 0, block); | |
3757 | - | |
3758 | - width = block[3] - block[1]; | |
3759 | - height = block[4] - block[2]; | |
3760 | - swi(Wimp_ForceRedraw, gui.window_handle, 0, -height, width, 0); | |
3761 | - gui_resize_shell(width, height); | |
3762 | - changed_mode = FALSE; | |
3763 | - } | |
3764 | - } | |
3765 | - | |
3766 | - void | |
3767 | - ro_open_window(block) | |
3768 | - int *block; | |
3769 | - { | |
3770 | - int pos; | |
3771 | - scrollbar_T *sb; | |
3772 | - | |
3773 | - if (block[0] == gui.window_handle) | |
3774 | - ro_open_main(block); | |
3775 | - else | |
3776 | - { | |
3777 | - swi(Wimp_OpenWindow, 0, block); | |
3778 | - if (block[0] != gui.window_handle) | |
3779 | - { | |
3780 | - sb = ro_find_sbar(block[0]); | |
3781 | - if (sb) | |
3782 | - { | |
3783 | - if (sb-> wp != NULL) | |
3784 | - gui_drag_scrollbar(sb, -block[6] / gui.char_height, FALSE); | |
3785 | - else | |
3786 | - gui_drag_scrollbar(sb, block[5] / gui.char_width, FALSE); | |
3787 | - } | |
3788 | - } | |
3789 | - } | |
3790 | - } | |
3791 | - | |
3792 | - void | |
3793 | - ro_menu_selection(block) | |
3794 | - int *block; | |
3795 | - { | |
3796 | - int *item = wimp_menu + 7; | |
3797 | - vimmenu_T *menu; | |
3798 | - /* wimp_menu points to a wimp menu structure */ | |
3799 | - | |
3800 | - for (;;) | |
3801 | - { | |
3802 | - while (block[0]--) | |
3803 | - item += 6; | |
3804 | - if (block[1] == -1) | |
3805 | - break; | |
3806 | - item = ((int *) item[1]) + 7; | |
3807 | - block++; | |
3808 | - } | |
3809 | - /* item points to the wimp menu item structure chosen */ | |
3810 | - menu = (vimmenu_T *) item[5]; | |
3811 | - | |
3812 | - swi(Wimp_GetPointerInfo, 0, block); | |
3813 | - if (block[2] == 1) | |
3814 | - /* Adjust used - keep menu open */ | |
3815 | - swi(Wimp_CreateMenu, 0, wimp_menu); | |
3816 | - | |
3817 | - if (menu-> cb) | |
3818 | - menu-> cb(menu); | |
3819 | - } | |
3820 | - | |
3821 | - void | |
3822 | - ro_open_parent() | |
3823 | - { | |
3824 | - int head; | |
3825 | - char_u *i = curbuf-> b_ffname; | |
3826 | - char_u buffer[256]; | |
3827 | - | |
3828 | - head = 0; | |
3829 | - for (; *i; i++) | |
3830 | - { | |
3831 | - if (*i == '.') | |
3832 | - head = i - curbuf-> b_ffname; | |
3833 | - } | |
3834 | - | |
3835 | - /* Append head chars to buffer */ | |
3836 | - if (head < 240 && curbuf-> b_ffname && head) | |
3837 | - { | |
3838 | - strcpy(buffer, "%filer_opendir "); | |
3839 | - strncpy(buffer + 15, curbuf-> b_ffname, head); | |
3840 | - buffer[15 + head] = '\0'; | |
3841 | - swi(OS_CLI, buffer); | |
3842 | - } | |
3843 | - } | |
3844 | - | |
3845 | - void | |
3846 | - process_event(event, block) | |
3847 | - int event; | |
3848 | - int *block; | |
3849 | - { | |
3850 | - switch (event) | |
3851 | - { | |
3852 | - case 0: /* Nothing - update drag state. */ | |
3853 | - if (ro_dragging) | |
3854 | - ro_continue_drag(block); | |
3855 | - break; | |
3856 | - case 1: /* Redraw window. */ | |
3857 | - redraw_window(block); | |
3858 | - break; | |
3859 | - case 2: /* Open window. */ | |
3860 | - ro_open_window(block); | |
3861 | - break; | |
3862 | - case 3: /* Close window. */ | |
3863 | - swi(Wimp_GetPointerInfo, 0, block + 1); | |
3864 | - if (block[3] == 1) | |
3865 | - ro_open_parent(); | |
3866 | - else | |
3867 | - if (ro_ok_to_quit()) | |
3868 | - ro_quit(); | |
3869 | - break; | |
3870 | - case 6: /* Mouse click. */ | |
3871 | - ro_mouse(block); | |
3872 | - break; | |
3873 | - case 7: /* Finished drag. */ | |
3874 | - ro_drag_finished(block); | |
3875 | - break; | |
3876 | - case 8: /* Key pressed. */ | |
3877 | - ro_insert_key((char_u *) &block[6]); | |
3878 | - break; | |
3879 | - case 9: | |
3880 | - ro_menu_selection(block); | |
3881 | - break; | |
3882 | - case 10: /* Scroll request. */ | |
3883 | - ro_scroll(block); | |
3884 | - break; | |
3885 | - case 11: /* Lose caret. */ | |
3886 | - if (block[0] == gui.window_handle) | |
3887 | - gui_focus_change(FALSE); | |
3888 | - break; | |
3889 | - case 12: /* Gain caret. */ | |
3890 | - if (block[0] == gui.window_handle) | |
3891 | - gui_focus_change(TRUE); | |
3892 | - break; | |
3893 | - case 17: /* User message. */ | |
3894 | - case 18: /* User message recorded. */ | |
3895 | - ro_message(block); | |
3896 | - break; | |
3897 | - } | |
3898 | - } | |
3899 | - | |
3900 | - /* | |
3901 | - * GUI input routine called by gui_wait_for_chars(). Waits for a character | |
3902 | - * from the keyboard. | |
3903 | - * wtime == -1 Wait forever. | |
3904 | - * wtime == 0 This should never happen. | |
3905 | - * wtime > 0 Wait wtime milliseconds for a character. | |
3906 | - * Returns OK if a character was found to be available within the given time, | |
3907 | - * or FAIL otherwise. | |
3908 | - */ | |
3909 | - int | |
3910 | - gui_mch_wait_for_chars(long wtime) | |
3911 | - { | |
3912 | - int block[64]; | |
3913 | - int reason; | |
3914 | - int start_time = -1; | |
3915 | - int ctime = wtime / 10; /* delay in cs */ | |
3916 | - | |
3917 | - if (wtime != -1) | |
3918 | - { | |
3919 | - swi(OS_ReadMonotonicTime); | |
3920 | - start_time = r0; | |
3921 | - } | |
3922 | - | |
3923 | - for (;;) | |
3924 | - { | |
3925 | - if (ro_dragging) | |
3926 | - reason = wimp_poll(0, block); /* Always return immediately */ | |
3927 | - else if (wtime == -1) | |
3928 | - reason = wimp_poll(1, block); | |
3929 | - else | |
3930 | - reason = wimp_pollidle(0, block, start_time + ctime); | |
3931 | - | |
3932 | - process_event(reason, block); | |
3933 | - | |
3934 | - if (input_available() || ro_return_early) | |
3935 | - { | |
3936 | - ro_return_early = FALSE; | |
3937 | - return OK; /* There is something to process (key / menu event) */ | |
3938 | - } | |
3939 | - | |
3940 | - if (wtime != -1) | |
3941 | - { | |
3942 | - swi(OS_ReadMonotonicTime); | |
3943 | - if (r0 - start_time > ctime) | |
3944 | - return FAIL; /* We've been waiting too long - return failure */ | |
3945 | - } | |
3946 | - } | |
3947 | - } | |
3948 | - | |
3949 | - /* Flush any output to the screen */ | |
3950 | - void | |
3951 | - gui_mch_flush(void) | |
3952 | - { | |
3953 | - } | |
3954 | - | |
3955 | - /* | |
3956 | - * Clear a rectangular region of the screen from text pos(row1, col1) to | |
3957 | - * (row2, col2) inclusive. | |
3958 | - */ | |
3959 | - void | |
3960 | - gui_mch_clear_block(int row1, int col1, int row2, int col2) | |
3961 | - { | |
3962 | - swi(ColourTrans_ReturnGCOL, gui.back_pixel << 8, 0, 0, 1<<7, 0); | |
3963 | - plot_rectangle(96 + 5, r0, | |
3964 | - FILL_X(col1), -FILL_Y(row2 + 1), | |
3965 | - FILL_X(col2 + 1), -FILL_Y(row1)); | |
3966 | - } | |
3967 | - | |
3968 | - void | |
3969 | - gui_mch_clear_all(void) | |
3970 | - { | |
3971 | - if (redraw_block) | |
3972 | - { | |
3973 | - swi(ColourTrans_SetGCOL, gui.back_pixel << 8, 0, 0, 1<<7, 0); | |
3974 | - swi(OS_WriteI + 16); | |
3975 | - } | |
3976 | - else | |
3977 | - { | |
3978 | - int block[44]; | |
3979 | - block[0] = gui.window_handle; | |
3980 | - block[1] = 0; | |
3981 | - block[2] = -gui.num_rows * gui.char_height; | |
3982 | - block[3] = gui.num_cols * gui.char_width; | |
3983 | - block[4] = 0; | |
3984 | - swi(Wimp_UpdateWindow, 0, block); | |
3985 | - while (r0) | |
3986 | - { | |
3987 | - swi(ColourTrans_SetGCOL, gui.back_pixel << 8, 0, 0, 1<<7, 0); | |
3988 | - swi(OS_WriteI + 16); | |
3989 | - swi(Wimp_GetRectangle, 0, block); | |
3990 | - } | |
3991 | - } | |
3992 | - } | |
3993 | - | |
3994 | - /* | |
3995 | - * Delete the given number of lines from the given row, scrolling up any | |
3996 | - * text further down within the scroll region. | |
3997 | - */ | |
3998 | - void | |
3999 | - gui_mch_delete_lines(int row, int num_lines) | |
4000 | - { | |
4001 | - int top_from = -row - num_lines; | |
4002 | - int bot_from = -gui.scroll_region_bot - 1; | |
4003 | - int bot_to = bot_from + num_lines; | |
4004 | - | |
4005 | - swi(ColourTrans_SetGCOL, gui.back_pixel << 8, 0, 0, 0x80, 0); | |
4006 | - | |
4007 | - /* Changed without checking! */ | |
4008 | - swi(Wimp_BlockCopy, gui.window_handle, | |
4009 | - gui.scroll_region_left * gui.char_width, | |
4010 | - bot_from * gui.char_height, | |
4011 | - (gui.scroll_region_right - gui.scroll_region_left | |
4012 | - + 1) * gui.char_width, | |
4013 | - top_from * gui.char_height, | |
4014 | - | |
4015 | - gui.scroll_region_left * gui.char_width, | |
4016 | - bot_to * gui.char_height); | |
4017 | - | |
4018 | - gui_clear_block(gui.scroll_region_bot - num_lines + 1, | |
4019 | - gui.scroll_region_left, | |
4020 | - gui.scroll_region_bot, gui.scroll_region_right); | |
4021 | - } | |
4022 | - | |
4023 | - /* | |
4024 | - * Insert the given number of lines before the given row, scrolling down any | |
4025 | - * following text within the scroll region. | |
4026 | - */ | |
4027 | - void | |
4028 | - gui_mch_insert_lines(int row, int num_lines) | |
4029 | - { | |
4030 | - int top_from = -row; | |
4031 | - int bot_to = -gui.scroll_region_bot - 1; | |
4032 | - int bot_from = bot_to + num_lines; | |
4033 | - | |
4034 | - swi(ColourTrans_SetGCOL, gui.back_pixel << 8, 0, 0, 0x80, 0); | |
4035 | - | |
4036 | - swi(Wimp_BlockCopy, gui.window_handle, | |
4037 | - gui.scroll_region_left * gui.char_width, | |
4038 | - bot_from * gui.char_height, | |
4039 | - (gui.scroll_region_right - gui.scroll_region_left | |
4040 | - + 1) * gui.char_width, | |
4041 | - top_from * gui.char_height, | |
4042 | - | |
4043 | - gui.scroll_region_left * gui.char_width, | |
4044 | - bot_to * gui.char_height); | |
4045 | - | |
4046 | - gui_clear_block(row, gui.scroll_region_left, | |
4047 | - row + num_lines - 1, gui.scroll_region_right); | |
4048 | - } | |
4049 | - | |
4050 | - /* Put selection in clipboard buffer. | |
4051 | - * Should we become the new owner? | |
4052 | - */ | |
4053 | - void | |
4054 | - clip_mch_request_selection(VimClipboard *cbd) | |
4055 | - { | |
4056 | - int block[64]; /* Will be used in Wimp_Poll. */ | |
4057 | - int reason; | |
4058 | - char_u *buffer; | |
4059 | - long_u length; | |
4060 | - | |
4061 | - block[0] = 48; /* Size of block. */ | |
4062 | - block[3] = 0; /* Original message. */ | |
4063 | - block[4] = 0x10; /* Data request. */ | |
4064 | - block[5] = gui.window_handle; | |
4065 | - block[6] = RO_LOAD_CLIPBOARD; /* Internal handle. */ | |
4066 | - block[7] = block[8] = 0; /* (x,y) not used. */ | |
4067 | - block[9] = 4; | |
4068 | - block[10] = 0xfff; /* We want text files if possible, I think. */ | |
4069 | - block[11] = -1; /* End of list. */ | |
4070 | - swi(Wimp_SendMessage, 17, block, 0); /* Broadcast request. */ | |
4071 | - | |
4072 | - /* OK, we've sent the request. Poll until we get a null poll (failure) or | |
4073 | - * we load the clipboard. | |
4074 | - * If we receive a DataSave event with icon handle = -2 then put it on the | |
4075 | - * clipboard. RISC OS should ensure that key events will not be delivered | |
4076 | - * until the clipboard operation completes (unless the owner starts idling | |
4077 | - * - we can't wait forever!). | |
4078 | - */ | |
4079 | - for (;;) | |
4080 | - { | |
4081 | - reason = wimp_poll(0, block); | |
4082 | - if (reason == 0) | |
4083 | - return; /* Failed to get clipboard. */ | |
4084 | - if ((reason == 17 || reason == 18) && | |
4085 | - block[4] == 1 && block[6] == RO_LOAD_CLIPBOARD) | |
4086 | - break; /* Got it - stop waiting. */ | |
4087 | - process_event(reason, block); | |
4088 | - if (ro_return_early) | |
4089 | - return; | |
4090 | - } | |
4091 | - /* Tell owner to save data in <Wimp$Scrap>. */ | |
4092 | - block[0] = 60; | |
4093 | - block[3] = block[2]; /* Copy myref -> yourref */ | |
4094 | - block[4] = 2; /* DataSaveAck. */ | |
4095 | - block[9] = -1; /* Data is unsafe. */ | |
4096 | - strcpy( ((char_u *) block) + 44, "<Wimp$Scrap>"); | |
4097 | - swi(Wimp_SendMessage, 17, block, block[1]); | |
4098 | - | |
4099 | - /* Wait again for reply. */ | |
4100 | - for (;;) | |
4101 | - { | |
4102 | - reason = wimp_poll(0, block); | |
4103 | - if (reason == 0) | |
4104 | - return; /* Other program has given up! */ | |
4105 | - if ((reason == 17 || reason == 18) && block[4] == 3 && block[6] == RO_LOAD_CLIPBOARD) | |
4106 | - break; /* Clipboard data saved to <Wimp$Scrap> */ | |
4107 | - process_event(reason, block); | |
4108 | - if (ro_return_early) | |
4109 | - return; | |
4110 | - } | |
4111 | - | |
4112 | - /* <Wimp$Scrap> contains clipboard - load it. */ | |
4113 | - if (xswi(OS_File, 17, "<Wimp$Scrap>") & v_flag) | |
4114 | - return; /* Error! */ | |
4115 | - if (r0 != 1 && r0 != 3) | |
4116 | - return; | |
4117 | - length = r4; | |
4118 | - | |
4119 | - buffer = lalloc(length, TRUE); /* Claim memory (and report errors). */ | |
4120 | - if (buffer == NULL) | |
4121 | - return; | |
4122 | - | |
4123 | - if (xswi(OS_File, 16, "<Wimp$Scrap>", buffer, 0) & v_flag) | |
4124 | - return; | |
4125 | - | |
4126 | - clip_yank_selection(MCHAR, buffer, length, cbd); | |
4127 | - | |
4128 | - vim_free(buffer); | |
4129 | - | |
4130 | - swi(OS_FSControl, 27, "<Wimp$Scrap>", 0, 0); /* Delete temp file. */ | |
4131 | - | |
4132 | - block[4] = 4; /* Send DataLoadAck. */ | |
4133 | - block[3] = block[2]; /* Copy myref -> yourref. */ | |
4134 | - swi(Wimp_SendMessage, 17, block, block[1]); | |
4135 | - } | |
4136 | - | |
4137 | - /* Not sure what this means under RISC OS. */ | |
4138 | - void | |
4139 | - clip_mch_lose_selection(VimClipboard *cbd) | |
4140 | - { | |
4141 | - } | |
4142 | - | |
4143 | - /* Tell everyone that we now own the clipboard. | |
4144 | - * Return OK if our claim is accepted (always, under RISC OS) | |
4145 | - */ | |
4146 | - int | |
4147 | - clip_mch_own_selection(VimClipboard *cbd) | |
4148 | - { | |
4149 | - int block[6]; | |
4150 | - block[0] = 24; /* Length of block. */ | |
4151 | - block[3] = 0; /* Original message. */ | |
4152 | - block[4] = 0xf; /* ClaimEntity. */ | |
4153 | - block[5] = 0x4; /* Claim clipboard only. */ | |
4154 | - swi(Wimp_SendMessage, 17, block, 0); | |
4155 | - return OK; | |
4156 | - } | |
4157 | - | |
4158 | - /* | |
4159 | - * Send the current selection to the clipboard. Do nothing for X because we | |
4160 | - * will fill in the selection only when requested by another app. Sounds good | |
4161 | - * for RISC OS too. | |
4162 | - */ | |
4163 | - void | |
4164 | - clip_mch_set_selection(VimClipboard *cbd) | |
4165 | - { | |
4166 | - clip_get_selection(cbd); | |
4167 | - } | |
4168 | - | |
4169 | - /* | |
4170 | - * Make a menu either grey or not grey. | |
4171 | - */ | |
4172 | - void | |
4173 | - gui_mch_menu_grey(vimmenu_T *menu, int grey) | |
4174 | - { | |
4175 | - menu-> greyed_out = grey; | |
4176 | - } | |
4177 | - | |
4178 | - /* | |
4179 | - * Make menu item hidden or not hidden | |
4180 | - */ | |
4181 | - void | |
4182 | - gui_mch_menu_hidden(vimmenu_T *menu, int hidden) | |
4183 | - { | |
4184 | - menu-> hidden = hidden; | |
4185 | - } | |
4186 | - | |
4187 | - /* | |
4188 | - * This is called after setting all the menus to grey/hidden or not. | |
4189 | - */ | |
4190 | - void | |
4191 | - gui_mch_draw_menubar(void) | |
4192 | - { | |
4193 | - swi(Wimp_CreateMenu, 0, -1); | |
4194 | - if (wimp_menu != (int *) -1) | |
4195 | - { | |
4196 | - ro_remove_menu(wimp_menu); | |
4197 | - wimp_menu = (int *) -1; | |
4198 | - } | |
4199 | - } | |
4200 | - | |
4201 | - /* Add or remove a scrollbar. Note that this is only called when | |
4202 | - * the scrollbar state is changing. | |
4203 | - * The scroll bar window has already been created. | |
4204 | - * We can't do anything except remove the scroll bar | |
4205 | - * until we know what size to use. | |
4206 | - */ | |
4207 | - void | |
4208 | - gui_mch_enable_scrollbar(sb, flag) | |
4209 | - scrollbar_T *sb; | |
4210 | - int flag; | |
4211 | - { | |
4212 | - if (!flag) | |
4213 | - swi(Wimp_CloseWindow, 0, & (sb->id) ); | |
4214 | - return; | |
4215 | - } | |
4216 | - | |
4217 | - void | |
4218 | - gui_mch_set_blinking(long waittime, long on, long off) | |
4219 | - { | |
4220 | - } | |
4221 | - | |
4222 | - /* | |
4223 | - * Stop the cursor blinking. Show the cursor if it wasn't shown. | |
4224 | - */ | |
4225 | - void | |
4226 | - gui_mch_stop_blink(void) | |
4227 | - { | |
4228 | - } | |
4229 | - | |
4230 | - /* | |
4231 | - * Start the cursor blinking. If it was already blinking, this restarts the | |
4232 | - * waiting time and shows the cursor. | |
4233 | - */ | |
4234 | - void | |
4235 | - gui_mch_start_blink(void) | |
4236 | - { | |
4237 | - } | |
4238 | - | |
4239 | - /* | |
4240 | - * Return the RGB value of a pixel as a long. | |
4241 | - */ | |
4242 | - long_u | |
4243 | - gui_mch_get_rgb(guicolor_T pixel) | |
4244 | - { | |
4245 | - return (long_u)pixel; | |
4246 | - } | |
4247 | - | |
4248 | - void | |
4249 | - gui_mch_set_text_area_pos(int x, int y, int w, int h) | |
4250 | - { | |
4251 | - } | |
4252 | - | |
4253 | - void | |
4254 | - gui_mch_enable_menu(int flag) | |
4255 | - { | |
4256 | - } | |
4257 | - | |
4258 | - void | |
4259 | - gui_mch_set_menu_pos(int x, int y, int w, int h) | |
4260 | - { | |
4261 | - } | |
4262 | - | |
4263 | - void | |
4264 | - gui_mch_add_menu(vimmenu_T *menu, int idx) | |
4265 | - { | |
4266 | - } | |
4267 | - | |
4268 | - void | |
4269 | - gui_mch_add_menu_item(vimmenu_T *menu, int idx) | |
4270 | - { | |
4271 | - } | |
4272 | - | |
4273 | - void | |
4274 | - gui_mch_new_menu_colors(void) | |
4275 | - { | |
4276 | - } | |
4277 | - | |
4278 | - void | |
4279 | - gui_mch_destroy_menu(vimmenu_T *menu) | |
4280 | - { | |
4281 | - } | |
4282 | - | |
4283 | - /* Size of buffer has changed. | |
4284 | - * Add one to max since gui.c subtracts one more than it should! | |
4285 | - */ | |
4286 | - void | |
4287 | - gui_mch_set_scrollbar_thumb(sb, val, size, max) | |
4288 | - scrollbar_T *sb; | |
4289 | - long val; | |
4290 | - long size; | |
4291 | - long max; | |
4292 | - { | |
4293 | - int block[10], width, height; | |
4294 | - | |
4295 | - width = (max + 1) * gui.char_width; | |
4296 | - height = (max + 1 + W_STATUS_HEIGHT(sb->wp)) * gui.char_height; | |
4297 | - | |
4298 | - block[0] = block[3] = 0; | |
4299 | - block[1] = -height + (1 << y_eigen_factor); | |
4300 | - block[2] = width; | |
4301 | - | |
4302 | - swi(Wimp_SetExtent, sb -> id, block); | |
4303 | - | |
4304 | - block[0] = sb -> id; | |
4305 | - swi(Wimp_GetWindowState, 0, block); | |
4306 | - block[5] = val * gui.char_width; | |
4307 | - block[6] = -val * gui.char_height; | |
4308 | - swi(Wimp_OpenWindow, 0, block, 0x4b534154, | |
4309 | - gui.window_handle, /* Parent window handle. */ | |
4310 | - (CHILD_FIX_TO_RIGHT << CHILD_LEFT ) | | |
4311 | - (CHILD_FIX_TO_RIGHT << CHILD_RIGHT ) | | |
4312 | - (CHILD_FIX_TO_BOTTOM << CHILD_TOP ) | | |
4313 | - (CHILD_FIX_TO_BOTTOM << CHILD_BOTTOM) | | |
4314 | - (CHILD_SELF_SCROLL << CHILD_SCROLL_X) | | |
4315 | - (CHILD_SELF_SCROLL << CHILD_SCROLL_Y) | |
4316 | - ); | |
4317 | - } | |
4318 | - | |
4319 | - /* Set the position of the scrollbar within the editor | |
4320 | - * window. Note that, for vertical scrollbars, x and w | |
4321 | - * are ignored. For horizontal bars y and h are ignored. | |
4322 | - */ | |
4323 | - void | |
4324 | - gui_mch_set_scrollbar_pos(sb, x, y, w, h) | |
4325 | - scrollbar_T *sb; | |
4326 | - int x; /* Horizontal sb position */ | |
4327 | - int y; /* Top of scroll bar */ | |
4328 | - int w; /* Width */ | |
4329 | - int h; /* Height */ | |
4330 | - { | |
4331 | - int block[24]; | |
4332 | - int px1, py1; /* Parent window min coords */ | |
4333 | - int px2, py2; /* Parent window max coords */ | |
4334 | - | |
4335 | - /* Find where the parent window is. */ | |
4336 | - block[0] = gui.window_handle; | |
4337 | - swi(Wimp_GetWindowState, 0, block); | |
4338 | - px1 = block[1]; | |
4339 | - py1 = block[2]; | |
4340 | - px2 = block[3]; | |
4341 | - py2 = block[4]; | |
4342 | - | |
4343 | - block[0] = sb -> id; | |
4344 | - | |
4345 | - /* Find out how big the scroll window is at the moment. */ | |
4346 | - swi(Wimp_GetWindowInfo, 0, ((char_u *)block) + 1); | |
4347 | - | |
4348 | - if (block[13] < w || block[12] > -h) | |
4349 | - { | |
4350 | - /* Current window is too small! */ | |
4351 | - if (block[12] > -h) | |
4352 | - block[12] = -h; | |
4353 | - if (block[13] < w) | |
4354 | - block[13] = w; | |
4355 | - swi(Wimp_SetExtent, block[0], block + 11); | |
4356 | - } | |
4357 | - | |
4358 | - /* This works better on the nested_wimp. */ | |
4359 | - if (sb-> wp) | |
4360 | - { | |
4361 | - /* This is a vertical scrollbar. */ | |
4362 | - block[1] = block[3] = px2 - gui.scrollbar_width + (1 << x_eigen_factor); | |
4363 | - block[2] = 1 + py2 - (y + h) + (1 << y_eigen_factor); | |
4364 | - block[4] = 1 + py2 - y; | |
4365 | - } | |
4366 | - else | |
4367 | - { | |
4368 | - /* This is a horizontal scrollbar. */ | |
4369 | - block[2] = block[4] = py1 + gui.scrollbar_height; | |
4370 | - block[1] = px1; | |
4371 | - block[3] = px2 - gui.scrollbar_width; | |
4372 | - } | |
4373 | - | |
4374 | - block[5] = 0; | |
4375 | - block[6] = 0; | |
4376 | - block[7] = -1; | |
4377 | - | |
4378 | - swi(Wimp_OpenWindow, 0, block, 0x4b534154, | |
4379 | - gui.window_handle, /* Parent window handle. */ | |
4380 | - (CHILD_FIX_TO_RIGHT << CHILD_LEFT ) | | |
4381 | - (CHILD_FIX_TO_RIGHT << CHILD_RIGHT ) | | |
4382 | - (CHILD_FIX_TO_BOTTOM << CHILD_TOP ) | | |
4383 | - (CHILD_FIX_TO_BOTTOM << CHILD_BOTTOM) | | |
4384 | - (CHILD_SELF_SCROLL << CHILD_SCROLL_X) | | |
4385 | - (CHILD_SELF_SCROLL << CHILD_SCROLL_Y) | |
4386 | - ); | |
4387 | - } | |
4388 | - | |
4389 | - /* Create a window with no workarea to place inside editor window. | |
4390 | - * (what happens without the nested wimp?) | |
4391 | - * Data for scrollbar is invalid. | |
4392 | - */ | |
4393 | - void | |
4394 | - gui_mch_create_scrollbar(sb, orient) | |
4395 | - scrollbar_T *sb; | |
4396 | - int orient; /* orient is SBAR_HORIZ or SBAR_VERT */ | |
4397 | - { | |
4398 | - int bar[] = | |
4399 | - { | |
4400 | - 0, 0, /* Visible area : min X,Y */ | |
4401 | - 100, 100, /* max X,Y */ | |
4402 | - 0, 0, /* Scroll offsets */ | |
4403 | - -1, /* Window in front */ | |
4404 | - 0x80800150 | (orient == SBAR_HORIZ ? (1 << 30) : (1 << 28)), | |
4405 | - 0xff070207, /* Colours */ | |
4406 | - 0x000c0103, /* More colours */ | |
4407 | - 0, -0x4000, /* Workarea extent */ | |
4408 | - 0x4000, 0, /* max X,Y */ | |
4409 | - 0x00000000, /* No title */ | |
4410 | - 0 << 12, /* No workarea button type */ | |
4411 | - 1, /* Wimp sprite area */ | |
4412 | - 0x00010001, /* Minimum width, height */ | |
4413 | - 0, 0, 0, /* Title data (none) */ | |
4414 | - 0 /* No icons */ | |
4415 | - }; | |
4416 | - swi(Wimp_CreateWindow, 0, bar); | |
4417 | - sb -> id = r0; | |
4418 | - } | |
4419 | - | |
4420 | - #if defined(FEAT_WINDOWS) || defined(PROTO) | |
4421 | - void | |
4422 | - gui_mch_destroy_scrollbar(scrollbar_T *sb) | |
4423 | - { | |
4424 | - swi(Wimp_DeleteWindow, 0, & (sb->id)); | |
4425 | - sb -> id = -1; | |
4426 | - } | |
4427 | - #endif | |
4428 | - | |
4429 | - void | |
4430 | - gui_mch_set_scrollbar_colors(scrollbar_T *sb) | |
4431 | - { | |
4432 | - /* Always use default RO colour scheme. */ | |
4433 | - } | |
4434 | - | |
4435 | - /* | |
4436 | - * Get current mouse coordinates in text window. | |
4437 | - * Note: (0,0) is the bottom left corner, positive y is UP. | |
4438 | - */ | |
4439 | - void | |
4440 | - gui_mch_getmouse(x, y) | |
4441 | - int *x; | |
4442 | - int *y; | |
4443 | - { | |
4444 | - int left; | |
4445 | - int top; | |
4446 | - int block[10]; | |
4447 | - | |
4448 | - block[0] = gui.window_handle; | |
4449 | - swi(Wimp_GetWindowState, 0, block); | |
4450 | - left = block[1]; | |
4451 | - top = block[4]; | |
4452 | - | |
4453 | - swi(Wimp_GetPointerInfo, 0, block); | |
4454 | - *x = block[0] - left; | |
4455 | - *y = top - block[1]; | |
4456 | - } | |
4457 | - | |
4458 | - /* MouseTo(x, y) */ | |
4459 | - void | |
4460 | - gui_mch_setmouse(x, y) | |
4461 | - int x; | |
4462 | - int y; | |
4463 | - { | |
4464 | - } | |
4465 | - | |
4466 | - void | |
4467 | - gui_mch_toggle_tearoffs(enable) | |
4468 | - int enable; | |
4469 | - { | |
4470 | - /* no tearoff menus */ | |
4471 | - } | |
4472 | - | |
4473 | - /* Redraw a window's title. | |
4474 | - * For the nested wimp we use the new 'redraw-title-bar' reason code. | |
4475 | - * For older wimps we mark the area of the screen where the title bar | |
4476 | - * is as invalid. | |
4477 | - */ | |
4478 | - void | |
4479 | - ro_redraw_title(window) | |
4480 | - int window; | |
4481 | - { | |
4482 | - if (nested_wimp) | |
4483 | - { | |
4484 | - swi(Wimp_ForceRedraw, window, 0x4b534154, 3); | |
4485 | - } | |
4486 | - else | |
4487 | - { | |
4488 | - int block[10]; | |
4489 | - int miny; | |
4490 | - | |
4491 | - block[0] = window; | |
4492 | - swi(Wimp_GetWindowState, 0, block); | |
4493 | - miny = block[4]; | |
4494 | - swi(Wimp_GetWindowOutline, 0, block); | |
4495 | - swi(Wimp_ForceRedraw, -1, | |
4496 | - block[1], miny, | |
4497 | - block[3], block[4]); | |
4498 | - } | |
4499 | - } | |
4500 | - | |
4501 | - /* Turn a vimmenu_T structure into a wimp menu structure. | |
4502 | - * -1 if resulting menu is empty. | |
4503 | - * Only the children and dname items in the root menu are used. | |
4504 | - */ | |
4505 | - int * | |
4506 | - ro_build_menu(menu) | |
4507 | - vimmenu_T *menu; | |
4508 | - { | |
4509 | - int *wimp_menu; | |
4510 | - int width = 4; | |
4511 | - int w; | |
4512 | - int size = 28; | |
4513 | - vimmenu_T *item; | |
4514 | - int *wimp_item; | |
4515 | - | |
4516 | - /* Find out how big the menu is so we can allocate memory for it */ | |
4517 | - for (item = menu-> children; item; item = item-> next) | |
4518 | - { | |
4519 | - if (item-> hidden == FALSE && !menu_is_separator(item->name)) | |
4520 | - size += 24; | |
4521 | - } | |
4522 | - | |
4523 | - if (size <= 28) | |
4524 | - return (int *) -1; /* No children - shouldn't happen */ | |
4525 | - | |
4526 | - wimp_menu = (int *) alloc(size); | |
4527 | - | |
4528 | - wimp_menu[0] = (int) menu-> dname; | |
4529 | - wimp_menu[1] = -1; | |
4530 | - wimp_menu[2] = 0; | |
4531 | - wimp_menu[3] = 0x00070207; | |
4532 | - wimp_menu[5] = 44; | |
4533 | - wimp_menu[6] = 0; | |
4534 | - | |
4535 | - wimp_item = wimp_menu + 7; | |
4536 | - | |
4537 | - for (item = menu-> children; item; item = item-> next) | |
4538 | - { | |
4539 | - if (menu_is_separator(item-> name)) | |
4540 | - { | |
4541 | - /* This menu entry is actually a separator. If it is not the first | |
4542 | - * menu entry then mark the previous menu item as needing a dotted | |
4543 | - * line after it. | |
4544 | - */ | |
4545 | - if (wimp_item > wimp_menu + 7) | |
4546 | - wimp_item[-6] |= 0x2; | |
4547 | - } | |
4548 | - else if (item-> hidden == FALSE) | |
4549 | - { | |
4550 | - wimp_item[0] = 0; | |
4551 | - wimp_item[1] = item-> children ? (int) ro_build_menu(item) : -1; | |
4552 | - wimp_item[2] = 0x07009131 | (item-> greyed_out << 22); | |
4553 | - wimp_item[3] = (int) item-> dname; | |
4554 | - wimp_item[4] = -1; | |
4555 | - wimp_item[5] = (int) item; /* Stuff the menu address in this unused space */ | |
4556 | - | |
4557 | - w = strlen(item-> dname) + 1; | |
4558 | - if (w > width) | |
4559 | - width = w; | |
4560 | - wimp_item += 6; | |
4561 | - } | |
4562 | - } | |
4563 | - | |
4564 | - wimp_menu[4] = (width + 2) * 16; | |
4565 | - wimp_menu[7] |= 0x100; /* Menu title is indirected */ | |
4566 | - wimp_item[-6] |= 0x080; /* Last entry in menu */ | |
4567 | - return wimp_menu; | |
4568 | - } | |
4569 | - | |
4570 | - static void | |
4571 | - ro_remove_menu(menu) | |
4572 | - int *menu; | |
4573 | - { | |
4574 | - int *item = menu + 7; | |
4575 | - | |
4576 | - if (menu == NULL || menu == (int *) -1) | |
4577 | - return; | |
4578 | - | |
4579 | - for (;;) | |
4580 | - { | |
4581 | - if (item[1] != -1) | |
4582 | - ro_remove_menu((int *) item[1]); /* Remove sub-menu */ | |
4583 | - if (item[0] & 0x80) | |
4584 | - break; /* This was the last entry */ | |
4585 | - item += 6; | |
4586 | - } | |
4587 | - vim_free(menu); | |
4588 | - } | |
4589 | - | |
4590 | - void | |
4591 | - gui_mch_show_popupmenu(menu) | |
4592 | - vimmenu_T *menu; | |
4593 | - { | |
4594 | - int block[10]; | |
4595 | - | |
4596 | - /* Remove the existing menu, if any */ | |
4597 | - if (wimp_menu != (int *) -1) | |
4598 | - { | |
4599 | - swi(Wimp_CreateMenu, 0, -1); | |
4600 | - ro_remove_menu(wimp_menu); | |
4601 | - wimp_menu = (int *) -1; | |
4602 | - } | |
4603 | - | |
4604 | - wimp_menu = ro_build_menu(menu); | |
4605 | - if (wimp_menu != (int *) -1) | |
4606 | - { | |
4607 | - swi(Wimp_GetPointerInfo, 0, block); | |
4608 | - swi(Wimp_CreateMenu, 0, wimp_menu, block[0] - 64, block[1] + 64); | |
4609 | - } | |
4610 | - } | |
4611 | - | |
4612 | - /* Run a command using the TaskWindow module. | |
4613 | - * If SHELL_FILTER is set then output is not echoed to the screen, | |
4614 | - * If it is not set, then \r is not sent to the output file. | |
4615 | - */ | |
4616 | - int | |
4617 | - gui_mch_call_shell(cmd, options) | |
4618 | - char_u *cmd; | |
4619 | - int options; /* SHELL_FILTER if called by do_filter() */ | |
4620 | - /* SHELL_COOKED if term needs cooked mode */ | |
4621 | - { | |
4622 | - char_u task_cmd[256]; /* Contains *TaskWindow command. */ | |
4623 | - int block[64]; | |
4624 | - int reason; | |
4625 | - char_u *out; | |
4626 | - char_u c; | |
4627 | - int old_msg_col; | |
4628 | - char_u *out_redir; | |
4629 | - int length; | |
4630 | - FILE *out_file = NULL; | |
4631 | - | |
4632 | - out_redir = strstr(cmd, " > "); | |
4633 | - if (out_redir == NULL) | |
4634 | - length = strlen(cmd); /* No redirection. */ | |
4635 | - else | |
4636 | - { | |
4637 | - length = out_redir - cmd; | |
4638 | - out_file = fopen(out_redir + 3, "wb"); | |
4639 | - if (out_file == NULL) | |
4640 | - smsg("WARNING : Can't open file %s for writing\n", out_redir + 3); | |
4641 | - } | |
4642 | - | |
4643 | - if (length > 180) | |
4644 | - { | |
4645 | - if (out_file) | |
4646 | - fclose(out_file); | |
4647 | - return FAIL; /* Command too long. */ | |
4648 | - } | |
4649 | - | |
4650 | - strcpy(task_cmd, "TaskWindow \""); | |
4651 | - strncpy(task_cmd + 12, cmd, length); | |
4652 | - sprintf(task_cmd + 12 + length, | |
4653 | - "\" -task &%08x -ctrl -quit -name \"Vim command\"", | |
4654 | - task_handle); | |
4655 | - | |
4656 | - if (options & SHELL_COOKED) | |
4657 | - settmode(TMODE_COOK); | |
4658 | - | |
4659 | - if (xswi(Wimp_StartTask, task_cmd) & v_flag) | |
4660 | - { | |
4661 | - /* Failed to even start a new task (out of memory?) */ | |
4662 | - settmode(TMODE_RAW); | |
4663 | - if (out_file) | |
4664 | - fclose(out_file); | |
4665 | - return FAIL; | |
4666 | - } | |
4667 | - | |
4668 | - /* Wait for the child process to initialise. */ | |
4669 | - child_handle = 0; | |
4670 | - while (!child_handle) | |
4671 | - { | |
4672 | - reason = wimp_poll(0, block); | |
4673 | - if ((reason == 17 || reason == 18) && block[4] == 0x808c2) | |
4674 | - child_handle = block[1]; | |
4675 | - else | |
4676 | - process_event(reason, block); | |
4677 | - } | |
4678 | - | |
4679 | - /* Block until finished */ | |
4680 | - while (child_handle) | |
4681 | - { | |
4682 | - reason = wimp_poll(1, block); | |
4683 | - if (reason == 3 || (reason == 8 && block[6] == 3)) | |
4684 | - { | |
4685 | - /* Close window request or CTRL-C - kill child task. */ | |
4686 | - block[0] = 20; | |
4687 | - block[3] = 0; | |
4688 | - block[4] = 0x808c4; /* Morite */ | |
4689 | - swi(Wimp_SendMessage, 17, block, child_handle); | |
4690 | - MSG_PUTS(_("\nSending message to terminate child process.\n")); | |
4691 | - continue; | |
4692 | - } | |
4693 | - else if (reason == 8) | |
4694 | - { | |
4695 | - block[0] = 28; | |
4696 | - block[3] = 0; | |
4697 | - block[4] = 0x808c0; /* Input */ | |
4698 | - block[5] = 1; | |
4699 | - /* Block[6] is OK as it is! */ | |
4700 | - swi(Wimp_SendMessage, 17, block, child_handle); | |
4701 | - continue; | |
4702 | - } | |
4703 | - else if (reason == 17 || reason == 18) | |
4704 | - { | |
4705 | - if (block[4] == 0x808c1) | |
4706 | - { | |
4707 | - /* Ack message. */ | |
4708 | - block[3] = block[2]; | |
4709 | - swi(Wimp_SendMessage, 19, block, block[1]); | |
4710 | - out = (char_u *)block + 24; | |
4711 | - old_msg_col = msg_col; | |
4712 | - while (block[5]--) | |
4713 | - { | |
4714 | - c = *out++; | |
4715 | - if (out_file && (c != '\r' || (options & SHELL_FILTER))) | |
4716 | - fputc(c, out_file); | |
4717 | - if ((options & SHELL_FILTER) == 0) | |
4718 | - { | |
4719 | - if (c == 127) | |
4720 | - msg_puts("\b \b"); | |
4721 | - else if (c > 31) | |
4722 | - msg_putchar(c); | |
4723 | - else if (c == 10) | |
4724 | - { | |
4725 | - lines_left = 8; /* Don't do More prompt! */ | |
4726 | - msg_putchar(10); | |
4727 | - } | |
4728 | - } | |
4729 | - } | |
4730 | - /* Flush output to the screen. */ | |
4731 | - windgoto(msg_row, msg_col); | |
4732 | - out_flush(); | |
4733 | - continue; | |
4734 | - } | |
4735 | - } | |
4736 | - process_event(reason, block); | |
4737 | - } | |
4738 | - msg_putchar('\n'); | |
4739 | - settmode(TMODE_RAW); | |
4740 | - if (out_file) | |
4741 | - fclose(out_file); | |
4742 | - return OK; | |
4743 | - } | |
4744 | - | |
4745 | - /* Like strsave(), but stops at any control char */ | |
4746 | - char_u * | |
4747 | - wimp_strsave(str) | |
4748 | - char *str; | |
4749 | - { | |
4750 | - int strlen = 0; | |
4751 | - char_u *retval; | |
4752 | - while (str[strlen] > 31) | |
4753 | - strlen++; | |
4754 | - retval = alloc(strlen + 1); | |
4755 | - if (retval) | |
4756 | - { | |
4757 | - memcpy(retval, str, strlen); | |
4758 | - retval[strlen] = '\0'; | |
4759 | - } | |
4760 | - return retval; | |
4761 | - } | |
4762 | - | |
4763 | - /* If we are saving then pop up a standard RISC OS save box. | |
4764 | - * Otherwise, open a directory viewer on the given directory (and return NULL) | |
4765 | - * The string we return will be freed later. | |
4766 | - */ | |
4767 | - char_u * | |
4768 | - gui_mch_browse(saving, title, dflt, ext, initdir, filter) | |
4769 | - int saving; /* write action */ | |
4770 | - char_u *title; /* title for the window */ | |
4771 | - char_u *dflt; /* default file name */ | |
4772 | - char_u *ext; /* extension added */ | |
4773 | - char_u *initdir; /* initial directory, NULL for current dir */ | |
4774 | - char_u *filter; /* file name filter */ | |
4775 | - { | |
4776 | - char command[256]; | |
4777 | - int length; | |
4778 | - | |
4779 | - if (saving) | |
4780 | - { | |
4781 | - int block[64]; | |
4782 | - int reason; | |
4783 | - int done_save = FALSE; | |
4784 | - char_u *retval = NULL; | |
4785 | - char_u *sprname; | |
4786 | - char_u *fname; | |
4787 | - int dragging_icon = FALSE; | |
4788 | - int filetype; | |
4789 | - | |
4790 | - if (!dflt) | |
4791 | - dflt = "TextFile"; | |
4792 | - | |
4793 | - block[0] = save_window; | |
4794 | - block[1] = 0; | |
4795 | - swi(Wimp_GetIconState, 0, block); | |
4796 | - sprname = ((char_u *) block[7]); | |
4797 | - block[1] = 1; | |
4798 | - swi(Wimp_GetIconState, 0, block); | |
4799 | - fname = ((char *) block[7]); | |
4800 | - strncpy(fname, dflt, 255); | |
4801 | - | |
4802 | - if (xswi(OS_FSControl, 31, curbuf->b_p_oft) & v_flag) | |
4803 | - { | |
4804 | - filetype = 0xfff; | |
4805 | - strcpy(sprname + 5, "xxx"); | |
4806 | - } | |
4807 | - else | |
4808 | - { | |
4809 | - filetype = r2; | |
4810 | - sprintf(sprname + 5, "%03x", filetype); | |
4811 | - } | |
4812 | - | |
4813 | - /* Open the save box */ | |
4814 | - | |
4815 | - swi(Wimp_GetPointerInfo, 0, block); | |
4816 | - swi(Wimp_CreateMenu, 0, save_window, block[0] - 64, block[1] + 64); | |
4817 | - swi(Wimp_SetCaretPosition, save_window, 1, 0, 0, -1, -1); | |
4818 | - | |
4819 | - while (!done_save) | |
4820 | - { | |
4821 | - reason = wimp_poll(1, block); | |
4822 | - switch (reason) | |
4823 | - { | |
4824 | - case 1: | |
4825 | - redraw_window(block); | |
4826 | - break; | |
4827 | - case 2: | |
4828 | - if (block[0] == save_window) | |
4829 | - swi(Wimp_OpenWindow, 0, block); | |
4830 | - else | |
4831 | - ro_open_window(block); | |
4832 | - break; | |
4833 | - case 3: | |
4834 | - done_save = TRUE; | |
4835 | - break; | |
4836 | - case 6: | |
4837 | - if (block[3] != save_window) | |
4838 | - done_save = TRUE; | |
4839 | - else | |
4840 | - { | |
4841 | - int drag_box[4]; | |
4842 | - int min_x, max_y; | |
4843 | - | |
4844 | - switch (block[4]) | |
4845 | - { | |
4846 | - case 0: /* Start drag */ | |
4847 | - block[0] = save_window; | |
4848 | - swi(Wimp_GetWindowState, 0, block); | |
4849 | - min_x = block[1]; | |
4850 | - max_y = block[4]; | |
4851 | - block[1] = 0; | |
4852 | - swi(Wimp_GetIconState, 0, block); | |
4853 | - drag_box[0] = block[2] + min_x; | |
4854 | - drag_box[1] = block[3] + max_y; | |
4855 | - drag_box[2] = block[4] + min_x; | |
4856 | - drag_box[3] = block[5] + max_y; | |
4857 | - | |
4858 | - swi(DragASprite_Start, | |
4859 | - 0x45, | |
4860 | - 1, | |
4861 | - sprname, | |
4862 | - drag_box); | |
4863 | - dragging_icon = TRUE; | |
4864 | - break; | |
4865 | - case 2: /* OK */ | |
4866 | - retval = wimp_strsave(fname); | |
4867 | - done_save = TRUE; | |
4868 | - break; | |
4869 | - case 3: /* Cancel */ | |
4870 | - done_save = TRUE; | |
4871 | - break; | |
4872 | - } | |
4873 | - } | |
4874 | - break; | |
4875 | - case 7: | |
4876 | - if (dragging_icon) | |
4877 | - { | |
4878 | - int len = 0; | |
4879 | - | |
4880 | - dragging_icon = FALSE; | |
4881 | - swi(Wimp_GetPointerInfo, 0, block); | |
4882 | - block[5] = block[3]; | |
4883 | - block[6] = block[4]; | |
4884 | - block[7] = block[0]; | |
4885 | - block[8] = block[1]; | |
4886 | - block[9] = 0; /* Don't know the size */ | |
4887 | - block[10] = filetype; | |
4888 | - | |
4889 | - while (fname[len] > 31) | |
4890 | - { | |
4891 | - if (fname[len] == '.') | |
4892 | - { | |
4893 | - fname += len + 1; | |
4894 | - len = 0; | |
4895 | - } | |
4896 | - else | |
4897 | - len++; | |
4898 | - } | |
4899 | - if (len > 211) | |
4900 | - len = 211; | |
4901 | - | |
4902 | - memcpy(((char_u *) block) + 44, fname, len); | |
4903 | - ((char_u *)block)[44 + len] = '\0'; | |
4904 | - | |
4905 | - block[0] = (len + 48) & 0xfc; | |
4906 | - block[3] = 0; | |
4907 | - block[4] = 1; /* DataSave */ | |
4908 | - | |
4909 | - swi(Wimp_SendMessage, 17, block, block[5], block[6]); | |
4910 | - } | |
4911 | - else | |
4912 | - ro_drag_finished(block); | |
4913 | - break; | |
4914 | - case 8: | |
4915 | - if (block[6] == 13) | |
4916 | - { | |
4917 | - retval = wimp_strsave(fname); | |
4918 | - done_save = TRUE; | |
4919 | - } | |
4920 | - else if (block[6] == 0x1b) | |
4921 | - done_save = TRUE; | |
4922 | - else | |
4923 | - swi(Wimp_ProcessKey, block[6]); | |
4924 | - break; | |
4925 | - case 17: | |
4926 | - case 18: | |
4927 | - if (block[4] == 2 && block[9] != -1) | |
4928 | - { | |
4929 | - /* DataSaveAck from dragging icon. */ | |
4930 | - retval = wimp_strsave(((char_u *) block) + 44); | |
4931 | - done_save = TRUE; | |
4932 | - } | |
4933 | - else if (block[4] == 0x400c9) | |
4934 | - { | |
4935 | - /* MenusDeleted */ | |
4936 | - done_save = TRUE; | |
4937 | - } | |
4938 | - else | |
4939 | - ro_message(block); | |
4940 | - break; | |
4941 | - } | |
4942 | - } | |
4943 | - block[0] = save_window; | |
4944 | - swi(Wimp_CloseWindow, 0, block); | |
4945 | - swi(Wimp_GetCaretPosition, 0, block); | |
4946 | - if (block[0] == -1) | |
4947 | - swi(Wimp_SetCaretPosition, gui.window_handle, -1, 0, 0, -1, -1); | |
4948 | - | |
4949 | - return retval; | |
4950 | - } | |
4951 | - else if (initdir) | |
4952 | - { | |
4953 | - /* Open a directory viewer */ | |
4954 | - length = strlen(initdir); | |
4955 | - | |
4956 | - if (length > 240) | |
4957 | - return NULL; /* Path too long! */ | |
4958 | - | |
4959 | - length = sprintf(command, "Filer_OpenDir %s", initdir); | |
4960 | - while (command[length - 1] == '.') | |
4961 | - length--; | |
4962 | - command[length] = '\0'; | |
4963 | - swi(OS_CLI, command); | |
4964 | - } | |
4965 | - return NULL; | |
4966 | - } | |
4967 | --- 0 ---- | |
4968 | *** ../vim-7.3.186/src/os_riscos.c 2010-08-15 21:57:27.000000000 +0200 | |
4969 | --- src/os_riscos.c 1970-01-01 01:00:00.000000000 +0100 | |
4970 | *************** | |
4971 | *** 1,1292 **** | |
4972 | - /* vi:set ts=8 sts=4 sw=4: | |
4973 | - * | |
4974 | - * VIM - Vi IMproved by Bram Moolenaar | |
4975 | - * | |
4976 | - * Do ":help uganda" in Vim to read copying and usage conditions. | |
4977 | - * Do ":help credits" in Vim to see a list of people who contributed. | |
4978 | - * See README.txt for an overview of the Vim source code. | |
4979 | - */ | |
4980 | - | |
4981 | - #include "vim.h" | |
4982 | - | |
4983 | - /* | |
4984 | - * os_riscos.c | |
4985 | - * | |
4986 | - * Thomas Leonard <tal197@ecs.soton.ac.uk> | |
4987 | - */ | |
4988 | - | |
4989 | - const char *__dynamic_da_name = "Vim heap"; /* Enable and name our dynamic area */ | |
4990 | - int ro_line_mode = TRUE; /* For Ex mode we much echo chars to the screen ourselves */ | |
4991 | - int windowed; /* Flag - are we running inside a text window? */ | |
4992 | - int WinLeft, WinTop; /* We might be started inside a text window */ | |
4993 | - int ScrollTop; /* Make cursor movements relative to ScrollTop. */ | |
4994 | - | |
4995 | - int old_escape_state = -1; | |
4996 | - int old_cursor_state = -1; | |
4997 | - | |
4998 | - #define rgb(r,g,b) ((b<<24) + (g<<16) + (r<<8)) | |
4999 | - #define NORMAL_FG 0x00000000 | |
5000 | - #define NORMAL_BG 0xffffffff | |
5001 | - | |
5002 | - /* Convert a DOS colour number to an RGB palette entry. | |
5003 | - * Mappings from X11 rgb/txt file. | |
5004 | - */ | |
5005 | - static int | |
5006 | - map_colour(dos) | |
5007 | - int dos; /* Standard DOS colour number. */ | |
5008 | - { | |
5009 | - switch (dos) | |
5010 | - { | |
5011 | - case 0: return 0; /* Black */ | |
5012 | - case 1: return rgb(0,0,139); /* DarkBlue */ | |
5013 | - case 2: return rgb(0,100,0); /* DarkGreen */ | |
5014 | - case 3: return rgb(0,139,139); /* DarkCyan */ | |
5015 | - case 4: return rgb(139,0,0); /* DarkRed */ | |
5016 | - case 5: return rgb(139,0,139); /* DarkMagenta */ | |
5017 | - case 6: return rgb(165,42,42); /* Brown, DarkYellow */ | |
5018 | - case 7: return rgb(211,211,211); /* LightGray, LightGrey, Gray, Grey */ | |
5019 | - case 8: return rgb(169,169,169); /* DarkGray, DarkGrey */ | |
5020 | - case 9: return rgb(173,216,230); /* Blue, LightBlue */ | |
5021 | - case 10: return rgb(144,238,144); /* Green, LightGreen */ | |
5022 | - case 11: return rgb(224,255,255); /* Cyan, LightCyan */ | |
5023 | - case 12: return rgb(255,0,0); /* Red, LightRed */ | |
5024 | - case 13: return rgb(255,0,255); /* Magenta, LightMagenta */ | |
5025 | - case 14: return rgb(255,255,0); /* Yellow, LightYellow */ | |
5026 | - case 15: return rgb(255,255,255); /* White */ | |
5027 | - } | |
5028 | - return rgb(100,100,100); | |
5029 | - } | |
5030 | - | |
5031 | - static void | |
5032 | - text_fg(fg) | |
5033 | - int fg; /* Foregound colour in the form &BBGGRR00 */ | |
5034 | - { | |
5035 | - xswi(ColourTrans_SetTextColour, fg, 0, 0, 0); | |
5036 | - } | |
5037 | - | |
5038 | - static void | |
5039 | - text_bg(bg) | |
5040 | - int bg; /* Backgound colour in the form &BBGGRR00 */ | |
5041 | - { | |
5042 | - xswi(ColourTrans_SetTextColour, bg, 0, 0, 1 << 7); | |
5043 | - } | |
5044 | - | |
5045 | - #define OUT_NORMAL 0 | |
5046 | - #define OUT_NUMBER 1 /* Reading in a number */ | |
5047 | - | |
5048 | - void | |
5049 | - mch_write(s, len) | |
5050 | - char_u *s; | |
5051 | - int len; | |
5052 | - { | |
5053 | - static int mode = OUT_NORMAL; | |
5054 | - static int x, y; /* For reading numbers in. */ | |
5055 | - | |
5056 | - if (!term_console) | |
5057 | - { | |
5058 | - /* Maybe we are running Vim remotely - don't interpret chars */ | |
5059 | - while (len--) | |
5060 | - { | |
5061 | - char_u c = *s++; | |
5062 | - swi(OS_WriteC, c); | |
5063 | - /* We might need to send a CR too. This shouldn't | |
5064 | - * hurt if we don't need it, should it? | |
5065 | - */ | |
5066 | - if (c == 10) | |
5067 | - swi(OS_WriteI + 13); | |
5068 | - } | |
5069 | - return; | |
5070 | - } | |
5071 | - | |
5072 | - while (len--) | |
5073 | - { | |
5074 | - char_u c = *s++; | |
5075 | - switch (mode) | |
5076 | - { | |
5077 | - case OUT_NUMBER: | |
5078 | - if (c < '0' || c > '9') | |
5079 | - { | |
5080 | - mode = OUT_NORMAL; | |
5081 | - } | |
5082 | - else | |
5083 | - { | |
5084 | - x = (x * 10) + c - '0'; | |
5085 | - continue; | |
5086 | - } | |
5087 | - /* note: no break here! */ | |
5088 | - | |
5089 | - case OUT_NORMAL: | |
5090 | - switch (c) | |
5091 | - { | |
5092 | - case 1: | |
5093 | - /* Number (in decimal) follows. */ | |
5094 | - mode = OUT_NUMBER; | |
5095 | - y = x; | |
5096 | - x = 0; | |
5097 | - break; | |
5098 | - case 2: | |
5099 | - /* Position cursor. */ | |
5100 | - swi(OS_WriteI + 31); | |
5101 | - swi(OS_WriteC, x); | |
5102 | - swi(OS_WriteC, y - ScrollTop); | |
5103 | - break; | |
5104 | - case 3: | |
5105 | - /* Set scroll region. */ | |
5106 | - if (x == Rows -1 && y == 0 && !windowed) | |
5107 | - { | |
5108 | - /* Whole screen - remove text window. | |
5109 | - * This is MUCH faster. | |
5110 | - */ | |
5111 | - swi(OS_WriteI + 26); | |
5112 | - } | |
5113 | - else | |
5114 | - { | |
5115 | - /* Create a text window. */ | |
5116 | - swi(OS_WriteI + 28); | |
5117 | - swi(OS_WriteC, WinLeft); | |
5118 | - swi(OS_WriteC, WinTop + x); | |
5119 | - swi(OS_WriteC, WinLeft + Columns - 1); | |
5120 | - swi(OS_WriteC, WinTop + y); | |
5121 | - } | |
5122 | - ScrollTop = y; | |
5123 | - break; | |
5124 | - case 4: | |
5125 | - /* Normal mode. */ | |
5126 | - text_fg(NORMAL_FG); | |
5127 | - text_bg(NORMAL_BG); | |
5128 | - break; | |
5129 | - case 5: | |
5130 | - /* Reverse mode. */ | |
5131 | - text_fg(NORMAL_BG); | |
5132 | - text_bg(NORMAL_FG); | |
5133 | - break; | |
5134 | - case 10: | |
5135 | - swi(OS_NewLine); | |
5136 | - break; | |
5137 | - case 14: | |
5138 | - /* Cursor invisible. */ | |
5139 | - swi(OS_WriteN, | |
5140 | - "\027\001\000\000\000\000\000\000\000\000", | |
5141 | - 10); | |
5142 | - break; | |
5143 | - case 15: | |
5144 | - /* Cursor visible. */ | |
5145 | - swi(OS_WriteN, | |
5146 | - "\027\001\002\000\000\000\000\000\000\000", | |
5147 | - 10); | |
5148 | - break; | |
5149 | - case 16: | |
5150 | - /* Cursor very visible (flash) */ | |
5151 | - swi(OS_WriteN, | |
5152 | - "\027\001\003\000\000\000\000\000\000\000", | |
5153 | - 10); | |
5154 | - case 17: | |
5155 | - /* Set foreground colour. */ | |
5156 | - text_fg(map_colour(x)); | |
5157 | - break; | |
5158 | - case 18: | |
5159 | - /* Set background colour. */ | |
5160 | - text_bg(map_colour(x)); | |
5161 | - break; | |
5162 | - case 19: | |
5163 | - /* Scroll text down. */ | |
5164 | - swi(OS_WriteN, | |
5165 | - "\027\007\000\002\000\000\000\000\000\000", | |
5166 | - 10); | |
5167 | - break; | |
5168 | - default: | |
5169 | - swi(OS_WriteC, c); | |
5170 | - } | |
5171 | - continue; | |
5172 | - | |
5173 | - default: | |
5174 | - printf("[output error]"); | |
5175 | - mode = OUT_NORMAL; | |
5176 | - } | |
5177 | - } | |
5178 | - } | |
5179 | - | |
5180 | - /* | |
5181 | - * mch_inchar(): low level input funcion. | |
5182 | - * Get a characters from the keyboard. | |
5183 | - * Return the number of characters that are available. | |
5184 | - * If wtime == 0 do not wait for characters. | |
5185 | - * If wtime == n wait n msecs for characters. | |
5186 | - * If wtime == -1 wait forever for characters. | |
5187 | - * | |
5188 | - * TODO: call convert_input() for 'fileencoding' to 'encoding' conversion. | |
5189 | - */ | |
5190 | - int | |
5191 | - mch_inchar(buf, maxlen, wtime, tb_change_cnt) | |
5192 | - char_u *buf; | |
5193 | - int maxlen; | |
5194 | - long wtime; | |
5195 | - int tb_change_cnt; | |
5196 | - { | |
5197 | - int got=0; | |
5198 | - unsigned int start_time = clock(); | |
5199 | - | |
5200 | - if (ro_line_mode) | |
5201 | - { | |
5202 | - /* We're probably in Ex mode - get whole lines at a time. */ | |
5203 | - | |
5204 | - static char_u line_buffer[256]; | |
5205 | - static int remaining_chars = 0; | |
5206 | - static int buf_pos = 0; | |
5207 | - | |
5208 | - /* Do we need to fetch another line? */ | |
5209 | - if (remaining_chars == 0) | |
5210 | - { | |
5211 | - int old_esc_state; | |
5212 | - swi(OS_Byte, 200, 1, 0xfe); | |
5213 | - old_esc_state = r1; | |
5214 | - | |
5215 | - buf_pos = 0; | |
5216 | - if (xswi(OS_ReadLine, line_buffer, 255, 0, 255) & (c_flag | v_flag)) | |
5217 | - { | |
5218 | - got_int = TRUE; /* ESC pressed */ | |
5219 | - r1 = 0; | |
5220 | - } | |
5221 | - line_buffer[r1] = 13; | |
5222 | - remaining_chars = r1 + 1; /* Count CR as part of input */ | |
5223 | - | |
5224 | - swi(OS_Byte, 200, old_esc_state, 0); | |
5225 | - } | |
5226 | - | |
5227 | - /* Can we send the rest of the buffer back in one go? */ | |
5228 | - if (remaining_chars <= maxlen) | |
5229 | - { | |
5230 | - int got = remaining_chars; | |
5231 | - | |
5232 | - memcpy(buf, line_buffer + buf_pos, got); | |
5233 | - remaining_chars = 0; | |
5234 | - return got; | |
5235 | - } | |
5236 | - | |
5237 | - /* Send as much as we can */ | |
5238 | - memcpy(buf, line_buffer + buf_pos, maxlen); | |
5239 | - buf_pos += maxlen; | |
5240 | - remaining_chars -= maxlen; | |
5241 | - | |
5242 | - return maxlen; | |
5243 | - } | |
5244 | - | |
5245 | - if (!term_console) | |
5246 | - { | |
5247 | - /* Use OS_ReadC for all input. | |
5248 | - * Avoids problems with remote access getting interference from | |
5249 | - * the keyboard. | |
5250 | - */ | |
5251 | - if (wtime == 0) | |
5252 | - return 0; /* Ignore quick key checks */ | |
5253 | - | |
5254 | - if (xswi(OS_ReadC) & c_flag) | |
5255 | - { | |
5256 | - got_int = TRUE; /* ESC pressed - can this happen? */ | |
5257 | - swi(OS_Byte, 124); /* Clear Escape state */ | |
5258 | - r0 = 0x1b; /* It *might* not have been Escape! */ | |
5259 | - } | |
5260 | - buf[0] = r0; | |
5261 | - return 1; | |
5262 | - } | |
5263 | - | |
5264 | - /* | |
5265 | - * OK, here's the plan: | |
5266 | - * | |
5267 | - * 1) Wait until wtime expires or we get a key | |
5268 | - * 2) Get keys until the keyboard buffer is empty or buf is full | |
5269 | - */ | |
5270 | - | |
5271 | - while (xswi(OS_Byte,145,0) & c_flag) | |
5272 | - { | |
5273 | - /* Nothing at all in the keyboard buffer. | |
5274 | - * Has our time expired yet? | |
5275 | - */ | |
5276 | - if ( (wtime != -1) && (clock() - start_time) >= wtime ) | |
5277 | - return 0; /* Nothing read - giving up */ | |
5278 | - } | |
5279 | - | |
5280 | - /* We've got one char (in r2) - are there any more? */ | |
5281 | - | |
5282 | - while (got < maxlen) | |
5283 | - { | |
5284 | - buf[got++] = r2; | |
5285 | - | |
5286 | - if (xswi(OS_Byte,145,0) & c_flag) | |
5287 | - return got; /* Keyboard buffer empty */ | |
5288 | - } | |
5289 | - return got; /* buf is full */ | |
5290 | - } | |
5291 | - | |
5292 | - /* | |
5293 | - * return non-zero if a character is available | |
5294 | - */ | |
5295 | - int | |
5296 | - mch_char_avail() | |
5297 | - { | |
5298 | - if (!term_console) | |
5299 | - return 0; /* Can't tell */ | |
5300 | - if (xswi(OS_Byte, 152, 0) & c_flag) | |
5301 | - return 0; | |
5302 | - return 1; | |
5303 | - } | |
5304 | - | |
5305 | - /* Find out how much free memory we have. | |
5306 | - * I don't know how to work this out exactly but, since we can claim | |
5307 | - * more memory from the OS, let's just report the free pool size. | |
5308 | - * Dynamic area 6 doesn't exist pre 3.6 according to StrongHelp, so | |
5309 | - * we'll use Wimp_SlotSize. If that fails (outside the desktop?) | |
5310 | - * then just return a big number and hope. | |
5311 | - */ | |
5312 | - long_u | |
5313 | - mch_avail_mem(special) | |
5314 | - int special; | |
5315 | - { | |
5316 | - if (xswi(Wimp_SlotSize, -1, -1) & v_flag) | |
5317 | - return 0x7fffffff; | |
5318 | - return r2; | |
5319 | - } | |
5320 | - | |
5321 | - void | |
5322 | - mch_delay(msec, ignoreinput) | |
5323 | - long msec; | |
5324 | - int ignoreinput; | |
5325 | - { | |
5326 | - int start_time, time_now; | |
5327 | - int csec = msec / 10; | |
5328 | - | |
5329 | - swi(OS_ReadMonotonicTime); | |
5330 | - start_time = r0; | |
5331 | - | |
5332 | - for (;;) | |
5333 | - { | |
5334 | - swi(OS_ReadMonotonicTime); | |
5335 | - time_now = r0; | |
5336 | - if (time_now - start_time > csec) | |
5337 | - return; | |
5338 | - #ifdef FEAT_GUI | |
5339 | - /* In the GUI, allow other programs to run while waiting. */ | |
5340 | - if (gui.in_use) | |
5341 | - gui_mch_wait_for_chars(start_time + csec); | |
5342 | - #endif | |
5343 | - } | |
5344 | - } | |
5345 | - | |
5346 | - /* | |
5347 | - * If the machine has job control, use it to suspend the program, | |
5348 | - * otherwise fake it by starting a new shell. | |
5349 | - */ | |
5350 | - void | |
5351 | - mch_suspend() | |
5352 | - { | |
5353 | - suspend_shell(); | |
5354 | - } | |
5355 | - | |
5356 | - void | |
5357 | - mch_init() | |
5358 | - { | |
5359 | - /* | |
5360 | - * Read window size first. Calls to mch_get_shellsize() will | |
5361 | - * simply return these values in future so that setting the | |
5362 | - * text window (used for scrolling) won't give strange results. | |
5363 | - */ | |
5364 | - | |
5365 | - int buf[7] = {132, 135, 256, 257, 1, 2, -1}; | |
5366 | - | |
5367 | - /* Command windows are no longer forced open, since if we are | |
5368 | - * in the desktop then we'll use the GUI version. | |
5369 | - * Opening a command window here messes up the GUI version startup | |
5370 | - */ | |
5371 | - #ifndef FEAT_GUI | |
5372 | - swi(OS_WriteI); | |
5373 | - #endif | |
5374 | - swi(OS_ReadVduVariables, buf, buf); | |
5375 | - WinLeft = buf[0]; | |
5376 | - WinTop = buf[1]; | |
5377 | - Columns = buf[2]; | |
5378 | - Rows = buf[3] + 1; /* Seems to be one off (VduVars wrong?) */ | |
5379 | - ScrollTop = 0; | |
5380 | - | |
5381 | - /* Are we running in a textwindow? */ | |
5382 | - if (Rows == buf[5] + 1 && Columns == buf[4] + 1) | |
5383 | - windowed = 0; | |
5384 | - else | |
5385 | - windowed = 1; | |
5386 | - | |
5387 | - /* Choose a nice colour scheme. */ | |
5388 | - text_fg(NORMAL_FG); | |
5389 | - text_bg(NORMAL_BG); | |
5390 | - } | |
5391 | - | |
5392 | - /* | |
5393 | - * Check_win checks whether we have an interactive stdout. | |
5394 | - */ | |
5395 | - /* ARGSUSED */ | |
5396 | - int | |
5397 | - mch_check_win(argc, argv) | |
5398 | - int argc; | |
5399 | - char **argv; | |
5400 | - { | |
5401 | - return OK; | |
5402 | - } | |
5403 | - | |
5404 | - /* | |
5405 | - * Return TRUE if the input comes from a terminal, FALSE otherwise. | |
5406 | - */ | |
5407 | - int | |
5408 | - mch_input_isatty() | |
5409 | - { | |
5410 | - if (xswi(OS_ChangeRedirection, -1, -1) & v_flag) | |
5411 | - return TRUE; /* Error - TRUE is probably correct though */ | |
5412 | - if (r0 == 0) | |
5413 | - return TRUE; | |
5414 | - return FALSE; | |
5415 | - } | |
5416 | - | |
5417 | - #ifdef FEAT_TITLE | |
5418 | - int | |
5419 | - mch_can_restore_title() | |
5420 | - { | |
5421 | - return FALSE; | |
5422 | - } | |
5423 | - | |
5424 | - int | |
5425 | - mch_can_restore_icon() | |
5426 | - { | |
5427 | - return FALSE; | |
5428 | - } | |
5429 | - | |
5430 | - | |
5431 | - /* | |
5432 | - * Set the window title and icon. | |
5433 | - */ | |
5434 | - void | |
5435 | - mch_settitle(title, icon) | |
5436 | - char_u *title; | |
5437 | - char_u *icon; | |
5438 | - { | |
5439 | - if (title == NULL) | |
5440 | - title = (char_u *) "<untitled>"; | |
5441 | - #ifdef FEAT_GUI | |
5442 | - if (gui.in_use && strcmp(title, gui.window_title)) | |
5443 | - { | |
5444 | - int length; | |
5445 | - length = strlen(title); | |
5446 | - if (length >= gui.window_title_size) | |
5447 | - length = gui.window_title_size - 1; | |
5448 | - strncpy(gui.window_title, title, length); | |
5449 | - gui.window_title[length] = 0; | |
5450 | - ro_redraw_title(gui.window_handle); | |
5451 | - } | |
5452 | - #endif | |
5453 | - return; | |
5454 | - } | |
5455 | - | |
5456 | - /* | |
5457 | - * Restore the window/icon title. | |
5458 | - * "which" is one of: | |
5459 | - * 1 only restore title | |
5460 | - * 2 only restore icon | |
5461 | - * 3 restore title and icon | |
5462 | - */ | |
5463 | - void | |
5464 | - mch_restore_title(which) | |
5465 | - int which; | |
5466 | - { | |
5467 | - return; | |
5468 | - } | |
5469 | - #endif | |
5470 | - | |
5471 | - /* | |
5472 | - * Insert user name in s[len]. | |
5473 | - * Return OK if a name found. | |
5474 | - */ | |
5475 | - int | |
5476 | - mch_get_user_name(s, len) | |
5477 | - char_u *s; | |
5478 | - int len; | |
5479 | - { | |
5480 | - /* RISC OS doesn't support user names. */ | |
5481 | - *s = NUL; | |
5482 | - return FAIL; | |
5483 | - } | |
5484 | - | |
5485 | - /* | |
5486 | - * Insert host name in s[len]. | |
5487 | - */ | |
5488 | - | |
5489 | - void | |
5490 | - mch_get_host_name(s, len) | |
5491 | - char_u *s; | |
5492 | - int len; | |
5493 | - { | |
5494 | - if (xswi(OS_ReadVarVal, "Machine$Name", s, len, 0, 3) & v_flag) | |
5495 | - { | |
5496 | - /* Variable does not exist (normal operation) */ | |
5497 | - vim_strncpy(s, "(unknown)", len - 1); | |
5498 | - } | |
5499 | - } | |
5500 | - | |
5501 | - /* | |
5502 | - * return process ID | |
5503 | - */ | |
5504 | - long | |
5505 | - mch_get_pid() | |
5506 | - { | |
5507 | - if (xswi(Wimp_ReadSysInfo, 5) & v_flag) | |
5508 | - return 0; | |
5509 | - return r0; | |
5510 | - } | |
5511 | - | |
5512 | - /* | |
5513 | - * Get name of current directory into buffer 'buf' of length 'len' bytes. | |
5514 | - * Return OK for success, FAIL for failure. | |
5515 | - */ | |
5516 | - int | |
5517 | - mch_dirname(buf, len) | |
5518 | - char_u *buf; | |
5519 | - int len; | |
5520 | - { | |
5521 | - if (xswi(OS_FSControl, 37, "@", buf, 0, 0, len) & v_flag) | |
5522 | - return FAIL; | |
5523 | - return OK; | |
5524 | - } | |
5525 | - | |
5526 | - /* | |
5527 | - * Get absolute file name into buffer 'buf' of length 'len' bytes. | |
5528 | - * | |
5529 | - * return FAIL for failure, OK for success | |
5530 | - */ | |
5531 | - int | |
5532 | - mch_FullName(fname, buf, len, force) | |
5533 | - char_u *fname, *buf; | |
5534 | - int len; | |
5535 | - int force; /* Also expand when already absolute path name. | |
5536 | - * Not used under RISC OS. | |
5537 | - */ | |
5538 | - { | |
5539 | - if (xswi(OS_FSControl, 37, fname, buf, 0, 0, len) & v_flag) | |
5540 | - return FAIL; | |
5541 | - return OK; | |
5542 | - } | |
5543 | - | |
5544 | - /* | |
5545 | - * Return TRUE if "fname" does not depend on the current directory. | |
5546 | - */ | |
5547 | - int | |
5548 | - mch_isFullName(fname) | |
5549 | - char_u *fname; | |
5550 | - { | |
5551 | - if (strstr(fname, "::") && strstr(fname,".$.")) | |
5552 | - return TRUE; | |
5553 | - return FALSE; | |
5554 | - } | |
5555 | - | |
5556 | - /* | |
5557 | - * Get file permissions for 'name'. | |
5558 | - * Returns -1 when it doesn't exist. | |
5559 | - */ | |
5560 | - long | |
5561 | - mch_getperm(name) | |
5562 | - char_u *name; | |
5563 | - { | |
5564 | - struct stat statb; | |
5565 | - | |
5566 | - if (stat((char *)name, &statb)) | |
5567 | - return -1; | |
5568 | - return statb.st_mode; | |
5569 | - } | |
5570 | - | |
5571 | - /* | |
5572 | - * set file permission for 'name' to 'perm' | |
5573 | - * | |
5574 | - * return FAIL for failure, OK otherwise | |
5575 | - */ | |
5576 | - int | |
5577 | - mch_setperm(name, perm) | |
5578 | - char_u *name; | |
5579 | - long perm; | |
5580 | - { | |
5581 | - return (chmod((char *)name, (mode_t)perm) == 0 ? OK : FAIL); | |
5582 | - } | |
5583 | - | |
5584 | - /* | |
5585 | - * Set hidden flag for "name". | |
5586 | - */ | |
5587 | - /* ARGSUSED */ | |
5588 | - void | |
5589 | - mch_hide(name) | |
5590 | - char_u *name; | |
5591 | - { | |
5592 | - /* can't hide a file */ | |
5593 | - } | |
5594 | - | |
5595 | - /* | |
5596 | - * return TRUE if "name" is a directory | |
5597 | - * return FALSE if "name" is not a directory | |
5598 | - * return FALSE for error | |
5599 | - */ | |
5600 | - int | |
5601 | - mch_isdir(name) | |
5602 | - char_u *name; | |
5603 | - { | |
5604 | - if (xswi(OS_File, 17, name) & v_flag) | |
5605 | - return FALSE; | |
5606 | - if (r0 == 2 || r0 == 3) | |
5607 | - return TRUE; /* Count image files as directories. */ | |
5608 | - return FALSE; | |
5609 | - } | |
5610 | - | |
5611 | - /* | |
5612 | - * Return 1 if "name" can be executed, 0 if not. | |
5613 | - * Return -1 if unknown. Requires which to work. | |
5614 | - */ | |
5615 | - int | |
5616 | - mch_can_exe(name) | |
5617 | - char_u *name; | |
5618 | - { | |
5619 | - char_u *buf; | |
5620 | - char_u *p; | |
5621 | - int retval; | |
5622 | - | |
5623 | - buf = alloc((unsigned)STRLEN(name) + 7); | |
5624 | - if (buf == NULL) | |
5625 | - return -1; | |
5626 | - sprintf((char *)buf, "which %s", name); | |
5627 | - p = get_cmd_output(buf, NULL, SHELL_SILENT); | |
5628 | - vim_free(buf); | |
5629 | - if (p == NULL) | |
5630 | - return -1; | |
5631 | - /* result can be: "name: Command not found" */ | |
5632 | - retval = (*p != NUL && strstr((char *)p, "not found") == NULL); | |
5633 | - vim_free(p); | |
5634 | - return retval; | |
5635 | - } | |
5636 | - | |
5637 | - /* | |
5638 | - * Check what "name" is: | |
5639 | - * NODE_NORMAL: file or directory (or doesn't exist) | |
5640 | - * NODE_WRITABLE: writable device, socket, fifo, etc. | |
5641 | - * NODE_OTHER: non-writable things | |
5642 | - */ | |
5643 | - int | |
5644 | - mch_nodetype(name) | |
5645 | - char_u *name; | |
5646 | - { | |
5647 | - /* TODO */ | |
5648 | - return NODE_NORMAL; | |
5649 | - } | |
5650 | - | |
5651 | - void | |
5652 | - mch_early_init() | |
5653 | - { | |
5654 | - /* Turn off all the horrible filename munging in UnixLib. */ | |
5655 | - int __riscosify_control = __RISCOSIFY_NO_PROCESS; | |
5656 | - } | |
5657 | - | |
5658 | - void | |
5659 | - mch_exit(r) | |
5660 | - int r; | |
5661 | - { | |
5662 | - settmode(TMODE_COOK); | |
5663 | - exiting = TRUE; | |
5664 | - out_flush(); | |
5665 | - ml_close_all(TRUE); /* remove all memfiles */ | |
5666 | - | |
5667 | - #ifdef FEAT_GUI | |
5668 | - if (gui.in_use) | |
5669 | - gui_exit(r); | |
5670 | - #endif | |
5671 | - swi(OS_NewLine); | |
5672 | - if (old_escape_state != -1) | |
5673 | - swi(OS_Byte, 229, old_escape_state, 0); | |
5674 | - if (old_cursor_state != -1) | |
5675 | - swi(OS_Byte, 4, old_cursor_state); | |
5676 | - exit(r); | |
5677 | - } | |
5678 | - | |
5679 | - void | |
5680 | - mch_settmode(tmode) | |
5681 | - int tmode; /* TMODE_RAW or TMODE_COOK */ | |
5682 | - { | |
5683 | - if (tmode == TMODE_COOK) | |
5684 | - { | |
5685 | - ro_line_mode = TRUE; | |
5686 | - return; | |
5687 | - } | |
5688 | - | |
5689 | - ro_line_mode = FALSE; | |
5690 | - | |
5691 | - if (term_console) | |
5692 | - { | |
5693 | - /* Block cursor. */ | |
5694 | - swi(OS_WriteN, | |
5695 | - "\027\000\012\000\000\000\000\000\000\000", | |
5696 | - 10); | |
5697 | - | |
5698 | - /* Disable the standard cursor key actions. */ | |
5699 | - swi(OS_Byte, 4, 1); | |
5700 | - if (old_cursor_state == -1) | |
5701 | - old_cursor_state = r1; | |
5702 | - } | |
5703 | - | |
5704 | - /* Stop Escape from quitting Vim! */ | |
5705 | - swi(OS_Byte, 229, 1, 0); | |
5706 | - if (old_escape_state == -1) | |
5707 | - old_escape_state = r1; | |
5708 | - } | |
5709 | - | |
5710 | - /* | |
5711 | - * set mouse clicks on or off (only works for xterms) | |
5712 | - */ | |
5713 | - void | |
5714 | - mch_setmouse(on) | |
5715 | - int on; | |
5716 | - { | |
5717 | - } | |
5718 | - | |
5719 | - /* | |
5720 | - * set screen mode, always fails. | |
5721 | - */ | |
5722 | - /* ARGSUSED */ | |
5723 | - int | |
5724 | - mch_screenmode(arg) | |
5725 | - char_u *arg; | |
5726 | - { | |
5727 | - EMSG(_(e_screenmode)); | |
5728 | - return FAIL; | |
5729 | - } | |
5730 | - | |
5731 | - /* | |
5732 | - * Try to get the current window size. | |
5733 | - * Return OK when size could be determined, FAIL otherwise. | |
5734 | - * Simply return results stored by mch_init() if we are the | |
5735 | - * machine's console. If not, we don't know how big the screen is. | |
5736 | - */ | |
5737 | - int | |
5738 | - mch_get_shellsize() | |
5739 | - { | |
5740 | - /* if size changed: screenalloc will allocate new screen buffers */ | |
5741 | - return term_console ? OK : FAIL; | |
5742 | - } | |
5743 | - | |
5744 | - /* | |
5745 | - * Can't change the size. | |
5746 | - * Assume the user knows what he's doing and use the new values. | |
5747 | - */ | |
5748 | - void | |
5749 | - mch_set_shellsize() | |
5750 | - { | |
5751 | - /* Assume the user knows what he's doing and use the new values. */ | |
5752 | - } | |
5753 | - | |
5754 | - /* | |
5755 | - * Rows and/or Columns has changed. | |
5756 | - */ | |
5757 | - void | |
5758 | - mch_new_shellsize() | |
5759 | - { | |
5760 | - /* Nothing to do. */ | |
5761 | - } | |
5762 | - | |
5763 | - int | |
5764 | - mch_call_shell(cmd, options) | |
5765 | - char_u *cmd; | |
5766 | - int options; /* SHELL_*, see vim.h */ | |
5767 | - { | |
5768 | - int retval; | |
5769 | - int tmode = cur_tmode; | |
5770 | - | |
5771 | - if (cmd == NULL) | |
5772 | - cmd = (char_u *) "GOS"; | |
5773 | - | |
5774 | - #ifdef FEAT_GUI | |
5775 | - if (gui.in_use) | |
5776 | - return gui_mch_call_shell(cmd, options); | |
5777 | - #endif | |
5778 | - if (options & SHELL_COOKED) | |
5779 | - settmode(TMODE_COOK); /* set to normal mode */ | |
5780 | - MSG_PUTS("\n"); | |
5781 | - | |
5782 | - /* I don't even want to think about what UnixLib must | |
5783 | - * be doing to allow this to work... | |
5784 | - */ | |
5785 | - retval = system(cmd); | |
5786 | - if (retval && !(options & SHELL_SILENT)) | |
5787 | - EMSG(strerror(EOPSYS)); /* Doesn't seem to set errno? */ | |
5788 | - | |
5789 | - swi(OS_Byte, 229, 1, 0); /* Re-disable escape */ | |
5790 | - if (tmode == TMODE_RAW) | |
5791 | - settmode(TMODE_RAW); /* set to raw mode */ | |
5792 | - return retval ? FAIL : OK; | |
5793 | - } | |
5794 | - | |
5795 | - /* | |
5796 | - * Check for Escape being pressed right now. | |
5797 | - * [ different if !term_console? ] | |
5798 | - */ | |
5799 | - void | |
5800 | - mch_breakcheck() | |
5801 | - { | |
5802 | - if (xswi(OS_Byte, 121, 0xf0) & v_flag) | |
5803 | - return; | |
5804 | - if (r1 == 0xff) | |
5805 | - { | |
5806 | - got_int = TRUE; | |
5807 | - swi(OS_Byte, 15, 1); /* Flush input buffer */ | |
5808 | - } | |
5809 | - } | |
5810 | - | |
5811 | - /* | |
5812 | - * Recursively expand one path component into all matching files and/or | |
5813 | - * directories. | |
5814 | - * "path" has backslashes before chars that are not to be expanded. | |
5815 | - * Return the number of matches found. | |
5816 | - */ | |
5817 | - int | |
5818 | - mch_expandpath(gap, path, flags) | |
5819 | - garray_T *gap; /* Grow array for results. */ | |
5820 | - char_u *path; | |
5821 | - int flags; /* EW_* flags */ | |
5822 | - { | |
5823 | - int got; /* Number of matches. */ | |
5824 | - char_u *pattern; | |
5825 | - | |
5826 | - /* Plan: | |
5827 | - * | |
5828 | - * 1) Get first part of path - no wildcards | |
5829 | - * 2) Get next path element (wildcarded) | |
5830 | - * 3) Get rest of path | |
5831 | - * | |
5832 | - * If (3) is nothing then only the leaf is wildcarded - add to gap | |
5833 | - * Otherwise call recursively for each path in (2), passing (3) | |
5834 | - * | |
5835 | - * This is just the header function. | |
5836 | - */ | |
5837 | - | |
5838 | - /* We must be able to modifiy path, so make a copy */ | |
5839 | - pattern = vim_strsave(path); | |
5840 | - if (pattern == NULL) | |
5841 | - return 0; | |
5842 | - got = expand_section(gap, (char_u *)"", pattern, flags); | |
5843 | - vim_free(pattern); | |
5844 | - return got; | |
5845 | - } | |
5846 | - | |
5847 | - /* | |
5848 | - * expand_section(gap, "$.Dir1.Dir2", "ABBA*.myleaf##") | |
5849 | - * | |
5850 | - * calls expand_section(gap, "$.Dir1.Dir2.ABBA_Gold", "myleaf##") | |
5851 | - * and expand_section(gap, "$.Dir1.Dir2.ABBA_Live", "myleaf##") | |
5852 | - * | |
5853 | - * If rest is just a leaf then all matches are added to gap. | |
5854 | - * | |
5855 | - * Returns number of items added to gap. | |
5856 | - */ | |
5857 | - int | |
5858 | - expand_section(gap, root, rest, flags) | |
5859 | - garray_T *gap; | |
5860 | - char_u *root; /* Non-wildcarded path to search */ | |
5861 | - char_u *rest; /* Wildcarded remainder of path */ | |
5862 | - int flags; /* Add dirs/files/missing objects. */ | |
5863 | - { | |
5864 | - static char_u buf[MAXPATHL]; /* Temporary buffer. */ | |
5865 | - char_u dir[MAXPATHL]; | |
5866 | - int start_element = -1; /* Start of wildcarded element */ | |
5867 | - char_u c; | |
5868 | - int i; | |
5869 | - int got, dir_pos; | |
5870 | - int buflen; /* Chars used in buf[] */ | |
5871 | - int colon = 0; /* Dir ends in ':' */ | |
5872 | - | |
5873 | - buflen = strlen(root); | |
5874 | - STRNCPY(buf, root, buflen); /* Copy root into buffer. */ | |
5875 | - | |
5876 | - /* | |
5877 | - * Find end of nonwildcarded section. | |
5878 | - * Count ':' as a path sep since Vim:Bug* is a valid pathname. | |
5879 | - */ | |
5880 | - | |
5881 | - for (i = 0; c = rest[i]; i++) | |
5882 | - { | |
5883 | - if (c == PATHSEP) | |
5884 | - { | |
5885 | - start_element = i; | |
5886 | - colon = 0; | |
5887 | - } | |
5888 | - if (c == ':') | |
5889 | - { | |
5890 | - start_element = i + 1; | |
5891 | - colon = 1; | |
5892 | - } | |
5893 | - if (c == '#' || c == '*') | |
5894 | - break; | |
5895 | - } | |
5896 | - if (c == 0) | |
5897 | - start_element = i; | |
5898 | - | |
5899 | - /* | |
5900 | - * start_element +> terminator for non-wildcarded section. | |
5901 | - * Transfer this bit into buf. | |
5902 | - */ | |
5903 | - if (buflen + start_element + 4 >= MAXPATHL) | |
5904 | - return 0; /* Buffer full */ | |
5905 | - if (start_element >= 0) | |
5906 | - { | |
5907 | - if (*root && !colon) | |
5908 | - buf[buflen++] = PATHSEP; | |
5909 | - strncpy(buf + buflen, rest, start_element); | |
5910 | - buflen += start_element; | |
5911 | - } | |
5912 | - buf[buflen] = 0; | |
5913 | - | |
5914 | - /* | |
5915 | - * Did we reach the end of the string without hitting any wildcards? | |
5916 | - */ | |
5917 | - if (c == 0) | |
5918 | - { | |
5919 | - /* Yes - add combined path to grow array and return. */ | |
5920 | - addfile(gap, buf, flags); | |
5921 | - return 1; | |
5922 | - } | |
5923 | - | |
5924 | - if (start_element < 0 || !colon) | |
5925 | - start_element++; | |
5926 | - rest += start_element; | |
5927 | - | |
5928 | - /* | |
5929 | - * rest does contain wildcards if we get here. | |
5930 | - * | |
5931 | - * Now : have we reached the leaf names part yet? | |
5932 | - * If so, add all matches (files and dirs) to gap. | |
5933 | - * If not, get next path element and scan all matching directories. | |
5934 | - */ | |
5935 | - | |
5936 | - start_element = -1; | |
5937 | - for (i = 0; rest[i]; i++) | |
5938 | - { | |
5939 | - if (rest[i] == '.') | |
5940 | - { | |
5941 | - start_element = i; | |
5942 | - rest[i] = 0; /* Break string here. */ | |
5943 | - break; | |
5944 | - } | |
5945 | - } | |
5946 | - | |
5947 | - /* If start_element is -1 then we are matching leaf names */ | |
5948 | - | |
5949 | - r3 = 0; /* Number of objs read. */ | |
5950 | - dir_pos = 0; /* Position through directory. */ | |
5951 | - got = 0; /* Files added so far. */ | |
5952 | - while (dir_pos != -1) | |
5953 | - { | |
5954 | - buf[buflen] = 0; | |
5955 | - if (xswi(OS_GBPB, 9, | |
5956 | - buf, /* Directory to scan. */ | |
5957 | - buf + buflen + (1 - colon), /* Buffer for result. */ | |
5958 | - 1, /* Number of objects to read. */ | |
5959 | - dir_pos, /* Search position. */ | |
5960 | - MAXPATHL - 2 - buflen, /* Size of result buffer. */ | |
5961 | - rest) /* Wildcarded leafname. */ | |
5962 | - & v_flag) | |
5963 | - { | |
5964 | - EMSG(r0 + 4); | |
5965 | - r4 = -1; | |
5966 | - } | |
5967 | - dir_pos = r4; /* r4 corrupted by addfile() */ | |
5968 | - if (r3 > 0) | |
5969 | - { | |
5970 | - char_u *path = buf; | |
5971 | - if (buflen == 0) | |
5972 | - path++; /* Don't do '.File' */ | |
5973 | - else if (!colon) | |
5974 | - buf[buflen] = '.'; /* Join path and leaf */ | |
5975 | - | |
5976 | - /* Path -> full path of object found */ | |
5977 | - if (start_element == -1) | |
5978 | - { | |
5979 | - addfile(gap, path, flags); | |
5980 | - got++; | |
5981 | - } | |
5982 | - else | |
5983 | - { | |
5984 | - /* Scan into subdirectories and images; ignore files */ | |
5985 | - swi(OS_File, 17, path); | |
5986 | - if (r0 == 2 || r0 == 3) | |
5987 | - got += expand_section(gap, | |
5988 | - path, | |
5989 | - rest + start_element + 1, | |
5990 | - flags); | |
5991 | - } | |
5992 | - } | |
5993 | - } | |
5994 | - | |
5995 | - /* Restore the dot if we removed it. */ | |
5996 | - if (start_element >= 0) | |
5997 | - rest[start_element] = '.'; | |
5998 | - return got; | |
5999 | - } | |
6000 | - | |
6001 | - /* | |
6002 | - * mch_expand_wildcards() - this code does wild-card pattern matching using | |
6003 | - * the shell. It isn't used under RISC OS. | |
6004 | - * | |
6005 | - * return OK for success, FAIL for error (you may lose some memory) and put | |
6006 | - * an error message in *file. | |
6007 | - * | |
6008 | - * num_pat is number of input patterns | |
6009 | - * pat is array of pointers to input patterns | |
6010 | - * num_file is pointer to number of matched file names | |
6011 | - * file is pointer to array of pointers to matched file names | |
6012 | - */ | |
6013 | - int | |
6014 | - mch_expand_wildcards(num_pat, pat, num_file, file, flags) | |
6015 | - int num_pat; | |
6016 | - char_u **pat; | |
6017 | - int *num_file; | |
6018 | - char_u ***file; | |
6019 | - int flags; /* EW_* flags */ | |
6020 | - { | |
6021 | - /* This doesn't get called unless SPECIAL_WILDCHAR is defined. */ | |
6022 | - return FAIL; | |
6023 | - } | |
6024 | - | |
6025 | - /* | |
6026 | - * Return TRUE if "p" contains wildcards which can be expanded by | |
6027 | - * mch_expandpath(). | |
6028 | - */ | |
6029 | - int | |
6030 | - mch_has_exp_wildcard(p) | |
6031 | - char_u *p; | |
6032 | - { | |
6033 | - if (vim_strpbrk((char_u *)"*#", p)) | |
6034 | - return TRUE; | |
6035 | - return FALSE; | |
6036 | - } | |
6037 | - | |
6038 | - /* Return TRUE if "p" contains wildcards. */ | |
6039 | - int | |
6040 | - mch_has_wildcard(p) | |
6041 | - char_u *p; | |
6042 | - { | |
6043 | - if (vim_strpbrk((char_u *)"*#`", p)) | |
6044 | - return TRUE; | |
6045 | - return FALSE; | |
6046 | - } | |
6047 | - | |
6048 | - int /* see Unix unlink(2) */ | |
6049 | - mch_remove(file) | |
6050 | - char_u *file; /* Name of file to delete. */ | |
6051 | - { | |
6052 | - if (xswi(OS_FSControl, 27, file, 0, 0) & v_flag) | |
6053 | - return EXIT_FAILURE; | |
6054 | - return EXIT_SUCCESS; | |
6055 | - } | |
6056 | - | |
6057 | - /* Try to make existing scripts work without modification. | |
6058 | - * Return a pointer to the new string (freed by caller), or NULL | |
6059 | - * | |
6060 | - * Two main cases: | |
6061 | - * - Absolute : $VIM/syntax/help.vim | |
6062 | - * - Relative : Adfs::4.$.!Vim.Resources.Syntax/help.vim | |
6063 | - */ | |
6064 | - char_u * | |
6065 | - mch_munge_fname(fname) | |
6066 | - char_u *fname; | |
6067 | - { | |
6068 | - char_u c; | |
6069 | - int len; | |
6070 | - char_u *retval; | |
6071 | - | |
6072 | - retval = fname = vim_strsave(fname); | |
6073 | - if (fname == NULL) | |
6074 | - return NULL; | |
6075 | - | |
6076 | - if (strncmp(fname, "$VIM/", 5) == 0) | |
6077 | - { | |
6078 | - strncpy(fname, "Vim:", 4); | |
6079 | - for (fname += 5; c = *fname; fname++) | |
6080 | - { | |
6081 | - if (c == '.') | |
6082 | - break; | |
6083 | - if (c == '/') | |
6084 | - fname[-1] = '.'; | |
6085 | - else | |
6086 | - fname[-1] = c; | |
6087 | - } | |
6088 | - fname[-1] = '\0'; | |
6089 | - } | |
6090 | - else | |
6091 | - { | |
6092 | - /* Check to see if the file exists without modification. */ | |
6093 | - if (xswi(OS_File, 17, fname) & v_flag) | |
6094 | - r0 == 0; /* Invalid filename? */ | |
6095 | - if (r0) | |
6096 | - return retval; | |
6097 | - | |
6098 | - len = strlen(fname); | |
6099 | - if (strcmp(fname + len - 4, ".vim") == 0) | |
6100 | - { | |
6101 | - fname[len - 4] = '\0'; | |
6102 | - for (; c = *fname; fname++) | |
6103 | - { | |
6104 | - if (c == '/') | |
6105 | - *fname = '.'; | |
6106 | - } | |
6107 | - } | |
6108 | - } | |
6109 | - return retval; | |
6110 | - } | |
6111 | - | |
6112 | - /* QuickFix reads munged names from the error file. | |
6113 | - * Correct them. | |
6114 | - */ | |
6115 | - int | |
6116 | - ro_buflist_add(old_name) | |
6117 | - char_u *old_name; /* Name of file found by quickfix */ | |
6118 | - { | |
6119 | - char_u *fname; | |
6120 | - char_u *leaf; /* Pointer to start of leaf in old_name */ | |
6121 | - char_u *ptr; | |
6122 | - char_u c; | |
6123 | - int retval; | |
6124 | - | |
6125 | - if (old_name == NULL) | |
6126 | - return buflist_add(NULL, 0); | |
6127 | - | |
6128 | - /* Copy the name so we can mess around with it. */ | |
6129 | - fname = vim_strsave(old_name); | |
6130 | - if (fname == NULL) | |
6131 | - /* Out of memory - can't modify name */ | |
6132 | - return buflist_add(old_name, 0); | |
6133 | - | |
6134 | - /* Change `dir/main.c' into `dir.c.main' */ | |
6135 | - leaf = fname; | |
6136 | - for (ptr = fname; c = *ptr; ptr++) | |
6137 | - { | |
6138 | - if (c == '/') | |
6139 | - { | |
6140 | - leaf = ptr + 1; | |
6141 | - *ptr = '.'; | |
6142 | - } | |
6143 | - else if (c == '.') | |
6144 | - break; | |
6145 | - } | |
6146 | - if (c == '.') | |
6147 | - { | |
6148 | - /* Change `main.c' into `c.main' | |
6149 | - * | | | |
6150 | - * leaf ptr | |
6151 | - */ | |
6152 | - ptr += old_name - fname; | |
6153 | - *ptr = '\0'; | |
6154 | - sprintf(leaf, | |
6155 | - "%s.%s", | |
6156 | - ptr + 1, | |
6157 | - leaf - fname + old_name); | |
6158 | - } | |
6159 | - | |
6160 | - retval = buflist_add(fname, 0); | |
6161 | - free(fname); | |
6162 | - return retval; | |
6163 | - } | |
6164 | - | |
6165 | - /* Change the current directory. | |
6166 | - * Strip trailing dots to make it easier to use with filename completion. | |
6167 | - * Return 0 for success, -1 for failure. | |
6168 | - */ | |
6169 | - int | |
6170 | - mch_chdir(dir) | |
6171 | - char_u *dir; | |
6172 | - { | |
6173 | - int length; | |
6174 | - int retval; | |
6175 | - char_u *new_dir; | |
6176 | - | |
6177 | - if (p_verbose >= 5) | |
6178 | - { | |
6179 | - verbose_enter(); | |
6180 | - smsg((char_u *)"chdir(%s)", dir); | |
6181 | - verbose_leave(); | |
6182 | - } | |
6183 | - length = strlen(dir); | |
6184 | - if (dir[length - 1] != '.') | |
6185 | - return chdir(dir); /* No trailing dots - nothing to do. */ | |
6186 | - new_dir = vim_strsave(dir); | |
6187 | - if (new_dir == NULL) | |
6188 | - return chdir(dir); /* Can't allocate memory. */ | |
6189 | - | |
6190 | - while (new_dir[--length] == '.') | |
6191 | - new_dir[length] = '\0'; | |
6192 | - | |
6193 | - retval = chdir(new_dir); | |
6194 | - vim_free(new_dir); | |
6195 | - return retval; | |
6196 | - } | |
6197 | - | |
6198 | - /* Examine the named file, and set the 'osfiletype' option | |
6199 | - * (in curbuf) to the file's type. | |
6200 | - */ | |
6201 | - void | |
6202 | - mch_read_filetype(file) | |
6203 | - char_u *file; | |
6204 | - { | |
6205 | - int type; | |
6206 | - char_u type_string[9]; | |
6207 | - int i; | |
6208 | - | |
6209 | - if (xswi(OS_File, 23, file) & v_flag) | |
6210 | - type = 0xfff; /* Default to Text */ | |
6211 | - else | |
6212 | - type = r6; | |
6213 | - | |
6214 | - /* Type is the numerical value - see if we have a textual equivalent */ | |
6215 | - swi(OS_FSControl, 18, 0, type); | |
6216 | - ((int *) type_string)[0] = r2; | |
6217 | - ((int *) type_string)[1] = r3; | |
6218 | - type_string[8] = 0; | |
6219 | - for (i = 0; type_string[i] > ' '; i++) | |
6220 | - ; | |
6221 | - type_string[i] = 0; | |
6222 | - | |
6223 | - set_string_option_direct("osfiletype", -1, type_string, OPT_FREE, 0); | |
6224 | - return; | |
6225 | - } | |
6226 | - | |
6227 | - void | |
6228 | - mch_set_filetype(file, type) | |
6229 | - char_u *file; | |
6230 | - char_u *type; | |
6231 | - { | |
6232 | - if (xswi(OS_FSControl, 31, type) & v_flag) | |
6233 | - { | |
6234 | - EMSG(_("E366: Invalid 'osfiletype' option - using Text")); | |
6235 | - r2 = 0xfff; | |
6236 | - } | |
6237 | - | |
6238 | - swi(OS_File, 18, file, r2); | |
6239 | - } | |
6240 | - | |
6241 | - /* Return TRUE if the file's type matches 'type' | |
6242 | - * RISC OS types always start with '&' | |
6243 | - */ | |
6244 | - int | |
6245 | - mch_check_filetype(fname, type) | |
6246 | - char_u *fname; | |
6247 | - char_u *type; | |
6248 | - { | |
6249 | - int value; | |
6250 | - char *end; | |
6251 | - | |
6252 | - if (*type != '&') | |
6253 | - return FALSE; | |
6254 | - | |
6255 | - value = strtol(type + 1, &end, 16); | |
6256 | - if (*end) | |
6257 | - return FALSE; /* Invalid type (report error?) */ | |
6258 | - | |
6259 | - if (xswi(OS_File, 23, fname) & v_flag) | |
6260 | - return FALSE; /* Invalid filename? */ | |
6261 | - | |
6262 | - return (r0 && r6 == value); | |
6263 | - } | |
6264 | --- 0 ---- | |
6265 | *** ../vim-7.3.186/runtime/doc/os_risc.txt 2010-08-15 21:57:16.000000000 +0200 | |
6266 | --- runtime/doc/os_risc.txt 2011-05-10 16:19:25.000000000 +0200 | |
6267 | *************** | |
6268 | *** 1,322 **** | |
6269 | ! *os_risc.txt* For Vim version 7.3. Last change: 2010 Aug 07 | |
6270 | ||
6271 | ||
6272 | VIM REFERENCE MANUAL by Thomas Leonard | |
6273 | ||
6274 | ||
6275 | *riscos* *RISCOS* *RISC-OS* | |
6276 | ! This file contains the particularities for the RISC OS version of Vim. | |
6277 | ||
6278 | - The RISC OS port is a completely new port and is not based on the old "archi" | |
6279 | - port. | |
6280 | ||
6281 | - 1. File locations |riscos-locations| | |
6282 | - 2. Filename munging |riscos-munging| | |
6283 | - 3. Command-line use |riscos-commandline| | |
6284 | - 4. Desktop (GUI) use |riscos-gui| | |
6285 | - 5. Remote use (telnet) |riscos-remote| | |
6286 | - 6. Temporary files |riscos-temp-files| | |
6287 | - 7. Interrupting |riscos-interrupt| | |
6288 | - 8. Memory usage |riscos-memory| | |
6289 | - 9. Filetypes |riscos-filetypes| | |
6290 | - 10. The shell |riscos-shell| | |
6291 | - 11. Porting new releases |riscos-porting| | |
6292 | - | |
6293 | - If I've missed anything, email me and I'll try to fix it. In fact, even if I | |
6294 | - haven't missed anything then email me anyway to give me some confidence that it | |
6295 | - actually works! | |
6296 | - | |
6297 | - Thomas Leonard <tal197@ecs.soton.ac.uk> | |
6298 | - | |
6299 | - [these URLs no longer work...] | |
6300 | - Port homepage: http://www.ecs.soton.ac.uk/~tal197/ | |
6301 | - or try: http://www.soton.ac.uk/~tal197/ | |
6302 | - | |
6303 | - ============================================================================== | |
6304 | - *riscos-locations* | |
6305 | - 1. File locations | |
6306 | - | |
6307 | - The Vim executable and shared resource files are all stored inside the !Vim | |
6308 | - application directory. | |
6309 | - | |
6310 | - When !Vim is first seen by the filer, it aliases the *vi and *ex commands to | |
6311 | - run the command-line versions of Vim (see |riscos-commandline|). | |
6312 | - | |
6313 | - !Vim.Resources and !Vim.Resources2 contain the files from the standard Vim | |
6314 | - distribution, but modified slightly to work within the limits of ADFS, plus | |
6315 | - some extra files such as the window templates. | |
6316 | - | |
6317 | - User choices are read from "Choices:*" and are saved to "<Choices$Write>.*". | |
6318 | - If you have the new !Boot structure then these should be set up already. If | |
6319 | - not, set Choices$Path to a list of directories to search when looking for | |
6320 | - user configuration files. Set Choices$Write to the directory you want files | |
6321 | - to be saved into (so your search patterns and marks can be remembered between | |
6322 | - sessions). | |
6323 | - | |
6324 | - ============================================================================== | |
6325 | - *riscos-munging* | |
6326 | - 2. Filename munging | |
6327 | - | |
6328 | - All pathname munging is disabled by default, so Vim should behave like a | |
6329 | - normal RISC OS application now. So, if you want to edit "doc/html" then you | |
6330 | - actually type "*vi doc/html". | |
6331 | - | |
6332 | - The only times munging is done is when: | |
6333 | - | |
6334 | - - Searching included files from C programs, since these are always munged. | |
6335 | - See |[I|. | |
6336 | - Note: make sure you are in the right directory when you use this | |
6337 | - command (i.e. the one with subdirectories "c" and "h"). | |
6338 | - | |
6339 | - - Sourcing files using |:so|. | |
6340 | - Paths starting "$VIM/" are munged like this: | |
6341 | - | |
6342 | - $VIM/syntax/help.vim -> Vim:syntax.help | |
6343 | - | |
6344 | - Also, files ending in ".vim" have their extensions removed, and slashes | |
6345 | - replaced with dots. | |
6346 | - | |
6347 | - Some tag files and script files may have to be edited to work under this port. | |
6348 | - | |
6349 | - ============================================================================== | |
6350 | - *riscos-commandline* | |
6351 | - 3. Command-line use | |
6352 | - | |
6353 | - To use Vim from the command-line use the "*vi" command (or "*ex" for | |
6354 | - |Ex-mode|). | |
6355 | - | |
6356 | - Type "*vi -h" for a list of options. | |
6357 | - | |
6358 | - Running the command-line version of Vim in a large high-color mode may cause | |
6359 | - the scrolling to be very slow. Either change to a mode with fewer colors or | |
6360 | - use the GUI version. | |
6361 | - | |
6362 | - Also, holding down Ctrl will slow it down even more, and Ctrl-Shift will | |
6363 | - freeze it, as usual for text programs. | |
6364 | - | |
6365 | - ============================================================================== | |
6366 | - *riscos-gui* | |
6367 | - 4. Desktop use | |
6368 | - | |
6369 | - Limitations: | |
6370 | - | |
6371 | - - Left scrollbars don't work properly (right and bottom are fine). | |
6372 | - - Doesn't increase scroll speed if it gets behind. | |
6373 | - | |
6374 | - You can resize the window by dragging the lower-right corner, even though | |
6375 | - there is no icon shown there. | |
6376 | - | |
6377 | - You can use the --rows and --columns arguments to specify the initial size of | |
6378 | - the Vim window, like this: > | |
6379 | - | |
6380 | - *Vi -g --rows 20 --columns 80 | |
6381 | - | |
6382 | - The global clipboard is supported, so you can select some text and then | |
6383 | - paste it directly into another application (provided it supports the | |
6384 | - clipboard too). | |
6385 | - | |
6386 | - Clicking Menu now opens a menu like a normal RISC OS program. Hold down Shift | |
6387 | - when clicking Menu to paste (from the global clipboard). | |
6388 | - | |
6389 | - Dragging a file to the window replaces the CURRENT buffer (the one with the | |
6390 | - cursor, NOT the one you dragged to) with the file. | |
6391 | - | |
6392 | - Dragging with Ctrl held down causes a new Vim window to be opened for the | |
6393 | - file (see |:sp|). | |
6394 | - | |
6395 | - Dragging a file in with Shift held down in insert mode inserts the pathname of | |
6396 | - the file. | |
6397 | - | |
6398 | - :browse :w opens a standard RISC OS save box. | |
6399 | - :browse :e opens a directory viewer. | |
6400 | - | |
6401 | - For fonts, you have the choice of the system font, an outline font, the system | |
6402 | - font via ZapRedraw and any of the Zap fonts via ZapRedraw: > | |
6403 | - | |
6404 | - :set guifont= | |
6405 | - < To use the system font via the VDU drivers. Supports | |
6406 | - bold and underline. | |
6407 | - > | |
6408 | - :set guifont=Corpus.Medium | |
6409 | - < Use the named outline font. You can use any font, but | |
6410 | - only monospaced ones like Corpus look right. | |
6411 | - > | |
6412 | - :set guifont=Corpus.Medium:w8:h12:b:i | |
6413 | - < As before, but with size of 8 point by 12 point, and | |
6414 | - in bold italic. | |
6415 | - If only one of width and height is given then that | |
6416 | - value is used for both. If neither is given then 10 | |
6417 | - point is used. | |
6418 | - | |
6419 | - Thanks to John Kortink, Vim can use the ZapRedraw module. Start the font name | |
6420 | - with "!" (or "!!" for double height), like this: > | |
6421 | - | |
6422 | - :set guifont=!! | |
6423 | - < Use the system font, but via ZapRedraw. This gives a | |
6424 | - faster redraw on StrongARM processors, but you can't | |
6425 | - get bold or italic text. Double height. | |
6426 | - > | |
6427 | - :set guifont=!script | |
6428 | - < Uses the named Zap font (a directory in VimFont$Path). | |
6429 | - The redraw is the same speed as for "!!", but you get | |
6430 | - a nicer looking font. | |
6431 | - Only the "man+" and "script" fonts are supplied | |
6432 | - currently, but you can use any of the Zap fonts if | |
6433 | - they are in VimFont$Path. | |
6434 | - Vim will try to load font files "0", "B", "I" and "IB" | |
6435 | - from the named directory. Only "0" (normal style) MUST | |
6436 | - be present. Link files are not currently supported. | |
6437 | - | |
6438 | - Note that when using ZapRedraw the edit bar is drawn in front of the character | |
6439 | - you are on rather than behind it. Also redraw is incorrect for screen modes | |
6440 | - with eigen values of 0. If the font includes control characters then you can | |
6441 | - get Vim to display them by changing the 'isprint' option. | |
6442 | - | |
6443 | - If you find the scrolling is too slow on your machine, try experimenting | |
6444 | - with the 'scrolljump' and 'ttyscroll' options. | |
6445 | - | |
6446 | - In particular, StrongARM users may find that: > | |
6447 | - | |
6448 | - :set ttyscroll=0 | |
6449 | - | |
6450 | - makes scrolling faster in high-color modes. | |
6451 | - | |
6452 | - ============================================================================= | |
6453 | - *riscos-remote* | |
6454 | - 5. Remote use (telnet) | |
6455 | - | |
6456 | - I have included a built-in termcap entry, but you can edit the termcap file to | |
6457 | - allow other codes to be used if you want to use Vim from a remote terminal. | |
6458 | - | |
6459 | - Although I do not have an internet connection to my Acorn, I have managed to | |
6460 | - run Vim in a FreeTerm window using the loopback connection. | |
6461 | - | |
6462 | - It seems to work pretty well now, using "*vi -T ansi". | |
6463 | - | |
6464 | - ============================================================================== | |
6465 | - *riscos-temp-files* | |
6466 | - 6. Temporary files | |
6467 | - | |
6468 | - If Vim crashes then the swap and backup files (if any) will be in the | |
6469 | - directories set with the 'directory' and 'bdir' options. By default the swap | |
6470 | - files are in <Wimp$ScrapDir> (i.e. inside !Scrap) and backups are in the | |
6471 | - directory you were saving to. Vim will allow you to try and recover the file | |
6472 | - when you next try to edit it. | |
6473 | - | |
6474 | - To see a list of swap files, press <F12> and type "*vi -r". | |
6475 | - | |
6476 | - Vim no longer brings up ATTENTION warnings if you try to edit two files with | |
6477 | - the same name in different directories. | |
6478 | - | |
6479 | - However, it also no longer warns if you try to edit the same file twice (with | |
6480 | - two copies of Vim), though you will still be warned when you save that the | |
6481 | - datestamp has changed. | |
6482 | - | |
6483 | - ============================================================================== | |
6484 | - *riscos-interrupt* | |
6485 | - 7. Interrupting | |
6486 | - | |
6487 | - To break out of a looping macro, or similar, hold down Escape in the | |
6488 | - command-line version, or press CTRL-C in the GUI version. | |
6489 | - | |
6490 | - ============================================================================== | |
6491 | - *riscos-memory* | |
6492 | - 8. Memory usage | |
6493 | - | |
6494 | - Vim will use dynamic areas on RISC OS 3.5 or later. If you can use them on | |
6495 | - older machines then edit the !RunTxt and GVim files. I don't know what UnixLib | |
6496 | - does by default on these machines so I'm playing safe. | |
6497 | - | |
6498 | - It doesn't work at all well without dynamic areas, since it can't change its | |
6499 | - memory allocation once running. Hence you should edit "!Vim.GVim" and | |
6500 | - "!Vim.!RunTxt" to choose the best size for you. You probably need at least | |
6501 | - about 1400K. | |
6502 | - | |
6503 | - ============================================================================== | |
6504 | - *riscos-filetypes* | |
6505 | - 9. Filetypes | |
6506 | - | |
6507 | - You can now specify that autocommands are only executed for files of certain | |
6508 | - types. The filetype is given in the form &xxx, when xxx is the filetype. | |
6509 | - | |
6510 | - Filetypes must be specified by number (e.g. &fff for Text). | |
6511 | - | |
6512 | - The system has changed from version 5.3. The new sequence of events is: | |
6513 | - | |
6514 | - - A file is loaded. |'osfiletype'| is set to the RISC OS filetype. | |
6515 | - - Based on the filetype and pathname, Vim will try to set |'filetype'| to the | |
6516 | - Vim-type of the file. | |
6517 | - - Setting this option may load syntax files and perform other actions. | |
6518 | - - Saving the file will give it a filetype of |'osfiletype'|. | |
6519 | - | |
6520 | - Some examples may make this clearer: | |
6521 | - | |
6522 | - Kind of file loaded osfiletype filetype ~ | |
6523 | - C code "c.hellow" Text (&fff) C | |
6524 | - LaTeX document LaTeX (&2a8) TeX | |
6525 | - Draw document DrawFile (&aff) (not changed) | |
6526 | - | |
6527 | - ============================================================================== | |
6528 | - *riscos-shell* | |
6529 | - 10. The shell | |
6530 | - | |
6531 | - - Bangs (!s) are only replaced if they are followed by a space or end-of-line, | |
6532 | - since many pathnames contain them. | |
6533 | - | |
6534 | - - You can prefix the command with "~", which stops any output from being | |
6535 | - displayed. This also means that you don't have to press <Enter> afterwards, | |
6536 | - and stops the screen from being redrawn. {only in the GUI version} | |
6537 | - | |
6538 | - ============================================================================== | |
6539 | - *riscos-porting* | |
6540 | - 11. Porting new releases to RISC OS | |
6541 | - | |
6542 | - Downloading everything you need: | |
6543 | - | |
6544 | - - Get the latest source distribution (see www.vim.org) | |
6545 | - - Get the runtime environment files (e.g. these help files) | |
6546 | - - Get the RISC OS binary distribution (if possible) | |
6547 | - | |
6548 | - | |
6549 | - Unarchiving: | |
6550 | - | |
6551 | - - Create a raFS disk and put the archives on it | |
6552 | - - Un-gzip them | |
6553 | - - Un-tar them (*tar xELf 50 archive/tar) | |
6554 | - | |
6555 | - | |
6556 | - Recompiling the sources: | |
6557 | - | |
6558 | - - Create c, s, and h directories. | |
6559 | - - Put all the header files in "h". \ | |
6560 | - - Put all the C files in "c". | And lose the extensions | |
6561 | - - Put the assembler file ("swis/s") in "s". / | |
6562 | - - Rename all the files in "proto" to "h", like this: | |
6563 | - raFS::VimSrc.source.proto.file/pro | |
6564 | - becomes | |
6565 | - raFS::VimSrc.source.h.file_pro | |
6566 | - - In the files "h.proto" and "c.termlib", search and replace | |
6567 | - .pro" | |
6568 | - with | |
6569 | - _pro.h" | |
6570 | - - Create a simple Makefile if desired and do "*make -k". | |
6571 | - Use "CC = gcc -DRISCOS -DUSE_GUI -O2 -x c" in the Makefile. | |
6572 | - - Save the binary as !Vim.Vim in the binary distribution. | |
6573 | - | |
6574 | - | |
6575 | - Updating the run-time environment: | |
6576 | - | |
6577 | - - Replace old or missing files inside !Vim.Resources with the | |
6578 | - new files. | |
6579 | - - Remove files in "doc" not ending in "/txt", except for "tags". | |
6580 | - - Lose the extensions from the files in "doc". | |
6581 | - - Edit the "doc.tags" file. Remove extensions from the second column: > | |
6582 | - :%s/^\(.[^\t]*\t.*\)\.txt\t/\1\t/ | |
6583 | - - Remove extensions from the syntax files. Split them into two directories | |
6584 | - to avoid the 77 entry limit on old ADFS filesystems. | |
6585 | - - Edit "Vim:FileType" to match "*.c.*" as well as "*/c" and so on. | |
6586 | - Add filetype checking too. | |
6587 | - - Edit "Vim:Menu" and remove all the keys from the menus: > | |
6588 | - :%s/<Tab>[^ \t]*// | |
6589 | - < | |
6590 | vim:tw=78:ts=8:ft=help:norl: | |
6591 | --- 1,12 ---- | |
6592 | ! *os_risc.txt* For Vim version 7.3. Last change: 2011 May 10 | |
6593 | ||
6594 | ||
6595 | VIM REFERENCE MANUAL by Thomas Leonard | |
6596 | ||
6597 | ||
6598 | *riscos* *RISCOS* *RISC-OS* | |
6599 | ! The RISC OS support has been removed from Vim with patch 7.3.187. | |
6600 | ! If you would like to use Vim on RISC OS get the files from before that patch. | |
6601 | ||
6602 | ||
6603 | vim:tw=78:ts=8:ft=help:norl: | |
6604 | *** ../vim-7.3.186/src/version.c 2011-05-10 16:12:40.000000000 +0200 | |
6605 | --- src/version.c 2011-05-10 16:37:20.000000000 +0200 | |
6606 | *************** | |
6607 | *** 716,717 **** | |
6608 | --- 716,719 ---- | |
6609 | { /* Add new patch number below this line */ | |
6610 | + /**/ | |
6611 | + 187, | |
6612 | /**/ | |
6613 | ||
6614 | -- | |
6615 | hundred-and-one symptoms of being an internet addict: | |
6616 | 81. At social functions you introduce your husband as "my domain server." | |
6617 | ||
6618 | /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\ | |
6619 | /// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\ | |
6620 | \\\ an exciting new programming language -- http://www.Zimbu.org /// | |
6621 | \\\ help me help AIDS victims -- http://ICCF-Holland.org /// |