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