Mercurial > vim
annotate src/integration.c @ 2474:a29301e7c05f vim73
Take OLE registration back to 32 bit registry, the unregister wasn't working
for the 64 registry.
| author | Bram Moolenaar <bram@vim.org> |
|---|---|
| date | Mon, 02 Aug 2010 22:13:25 +0200 |
| parents | 1bac28a53fae |
| children | 6768ebd0bc04 |
| rev | line source |
|---|---|
| 7 | 1 /* vi:set ts=8 sw=8: |
| 2 * | |
| 3 * VIM - Vi IMproved by Bram Moolenaar | |
| 4 * Visual Workshop integration by Gordon Prieur | |
| 5 * | |
| 6 * Do ":help uganda" in Vim to read copying and usage conditions. | |
| 7 * Do ":help credits" in Vim to see a list of people who contributed. | |
| 8 * See README.txt for an overview of the Vim source code. | |
| 9 */ | |
| 10 | |
| 11 /* | |
| 12 * Integration with Sun Workshop. | |
| 13 * | |
| 14 * This file should not change much, it's also used by other editors that | |
| 15 * connect to Workshop. Consider changing workshop.c instead. | |
| 16 */ | |
| 17 /* | |
| 18 -> consider using MakeSelectionVisible instead of gotoLine hacks | |
| 19 to show the line properly | |
| 20 -> consider using glue instead of our own message wrapping functions | |
| 21 (but can only use glue if we don't have to distribute source) | |
| 22 */ | |
| 23 | |
| 24 #include "vim.h" | |
| 25 | |
| 26 #include <stdio.h> | |
| 27 #include <stdlib.h> | |
| 28 | |
| 29 #ifdef INET_SOCKETS | |
| 30 #include <netdb.h> | |
| 31 #include <netinet/in.h> | |
| 32 #else | |
| 33 #include <sys/un.h> | |
| 34 #endif | |
| 35 | |
| 36 #include <errno.h> | |
| 37 #include <sys/types.h> | |
| 38 #include <sys/socket.h> | |
| 39 #include <sys/param.h> | |
| 40 #ifdef HAVE_LIBGEN_H | |
| 41 # include <libgen.h> | |
| 42 #endif | |
| 43 #include <unistd.h> | |
| 44 #include <string.h> | |
| 45 | |
| 46 #include <X11/Intrinsic.h> | |
| 47 #include <Xm/Xm.h> | |
| 48 #include <Xm/AtomMgr.h> | |
| 49 #include <Xm/PushB.h> | |
| 50 | |
| 51 #ifdef HAVE_X11_XPM_H | |
| 52 # include <X11/xpm.h> | |
| 53 #else | |
| 54 # ifdef HAVE_XM_XPMP_H | |
| 55 # include <Xm/XpmP.h> | |
| 56 # endif | |
| 57 #endif | |
| 58 | |
| 59 #ifdef HAVE_UTIL_DEBUG_H | |
| 60 # include <util/debug.h> | |
| 61 #endif | |
| 62 #ifdef HAVE_UTIL_MSGI18N_H | |
| 63 # include <util/msgi18n.h> | |
| 64 #endif | |
| 65 | |
| 66 #include "integration.h" /* <EditPlugin/integration.h> */ | |
| 67 #ifdef HAVE_FRAME_H | |
| 68 # include <frame.h> | |
| 69 #endif | |
| 70 | |
| 71 #ifndef MAX | |
| 72 # define MAX(a, b) (a) > (b) ? (a) : (b) | |
| 73 #endif | |
| 74 | |
| 75 #ifndef NOCATGETS | |
| 76 # define NOCATGETS(x) x | |
| 77 #endif | |
| 78 | |
| 79 /* Functions private to this file */ | |
| 80 static void workshop_connection_closed(void); | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
81 static void messageFromEserve(XtPointer clientData, int *dum1, XtInputId *dum2); |
| 7 | 82 static void workshop_disconnect(void); |
| 83 static void workshop_sensitivity(int num, char *table); | |
| 84 static void adjust_sign_name(char *filename); | |
| 85 static void process_menuItem(char *); | |
| 86 static void process_toolbarButton(char *); | |
| 87 static void workshop_set_option_first(char *name, char *value); | |
| 88 | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
89 static size_t dummy; /* to ignore return value of write() */ |
| 7 | 90 |
| 91 #define CMDBUFSIZ 2048 | |
| 92 | |
| 93 #ifdef DEBUG | |
| 94 static FILE *dfd; | |
| 95 static void pldebug(char *, ...); | |
| 96 static void unrecognised_message(char *); | |
| 97 | |
| 98 #define HANDLE_ERRORS(cmd) else unrecognised_message(cmd); | |
| 99 #else | |
| 100 #define HANDLE_ERRORS(cmd) | |
| 101 #endif | |
| 102 | |
| 103 /* | |
| 104 * Version number of the protocol between an editor and eserve. | |
| 105 * This number should be incremented when the protocol | |
| 106 * is changed. | |
| 107 */ | |
| 108 #define PROTOCOL_VERSION "4.0.0" | |
| 109 | |
| 110 static int sd = -1; | |
| 111 static XtInputId inputHandler; /* Cookie for input */ | |
| 112 | |
| 113 Boolean save_files = True; /* When true, save all files before build actions */ | |
| 114 | |
| 115 void | |
| 116 workshop_connection_closed(void) | |
| 117 { | |
| 118 /* | |
| 119 * socket closed on other end | |
| 120 */ | |
| 121 XtRemoveInput(inputHandler); | |
| 122 inputHandler = 0; | |
| 123 sd = -1; | |
| 124 } | |
| 125 | |
| 126 static char * | |
| 127 getCommand(void) | |
| 128 { | |
| 129 int len; /* length of this command */ | |
| 130 char lenbuf[7]; /* get the length string here */ | |
| 131 char *newcb; /* used to realloc cmdbuf */ | |
| 132 static char *cmdbuf;/* get the command string here */ | |
| 133 static int cbsize;/* size of cmdbuf */ | |
| 134 | |
| 135 if ((len = read(sd, &lenbuf, 6)) == 6) { | |
| 136 lenbuf[6] = 0; /* Terminate buffer such that atoi() works right */ | |
| 137 len = atoi(lenbuf); | |
| 138 if (cbsize < (len + 1)) { | |
| 139 newcb = (char *) realloc(cmdbuf, | |
| 140 MAX((len + 256), CMDBUFSIZ)); | |
| 141 if (newcb != NULL) { | |
| 142 cmdbuf = newcb; | |
| 143 cbsize = MAX((len + 256), CMDBUFSIZ); | |
| 144 } | |
| 145 } | |
| 146 if (cbsize >= len && (len = read(sd, cmdbuf, len)) > 0) { | |
| 147 cmdbuf[len] = 0; | |
| 148 return cmdbuf; | |
| 149 } else { | |
| 150 return NULL; | |
| 151 } | |
| 152 } else { | |
| 153 if (len == 0) { /* EOF */ | |
| 154 workshop_connection_closed(); | |
| 155 } | |
| 156 return NULL; | |
| 157 } | |
| 158 | |
| 159 } | |
| 160 | |
| 161 void | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
162 messageFromEserve(XtPointer clientData UNUSED, |
|
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
163 int *dum1 UNUSED, |
|
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
164 XtInputId *dum2 UNUSED) |
| 7 | 165 { |
| 166 char *cmd; /* the 1st word of the command */ | |
| 167 | |
| 168 cmd = getCommand(); | |
| 169 if (cmd == NULL) { | |
| 170 /* We're being shut down by eserve and the "quit" message | |
| 171 * didn't arrive before the socket connection got closed */ | |
| 172 return; | |
| 173 } | |
| 174 #ifdef DEBUG | |
| 175 pldebug("%s\n", cmd); | |
| 176 #endif | |
| 177 switch (*cmd) { | |
| 178 case 'a': | |
| 179 if (cmd[1] == 'c' && | |
| 180 strncmp(cmd, NOCATGETS("ack "), 4) == 0) { | |
| 181 int ackNum; | |
| 182 char buf[20]; | |
| 183 | |
| 184 ackNum = atoi(&cmd[4]); | |
| 272 | 185 vim_snprintf(buf, sizeof(buf), |
| 186 NOCATGETS("ack %d\n"), ackNum); | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
187 dummy = write(sd, buf, strlen(buf)); |
| 7 | 188 } else if (strncmp(cmd, |
| 189 NOCATGETS("addMarkType "), 12) == 0) { | |
| 190 int idx; | |
| 191 char *color; | |
| 192 char *sign; | |
| 193 | |
| 194 idx = atoi(strtok(&cmd[12], " ")); | |
| 195 color = strtok(NULL, NOCATGETS("\001")); | |
| 196 sign = strtok(NULL, NOCATGETS("\001")); | |
| 197 /* Skip space that separates names */ | |
| 198 if (color) { | |
| 199 color++; | |
| 200 } | |
| 201 if (sign) { | |
| 202 sign++; | |
| 203 } | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
204 /* Change sign name to accommodate a different size? */ |
| 7 | 205 adjust_sign_name(sign); |
| 206 workshop_add_mark_type(idx, color, sign); | |
| 207 } | |
| 208 HANDLE_ERRORS(cmd); | |
| 209 break; | |
| 210 | |
| 211 case 'b': | |
| 212 if (strncmp(cmd, | |
| 213 NOCATGETS("balloon "), 8) == 0) { | |
| 214 char *tip; | |
| 215 | |
| 216 tip = strtok(&cmd[8], NOCATGETS("\001")); | |
| 217 workshop_show_balloon_tip(tip); | |
| 218 } | |
| 219 HANDLE_ERRORS(cmd); | |
| 220 break; | |
| 221 | |
| 222 case 'c': | |
| 223 if (strncmp(cmd, | |
| 224 NOCATGETS("changeMarkType "), 15) == 0) { | |
| 225 char *file; | |
| 226 int markId; | |
| 227 int type; | |
| 228 | |
| 229 file = strtok(&cmd[15], " "); | |
| 230 markId = atoi(strtok(NULL, " ")); | |
| 231 type = atoi(strtok(NULL, " ")); | |
| 232 workshop_change_mark_type(file, markId, type); | |
| 233 } | |
| 234 HANDLE_ERRORS(cmd); | |
| 235 break; | |
| 236 | |
| 237 case 'd': | |
| 238 if (strncmp(cmd, NOCATGETS("deleteMark "), 11) == 0) { | |
| 239 char *file; | |
| 240 int markId; | |
| 241 | |
| 242 file = strtok(&cmd[11], " "); | |
| 243 markId = atoi(strtok(NULL, " ")); | |
| 244 workshop_delete_mark(file, markId); | |
| 245 } | |
| 246 HANDLE_ERRORS(cmd); | |
| 247 break; | |
| 248 | |
| 249 case 'f': | |
| 250 if (cmd[1] == 'o' && | |
| 251 strncmp(cmd, NOCATGETS("footerMsg "), 10) == 0) { | |
| 252 int severity; | |
| 253 char *message; | |
| 254 | |
| 255 severity = | |
| 256 atoi(strtok(&cmd[10], " ")); | |
| 257 message = strtok(NULL, NOCATGETS("\001")); | |
| 258 | |
| 259 workshop_footer_message(message, severity); | |
| 260 } else if (strncmp(cmd, | |
| 261 NOCATGETS("frontFile "), 10) == 0) { | |
| 262 char *file; | |
| 263 | |
| 264 file = strtok(&cmd[10], " "); | |
| 265 workshop_front_file(file); | |
| 266 } | |
| 267 HANDLE_ERRORS(cmd); | |
| 268 break; | |
| 269 | |
| 270 case 'g': | |
| 271 if (cmd[1] == 'e' && | |
| 272 strncmp(cmd, NOCATGETS("getMarkLine "), 12) == 0) { | |
| 273 char *file; | |
| 274 int markid; | |
| 275 int line; | |
| 276 char buf[100]; | |
| 277 | |
| 278 file = strtok(&cmd[12], " "); | |
| 279 markid = atoi(strtok(NULL, " ")); | |
| 280 line = workshop_get_mark_lineno(file, markid); | |
| 272 | 281 vim_snprintf(buf, sizeof(buf), |
| 282 NOCATGETS("markLine %s %d %d\n"), | |
| 7 | 283 file, markid, line); |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
284 dummy = write(sd, buf, strlen(buf)); |
| 7 | 285 } else if (cmd[1] == 'o' && cmd[4] == 'L' && |
| 286 strncmp(cmd, NOCATGETS("gotoLine "), 9) == 0) { | |
| 287 char *file; | |
| 288 int lineno; | |
| 289 | |
| 290 file = strtok(&cmd[9], " "); | |
| 291 lineno = atoi(strtok(NULL, " ")); | |
| 292 workshop_goto_line(file, lineno); | |
| 293 } else if (strncmp(cmd, | |
| 294 NOCATGETS("gotoMark "), 9) == 0) { | |
| 295 char *file; | |
| 296 int markId; | |
| 297 char *message; | |
| 298 | |
| 299 file = strtok(&cmd[9], " "); | |
| 300 markId = atoi(strtok(NULL, " ")); | |
| 301 message = strtok(NULL, NOCATGETS("\001")); | |
| 302 workshop_goto_mark(file, markId, message); | |
| 303 #ifdef NOHANDS_SUPPORT_FUNCTIONS | |
| 304 } else if (strcmp(cmd, NOCATGETS("getCurrentFile")) == 0) { | |
| 305 char *f = workshop_test_getcurrentfile(); | |
| 306 char buffer[2*MAXPATHLEN]; | |
| 272 | 307 vim_snprintf(buffer, sizeof(buffer), |
| 308 NOCATGETS("currentFile %d %s"), | |
| 7 | 309 f ? strlen(f) : 0, f ? f : ""); |
| 310 workshop_send_message(buffer); | |
| 311 } else if (strcmp(cmd, NOCATGETS("getCursorRow")) == 0) { | |
| 312 int row = workshop_test_getcursorrow(); | |
| 313 char buffer[2*MAXPATHLEN]; | |
| 272 | 314 vim_snprintf(buffer, sizeof(buffer), |
| 315 NOCATGETS("cursorRow %d"), row); | |
| 7 | 316 workshop_send_message(buffer); |
| 317 } else if (strcmp(cmd, NOCATGETS("getCursorCol")) == 0) { | |
| 318 int col = workshop_test_getcursorcol(); | |
| 319 char buffer[2*MAXPATHLEN]; | |
| 272 | 320 vim_snprintf(buffer, sizeof(buffer), |
| 321 NOCATGETS("cursorCol %d"), col); | |
| 7 | 322 workshop_send_message(buffer); |
| 323 } else if (strcmp(cmd, NOCATGETS("getCursorRowText")) == 0) { | |
| 324 char *t = workshop_test_getcursorrowtext(); | |
| 325 char buffer[2*MAXPATHLEN]; | |
| 272 | 326 vim_snprintf(buffer, sizeof(buffer), |
| 327 NOCATGETS("cursorRowText %d %s"), | |
| 7 | 328 t ? strlen(t) : 0, t ? t : ""); |
| 329 workshop_send_message(buffer); | |
| 330 } else if (strcmp(cmd, NOCATGETS("getSelectedText")) == 0) { | |
| 331 char *t = workshop_test_getselectedtext(); | |
| 332 char buffer[2*MAXPATHLEN]; | |
| 272 | 333 vim_snprintf(buffer, sizeof(buffer), |
| 334 NOCATGETS("selectedText %d %s"), | |
| 7 | 335 t ? strlen(t) : 0, t ? t : ""); |
| 336 workshop_send_message(buffer); | |
| 337 #endif | |
| 338 } | |
| 339 HANDLE_ERRORS(cmd); | |
| 340 break; | |
| 341 | |
| 342 case 'l': | |
| 343 if (strncmp(cmd, NOCATGETS("loadFile "), 9) == 0) { | |
| 344 char *file; | |
| 345 int line; | |
| 346 char *frameid; | |
| 347 | |
| 348 file = strtok(&cmd[9], " "); | |
| 349 line = atoi(strtok(NULL, " ")); | |
| 350 frameid = strtok(NULL, " "); | |
| 351 workshop_load_file(file, line, frameid); | |
| 352 } | |
| 353 HANDLE_ERRORS(cmd); | |
| 354 break; | |
| 355 | |
| 356 case 'm': /* Menu, minimize, maximize */ | |
| 357 if (cmd[1] == 'e' && cmd[4] == 'B' && | |
| 358 strncmp(cmd, NOCATGETS("menuBegin "), 10) == 0) { | |
| 359 workshop_menu_begin(&cmd[10]); | |
| 360 } else if (cmd[1] == 'e' && cmd[4] == 'I' && | |
| 361 strncmp(cmd, NOCATGETS("menuItem "), 9) == 0) { | |
| 362 process_menuItem(cmd); | |
| 363 } else if (cmd[1] == 'e' && cmd[4] == 'E' && | |
| 364 strcmp(cmd, NOCATGETS("menuEnd")) == 0) { | |
| 365 workshop_menu_end(); | |
| 366 } else if (cmd[1] == 'a' && | |
| 367 strcmp(cmd, NOCATGETS("maximize")) == 0) { | |
| 368 workshop_maximize(); | |
| 369 } else if (strcmp(cmd, NOCATGETS("minimize")) == 0) { | |
| 370 workshop_minimize(); | |
| 371 } | |
| 372 HANDLE_ERRORS(cmd); | |
| 373 break; | |
| 374 | |
| 375 case 'o': | |
| 376 if (cmd[1] == 'p' && | |
| 377 strcmp(cmd, NOCATGETS("option"))) { | |
| 378 char *name; | |
| 379 char *value; | |
| 380 | |
| 381 name = strtok(&cmd[7], " "); | |
| 382 value = strtok(NULL, " "); | |
| 383 workshop_set_option_first(name, value); | |
| 384 } | |
| 385 HANDLE_ERRORS(cmd); | |
| 386 break; | |
| 387 | |
| 388 case 'p': | |
| 389 if (strcmp(cmd, NOCATGETS("ping")) == 0) { | |
| 390 #if 0 | |
| 391 int pingNum; | |
| 392 | |
| 393 pingNum = atoi(&cmd[5]); | |
| 394 workshop_send_ack(ackNum); | |
| 395 WHAT DO I DO HERE? | |
| 396 #endif | |
| 397 } | |
| 398 HANDLE_ERRORS(cmd); | |
| 399 break; | |
| 400 | |
| 401 case 'q': | |
| 402 if (strncmp(cmd, NOCATGETS("quit"), 4) == 0) { | |
| 403 | |
| 404 /* Close the connection. It's important to do | |
| 405 * that now, since workshop_quit might be | |
| 406 * looking at open files. For example, if you | |
| 407 * have modified one of the files without | |
| 408 * saving, NEdit will ask you what you want to | |
| 409 * do, and spin loop by calling | |
| 410 * XtAppProcessEvent while waiting for your | |
| 411 * reply. In this case, if we still have an | |
| 412 * input handler and the socket has been | |
| 413 * closed on the other side when eserve | |
| 414 * expired, we will hang in IoWait. | |
| 415 */ | |
| 416 workshop_disconnect(); | |
| 417 | |
| 418 workshop_quit(); | |
| 419 } | |
| 420 HANDLE_ERRORS(cmd); | |
| 421 break; | |
| 422 | |
| 423 case 'r': | |
| 424 if (cmd[1] == 'e' && | |
| 425 strncmp(cmd, NOCATGETS("reloadFile "), 11) == 0) { | |
| 426 char *file; | |
| 427 int line; | |
| 428 | |
| 429 file = strtok(&cmd[11], " "); | |
| 430 line = atoi(strtok(NULL, " ")); | |
| 431 workshop_reload_file(file, line); | |
| 432 } | |
| 433 HANDLE_ERRORS(cmd); | |
| 434 break; | |
| 435 | |
| 436 case 's': | |
| 437 if (cmd[1] == 'e' && cmd[2] == 't' && | |
| 438 strncmp(cmd, NOCATGETS("setMark "), 8) == 0) { | |
| 439 char *file; | |
| 440 int line; | |
| 441 int markId; | |
| 442 int type; | |
| 443 | |
| 444 file = strtok(&cmd[8], " "); | |
| 445 line = atoi(strtok(NULL, " ")); | |
| 446 markId = atoi(strtok(NULL, " ")); | |
| 447 type = atoi(strtok(NULL, " ")); | |
| 448 workshop_set_mark(file, line, markId, type); | |
| 449 } else if (cmd[1] == 'h' && | |
| 450 strncmp(cmd, NOCATGETS("showFile "), 9) == 0) { | |
| 451 workshop_show_file(&cmd[9]); | |
| 452 } else if (cmd[1] == 'u' && | |
| 453 strncmp(cmd, NOCATGETS("subMenu "), 8) == 0) { | |
| 454 char *label; | |
| 455 | |
| 456 label = strtok(&cmd[8], NOCATGETS("\001")); | |
| 457 workshop_submenu_begin(label); | |
| 458 } else if (cmd[1] == 'u' && | |
| 459 strcmp(cmd, NOCATGETS("subMenuEnd")) == 0) { | |
| 460 workshop_submenu_end(); | |
| 461 } else if (cmd[1] == 'e' && cmd[2] == 'n' && | |
| 462 strncmp(cmd, NOCATGETS("sensitivity "), 12) == 0) { | |
| 463 int num; | |
| 464 char *bracket; | |
| 465 char *table; | |
| 466 | |
| 467 num = atoi(strtok(&cmd[12], " ")); | |
| 468 bracket = strtok(NULL, " "); | |
| 469 if (*bracket != '[') { | |
| 470 fprintf(stderr, NOCATGETS("Parsing " | |
| 471 "error for sensitivity\n")); | |
| 472 } else { | |
| 473 table = strtok(NULL, NOCATGETS("]")); | |
| 474 workshop_sensitivity(num, table); | |
| 475 } | |
| 476 } else if (cmd[1] == 'e' && cmd[2] == 'n' && cmd[3] == 'd' && | |
| 477 strncmp(cmd, NOCATGETS("sendVerb "), 9) == 0) { | |
| 478 /* Send the given verb back (used for the | |
| 479 * debug.lineno callback (such that other tools | |
| 480 * can obtain the position coordinates or the | |
| 481 * selection) */ | |
| 482 char *verb; | |
| 483 | |
| 484 verb = strtok(&cmd[9], " "); | |
| 485 workshop_perform_verb(verb, NULL); | |
| 486 } else if (cmd[1] == 'a' && | |
| 487 strncmp(cmd, NOCATGETS("saveFile "), 9) == 0) { | |
| 488 workshop_save_file(&cmd[9]); | |
| 489 #ifdef NOHANDS_SUPPORT_FUNCTIONS | |
| 490 } else if (strncmp(cmd, NOCATGETS("saveSensitivity "), 16) == 0) { | |
| 491 char *file; | |
| 492 | |
| 493 file = strtok(&cmd[16], " "); | |
| 494 workshop_save_sensitivity(file); | |
| 495 #endif | |
| 496 } | |
| 497 HANDLE_ERRORS(cmd); | |
| 498 break; | |
| 499 | |
| 500 case 't': /* Toolbar */ | |
| 501 if (cmd[8] == 'e' && | |
| 502 strncmp(cmd, NOCATGETS("toolbarBegin"), 12) == 0) { | |
| 503 workshop_toolbar_begin(); | |
| 504 } else if (cmd[8] == 'u' && | |
| 505 strncmp(cmd, NOCATGETS("toolbarButton"), 13) == 0) { | |
| 506 process_toolbarButton(cmd); | |
| 507 } else if (cmd[7] == 'E' && | |
| 508 strcmp(cmd, NOCATGETS("toolbarEnd")) == 0) { | |
| 509 workshop_toolbar_end(); | |
| 510 } | |
| 511 HANDLE_ERRORS(cmd); | |
| 512 break; | |
| 513 | |
| 514 #ifdef DEBUG | |
| 515 default: | |
| 516 unrecognised_message(cmd); | |
| 517 break; | |
| 518 #endif | |
| 519 } | |
| 520 } | |
| 521 | |
| 522 static void | |
| 523 process_menuItem( | |
| 524 char *cmd) | |
| 525 { | |
| 526 char *label = strtok(&cmd[9], NOCATGETS("\001")); | |
| 527 char *verb = strtok(NULL, NOCATGETS("\001")); | |
| 528 char *acc = strtok(NULL, NOCATGETS("\001")); | |
| 529 char *accText = strtok(NULL, NOCATGETS("\001")); | |
| 530 char *name = strtok(NULL, NOCATGETS("\001")); | |
| 531 char *sense = strtok(NULL, NOCATGETS("\n")); | |
| 532 char *filepos = strtok(NULL, NOCATGETS("\n")); | |
| 533 if (*acc == '-') { | |
| 534 acc = NULL; | |
| 535 } | |
| 536 if (*accText == '-') { | |
| 537 accText = NULL; | |
| 538 } | |
| 539 workshop_menu_item(label, verb, acc, accText, name, filepos, sense); | |
| 540 | |
| 541 } | |
| 542 | |
| 543 | |
| 544 static void | |
| 545 process_toolbarButton( | |
| 546 char *cmd) /* button definition */ | |
| 547 { | |
| 548 char *label = strtok(&cmd[14], NOCATGETS("\001")); | |
| 549 char *verb = strtok(NULL, NOCATGETS("\001")); | |
| 550 char *senseVerb = strtok(NULL, NOCATGETS("\001")); | |
| 551 char *filepos = strtok(NULL, NOCATGETS("\001")); | |
| 552 char *help = strtok(NULL, NOCATGETS("\001")); | |
| 553 char *sense = strtok(NULL, NOCATGETS("\001")); | |
| 554 char *file = strtok(NULL, NOCATGETS("\001")); | |
| 555 char *left = strtok(NULL, NOCATGETS("\n")); | |
| 556 | |
| 557 if (!strcmp(label, NOCATGETS("-"))) { | |
| 558 label = NULL; | |
| 559 } | |
| 560 if (!strcmp(help, NOCATGETS("-"))) { | |
| 561 help = NULL; | |
| 562 } | |
| 563 if (!strcmp(file, NOCATGETS("-"))) { | |
| 564 file = NULL; | |
| 565 } | |
| 566 if (!strcmp(senseVerb, NOCATGETS("-"))) { | |
| 567 senseVerb = NULL; | |
| 568 } | |
| 569 workshop_toolbar_button(label, verb, senseVerb, filepos, help, | |
| 570 sense, file, left); | |
| 571 } | |
| 572 | |
| 573 | |
| 574 #ifdef DEBUG | |
| 575 void | |
| 576 unrecognised_message( | |
| 577 char *cmd) | |
| 578 { | |
| 579 pldebug("Unrecognised eserve message:\n\t%s\n", cmd); | |
| 580 /* abort(); */ | |
| 581 } | |
| 582 #endif | |
| 583 | |
| 584 | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
585 /* Change sign name to accommodate a different size: |
| 7 | 586 * Create the filename based on the height. The filename format |
| 587 * of multisize icons are: | |
| 588 * x.xpm : largest icon | |
| 589 * x1.xpm : smaller icon | |
| 590 * x2.xpm : smallest icon */ | |
| 591 void | |
| 592 adjust_sign_name(char *filename) | |
| 593 { | |
| 594 char *s; | |
| 595 static int fontSize = -1; | |
| 596 | |
| 597 if (fontSize == -1) | |
| 598 fontSize = workshop_get_font_height(); | |
| 599 if (fontSize == 0) | |
| 600 return; | |
| 601 if (filename[0] == '-') | |
| 602 return; | |
| 603 | |
| 604 /* This is ugly: later we should instead pass the fontheight over | |
| 605 * to eserve on startup and let eserve just send the right filenames | |
| 606 * to us in the first place | |
| 607 | |
| 608 * I know that the filename will end with 1.xpm (see | |
| 609 * GuiEditor.cc`LispPrintSign if you wonder why) */ | |
| 610 s = filename+strlen(filename)-5; | |
| 611 if (fontSize <= 11) | |
| 612 strcpy(s, "2.xpm"); | |
| 613 else if (fontSize <= 15) | |
| 614 strcpy(s, "1.xpm"); | |
| 615 else | |
| 616 strcpy(s, ".xpm"); | |
| 617 } | |
| 618 | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
619 #if 0 |
| 7 | 620 /* Were we invoked by WorkShop? This function can be used early during startup |
| 621 if you want to do things differently if the editor is started standalone | |
| 622 or in WorkShop mode. For example, in standalone mode you may not want to | |
| 623 add a footer/message area or a sign gutter. */ | |
| 624 int | |
| 625 workshop_invoked() | |
| 626 { | |
| 627 static int result = -1; | |
| 628 if (result == -1) { | |
| 629 result = (getenv(NOCATGETS("SPRO_EDITOR_SOCKET")) != NULL); | |
| 630 } | |
| 631 return result; | |
| 632 } | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
633 #endif |
| 7 | 634 |
| 635 /* Connect back to eserve */ | |
| 636 void workshop_connect(XtAppContext context) | |
| 637 { | |
| 638 #ifdef INET_SOCKETS | |
| 639 struct sockaddr_in server; | |
| 640 struct hostent * host; | |
| 641 int port; | |
| 642 #else | |
| 643 struct sockaddr_un server; | |
| 644 #endif | |
| 645 char buf[32]; | |
| 646 char * address; | |
| 647 #ifdef DEBUG | |
| 648 char *file; | |
| 649 #endif | |
| 650 | |
| 651 address = getenv(NOCATGETS("SPRO_EDITOR_SOCKET")); | |
| 652 if (address == NULL) { | |
| 653 return; | |
| 654 } | |
| 655 | |
| 656 #ifdef INET_SOCKETS | |
| 657 port = atoi(address); | |
| 658 | |
| 659 if ((sd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { | |
| 660 PERROR(NOCATGETS("workshop_connect")); | |
| 661 return; | |
| 662 } | |
| 663 | |
| 664 /* Get the server internet address and put into addr structure */ | |
| 665 /* fill in the socket address structure and connect to server */ | |
|
2215
cccb71c2c5c1
Fix uninit memory read in undo code. Fix uint32_t in proto file.
Bram Moolenaar <bram@vim.org>
parents:
2031
diff
changeset
|
666 vim_memset((char *)&server, '\0', sizeof(server)); |
| 7 | 667 server.sin_family = AF_INET; |
| 668 server.sin_port = port; | |
| 669 if ((host = gethostbyname(NOCATGETS("localhost"))) == NULL) { | |
| 670 PERROR(NOCATGETS("gethostbyname")); | |
| 671 sd = -1; | |
| 672 return; | |
| 673 } | |
| 674 memcpy((char *)&server.sin_addr, host->h_addr, host->h_length); | |
| 675 #else | |
| 676 if ((sd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { | |
| 677 PERROR(NOCATGETS("workshop_connect")); | |
| 678 return; | |
| 679 } | |
| 680 | |
| 681 server.sun_family = AF_UNIX; | |
| 682 strcpy(server.sun_path, address); | |
| 683 #endif | |
| 684 /* Connect to server */ | |
| 685 if (connect(sd, (struct sockaddr *)&server, sizeof(server))) { | |
| 686 if (errno == ECONNREFUSED) { | |
| 687 close(sd); | |
| 688 #ifdef INET_SOCKETS | |
| 689 if ((sd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { | |
| 690 PERROR(NOCATGETS("workshop_connect")); | |
| 691 return; | |
| 692 } | |
| 693 #else | |
| 694 if ((sd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { | |
| 695 PERROR(NOCATGETS("workshop_connect")); | |
| 696 return; | |
| 697 } | |
| 698 #endif | |
| 699 if (connect(sd, (struct sockaddr *)&server, | |
| 700 sizeof(server))) { | |
| 701 PERROR(NOCATGETS("workshop_connect")); | |
| 702 return; | |
| 703 } | |
| 704 | |
| 705 } else { | |
| 706 PERROR(NOCATGETS("workshop_connect")); | |
| 707 return; | |
| 708 } | |
| 709 } | |
| 710 | |
| 711 /* tell notifier we are interested in being called | |
| 712 * when there is input on the editor connection socket | |
| 713 */ | |
| 714 inputHandler = XtAppAddInput(context, sd, (XtPointer) XtInputReadMask, | |
| 715 messageFromEserve, NULL); | |
| 716 #ifdef DEBUG | |
| 717 if ((file = getenv(NOCATGETS("SPRO_PLUGIN_DEBUG"))) != NULL) { | |
| 718 char buf[BUFSIZ]; | |
| 719 | |
| 720 unlink(file); | |
| 272 | 721 vim_snprintf(buf, sizeof(buf), "date > %s", file); |
| 7 | 722 system(buf); |
| 723 dfd = fopen(file, "a"); | |
| 724 } else { | |
| 725 dfd = NULL; | |
| 726 } | |
| 727 #endif | |
| 728 | |
| 272 | 729 vim_snprintf(buf, sizeof(buf), NOCATGETS("connected %s %s %s\n"), |
| 7 | 730 workshop_get_editor_name(), |
| 731 PROTOCOL_VERSION, | |
| 732 workshop_get_editor_version()); | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
733 dummy = write(sd, buf, strlen(buf)); |
| 7 | 734 |
| 272 | 735 vim_snprintf(buf, sizeof(buf), NOCATGETS("ack 1\n")); |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
736 dummy = write(sd, buf, strlen(buf)); |
| 7 | 737 } |
| 738 | |
| 739 void workshop_disconnect() | |
| 740 { | |
| 741 /* Probably need to send some message here */ | |
| 742 | |
| 743 /* | |
| 744 * socket closed on other end | |
| 745 */ | |
| 746 XtRemoveInput(inputHandler); | |
| 747 close(sd); | |
| 748 inputHandler = 0; | |
| 749 sd = -1; | |
| 750 | |
| 751 } | |
| 752 | |
| 753 /* | |
| 754 * Utility functions | |
| 755 */ | |
| 756 | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
757 #if 0 |
| 7 | 758 /* Set icon for the window */ |
| 759 void | |
| 760 workshop_set_icon(Display *display, Widget shell, char **xpmdata, | |
| 761 int width, int height) | |
| 762 { | |
| 763 Pixel bgPixel; | |
| 764 XpmAttributes xpmAttributes; | |
| 765 XSetWindowAttributes attr; | |
| 766 Window iconWindow; | |
| 767 int depth; | |
| 768 int screenNum; | |
| 769 Pixmap pixmap; | |
| 770 | |
| 771 /* Create the pixmap/icon window which is shown when you | |
| 772 * iconify the sccs viewer | |
| 773 * This code snipped was adapted from Sun WorkShop's source base, | |
| 774 * setIcon.cc. | |
| 775 */ | |
| 776 XtVaGetValues(shell, XmNbackground, &bgPixel, NULL); | |
| 777 screenNum = XScreenNumberOfScreen(XtScreen(shell)); | |
| 778 depth = DisplayPlanes(display, screenNum); | |
| 779 xpmAttributes.valuemask = XpmColorSymbols; | |
| 780 xpmAttributes.numsymbols = 1; | |
| 781 xpmAttributes.colorsymbols = | |
| 782 (XpmColorSymbol *)XtMalloc(sizeof (XpmColorSymbol) * | |
| 783 xpmAttributes.numsymbols); | |
| 784 xpmAttributes.colorsymbols[0].name = NOCATGETS("BgColor"); | |
| 785 xpmAttributes.colorsymbols[0].value = NULL; | |
| 786 xpmAttributes.colorsymbols[0].pixel = bgPixel; | |
| 787 if (XpmCreatePixmapFromData(display, | |
| 788 RootWindow(display, screenNum), xpmdata, &pixmap, | |
| 789 NULL, &xpmAttributes) >= 0) { | |
| 790 attr.background_pixmap = pixmap; | |
| 791 iconWindow = XCreateWindow(display, RootWindow(display, | |
| 792 screenNum), 0, 0, width, height, 0, depth, | |
| 793 (unsigned int)CopyFromParent, | |
| 794 CopyFromParent, CWBackPixmap, &attr); | |
| 795 | |
| 796 XtVaSetValues(shell, | |
| 797 XtNiconWindow, iconWindow, NULL); | |
| 798 } | |
| 799 XtFree((char *)xpmAttributes.colorsymbols); | |
| 800 } | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
801 #endif |
| 7 | 802 |
| 803 /* Minimize and maximize shells. From libutil's shell.cc. */ | |
| 804 | |
| 805 /* utility functions from libutil's shell.cc */ | |
| 806 static Boolean | |
| 807 isWindowMapped(Display *display, Window win) | |
| 808 { | |
| 809 XWindowAttributes winAttrs; | |
| 810 XGetWindowAttributes(display, | |
| 811 win, | |
| 812 &winAttrs); | |
| 813 if (winAttrs.map_state == IsViewable) { | |
| 814 return(True); | |
| 815 } else { | |
| 816 return(False); | |
| 817 } | |
| 818 } | |
| 819 | |
| 820 static Boolean | |
| 821 isMapped(Widget widget) | |
| 822 { | |
| 823 if (widget == NULL) { | |
| 824 return(False); | |
| 825 } | |
| 826 | |
| 827 if (XtIsRealized(widget) == False) { | |
| 828 return(False); | |
| 829 } | |
| 830 | |
| 831 return(isWindowMapped(XtDisplay(widget), XtWindow(widget))); | |
| 832 } | |
| 833 | |
| 834 static Boolean | |
| 835 widgetIsIconified( | |
| 836 Widget w) | |
| 837 { | |
| 838 Atom wm_state; | |
| 839 Atom act_type; /* actual Atom type returned */ | |
| 840 int act_fmt; /* actual format returned */ | |
| 841 u_long nitems_ret; /* number of items returned */ | |
| 842 u_long bytes_after; /* number of bytes remaining */ | |
| 843 u_long *property; /* actual property returned */ | |
| 844 | |
| 845 /* | |
| 846 * If a window is iconified its WM_STATE is set to IconicState. See | |
| 847 * ICCCM Version 2.0, section 4.1.3.1 for more details. | |
| 848 */ | |
| 849 | |
| 850 wm_state = XmInternAtom(XtDisplay(w), NOCATGETS("WM_STATE"), False); | |
| 851 if (XtWindow(w) != 0) { /* only check if window exists! */ | |
| 852 XGetWindowProperty(XtDisplay(w), XtWindow(w), wm_state, 0L, 2L, | |
| 853 False, AnyPropertyType, &act_type, &act_fmt, &nitems_ret, | |
| 854 &bytes_after, (u_char **) &property); | |
| 855 if (nitems_ret == 2 && property[0] == IconicState) { | |
| 856 return True; | |
| 857 } | |
| 858 } | |
| 859 | |
| 860 return False; | |
| 861 | |
| 862 } /* end widgetIsIconified */ | |
| 863 | |
| 864 void | |
| 865 workshop_minimize_shell(Widget shell) | |
| 866 { | |
| 867 if (shell != NULL && | |
| 868 XtIsObject(shell) && | |
| 869 XtIsRealized(shell) == True) { | |
| 870 if (isMapped(shell) == True) { | |
| 871 XIconifyWindow(XtDisplay(shell), XtWindow(shell), | |
| 872 XScreenNumberOfScreen(XtScreen(shell))); | |
| 873 } | |
| 874 XtVaSetValues(shell, | |
| 875 XmNiconic, True, | |
| 876 NULL); | |
| 877 } | |
| 878 } | |
| 879 | |
| 880 void workshop_maximize_shell(Widget shell) | |
| 881 { | |
| 882 if (shell != NULL && | |
| 883 XtIsRealized(shell) == True && | |
| 884 widgetIsIconified(shell) == True && | |
| 885 isMapped(shell) == False) { | |
| 886 XtMapWidget(shell); | |
| 887 /* This used to be | |
| 888 XtPopdown(shell); | |
| 889 XtPopup(shell, XtGrabNone); | |
| 890 However, I found that that would drop any transient | |
| 891 windows that had been iconified with the window. | |
| 892 According to the ICCCM, XtMapWidget should be used | |
| 893 to bring a window from Iconic to Normal state. | |
| 894 However, Rich Mauri did a lot of work on this during | |
| 895 Bart, and found that XtPopDown,XtPopup was required | |
| 896 to fix several bugs involving multiple CDE workspaces. | |
| 897 I've tested it now and things seem to work fine but | |
| 898 I'm leaving this note for history in case this needs | |
| 899 to be revisited. | |
| 900 */ | |
| 901 } | |
| 902 } | |
| 903 | |
| 904 | |
| 905 Boolean workshop_get_width_height(int *width, int *height) | |
| 906 { | |
| 907 static int wid = 0; | |
| 908 static int hgt = 0; | |
| 909 static Boolean firstTime = True; | |
| 910 static Boolean success = False; | |
| 911 | |
| 912 if (firstTime) { | |
| 913 char *settings; | |
| 914 | |
| 915 settings = getenv(NOCATGETS("SPRO_GUI_WIDTH_HEIGHT")); | |
| 916 if (settings != NULL) { | |
| 917 wid = atoi(settings); | |
| 918 settings = strrchr(settings, ':'); | |
| 919 if (settings++ != NULL) { | |
| 920 hgt = atoi(settings); | |
| 921 } | |
| 922 if (wid > 0 && hgt > 0) { | |
| 923 success = True; | |
| 924 } | |
| 925 firstTime = False; | |
| 926 } | |
| 927 } | |
| 928 | |
| 929 if (success) { | |
| 930 *width = wid; | |
| 931 *height = hgt; | |
| 932 } | |
| 933 return success; | |
| 934 } | |
| 935 | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
936 #if 0 |
| 7 | 937 Boolean workshop_get_rows_cols(int *rows, int *cols) |
| 938 { | |
| 939 static int r = 0; | |
| 940 static int c = 0; | |
| 941 static Boolean firstTime = True; | |
| 942 static Boolean success = False; | |
| 943 | |
| 944 if (firstTime) { | |
| 945 char *settings; | |
| 946 | |
| 947 settings = getenv(NOCATGETS("SPRO_GUI_ROWS_COLS")); | |
| 948 if (settings != NULL) { | |
| 949 r = atoi(settings); | |
| 950 settings = strrchr(settings, ':'); | |
| 951 if (settings++ != NULL) { | |
| 952 c = atoi(settings); | |
| 953 } | |
| 954 if (r > 0 && c > 0) { | |
| 955 success = True; | |
| 956 } | |
| 957 firstTime = False; | |
| 958 } | |
| 959 } | |
| 960 | |
| 961 if (success) { | |
| 962 *rows = r; | |
| 963 *cols = c; | |
| 964 } | |
| 965 return success; | |
| 966 } | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
967 #endif |
| 7 | 968 |
| 969 /* | |
| 970 * Toolbar code | |
| 971 */ | |
| 972 | |
| 973 void workshop_sensitivity(int num, char *table) | |
| 974 { | |
| 975 /* build up a verb table */ | |
| 976 VerbSense *vs; | |
| 977 int i; | |
| 978 char *s; | |
| 979 if ((num < 1) || (num > 500)) { | |
| 980 return; | |
| 981 } | |
| 982 | |
| 983 vs = (VerbSense *)malloc((num+1)*sizeof(VerbSense)); | |
| 984 | |
| 985 /* Point to the individual names (destroys the table string, but | |
| 986 * that's okay -- this is more efficient than duplicating strings) */ | |
| 987 s = table; | |
| 988 for (i = 0; i < num; i++) { | |
| 989 while (*s == ' ') { | |
| 990 s++; | |
| 991 } | |
| 992 vs[i].verb = s; | |
| 993 while (*s && (*s != ' ') && (*s != '\001')) { | |
| 994 s++; | |
| 995 } | |
| 996 if (*s == 0) { | |
| 997 vs[i].verb = NULL; | |
| 998 break; | |
| 999 } | |
| 1000 if (*s == '\001') { | |
| 1001 *s = 0; | |
| 1002 s++; | |
| 1003 } | |
| 1004 *s = 0; | |
| 1005 s++; | |
| 1006 while (*s == ' ') { | |
| 1007 s++; | |
| 1008 } | |
| 1009 if (*s == '1') { | |
| 1010 vs[i].sense = 1; | |
| 1011 } else { | |
| 1012 vs[i].sense = 0; | |
| 1013 } | |
| 1014 s++; | |
| 1015 } | |
| 1016 vs[i].verb = NULL; | |
| 1017 | |
| 1018 workshop_frame_sensitivities(vs); | |
| 1019 | |
| 1020 free(vs); | |
| 1021 } | |
| 1022 | |
| 1023 /* | |
| 1024 * Options code | |
| 1025 */ | |
| 1026 /* Set an editor option. | |
| 1027 * IGNORE an option if you do not recognize it. | |
| 1028 */ | |
| 1029 void workshop_set_option_first(char *name, char *value) | |
| 1030 { | |
| 1031 /* Currently value can only be on/off. This may change later (for | |
| 1032 * example to set an option like "balloon evaluate delay", but | |
| 1033 * for now just convert it into a boolean */ | |
| 1034 Boolean on = !strcmp(value, "on"); | |
| 1035 | |
| 1036 if (!strcmp(name, "workshopkeys")) { | |
| 1037 workshop_hotkeys(on); | |
| 1038 } else if (!strcmp(name, "savefiles")) { | |
| 1039 save_files = on; | |
| 1040 } else if (!strcmp(name, "balloon")) { | |
| 1041 workshop_balloon_mode(on); | |
| 1042 } else if (!strcmp(name, "balloondelay")) { | |
| 1043 int delay = atoi(value); | |
| 1044 /* Should I validate the number here?? */ | |
| 1045 workshop_balloon_delay(delay); | |
| 1046 } else { | |
| 1047 /* Let editor interpret it */ | |
| 1048 workshop_set_option(name, value); | |
| 1049 } | |
| 1050 } | |
| 1051 | |
| 1052 | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1053 #if 0 |
| 7 | 1054 /* |
| 1055 * Send information to eserve on certain editor events | |
| 1056 * You must make sure these are called when necessary | |
| 1057 */ | |
| 1058 void workshop_file_closed(char *filename) | |
| 1059 { | |
| 1060 char buffer[2*MAXPATHLEN]; | |
| 272 | 1061 vim_snprintf(buffer, sizeof(buffer), |
| 1062 NOCATGETS("deletedFile %s\n"), filename); | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1063 dummy = write(sd, buffer, strlen(buffer)); |
| 7 | 1064 } |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1065 #endif |
| 7 | 1066 |
| 1067 void workshop_file_closed_lineno(char *filename, int lineno) | |
| 1068 { | |
| 1069 char buffer[2*MAXPATHLEN]; | |
| 272 | 1070 vim_snprintf(buffer, sizeof(buffer), |
| 1071 NOCATGETS("deletedFile %s %d\n"), filename, lineno); | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1072 dummy = write(sd, buffer, strlen(buffer)); |
| 7 | 1073 } |
| 1074 | |
| 1075 void workshop_file_opened(char *filename, int readOnly) | |
| 1076 { | |
| 1077 char buffer[2*MAXPATHLEN]; | |
| 272 | 1078 vim_snprintf(buffer, sizeof(buffer), |
| 1079 NOCATGETS("loadedFile %s %d\n"), filename, readOnly); | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1080 dummy = write(sd, buffer, strlen(buffer)); |
| 7 | 1081 } |
| 1082 | |
| 1083 | |
| 1084 void workshop_file_saved(char *filename) | |
| 1085 { | |
| 1086 char buffer[2*MAXPATHLEN]; | |
| 272 | 1087 vim_snprintf(buffer, sizeof(buffer), |
| 1088 NOCATGETS("savedFile %s\n"), filename); | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1089 dummy = write(sd, buffer, strlen(buffer)); |
| 7 | 1090 |
| 1091 /* Let editor report any moved marks that the eserve client | |
| 1092 * should deal with (for example, moving location-based breakpoints) */ | |
| 1093 workshop_moved_marks(filename); | |
| 1094 } | |
| 1095 | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1096 #if 0 |
| 7 | 1097 void workshop_file_modified(char *filename) |
| 1098 { | |
| 1099 char buffer[2*MAXPATHLEN]; | |
| 272 | 1100 vim_snprintf(buffer, sizeof(buffer), |
| 1101 NOCATGETS("modifiedFile %s\n"), filename); | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1102 dummy = write(sd, buffer, strlen(buffer)); |
| 7 | 1103 } |
| 1104 | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1105 void workshop_move_mark(char *filename, int markId, int newLineno) |
|
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1106 { |
|
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1107 char buffer[2*MAXPATHLEN]; |
|
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1108 vim_snprintf(buffer, sizeof(buffer), |
|
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1109 NOCATGETS("moveMark %s %d %d\n"), filename, markId, newLineno); |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1110 dummy = write(sd, buffer, strlen(buffer)); |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1111 } |
|
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1112 #endif |
|
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1113 |
| 7 | 1114 void workshop_frame_moved(int new_x, int new_y, int new_w, int new_h) |
| 1115 { | |
| 1116 char buffer[200]; | |
| 1117 | |
| 1118 if (sd >= 0) | |
| 1119 { | |
| 272 | 1120 vim_snprintf(buffer, sizeof(buffer), |
| 1121 NOCATGETS("frameAt %d %d %d %d\n"), | |
| 7 | 1122 new_x, new_y, new_w, new_h); |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1123 dummy = write(sd, buffer, strlen(buffer)); |
| 7 | 1124 } |
| 1125 } | |
| 1126 | |
| 1127 /* A button in the toolbar has been pushed. | |
| 1128 * Clientdata is a pointer used by the editor code to figure out the | |
| 1129 * positions for this toolbar (probably by storing a window pointer, | |
| 1130 * and then fetching the current buffer for that window and looking up | |
| 1131 * cursor and selection positions etc.) */ | |
| 1132 void workshop_perform_verb(char *verb, void *clientData) | |
| 1133 { | |
| 1134 char *filename; | |
| 1135 int curLine; | |
| 1136 int curCol; | |
| 1137 int selStartLine; | |
| 1138 int selStartCol; | |
| 1139 int selEndLine; | |
| 1140 int selEndCol; | |
| 1141 int selLength; | |
| 1142 char *selection; | |
| 1143 | |
| 1144 char buf[2*MAXPATHLEN]; | |
| 1145 /* Later: needsFilePos indicates whether or not we need to fetch all this | |
| 1146 * info for this verb... for now, however, it looks as if | |
| 1147 * eserve parsing routines depend on it always being present */ | |
| 1148 | |
| 1149 if (workshop_get_positions(clientData, | |
| 1150 &filename, | |
| 1151 &curLine, | |
| 1152 &curCol, | |
| 1153 &selStartLine, | |
| 1154 &selStartCol, | |
| 1155 &selEndLine, | |
| 1156 &selEndCol, | |
| 1157 &selLength, | |
| 1158 &selection)) { | |
| 1159 if (selection == NULL) { | |
| 1160 selection = NOCATGETS(""); | |
| 1161 } | |
| 1162 | |
| 1163 /* Should I save the files??? This is currently done by checking | |
| 1164 if the verb is one of a few recognized ones. Later we can pass | |
| 1165 this list from eserve to the editor (it's currently hardcoded in | |
| 1166 vi and emacs as well). */ | |
| 1167 if (save_files) { | |
| 1168 if (!strcmp(verb, "build.build") || !strcmp(verb, "build.build-file") || | |
| 1169 !strcmp(verb, "debug.fix") || !strcmp(verb, "debug.fix-all")) { | |
| 1170 workshop_save_files(); | |
| 1171 } | |
| 1172 } | |
| 1173 | |
| 272 | 1174 vim_snprintf(buf, sizeof(buf), |
| 1175 NOCATGETS("toolVerb %s %s %d,%d %d,%d %d,%d %d %s\n"), | |
| 7 | 1176 verb, |
| 1177 filename, | |
| 1178 curLine, curCol, | |
| 1179 selStartLine, selStartCol, | |
| 1180 selEndLine, selEndCol, | |
| 1181 selLength, | |
| 1182 selection); | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1183 dummy = write(sd, buf, strlen(buf)); |
| 7 | 1184 if (*selection) { |
| 1185 free(selection); | |
| 1186 } | |
| 1187 } | |
| 1188 } | |
| 1189 | |
| 1190 /* Send a message to eserve */ | |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1191 #if defined(NOHANDS_SUPPORT_FUNCTIONS) || defined(FEAT_BEVAL) |
| 7 | 1192 void workshop_send_message(char *buf) |
| 1193 { | |
|
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2245
diff
changeset
|
1194 dummy = write(sd, buf, strlen(buf)); |
| 7 | 1195 } |
|
2031
07de57cbcb25
updated for version 7.2.327
Bram Moolenaar <bram@zimbu.org>
parents:
1619
diff
changeset
|
1196 #endif |
| 7 | 1197 |
| 1198 /* Some methods, like currentFile, cursorPos, etc. are missing here. | |
| 1199 * But it looks like these are used for NoHands testing only so we | |
| 1200 * won't bother requiring editors to implement these | |
| 1201 */ | |
| 1202 | |
| 1203 | |
| 1204 #ifdef DEBUG | |
| 1205 | |
| 1206 void | |
| 1207 pldebug( | |
| 1208 char *fmt, /* a printf style format line */ | |
| 1209 ...) | |
| 1210 { | |
| 1211 va_list ap; | |
| 1212 | |
| 1213 if (dfd != NULL) { | |
| 1214 va_start(ap, fmt); | |
| 1215 vfprintf(dfd, fmt, ap); | |
| 1216 va_end(ap); | |
| 1217 fflush(dfd); | |
| 1218 } | |
| 1219 | |
| 1220 } /* end pldebug */ | |
| 1221 | |
| 1222 #endif |