source/menu.c

   1 static const char CVSID[] = "$Id: menu.c,v 1.66 2002/11/08 20:22:45 edg Exp $";
   2 /*******************************************************************************
   3 *                                                                              *
   4 * menu.c -- Nirvana Editor menus                                               *
   5 *                                                                              *
   6 * Copyright (C) 1999 Mark Edel                                                 *
   7 *                                                                              *
   8 * This is free software; you can redistribute it and/or modify it under the    *
   9 * terms of the GNU General Public License as published by the Free Software    *
  10 * Foundation; either version 2 of the License, or (at your option) any later   *
  11 * version.                                                                     *
  12 *                                                                              *
  13 * This software is distributed in the hope that it will be useful, but WITHOUT *
  14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
  15 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License        *
  16 * for more details.                                                            *
  17 *                                                                              *
  18 * You should have received a copy of the GNU General Public License along with *
  19 * software; if not, write to the Free Software Foundation, Inc., 59 Temple     *
  20 * Place, Suite 330, Boston, MA  02111-1307 USA                                 *
  21 *                                                                              *
  22 * Nirvana Text Editor                                                          *
  23 * May 10, 1991                                                                 *
  24 *                                                                              *
  25 * Written by Mark Edel                                                         *
  26 *                                                                              *
  27 *******************************************************************************/
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "../config.h"
  31 #endif
  32
  33 #include "menu.h"
  34 #include "textBuf.h"
  35 #include "text.h"
  36 #include "nedit.h"
  37 #include "file.h"
  38 #include "window.h"
  39 #include "search.h"
  40 #include "selection.h"
  41 #include "undo.h"
  42 #include "shift.h"
  43 #include "help.h"
  44 #include "preferences.h"
  45 #include "tags.h"
  46 #include "userCmds.h"
  47 #include "shell.h"
  48 #include "macro.h"
  49 #include "highlight.h"
  50 #include "highlightData.h"
  51 #include "interpret.h"
  52 #include "smartIndent.h"
  53 #include "windowTitle.h"
  54 #include "../util/getfiles.h"
  55 #include "../util/DialogF.h"
  56 #include "../util/misc.h"
  57 #include "../util/fileUtils.h"
  58 #include "../util/utils.h"
  59
  60 #include <stdlib.h>
  61 #include <stdio.h>
  62 #include <string.h>
  63 #include <ctype.h>
  64 #ifdef VMS
  65 #include "../util/VMSparam.h"
  66 #else
  67 #ifndef __MVS__
  68 #include <sys/param.h>
  69 #endif
  70 #endif /*VMS*/
  71 #include <X11/X.h>
  72 #include <Xm/Xm.h>
  73 #include <Xm/CascadeB.h>
  74 #include <Xm/PushB.h>
  75 #include <Xm/ToggleB.h>
  76 #include <Xm/RowColumn.h>
  77 #include <Xm/Separator.h>
  78 #include <Xm/MenuShell.h>
  79
  80 #ifdef HAVE_DEBUG_H
  81 #include "../debug.h"
  82 #endif
  83
  84 #if XmVersion >= 1002
  85 #define MENU_WIDGET(w) (XmGetPostedFromWidget(XtParent(w)))
  86 #else
  87 #define MENU_WIDGET(w) (w)
  88 #endif
  89
  90 /* Menu modes for SGI_CUSTOM short-menus feature */
  91 enum menuModes {FULL, SHORT};
  92
  93 typedef void (*menuCallbackProc)();
  94
  95 static void doActionCB(Widget w, XtPointer clientData, XtPointer callData);
  96 static void pasteColCB(Widget w, XtPointer clientData, XtPointer callData);
  97 static void shiftLeftCB(Widget w, XtPointer clientData, XtPointer callData);
  98 static void shiftRightCB(Widget w, XtPointer clientData, XtPointer callData);
  99 static void findCB(Widget w, XtPointer clientData, XtPointer callData);
 100 static void findSameCB(Widget w, XtPointer clientData, XtPointer callData);
 101 static void findSelCB(Widget w, XtPointer clientData, XtPointer callData);
 102 static void findIncrCB(Widget w, XtPointer clientData, XtPointer callData);
 103 static void replaceCB(Widget w, XtPointer clientData, XtPointer callData);
 104 static void replaceSameCB(Widget w, XtPointer clientData, XtPointer callData);
 105 static void replaceFindSameCB(Widget w, XtPointer clientData, XtPointer callData);
 106 static void markCB(Widget w, XtPointer clientData, XtPointer callData);
 107 static void gotoMarkCB(Widget w, XtPointer clientData, XtPointer callData);
 108 static void gotoMatchingCB(Widget w, XtPointer clientData, XtPointer callData);
 109 static void autoIndentOffCB(Widget w, WindowInfo *window, caddr_t callData);
 110 static void autoIndentCB(Widget w, WindowInfo *window, caddr_t callData);
 111 static void smartIndentCB(Widget w, WindowInfo *window, caddr_t callData);
 112 static void preserveCB(Widget w, WindowInfo *window, caddr_t callData);
 113 static void autoSaveCB(Widget w, WindowInfo *window, caddr_t callData);
 114 static void newlineWrapCB(Widget w, WindowInfo *window, caddr_t callData);
 115 static void noWrapCB(Widget w, WindowInfo *window, caddr_t callData);
 116 static void continuousWrapCB(Widget w, WindowInfo *window, caddr_t callData);
 117 static void wrapMarginCB(Widget w, WindowInfo *window, caddr_t callData);
 118 static void fontCB(Widget w, WindowInfo *window, caddr_t callData);
 119 static void tabsCB(Widget w, WindowInfo *window, caddr_t callData);
 120 static void backlightCharsCB(Widget w, WindowInfo *window, caddr_t callData);
 121 static void showMatchingOffCB(Widget w, WindowInfo *window, caddr_t callData);
 122 static void showMatchingDelimitCB(Widget w, WindowInfo *window, caddr_t callData);
 123 static void showMatchingRangeCB(Widget w, WindowInfo *window, caddr_t callData);
 124 static void matchSyntaxBasedCB(Widget w, WindowInfo *window, caddr_t callData);
 125 static void statsCB(Widget w, WindowInfo *window, caddr_t callData);
 126 static void autoIndentOffDefCB(Widget w, WindowInfo *window, caddr_t callData);
 127 static void autoIndentDefCB(Widget w, WindowInfo *window, caddr_t callData);
 128 static void smartIndentDefCB(Widget w, WindowInfo *window, caddr_t callData);
 129 static void autoSaveDefCB(Widget w, WindowInfo *window, caddr_t callData);
 130 static void preserveDefCB(Widget w, WindowInfo *window, caddr_t callData);
 131 static void noWrapDefCB(Widget w, WindowInfo *window, caddr_t callData);
 132 static void newlineWrapDefCB(Widget w, WindowInfo *window, caddr_t callData);
 133 static void contWrapDefCB(Widget w, WindowInfo *window, caddr_t callData);
 134 static void wrapMarginDefCB(Widget w, WindowInfo *window, caddr_t callData);
 135 static void statsLineDefCB(Widget w, WindowInfo *window, caddr_t callData);
 136 static void iSearchLineDefCB(Widget w, WindowInfo *window, caddr_t callData);
 137 static void lineNumsDefCB(Widget w, WindowInfo *window, caddr_t callData);
 138 static void pathInWindowsMenuDefCB(Widget w, WindowInfo *window, caddr_t callData);
 139 static void customizeTitleDefCB(Widget w, WindowInfo *window, caddr_t callData);
 140 static void tabsDefCB(Widget w, WindowInfo *window, caddr_t callData);
 141 static void showMatchingOffDefCB(Widget w, WindowInfo *window, caddr_t callData);
 142 static void showMatchingDelimitDefCB(Widget w, WindowInfo *window, caddr_t callData);
 143 static void showMatchingRangeDefCB(Widget w, WindowInfo *window, caddr_t callData);
 144 static void matchSyntaxBasedDefCB(Widget w, WindowInfo *window, caddr_t callData);
 145 static void highlightOffDefCB(Widget w, WindowInfo *window, caddr_t callData);
 146 static void highlightDefCB(Widget w, WindowInfo *window, caddr_t callData);
 147 static void backlightCharsDefCB(Widget w, WindowInfo *window, caddr_t callData);
 148 static void backlightCharTypesDefCB(Widget w, WindowInfo *window,
 149         caddr_t callData);
 150 static void fontDefCB(Widget w, WindowInfo *window, caddr_t callData);
 151 static void smartTagsDefCB(Widget parent, XtPointer client_data, XtPointer call_data);
 152 static void showAllTagsDefCB(Widget parent, XtPointer client_data, XtPointer call_data);
 153 static void languageDefCB(Widget w, WindowInfo *window, caddr_t callData);
 154 static void highlightingDefCB(Widget w, WindowInfo *window, caddr_t callData);
 155 static void smartMacrosDefCB(Widget w, WindowInfo *window, caddr_t callData);
 156 static void stylesDefCB(Widget w, WindowInfo *window, caddr_t callData);
 157 static void shellDefCB(Widget w, WindowInfo *window, caddr_t callData);
 158 static void macroDefCB(Widget w, WindowInfo *window, caddr_t callData);
 159 static void bgMenuDefCB(Widget w, WindowInfo *window, caddr_t callData);
 160 static void searchDlogsDefCB(Widget w, WindowInfo *window, caddr_t callData);
 161 static void beepOnSearchWrapDefCB(Widget w, WindowInfo *window, caddr_t callData);
 162 static void keepSearchDlogsDefCB(Widget w, WindowInfo *window,
 163         caddr_t callData);
 164 static void searchWrapsDefCB(Widget w, WindowInfo *window, caddr_t callData);
 165 static void appendLFCB(Widget w, WindowInfo* window, caddr_t callData);
 166 static void sortOpenPrevDefCB(Widget w, WindowInfo *window, caddr_t callData);
 167 static void reposDlogsDefCB(Widget w, WindowInfo *window, caddr_t callData);
 168 static void modWarnDefCB(Widget w, WindowInfo *window, caddr_t callData);
 169 static void modWarnRealDefCB(Widget w, WindowInfo *window, caddr_t callData);
 170 static void exitWarnDefCB(Widget w, WindowInfo *window, caddr_t callData);
 171 static void searchLiteralCB(Widget w, WindowInfo *window, caddr_t callData);
 172 static void searchCaseSenseCB(Widget w, WindowInfo *window, caddr_t callData);
 173 static void searchLiteralWordCB(Widget w, WindowInfo *window, caddr_t callData);
 174 static void searchCaseSenseWordCB(Widget w, WindowInfo *window, caddr_t callData);
 175 static void searchRegexNoCaseCB(Widget w, WindowInfo *window, caddr_t callData);
 176 static void searchRegexCB(Widget w, WindowInfo *window, caddr_t callData);
 177 #ifdef REPLACE_SCOPE
 178 static void replaceScopeWindowCB(Widget w, WindowInfo *window, caddr_t callData);
 179 static void replaceScopeSelectionCB(Widget w, WindowInfo *window, caddr_t callData);
 180 static void replaceScopeSmartCB(Widget w, WindowInfo *window, caddr_t callData);
 181 #endif
 182 static void size24x80CB(Widget w, WindowInfo *window, caddr_t callData);
 183 static void size40x80CB(Widget w, WindowInfo *window, caddr_t callData);
 184 static void size60x80CB(Widget w, WindowInfo *window, caddr_t callData);
 185 static void size80x80CB(Widget w, WindowInfo *window, caddr_t callData);
 186 static void sizeCustomCB(Widget w, WindowInfo *window, caddr_t callData);
 187 static void savePrefCB(Widget w, WindowInfo *window, caddr_t callData);
 188 static void formFeedCB(Widget w, XtPointer clientData, XtPointer callData);
 189 static void cancelShellCB(Widget w, WindowInfo *window, XtPointer callData);
 190 static void learnCB(Widget w, WindowInfo *window, caddr_t callData);
 191 static void finishLearnCB(Widget w, WindowInfo *window, caddr_t callData);
 192 static void cancelLearnCB(Widget w, WindowInfo *window, caddr_t callData);
 193 static void replayCB(Widget w, WindowInfo *window, caddr_t callData);
 194 static void windowMenuCB(Widget w, WindowInfo *window, caddr_t callData);
 195 static void prevOpenMenuCB(Widget w, WindowInfo *window, caddr_t callData);
 196 static void unloadTagsFileMenuCB(Widget w, WindowInfo *window,
 197         caddr_t callData);
 198 static void unloadTipsFileMenuCB(Widget w, WindowInfo *window,
 199         caddr_t callData);
 200 static void newAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 201 static void openDialogAP(Widget w, XEvent *event, String *args,
 202         Cardinal *nArgs);
 203 static void openAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 204 static void openSelectedAP(Widget w, XEvent *event, String *args,
 205         Cardinal *nArgs);
 206 static void closeAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 207 static void saveAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 208 static void saveAsDialogAP(Widget w, XEvent *event, String *args,
 209         Cardinal *nArgs);
 210 static void saveAsAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 211 static void revertDialogAP(Widget w, XEvent *event, String *args,
 212         Cardinal *nArgs);
 213 static void revertAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 214 static void includeDialogAP(Widget w, XEvent *event, String *args,
 215         Cardinal *nArgs);
 216 static void includeAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 217 static void loadMacroDialogAP(Widget w, XEvent *event, String *args,
 218         Cardinal *nArgs) ;
 219 static void loadMacroAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 220 static void loadTagsDialogAP(Widget w, XEvent *event, String *args,
 221         Cardinal *nArgs);
 222 static void loadTagsAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 223 static void unloadTagsAP(Widget w, XEvent *event, String *args,
 224         Cardinal *nArgs);
 225 static void loadTipsDialogAP(Widget w, XEvent *event, String *args,
 226         Cardinal *nArgs);
 227 static void loadTipsAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 228 static void unloadTipsAP(Widget w, XEvent *event, String *args,
 229         Cardinal *nArgs);
 230 static void printAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 231 static void printSelAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 232 static void exitAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 233 static void undoAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 234 static void redoAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 235 static void clearAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 236 static void selAllAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 237 static void shiftLeftAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 238 static void shiftLeftTabAP(Widget w, XEvent *event, String *args,
 239         Cardinal *nArgs);
 240 static void shiftRightAP(Widget w, XEvent *event, String *args,
 241         Cardinal *nArgs);
 242 static void shiftRightTabAP(Widget w, XEvent *event, String *args,
 243         Cardinal *nArgs);
 244 static void findDialogAP(Widget w, XEvent *event, String *args,
 245         Cardinal *nArgs);
 246 static void findAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 247 static void findSameAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 248 static void findSelAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 249 static void findIncrAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 250 static void startIncrFindAP(Widget w, XEvent *event, String *args,
 251         Cardinal *nArgs);
 252 static void replaceDialogAP(Widget w, XEvent *event, String *args,
 253         Cardinal *nArgs);
 254 static void replaceAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 255 static void replaceAllAP(Widget w, XEvent *event, String *args,
 256         Cardinal *nArgs);
 257 static void replaceInSelAP(Widget w, XEvent *event, String *args,
 258         Cardinal *nArgs);
 259 static void replaceSameAP(Widget w, XEvent *event, String *args,
 260         Cardinal *nArgs);
 261 static void replaceFindAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 262 static void replaceFindSameAP(Widget w, XEvent *event, String *args,
 263         Cardinal *nArgs);
 264 static void gotoAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 265 static void gotoDialogAP(Widget w, XEvent *event, String *args,
 266         Cardinal *nArgs);
 267 static void gotoSelectedAP(Widget w, XEvent *event, String *args,
 268         Cardinal *nArgs);
 269 static void repeatDialogAP(Widget w, XEvent *event, String *args,
 270         Cardinal *nArgs);
 271 static void repeatMacroAP(Widget w, XEvent *event, String *args,
 272         Cardinal *nArgs);
 273 static void markAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 274 static void markDialogAP(Widget w, XEvent *event, String *args,
 275         Cardinal *nArgs);
 276 static void gotoMarkAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 277 static void gotoMarkDialogAP(Widget w, XEvent *event, String *args,
 278         Cardinal *nArgs);
 279 static void selectToMatchingAP(Widget w, XEvent *event, String *args,
 280         Cardinal *nArgs);
 281 static void gotoMatchingAP(Widget w, XEvent *event, String *args,
 282         Cardinal *nArgs);
 283 static void findDefAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 284 static void showTipAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 285 static void splitWindowAP(Widget w, XEvent *event, String *args,
 286         Cardinal *nArgs);
 287 static void closePaneAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 288 static void capitalizeAP(Widget w, XEvent *event, String *args,
 289         Cardinal *nArgs);
 290 static void lowercaseAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 291 static void fillAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 292 static void controlDialogAP(Widget w, XEvent *event, String *args,
 293         Cardinal *nArgs);
 294 #ifndef VMS
 295 static void filterDialogAP(Widget w, XEvent *event, String *args,
 296         Cardinal *nArgs);
 297 static void shellFilterAP(Widget w, XEvent *event, String *args,
 298         Cardinal *nArgs);
 299 static void execDialogAP(Widget w, XEvent *event, String *args,
 300         Cardinal *nArgs);
 301 static void execAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 302 static void execLineAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 303 static void shellMenuAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 304 #endif
 305 static void macroMenuAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 306 static void bgMenuAP(Widget w, XEvent *event, String *args, Cardinal *nArgs);
 307 static void beginningOfSelectionAP(Widget w, XEvent *event, String *args,
 308         Cardinal *nArgs);
 309 static void endOfSelectionAP(Widget w, XEvent *event, String *args,
 310         Cardinal *nArgs);
 311 static Widget createMenu(Widget parent, char *name, char *label,
 312         char mnemonic, Widget *cascadeBtn, int mode);
 313 static Widget createMenuItem(Widget parent, char *name, char *label,
 314         char mnemonic, menuCallbackProc callback, void *cbArg, int mode);
 315 static Widget createFakeMenuItem(Widget parent, char *name,
 316         menuCallbackProc callback, void *cbArg);
 317 static Widget createMenuToggle(Widget parent, char *name, char *label,
 318         char mnemonic, menuCallbackProc callback, void *cbArg, int set,
 319         int mode);
 320 static Widget createMenuRadioToggle(Widget parent, char *name, char *label,
 321         char mnemonic, menuCallbackProc callback, void *cbArg, int set,
 322         int mode);
 323 static Widget createMenuSeparator(Widget parent, char *name, int mode);
 324 static void invalidatePrevOpenMenus(void);
 325 static void updateWindowMenu(const WindowInfo *window);
 326 static void updatePrevOpenMenu(WindowInfo *window);
 327 static void updateTagsFileMenu(WindowInfo *window);
 328 static void updateTipsFileMenu(WindowInfo *window);
 329 static int searchDirection(int ignoreArgs, String *args, Cardinal *nArgs);
 330 static int searchWrap(int ignoreArgs, String *args, Cardinal *nArgs);
 331 static int searchKeepDialogs(int ignoreArgs, String *args, Cardinal *nArgs);
 332 static int searchType(int ignoreArgs, String *args, Cardinal *nArgs);
 333 static char **shiftKeyToDir(XtPointer callData);
 334 static void raiseCB(Widget w, WindowInfo *window, caddr_t callData);
 335 static void openPrevCB(Widget w, char *name, caddr_t callData);
 336 static void unloadTagsFileCB(Widget w, char *name, caddr_t callData);
 337 static void unloadTipsFileCB(Widget w, char *name, caddr_t callData);
 338 static int cmpStrPtr(const void *strA, const void *strB);
 339 static void setWindowSizeDefault(int rows, int cols);
 340 static void updateWindowSizeMenus(void);
 341 static void updateWindowSizeMenu(WindowInfo *win);
 342 static int strCaseCmp(const char *str1, const char *str2);
 343 static int compareWindowNames(const void *windowA, const void *windowB);
 344 static void bgMenuPostAP(Widget w, XEvent *event, String *args,
 345         Cardinal *nArgs);
 346 static void raiseWindowAP(Widget w, XEvent *event, String *args,
 347         Cardinal *nArgs);
 348 static void focusPaneAP(Widget w, XEvent *event, String *args,
 349     Cardinal *nArgs);
 350 static void setStatisticsLineAP(Widget w, XEvent *event, String *args,
 351     Cardinal *nArgs);
 352 static void setIncrementalSearchLineAP(Widget w, XEvent *event, String *args,
 353     Cardinal *nArgs);
 354 static void setShowLineNumbersAP(Widget w, XEvent *event, String *args,
 355     Cardinal *nArgs);
 356 static void setAutoIndentAP(Widget w, XEvent *event, String *args,
 357     Cardinal *nArgs);
 358 static void setWrapTextAP(Widget w, XEvent *event, String *args,
 359     Cardinal *nArgs);
 360 static void setWrapMarginAP(Widget w, XEvent *event, String *args,
 361     Cardinal *nArgs);
 362 static void setHighlightSyntaxAP(Widget w, XEvent *event, String *args,
 363     Cardinal *nArgs);
 364 static void setMakeBackupCopyAP(Widget w, XEvent *event, String *args,
 365     Cardinal *nArgs);
 366 static void setIncrementalBackupAP(Widget w, XEvent *event, String *args,
 367     Cardinal *nArgs);
 368 static void setShowMatchingAP(Widget w, XEvent *event, String *args,
 369     Cardinal *nArgs);
 370 static void setMatchSyntaxBasedAP(Widget w, XEvent *event, String *args,
 371     Cardinal *nArgs);
 372 static void setOvertypeModeAP(Widget w, XEvent *event, String *args,
 373     Cardinal *nArgs);
 374 static void setLockedAP(Widget w, XEvent *event, String *args,
 375     Cardinal *nArgs);
 376 static void setUseTabsAP(Widget w, XEvent *event, String *args,
 377     Cardinal *nArgs);
 378 static void setEmTabDistAP(Widget w, XEvent *event, String *args,
 379     Cardinal *nArgs);
 380 static void setTabDistAP(Widget w, XEvent *event, String *args,
 381     Cardinal *nArgs);
 382 static void setFontsAP(Widget w, XEvent *event, String *args,
 383     Cardinal *nArgs);
 384 static void setLanguageModeAP(Widget w, XEvent *event, String *args,
 385     Cardinal *nArgs);
 386 #ifdef SGI_CUSTOM
 387 static void shortMenusCB(Widget w, WindowInfo *window, caddr_t callData);
 388 static void addToToggleShortList(Widget w);
 389 static int shortPrefAskDefault(Widget parent, Widget w, const char *settingName);
 390 #endif
 391
 392 static HelpMenu * buildHelpMenu( Widget pane, HelpMenu * menu,
 393         WindowInfo * window);
 394
 395 /* Application action table */
 396 static XtActionsRec Actions[] = {
 397     {"new", newAP},
 398     {"open", openAP},
 399     {"open-dialog", openDialogAP},
 400     {"open_dialog", openDialogAP},
 401     {"open-selected", openSelectedAP},
 402     {"open_selected", openSelectedAP},
 403     {"close", closeAP},
 404     {"save", saveAP},
 405     {"save-as", saveAsAP},
 406     {"save_as", saveAsAP},
 407     {"save-as-dialog", saveAsDialogAP},
 408     {"save_as_dialog", saveAsDialogAP},
 409     {"revert-to-saved", revertAP},
 410     {"revert_to_saved", revertAP},
 411     {"revert_to_saved_dialog", revertDialogAP},
 412     {"include-file", includeAP},
 413     {"include_file", includeAP},
 414     {"include-file-dialog", includeDialogAP},
 415     {"include_file_dialog", includeDialogAP},
 416     {"load-macro-file", loadMacroAP},
 417     {"load_macro_file", loadMacroAP},
 418     {"load-macro-file-dialog", loadMacroDialogAP},
 419     {"load_macro_file_dialog", loadMacroDialogAP},
 420     {"load-tags-file", loadTagsAP},
 421     {"load_tags_file", loadTagsAP},
 422     {"load-tags-file-dialog", loadTagsDialogAP},
 423     {"load_tags_file_dialog", loadTagsDialogAP},
 424     {"unload_tags_file", unloadTagsAP},
 425     {"load_tips_file", loadTipsAP},
 426     {"load_tips_file_dialog", loadTipsDialogAP},
 427     {"unload_tips_file", unloadTipsAP},
 428     {"print", printAP},
 429     {"print-selection", printSelAP},
 430     {"print_selection", printSelAP},
 431     {"exit", exitAP},
 432     {"undo", undoAP},
 433     {"redo", redoAP},
 434     {"delete", clearAP},
 435     {"select-all", selAllAP},
 436     {"select_all", selAllAP},
 437     {"shift-left", shiftLeftAP},
 438     {"shift_left", shiftLeftAP},
 439     {"shift-left-by-tab", shiftLeftTabAP},
 440     {"shift_left_by_tab", shiftLeftTabAP},
 441     {"shift-right", shiftRightAP},
 442     {"shift_right", shiftRightAP},
 443     {"shift-right-by-tab", shiftRightTabAP},
 444     {"shift_right_by_tab", shiftRightTabAP},
 445     {"find", findAP},
 446     {"find-dialog", findDialogAP},
 447     {"find_dialog", findDialogAP},
 448     {"find-again", findSameAP},
 449     {"find_again", findSameAP},
 450     {"find-selection", findSelAP},
 451     {"find_selection", findSelAP},
 452     {"find_incremental", findIncrAP},
 453     {"start_incremental_find", startIncrFindAP},
 454     {"replace", replaceAP},
 455     {"replace-dialog", replaceDialogAP},
 456     {"replace_dialog", replaceDialogAP},
 457     {"replace-all", replaceAllAP},
 458     {"replace_all", replaceAllAP},
 459     {"replace-in-selection", replaceInSelAP},
 460     {"replace_in_selection", replaceInSelAP},
 461     {"replace-again", replaceSameAP},
 462     {"replace_again", replaceSameAP},
 463     {"replace_find", replaceFindAP},
 464     {"replace_find_same", replaceFindSameAP},
 465     {"replace_find_again", replaceFindSameAP},
 466     {"goto-line-number", gotoAP},
 467     {"goto_line_number", gotoAP},
 468     {"goto-line-number-dialog", gotoDialogAP},
 469     {"goto_line_number_dialog", gotoDialogAP},
 470     {"goto-selected", gotoSelectedAP},
 471     {"goto_selected", gotoSelectedAP},
 472     {"mark", markAP},
 473     {"mark-dialog", markDialogAP},
 474     {"mark_dialog", markDialogAP},
 475     {"goto-mark", gotoMarkAP},
 476     {"goto_mark", gotoMarkAP},
 477     {"goto-mark-dialog", gotoMarkDialogAP},
 478     {"goto_mark_dialog", gotoMarkDialogAP},
 479     {"match", selectToMatchingAP},
 480     {"select_to_matching", selectToMatchingAP},
 481     {"goto_matching", gotoMatchingAP},
 482     {"find-definition", findDefAP},
 483     {"find_definition", findDefAP},
 484     {"show_tip", showTipAP},
 485     {"split-window", splitWindowAP},
 486     {"split_window", splitWindowAP},
 487     {"close-pane", closePaneAP},
 488     {"close_pane", closePaneAP},
 489     {"uppercase", capitalizeAP},
 490     {"lowercase", lowercaseAP},
 491     {"fill-paragraph", fillAP},
 492     {"fill_paragraph", fillAP},
 493     {"control-code-dialog", controlDialogAP},
 494     {"control_code_dialog", controlDialogAP},
 495 #ifndef VMS
 496     {"filter-selection-dialog", filterDialogAP},
 497     {"filter_selection_dialog", filterDialogAP},
 498     {"filter-selection", shellFilterAP},
 499     {"filter_selection", shellFilterAP},
 500     {"execute-command", execAP},
 501     {"execute_command", execAP},
 502     {"execute-command-dialog", execDialogAP},
 503     {"execute_command_dialog", execDialogAP},
 504     {"execute-command-line", execLineAP},
 505     {"execute_command_line", execLineAP},
 506     {"shell-menu-command", shellMenuAP},
 507     {"shell_menu_command", shellMenuAP},
 508 #endif /*VMS*/
 509     {"macro-menu-command", macroMenuAP},
 510     {"macro_menu_command", macroMenuAP},
 511     {"bg_menu_command", bgMenuAP},
 512     {"post_window_bg_menu", bgMenuPostAP},
 513     {"beginning-of-selection", beginningOfSelectionAP},
 514     {"beginning_of_selection", beginningOfSelectionAP},
 515     {"end-of-selection", endOfSelectionAP},
 516     {"end_of_selection", endOfSelectionAP},
 517     {"repeat_macro", repeatMacroAP},
 518     {"repeat_dialog", repeatDialogAP},
 519     {"raise_window", raiseWindowAP},
 520     {"focus_pane", focusPaneAP},
 521     {"set_statistics_line", setStatisticsLineAP},
 522     {"set_incremental_search_line", setIncrementalSearchLineAP},
 523     {"set_show_line_numbers", setShowLineNumbersAP},
 524     {"set_auto_indent", setAutoIndentAP},
 525     {"set_wrap_text", setWrapTextAP},
 526     {"set_wrap_margin", setWrapMarginAP},
 527     {"set_highlight_syntax", setHighlightSyntaxAP},
 528 #ifndef VMS
 529     {"set_make_backup_copy", setMakeBackupCopyAP},
 530 #endif
 531     {"set_incremental_backup", setIncrementalBackupAP},
 532     {"set_show_matching", setShowMatchingAP},
 533     {"set_match_syntax_based", setMatchSyntaxBasedAP},
 534     {"set_overtype_mode", setOvertypeModeAP},
 535     {"set_locked", setLockedAP},
 536     {"set_tab_dist", setTabDistAP},
 537     {"set_em_tab_dist", setEmTabDistAP},
 538     {"set_use_tabs", setUseTabsAP},
 539     {"set_fonts", setFontsAP},
 540     {"set_language_mode", setLanguageModeAP}
 541 };
 542
 543 /* List of previously opened files for File menu */
 544 static int NPrevOpen = 0;
 545 static char **PrevOpen;
 546
 547 #ifdef SGI_CUSTOM
 548 /* Window to receive items to be toggled on and off in short menus mode */
 549 static WindowInfo *ShortMenuWindow;
 550 #endif
 551
 552 void HidePointerOnKeyedEvent(Widget w, XEvent *event)
 553 {
 554     if (event && (event->type == KeyPress || event->type == KeyRelease)) {
 555         ShowHidePointer((TextWidget)w, True);
 556     }
 557 }
 558
 559 /*
 560 ** Install actions for use in translation tables and macro recording, relating
 561 ** to menu item commands
 562 */
 563 void InstallMenuActions(XtAppContext context)
 564 {
 565     XtAppAddActions(context, Actions, XtNumber(Actions));
 566 }
 567
 568 /*
 569 ** Return the (statically allocated) action table for menu item actions.
 570 */
 571 XtActionsRec *GetMenuActions(int *nActions)
 572 {
 573     *nActions = XtNumber(Actions);
 574     return Actions;
 575 }
 576
 577 /*
 578 ** Create the menu bar
 579 */
 580 Widget CreateMenuBar(Widget parent, WindowInfo *window)
 581 {
 582     Widget menuBar, menuPane, btn, subPane, subSubPane, subSubSubPane, cascade;
 583
 584     /*
 585     ** Create the menu bar (row column) widget
 586     */
 587     menuBar = XmCreateMenuBar(parent, "menuBar", NULL, 0);
 588
 589 #ifdef SGI_CUSTOM
 590     /*
 591     ** Short menu mode is a special feature for the SGI system distribution
 592     ** version of NEdit.
 593     **
 594     ** To make toggling short-menus mode faster (re-creating the menus was
 595     ** too slow), a list is kept in the window data structure of items to
 596     ** be turned on and off.  Initialize that list and give the menu creation
 597     ** routines a pointer to the window on which this list is kept.  This is
 598     ** (unfortunately) a global variable to keep the interface simple for
 599     ** the mainstream case.
 600     */
 601     ShortMenuWindow = window;
 602     window->nToggleShortItems = 0;
 603 #endif
 604
 605     /*
 606     ** "File" pull down menu.
 607     */
 608     menuPane = createMenu(menuBar, "fileMenu", "File", 0, NULL, SHORT);
 609     createMenuItem(menuPane, "new", "New", 'N', doActionCB, "new", SHORT);
 610     createMenuItem(menuPane, "open", "Open...", 'O', doActionCB, "open_dialog",
 611             SHORT);
 612     window->openSelItem=createMenuItem(menuPane, "openSelected", "Open Selected", 'd',
 613             doActionCB, "open_selected", FULL);
 614     if (GetPrefMaxPrevOpenFiles() != 0) {
 615         window->prevOpenMenuPane = createMenu(menuPane, "openPrevious",
 616                 "Open Previous", 'v', &window->prevOpenMenuItem, SHORT);
 617         XtSetSensitive(window->prevOpenMenuItem, NPrevOpen != 0);
 618         XtAddCallback(window->prevOpenMenuItem, XmNcascadingCallback,
 619                 (XtCallbackProc)prevOpenMenuCB, window);
 620     }
 621     createMenuSeparator(menuPane, "sep1", SHORT);
 622     window->closeItem = createMenuItem(menuPane, "close", "Close", 'C',
 623             doActionCB, "close", SHORT);
 624     createMenuItem(menuPane, "save", "Save", 'S', doActionCB, "save", SHORT);
 625     createMenuItem(menuPane, "saveAs", "Save As...", 'A', doActionCB,
 626             "save_as_dialog", SHORT);
 627     createMenuItem(menuPane, "revertToSaved", "Revert to Saved", 'R',
 628             doActionCB, "revert_to_saved_dialog", SHORT);
 629     createMenuSeparator(menuPane, "sep2", SHORT);
 630     createMenuItem(menuPane, "includeFile", "Include File...", 'I',
 631             doActionCB, "include_file_dialog", SHORT);
 632     createMenuItem(menuPane, "loadMacroFile", "Load Macro File...", 'M',
 633             doActionCB, "load_macro_file_dialog", FULL);
 634     createMenuItem(menuPane, "loadTagsFile", "Load Tags File...", 'T',
 635             doActionCB, "load_tags_file_dialog", FULL);
 636     window->unloadTagsMenuPane = createMenu(menuPane, "unloadTagsFiles",
 637             "Unload Tags File", 'U', &window->unloadTagsMenuItem, FULL);
 638     XtSetSensitive(window->unloadTagsMenuItem, TagsFileList != NULL);
 639     XtAddCallback(window->unloadTagsMenuItem, XmNcascadingCallback,
 640             (XtCallbackProc)unloadTagsFileMenuCB, window);
 641     createMenuItem(menuPane, "loadTipsFile", "Load Calltips File...", 'F',
 642             doActionCB, "load_tips_file_dialog", FULL);
 643     window->unloadTipsMenuPane = createMenu(menuPane, "unloadTipsFiles",
 644             "Unload Calltips File", 'e', &window->unloadTipsMenuItem, FULL);
 645     XtSetSensitive(window->unloadTipsMenuItem, TipsFileList != NULL);
 646     XtAddCallback(window->unloadTipsMenuItem, XmNcascadingCallback,
 647             (XtCallbackProc)unloadTipsFileMenuCB, window);
 648     createMenuSeparator(menuPane, "sep3", SHORT);
 649     createMenuItem(menuPane, "print", "Print...", 'P', doActionCB, "print",
 650             SHORT);
 651     window->printSelItem = createMenuItem(menuPane, "printSelection",
 652             "Print Selection...", 'l', doActionCB, "print_selection",
 653             SHORT);
 654     XtSetSensitive(window->printSelItem, window->wasSelected);
 655     createMenuSeparator(menuPane, "sep4", SHORT);
 656     createMenuItem(menuPane, "exit", "Exit", 'x', doActionCB, "exit", SHORT);
 657     CheckCloseDim();
 658
 659     /*
 660     ** "Edit" pull down menu.
 661     */
 662     menuPane = createMenu(menuBar, "editMenu", "Edit", 0, NULL, SHORT);
 663     window->undoItem = createMenuItem(menuPane, "undo", "Undo", 'U',
 664             doActionCB, "undo", SHORT);
 665     XtSetSensitive(window->undoItem, False);
 666     window->redoItem = createMenuItem(menuPane, "redo", "Redo", 'R',
 667             doActionCB, "redo", SHORT);
 668     XtSetSensitive(window->redoItem, False);
 669     createMenuSeparator(menuPane, "sep1", SHORT);
 670     window->cutItem = createMenuItem(menuPane, "cut", "Cut", 't', doActionCB,
 671             "cut_clipboard", SHORT);
 672     XtSetSensitive(window->cutItem, window->wasSelected);
 673     window->copyItem = createMenuItem(menuPane, "copy", "Copy", 'C', doActionCB,
 674             "copy_clipboard", SHORT);
 675     XtSetSensitive(window->copyItem, window->wasSelected);
 676     createMenuItem(menuPane, "paste", "Paste", 'P', doActionCB,
 677             "paste_clipboard", SHORT);
 678     createMenuItem(menuPane, "pasteColumn", "Paste Column", 's', pasteColCB,
 679             window, SHORT);
 680     window->delItem=createMenuItem(menuPane, "delete", "Delete", 'D', doActionCB, "delete_selection",
 681             SHORT);
 682     XtSetSensitive(window->delItem, window->wasSelected);
 683     createMenuItem(menuPane, "selectAll", "Select All", 'A', doActionCB,
 684             "select_all", SHORT);
 685     createMenuSeparator(menuPane, "sep2", SHORT);
 686     createMenuItem(menuPane, "shiftLeft", "Shift Left", 'L',
 687             shiftLeftCB, window, SHORT);
 688     createFakeMenuItem(menuPane, "shiftLeftShift", shiftLeftCB, window);
 689     createMenuItem(menuPane, "shiftRight", "Shift Right", 'g',
 690             shiftRightCB, window, SHORT);
 691     createFakeMenuItem(menuPane, "shiftRightShift", shiftRightCB, window);
 692     window->lowerItem=createMenuItem(menuPane, "lowerCase", "Lower-case", 'w',
 693             doActionCB, "lowercase", SHORT);
 694     window->upperItem=createMenuItem(menuPane, "upperCase", "Upper-case", 'e',
 695             doActionCB, "uppercase", SHORT);
 696     createMenuItem(menuPane, "fillParagraph", "Fill Paragraph", 'F',
 697             doActionCB, "fill_paragraph", SHORT);
 698     createMenuSeparator(menuPane, "sep3", FULL);
 699     createMenuItem(menuPane, "insertFormFeed", "Insert Form Feed", 'I',
 700             formFeedCB, window, FULL);
 701     createMenuItem(menuPane, "insertCtrlCode", "Insert Ctrl Code...", 'n',
 702             doActionCB, "control_code_dialog", FULL);
 703 #ifdef SGI_CUSTOM
 704     createMenuSeparator(menuPane, "sep4", SHORT);
 705     createMenuToggle(menuPane, "overtype", "Overtype", 'O',
 706             doActionCB, "set_overtype_mode", False, SHORT);
 707     window->readOnlyItem = createMenuToggle(menuPane, "readOnly", "Read Only",
 708             'y', doActionCB, "set_locked", IS_USER_LOCKED(window->lockReasons), FULL);
 709 #endif
 710
 711     /*
 712     ** "Search" pull down menu.
 713     */
 714     menuPane = createMenu(menuBar, "searchMenu", "Search", 0, NULL, SHORT);
 715     createMenuItem(menuPane, "find", "Find...", 'F', findCB, window, SHORT);
 716     createFakeMenuItem(menuPane, "findShift", findCB, window);
 717     window->findAgainItem=createMenuItem(menuPane, "findAgain", "Find Again", 'i', findSameCB, window,
 718             SHORT);
 719     XtSetSensitive(window->findAgainItem, NHist);
 720     createFakeMenuItem(menuPane, "findAgainShift", findSameCB, window);
 721     window->findSelItem=createMenuItem(menuPane, "findSelection", "Find Selection", 'S',
 722             findSelCB, window, SHORT);
 723     createFakeMenuItem(menuPane, "findSelectionShift", findSelCB, window);
 724     createMenuItem(menuPane, "findIncremental", "Find Incremental", 'n',
 725             findIncrCB, window, SHORT);
 726     createFakeMenuItem(menuPane, "findIncrementalShift", findIncrCB, window);
 727     createMenuItem(menuPane, "replace", "Replace...", 'R', replaceCB, window,
 728             SHORT);
 729     createFakeMenuItem(menuPane, "replaceShift", replaceCB, window);
 730     window->replaceFindAgainItem=createMenuItem(menuPane, "replaceFindAgain", "Replace Find Again", 'A',
 731             replaceFindSameCB, window, SHORT);
 732     XtSetSensitive(window->replaceFindAgainItem, NHist);
 733     createFakeMenuItem(menuPane, "replaceFindAgainShift", replaceFindSameCB, window);
 734     window->replaceAgainItem=createMenuItem(menuPane, "replaceAgain", "Replace Again", 'p',
 735             replaceSameCB, window, SHORT);
 736     XtSetSensitive(window->replaceAgainItem, NHist);
 737     createFakeMenuItem(menuPane, "replaceAgainShift", replaceSameCB, window);
 738     createMenuSeparator(menuPane, "sep1", FULL);
 739     createMenuItem(menuPane, "gotoLineNumber", "Goto Line Number...", 'L',
 740             doActionCB, "goto_line_number_dialog", FULL);
 741     window->gotoSelItem=createMenuItem(menuPane, "gotoSelected", "Goto Selected", 'G',
 742             doActionCB, "goto_selected", FULL);
 743     createMenuSeparator(menuPane, "sep2", FULL);
 744     createMenuItem(menuPane, "mark", "Mark", 'k', markCB, window, FULL);
 745     createMenuItem(menuPane, "gotoMark", "Goto Mark", 'o', gotoMarkCB, window,
 746             FULL);
 747     createFakeMenuItem(menuPane, "gotoMarkShift", gotoMarkCB, window);
 748     createMenuSeparator(menuPane, "sep3", FULL);
 749     createMenuItem(menuPane, "gotoMatching", "Goto Matching (..)", 'M',
 750             gotoMatchingCB, window, FULL);
 751     createFakeMenuItem(menuPane, "gotoMatchingShift", gotoMatchingCB, window);
 752     window->findDefItem = createMenuItem(menuPane, "findDefinition",
 753             "Find Definition", 'D', doActionCB, "find_definition", FULL);
 754     XtSetSensitive(window->findDefItem, TagsFileList != NULL);
 755     window->showTipItem = createMenuItem(menuPane, "showCalltip",
 756             "Show Calltip", 'C', doActionCB, "show_tip", FULL);
 757     XtSetSensitive(window->showTipItem, (TagsFileList != NULL ||
 758                                          TipsFileList != NULL) );
 759
 760     /*
 761     ** Preferences menu, Default Settings sub menu
 762     */
 763     menuPane = createMenu(menuBar, "preferencesMenu", "Preferences", 0, NULL,
 764             SHORT);
 765     subPane = createMenu(menuPane, "defaultSettings", "Default Settings", 'D',
 766             NULL, FULL);
 767     createMenuItem(subPane, "languageModes", "Language Modes...", 'L',
 768             languageDefCB, window, FULL);
 769
 770     /* Auto Indent sub menu */
 771     subSubPane = createMenu(subPane, "autoIndent", "Auto Indent", 'A',
 772             NULL, FULL);
 773     window->autoIndentOffDefItem = createMenuRadioToggle(subSubPane, "off",
 774             "Off", 'O', autoIndentOffDefCB, window,
 775             GetPrefAutoIndent(PLAIN_LANGUAGE_MODE) == NO_AUTO_INDENT, SHORT);
 776     window->autoIndentDefItem = createMenuRadioToggle(subSubPane, "on",
 777             "On", 'n', autoIndentDefCB, window,
 778             GetPrefAutoIndent(PLAIN_LANGUAGE_MODE) == AUTO_INDENT, SHORT);
 779     window->smartIndentDefItem = createMenuRadioToggle(subSubPane, "smart",
 780             "Smart", 'S', smartIndentDefCB, window,
 781             GetPrefAutoIndent(PLAIN_LANGUAGE_MODE) == SMART_INDENT, SHORT);
 782     createMenuSeparator(subSubPane, "sep1", SHORT);
 783     createMenuItem(subSubPane, "ProgramSmartIndent", "Program Smart Indent...",
 784             'P', smartMacrosDefCB, window, FULL);
 785
 786     /* Wrap sub menu */
 787     subSubPane = createMenu(subPane, "wrap", "Wrap", 'W', NULL, FULL);
 788     window->noWrapDefItem = createMenuRadioToggle(subSubPane,
 789             "none", "None", 'N', noWrapDefCB,
 790             window, GetPrefWrap(PLAIN_LANGUAGE_MODE) == NO_WRAP, SHORT);
 791     window->newlineWrapDefItem = createMenuRadioToggle(subSubPane,
 792             "autoNewline", "Auto Newline", 'A', newlineWrapDefCB,
 793             window, GetPrefWrap(PLAIN_LANGUAGE_MODE) == NEWLINE_WRAP, SHORT);
 794     window->contWrapDefItem = createMenuRadioToggle(subSubPane, "continuous",
 795             "Continuous", 'C', contWrapDefCB, window,
 796             GetPrefWrap(PLAIN_LANGUAGE_MODE) == CONTINUOUS_WRAP, SHORT);
 797     createMenuSeparator(subSubPane, "sep1", SHORT);
 798     createMenuItem(subSubPane, "wrapMargin", "Wrap Margin...", 'W',
 799             wrapMarginDefCB, window, SHORT);
 800
 801     /* Smart Tags sub menu */
 802     subSubPane = createMenu(subPane, "smartTags", "Tag Collisions", 'C',
 803             NULL, FULL);
 804     window->allTagsDefItem = createMenuRadioToggle(subSubPane, "showall",
 805             "Show All", 'A', showAllTagsDefCB, window, !GetPrefSmartTags(),
 806             FULL);
 807     window->smartTagsDefItem = createMenuRadioToggle(subSubPane, "smart",
 808             "Smart", 'S', smartTagsDefCB, window, GetPrefSmartTags(), FULL);
 809
 810     createMenuItem(subPane, "tabDistance", "Tabs...", 'T', tabsDefCB, window,
 811             SHORT);
 812     createMenuItem(subPane, "textFont", "Text Font...", 'F', fontDefCB, window,
 813             FULL);
 814
 815     /* Customize Menus sub menu */
 816     subSubPane = createMenu(subPane, "customizeMenus", "Customize Menus",
 817             'u', NULL, FULL);
 818 #ifndef VMS
 819     createMenuItem(subSubPane, "shellMenu", "Shell Menu...", 'S',
 820             shellDefCB, window, FULL);
 821 #endif
 822     createMenuItem(subSubPane, "macroMenu", "Macro Menu...", 'M',
 823             macroDefCB, window, FULL);
 824     createMenuItem(subSubPane, "windowBackgroundMenu",
 825             "Window Background Menu...", 'W', bgMenuDefCB, window, FULL);
 826     createMenuSeparator(subSubPane, "sep1", SHORT);
 827     window->pathInWindowsMenuDefItem = createMenuToggle(subSubPane, "pathInWindowsMenu",
 828             "Show Path In Windows Menu", 'P', pathInWindowsMenuDefCB, window, GetPrefShowPathInWindowsMenu(),
 829             SHORT);
 830     createMenuItem(subPane, "custimizeTitle", "Customize Window Title...", 'd',
 831             customizeTitleDefCB, window, FULL);
 832
 833     /* Search sub menu */
 834     subSubPane = createMenu(subPane, "searching", "Searching",
 835             'g', NULL, FULL);
 836     window->searchDlogsDefItem = createMenuToggle(subSubPane, "verbose",
 837             "Verbose", 'V', searchDlogsDefCB, window,
 838             GetPrefSearchDlogs(), SHORT);
 839     window->searchWrapsDefItem = createMenuToggle(subSubPane, "wrapAround",
 840             "Wrap Around", 'W', searchWrapsDefCB, window,
 841             GetPrefSearchWraps(), SHORT);
 842     window->beepOnSearchWrapDefItem = createMenuToggle(subSubPane,
 843           "beepOnSearchWrap", "Beep On Search Wrap", 'B',
 844           beepOnSearchWrapDefCB, window, GetPrefBeepOnSearchWrap(), SHORT);
 845     window->keepSearchDlogsDefItem = createMenuToggle(subSubPane,
 846             "keepDialogsUp", "Keep Dialogs Up", 'K',
 847             keepSearchDlogsDefCB, window, GetPrefKeepSearchDlogs(), SHORT);
 848     subSubSubPane = createMenu(subSubPane, "defaultSearchStyle",
 849             "Default Search Style", 'D', NULL, FULL);
 850     XtVaSetValues(subSubSubPane, XmNradioBehavior, True, NULL);
 851     window->searchLiteralDefItem = createMenuToggle(subSubSubPane, "literal",
 852             "Literal", 'L', searchLiteralCB, window,
 853             GetPrefSearch() == SEARCH_LITERAL, FULL);
 854     window->searchCaseSenseDefItem = createMenuToggle(subSubSubPane,
 855             "caseSensitive", "Literal, Case Sensitive", 'C', searchCaseSenseCB, window,
 856             GetPrefSearch() == SEARCH_CASE_SENSE, FULL);
 857     window->searchLiteralWordDefItem = createMenuToggle(subSubSubPane, "literalWord",
 858             "Literal, Whole Word", 'W', searchLiteralWordCB, window,
 859             GetPrefSearch() == SEARCH_LITERAL_WORD, FULL);
 860     window->searchCaseSenseWordDefItem = createMenuToggle(subSubSubPane,
 861             "caseSensitiveWord", "Literal, Case Sensitive, Whole Word", 't', searchCaseSenseWordCB, window,
 862             GetPrefSearch() == SEARCH_CASE_SENSE_WORD, FULL);
 863     window->searchRegexDefItem = createMenuToggle(subSubSubPane,
 864             "regularExpression", "Regular Expression", 'R', searchRegexCB,
 865             window, GetPrefSearch() == SEARCH_REGEX, FULL);
 866     window->searchRegexNoCaseDefItem = createMenuToggle(subSubSubPane,
 867             "regularExpressionNoCase", "Regular Expression, Case Insensitive", 'I', searchRegexNoCaseCB, window,
 868             GetPrefSearch() == SEARCH_REGEX_NOCASE, FULL);
 869 #ifdef REPLACE_SCOPE
 870     subSubSubPane = createMenu(subSubPane, "defaultReplaceScope",
 871             "Default Replace Scope", 'R', NULL, FULL);
 872     XtVaSetValues(subSubSubPane, XmNradioBehavior, True, NULL);
 873     window->replScopeWinDefItem = createMenuToggle(subSubSubPane, "window",
 874             "In Window", 'W', replaceScopeWindowCB, window,
 875             GetPrefReplaceDefScope() == REPL_DEF_SCOPE_WINDOW, FULL);
 876     window->replScopeSelDefItem = createMenuToggle(subSubSubPane, "selection",
 877             "In Selection", 'S', replaceScopeSelectionCB, window,
 878             GetPrefReplaceDefScope() == REPL_DEF_SCOPE_SELECTION, FULL);
 879     window->replScopeSmartDefItem = createMenuToggle(subSubSubPane, "window",
 880             "Smart", 'm', replaceScopeSmartCB, window,
 881             GetPrefReplaceDefScope() == REPL_DEF_SCOPE_SMART, FULL);
 882 #endif
 883
 884     /* Syntax Highlighting sub menu */
 885     subSubPane = createMenu(subPane, "syntaxHighlighting","Syntax Highlighting",
 886             'H', NULL, FULL);
 887     window->highlightOffDefItem = createMenuRadioToggle(subSubPane, "off","Off",
 888             'O', highlightOffDefCB, window, !GetPrefHighlightSyntax(), FULL);
 889     window->highlightDefItem = createMenuRadioToggle(subSubPane, "on",
 890             "On", 'n', highlightDefCB, window, GetPrefHighlightSyntax(), FULL);
 891     createMenuSeparator(subSubPane, "sep1", SHORT);
 892     createMenuItem(subSubPane, "recognitionPatterns", "Recognition Patterns...",
 893             'R', highlightingDefCB, window, FULL);
 894     createMenuItem(subSubPane, "textDrawingStyles", "Text Drawing Styles...", 'T',
 895             stylesDefCB, window, FULL);
 896     subSubPane = createMenu(subPane, "backlighting", "Backlighting",
 897           'g', NULL, FULL);
 898     window->backlightCharsDefItem = createMenuToggle(subSubPane,
 899           "backlightChars", "Apply Backlighting", 'g', backlightCharsDefCB,
 900           window, GetPrefBacklightChars(), FULL);
 901     createMenuItem(subSubPane, "backlightCharTypes", "Use Current",
 902           'U', backlightCharTypesDefCB, window, FULL);
 903
 904     window->statsLineDefItem = createMenuToggle(subPane, "statisticsLine",
 905             "Statistics Line", 'S', statsLineDefCB, window, GetPrefStatsLine(),
 906             SHORT);
 907     window->iSearchLineDefItem = createMenuToggle(subPane,
 908             "incrementalSearchLine", "Incremental Search Line", 'i',
 909             iSearchLineDefCB, window, GetPrefISearchLine(), FULL);
 910     window->lineNumsDefItem = createMenuToggle(subPane, "showLineNumbers",
 911             "Show Line Numbers", 'N', lineNumsDefCB, window, GetPrefLineNums(),
 912             SHORT);
 913     window->saveLastDefItem = createMenuToggle(subPane, "preserveLastVersion",
 914             "Make Backup Copy (*.bck)", 'e', preserveDefCB, window,
 915             GetPrefSaveOldVersion(), SHORT);
 916     window->autoSaveDefItem = createMenuToggle(subPane, "incrementalBackup",
 917             "Incremental Backup", 'B', autoSaveDefCB, window, GetPrefAutoSave(),
 918             SHORT);
 919
 920     /* Show Matching sub menu */
 921     subSubPane = createMenu(subPane, "showMatching", "Show Matching (..)", 'M',
 922             NULL, FULL);
 923     window->showMatchingOffDefItem = createMenuRadioToggle(subSubPane, "off",
 924             "Off", 'O', showMatchingOffDefCB, window,
 925             GetPrefShowMatching() == NO_FLASH, SHORT);
 926     window->showMatchingDelimitDefItem = createMenuRadioToggle(subSubPane,
 927             "delimiter", "Delimiter", 'D', showMatchingDelimitDefCB, window,
 928             GetPrefShowMatching() == FLASH_DELIMIT, SHORT);
 929     window->showMatchingRangeDefItem = createMenuRadioToggle(subSubPane,
 930             "range", "Range", 'R', showMatchingRangeDefCB, window,
 931             GetPrefShowMatching() == FLASH_RANGE, SHORT);
 932     createMenuSeparator(subSubPane, "sep", SHORT);
 933     window->matchSyntaxBasedDefItem = createMenuToggle(subSubPane,
 934            "matchSyntax", "Syntax Based", 'S', matchSyntaxBasedDefCB, window,
 935             GetPrefMatchSyntaxBased(), SHORT);
 936
 937     /* Append LF at end of files on save */
 938     window->appendLFItem = createMenuToggle(subPane, "appendLFItem",
 939             "Append Line Feed on Save", 'v', appendLFCB, NULL,
 940             GetPrefAppendLF(), FULL);
 941
 942     window->sortOpenPrevDefItem = createMenuToggle(subPane, "sortOpenPrevMenu",
 943             "Sort Open Prev. Menu", 'o', sortOpenPrevDefCB, window,
 944             GetPrefSortOpenPrevMenu(), FULL);
 945     window->reposDlogsDefItem = createMenuToggle(subPane, "popupsUnderPointer",
 946             "Popups Under Pointer", 'P', reposDlogsDefCB, window,
 947             GetPrefRepositionDialogs(), FULL);
 948     subSubPane = createMenu(subPane, "warnings", "Warnings", 'r', NULL, FULL);
 949     window->modWarnDefItem = createMenuToggle(subSubPane,
 950             "filesModifiedExternally", "Files Modified Externally", 'F',
 951             modWarnDefCB, window, GetPrefWarnFileMods(), FULL);
 952     window->modWarnRealDefItem = createMenuToggle(subSubPane,
 953             "checkModifiedFileContents", "Check Modified File Contents", 'C',
 954             modWarnRealDefCB, window, GetPrefWarnRealFileMods(), FULL);
 955     XtSetSensitive(window->modWarnRealDefItem, GetPrefWarnFileMods());
 956     window->exitWarnDefItem = createMenuToggle(subSubPane, "onExit", "On Exit", 'O',
 957             exitWarnDefCB, window, GetPrefWarnExit(), FULL);
 958
 959     /* Initial Window Size sub menu (simulates radioBehavior) */
 960     subSubPane = createMenu(subPane, "initialwindowSize",
 961             "Initial Window Size", 'z', NULL, FULL);
 962     /* XtVaSetValues(subSubPane, XmNradioBehavior, True, NULL);  */
 963     window->size24x80DefItem = btn = createMenuToggle(subSubPane, "24X80",
 964             "24 x 80", '2', size24x80CB, window, False, SHORT);
 965     XtVaSetValues(btn, XmNindicatorType, XmONE_OF_MANY, NULL);
 966     window->size40x80DefItem = btn = createMenuToggle(subSubPane, "40X80",
 967             "40 x 80", '4', size40x80CB, window, False, SHORT);
 968     XtVaSetValues(btn, XmNindicatorType, XmONE_OF_MANY, NULL);
 969     window->size60x80DefItem = btn = createMenuToggle(subSubPane, "60X80",
 970             "60 x 80", '6', size60x80CB, window, False, SHORT);
 971     XtVaSetValues(btn, XmNindicatorType, XmONE_OF_MANY, NULL);
 972     window->size80x80DefItem = btn = createMenuToggle(subSubPane, "80X80",
 973             "80 x 80", '8', size80x80CB, window, False, SHORT);
 974     XtVaSetValues(btn, XmNindicatorType, XmONE_OF_MANY, NULL);
 975     window->sizeCustomDefItem = btn = createMenuToggle(subSubPane, "custom",
 976             "Custom...", 'C', sizeCustomCB, window, False, SHORT);
 977     XtVaSetValues(btn, XmNindicatorType, XmONE_OF_MANY, NULL);
 978     updateWindowSizeMenu(window);
 979
 980     /*
 981     ** Remainder of Preferences menu
 982     */
 983     createMenuItem(menuPane, "saveDefaults", "Save Defaults...", 'v',
 984             savePrefCB, window, FULL);
 985 #ifdef SGI_CUSTOM
 986     window->shortMenusDefItem = createMenuToggle(menuPane,
 987             "shortMenus", "Short Menus", 'h', shortMenusCB, window,
 988             GetPrefShortMenus(), SHORT);
 989 #endif
 990     createMenuSeparator(menuPane, "sep1", SHORT);
 991     window->statsLineItem = createMenuToggle(menuPane, "statisticsLine", "Statistics Line", 'S',
 992             statsCB, window, GetPrefStatsLine(), SHORT);
 993     window->iSearchLineItem = createMenuToggle(menuPane, "incremntalSearchLine","Incremental Search Line",
 994             'I', doActionCB, "set_incremental_search_line", GetPrefISearchLine(), FULL);
 995     window->lineNumsItem = createMenuToggle(menuPane, "lineNumbers", "Show Line Numbers", 'N',
 996             doActionCB, "set_show_line_numbers", GetPrefLineNums(), SHORT);
 997     CreateLanguageModeSubMenu(window, menuPane, "languageMode",
 998             "Language Mode", 'L');
 999     subPane = createMenu(menuPane, "autoIndent", "Auto Indent",
1000             'A', NULL, FULL);
1001     window->autoIndentOffItem = createMenuRadioToggle(subPane, "off", "Off",
1002             'O', autoIndentOffCB, window, window->indentStyle == NO_AUTO_INDENT,
1003             SHORT);
1004     window->autoIndentItem = createMenuRadioToggle(subPane, "on", "On", 'n',
1005             autoIndentCB, window, window->indentStyle == AUTO_INDENT, SHORT);
1006     window->smartIndentItem = createMenuRadioToggle(subPane, "smart", "Smart",
1007             'S', smartIndentCB, window, window->indentStyle == SMART_INDENT,
1008             SHORT);
1009     subPane = createMenu(menuPane, "wrap", "Wrap",
1010             'W', NULL, FULL);
1011     window->noWrapItem = createMenuRadioToggle(subPane, "none",
1012             "None", 'N', noWrapCB, window,
1013             window->wrapMode==NO_WRAP, SHORT);
1014     window->newlineWrapItem = createMenuRadioToggle(subPane, "autoNewlineWrap",
1015             "Auto Newline", 'A', newlineWrapCB, window,
1016             window->wrapMode==NEWLINE_WRAP, SHORT);
1017     window->continuousWrapItem = createMenuRadioToggle(subPane,
1018             "continuousWrap", "Continuous", 'C', continuousWrapCB, window,
1019             window->wrapMode==CONTINUOUS_WRAP, SHORT);
1020     createMenuSeparator(subPane, "sep1", SHORT);
1021     createMenuItem(subPane, "wrapMargin", "Wrap Margin...", 'W',
1022             wrapMarginCB, window, SHORT);
1023     createMenuItem(menuPane, "tabs", "Tabs...", 'T', tabsCB, window, SHORT);
1024     createMenuItem(menuPane, "textFont", "Text Font...", 'F', fontCB, window,
1025             FULL);
1026     window->highlightItem = createMenuToggle(menuPane, "highlightSyntax",
1027             "Highlight Syntax", 'H', doActionCB, "set_highlight_syntax",
1028             GetPrefHighlightSyntax(), SHORT);
1029     window->backlightCharsItem = createMenuToggle(menuPane, "backlightChars",
1030           "Apply Backlighting", 'g', backlightCharsCB, window,
1031           window->backlightChars, FULL);
1032 #ifndef VMS
1033     window->saveLastItem = createMenuToggle(menuPane, "makeBackupCopy",
1034             "Make Backup Copy (*.bck)", 'e', preserveCB, window,
1035             window->saveOldVersion, SHORT);
1036 #endif
1037     window->autoSaveItem = createMenuToggle(menuPane, "incrementalBackup",
1038             "Incremental Backup", 'B', autoSaveCB, window, window->autoSave,
1039             SHORT);
1040
1041     subPane = createMenu(menuPane, "showMatching", "Show Matching (..)",
1042         'M', NULL, FULL);
1043     window->showMatchingOffItem = createMenuRadioToggle(subPane, "off", "Off",
1044         'O', showMatchingOffCB, window, window->showMatchingStyle == NO_FLASH,
1045         SHORT);
1046     window->showMatchingDelimitItem = createMenuRadioToggle(subPane,
1047         "delimiter", "Delimiter", 'D', showMatchingDelimitCB, window,
1048         window->showMatchingStyle == FLASH_DELIMIT, SHORT);
1049     window->showMatchingRangeItem = createMenuRadioToggle(subPane, "range",
1050         "Range", 'R', showMatchingRangeCB, window,
1051         window->showMatchingStyle == FLASH_RANGE, SHORT);
1052     createMenuSeparator(subPane, "sep", SHORT);
1053     window->matchSyntaxBasedItem = createMenuToggle(subPane, "matchSyntax",
1054             "Syntax Based", 'S', matchSyntaxBasedCB, window,
1055             window->matchSyntaxBased, SHORT);
1056
1057 #ifndef SGI_CUSTOM
1058     createMenuSeparator(menuPane, "sep2", SHORT);
1059     window->overtypeModeItem = createMenuToggle(menuPane, "overtype", "Overtype", 'O',
1060             doActionCB, "set_overtype_mode", False, SHORT);
1061     window->readOnlyItem = createMenuToggle(menuPane, "readOnly", "Read Only",
1062             'y', doActionCB, "set_locked", IS_USER_LOCKED(window->lockReasons), FULL);
1063 #endif
1064
1065 #ifndef VMS
1066     /*
1067     ** Create the Shell menu
1068     */
1069     menuPane = window->shellMenuPane =
1070             createMenu(menuBar, "shellMenu", "Shell", 0, NULL, FULL);
1071     btn = createMenuItem(menuPane, "executeCommand", "Execute Command...",
1072             'E', doActionCB, "execute_command_dialog", SHORT);
1073     XtVaSetValues(btn, XmNuserData, PERMANENT_MENU_ITEM, NULL);
1074     btn = createMenuItem(menuPane, "executeCommandLine", "Execute Command Line",
1075             'x', doActionCB, "execute_command_line", SHORT);
1076     XtVaSetValues(btn, XmNuserData, PERMANENT_MENU_ITEM, NULL);
1077     window->filterItem = createMenuItem(menuPane, "filterSelection",
1078             "Filter Selection...", 'F', doActionCB, "filter_selection_dialog",
1079             SHORT);
1080     XtVaSetValues(window->filterItem, XmNuserData, PERMANENT_MENU_ITEM,
1081             XmNsensitive, window->wasSelected, NULL);
1082     window->cancelShellItem = createMenuItem(menuPane, "cancelShellCommand",
1083             "Cancel Shell Command", 'C', cancelShellCB, window, SHORT);
1084     XtVaSetValues(window->cancelShellItem, XmNuserData, PERMANENT_MENU_ITEM,
1085             XmNsensitive, False, NULL);
1086     btn = createMenuSeparator(menuPane, "sep1", SHORT);
1087     XtVaSetValues(btn, XmNuserData, PERMANENT_MENU_ITEM, NULL);
1088     /* UpdateShellMenu(window) now done in DetermineLanguageMode */
1089 #endif
1090
1091     /*
1092     ** Create the Macro menu
1093     */
1094     menuPane = window->macroMenuPane =
1095             createMenu(menuBar, "macroMenu", "Macro", 0, NULL, FULL);
1096     window->learnItem = createMenuItem(menuPane, "learnKeystrokes",
1097             "Learn Keystrokes", 'L', learnCB, window, SHORT);
1098     XtVaSetValues(window->learnItem , XmNuserData, PERMANENT_MENU_ITEM, NULL);
1099     window->finishLearnItem = createMenuItem(menuPane, "finishLearn",
1100             "Finish Learn", 'F', finishLearnCB, window, SHORT);
1101     XtVaSetValues(window->finishLearnItem , XmNuserData, PERMANENT_MENU_ITEM,
1102             XmNsensitive, False, NULL);
1103     window->cancelMacroItem = createMenuItem(menuPane, "cancelLearn",
1104             "Cancel Learn", 'C', cancelLearnCB, window, SHORT);
1105     XtVaSetValues(window->cancelMacroItem, XmNuserData, PERMANENT_MENU_ITEM,
1106             XmNsensitive, False, NULL);
1107     window->replayItem = createMenuItem(menuPane, "replayKeystrokes",
1108             "Replay Keystrokes", 'K', replayCB, window, SHORT);
1109     XtVaSetValues(window->replayItem, XmNuserData, PERMANENT_MENU_ITEM,
1110             XmNsensitive, GetReplayMacro() != NULL, NULL);
1111     window->repeatItem = createMenuItem(menuPane, "repeat",
1112             "Repeat...", 'R', doActionCB, "repeat_dialog", SHORT);
1113     XtVaSetValues(window->repeatItem, XmNuserData, PERMANENT_MENU_ITEM, NULL);
1114     XtVaSetValues(btn, XmNuserData, PERMANENT_MENU_ITEM, NULL);
1115     btn = createMenuSeparator(menuPane, "sep1", SHORT);
1116     XtVaSetValues(btn, XmNuserData, PERMANENT_MENU_ITEM, NULL);
1117     /* UpdateMacroMenu(window) now done in DetermineLanguageMode */
1118
1119     /*
1120     ** Create the Windows menu
1121     */
1122     menuPane = window->windowMenuPane = createMenu(menuBar, "windowsMenu",
1123             "Windows", 0, &cascade, FULL);
1124     XtAddCallback(cascade, XmNcascadingCallback, (XtCallbackProc)windowMenuCB,
1125             window);
1126     window->splitWindowItem = createMenuItem(menuPane, "splitWindow",
1127             "Split Window", 'S', doActionCB, "split_window", SHORT);
1128     XtVaSetValues(window->splitWindowItem, XmNuserData, PERMANENT_MENU_ITEM,
1129             NULL);
1130     window->closePaneItem = createMenuItem(menuPane, "closePane",
1131             "Close Pane", 'C', doActionCB, "close_pane", SHORT);
1132     XtVaSetValues(window->closePaneItem, XmNuserData, PERMANENT_MENU_ITEM,NULL);
1133     XtSetSensitive(window->closePaneItem, False);
1134     btn = createMenuSeparator(menuPane, "sep1", SHORT);
1135     XtVaSetValues(btn, XmNuserData, PERMANENT_MENU_ITEM, NULL);
1136
1137     /*
1138     ** Create "Help" pull down menu.
1139     */
1140     menuPane = createMenu(menuBar, "helpMenu", "Help", 0, &cascade, SHORT);
1141     XtVaSetValues(menuBar, XmNmenuHelpWidget, cascade, NULL);
1142     buildHelpMenu( menuPane, &H_M[0], window );
1143
1144     return menuBar;
1145 }
1146
1147 /*----------------------------------------------------------------------------*/
1148
1149 static Widget makeHelpMenuItem(
1150
1151     Widget           parent,
1152     char            *name,      /* to be assigned to the child widget */
1153     char            *label,     /* text to be displayed in menu       */
1154     char             mnemonic,  /* letter in label to be underlined   */
1155     menuCallbackProc callback,  /* activated when menu item selected  */
1156     void            *cbArg,     /* passed to activated call back      */
1157     int              mode,      /* SGI_CUSTOM menu option             */
1158     enum HelpTopic   topic      /* associated with this menu item     */
1159 )
1160 {
1161     Widget menuItem =
1162         createMenuItem( parent, name, label, mnemonic, callback, cbArg, mode );
1163
1164     XtVaSetValues( menuItem, XmNuserData, topic, 0 );
1165     return menuItem;
1166 }
1167
1168 /*----------------------------------------------------------------------------*/
1169
1170 static void helpCB( Widget menuItem, XtPointer clientData, XtPointer callData )
1171 {
1172     WindowInfo *window = (WindowInfo*) clientData;
1173     enum HelpTopic topic;
1174
1175     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(menuItem))->lastFocus,
1176             ((XmAnyCallbackStruct *)callData)->event);
1177     XtVaGetValues( menuItem, XmNuserData, &topic, 0 );
1178
1179     Help( window->shell, topic );
1180 }
1181
1182 /*----------------------------------------------------------------------------*/
1183
1184 #define NON_MENU_HELP 9
1185
1186 static HelpMenu * buildHelpMenu(
1187
1188     Widget       pane,  /* Menu pane on which to place new menu items */
1189     HelpMenu   * menu,  /* Data to drive building the help menu       */
1190     WindowInfo * window /* Main NEdit window information              */
1191 )
1192 {
1193 #ifdef VMS
1194     int hideIt = 1;  /* All menu items matching this will be inaccessible */
1195 #else
1196     int hideIt = -1; /* This value should make all menu items accessible  */
1197 #endif
1198
1199     if( menu != NULL )
1200     {
1201         int crntLevel = menu->level;
1202
1203         /*-------------------------
1204         * For each menu element ...
1205         *-------------------------*/
1206         while( menu != NULL && menu->level == crntLevel )
1207         {
1208             /*----------------------------------------------
1209             * ... see if dealing with a separator or submenu
1210             *----------------------------------------------*/
1211             if( menu->topic == HELP_none )
1212             {
1213                 if( menu->mnemonic == '-' )
1214                 {
1215                     createMenuSeparator(pane, menu->wgtName, SHORT);
1216                     menu = menu->next;
1217                 }
1218                 else
1219                 {
1220                     /*-------------------------------------------------------
1221                     * Do not show any of the submenu when it is to be hidden.
1222                     *-------------------------------------------------------*/
1223                     if( menu->hideIt == hideIt || menu->hideIt == NON_MENU_HELP )
1224                     {
1225                         do {     menu = menu->next;
1226                         } while( menu != NULL && menu->level > crntLevel );
1227
1228                     }
1229                     else
1230                     {
1231                         Widget subPane =
1232                             createMenu( pane, menu->wgtName, menu->subTitle,
1233                                menu->mnemonic, NULL, FULL);
1234
1235                         menu = buildHelpMenu( subPane, menu->next, window );
1236                     }
1237                 }
1238             }
1239
1240             else
1241             {
1242                 /*---------------------------------------
1243                 * Show menu item if not going to hide it.
1244                 * This is the easy way out of hiding
1245                 * menu items. When entire submenus want
1246                 * to be hidden, either the entire branch
1247                 * will have to be marked, or this algorithm
1248                 * will have to become a lot smarter.
1249                 *---------------------------------------*/
1250                 if( menu->hideIt != hideIt && menu->hideIt != NON_MENU_HELP )
1251                     makeHelpMenuItem(
1252                         pane, menu->wgtName, HelpTitles[menu->topic],
1253                         menu->mnemonic, helpCB, window, SHORT, menu->topic );
1254
1255                 menu = menu->next;
1256             }
1257         }
1258     }
1259
1260     return menu;
1261 }
1262
1263 /*----------------------------------------------------------------------------*/
1264
1265 static void doActionCB(Widget w, XtPointer clientData, XtPointer callData)
1266 {
1267     Widget menu = MENU_WIDGET(w);
1268
1269     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1270             ((XmAnyCallbackStruct *)callData)->event);
1271     XtCallActionProc(WidgetToWindow(menu)->lastFocus, (char *)clientData,
1272             ((XmAnyCallbackStruct *)callData)->event, NULL, 0);
1273 }
1274
1275 static void pasteColCB(Widget w, XtPointer clientData, XtPointer callData)
1276 {
1277     static char *params[1] = {"rect"};
1278
1279     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1280             ((XmAnyCallbackStruct *)callData)->event);
1281     XtCallActionProc(((WindowInfo *)clientData)->lastFocus, "paste_clipboard",
1282             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1283 }
1284
1285 static void shiftLeftCB(Widget w, XtPointer clientData, XtPointer callData)
1286 {
1287     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1288             ((XmAnyCallbackStruct *)callData)->event);
1289     XtCallActionProc(((WindowInfo *)clientData)->lastFocus,
1290             ((XmAnyCallbackStruct *)callData)->event->xbutton.state & ShiftMask
1291             ? "shift_left_by_tab" : "shift_left",
1292             ((XmAnyCallbackStruct *)callData)->event, NULL, 0);
1293 }
1294
1295 static void shiftRightCB(Widget w, XtPointer clientData, XtPointer callData)
1296 {
1297     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1298             ((XmAnyCallbackStruct *)callData)->event);
1299     XtCallActionProc(((WindowInfo *)clientData)->lastFocus,
1300             ((XmAnyCallbackStruct *)callData)->event->xbutton.state & ShiftMask
1301             ? "shift_right_by_tab" : "shift_right",
1302             ((XmAnyCallbackStruct *)callData)->event, NULL, 0);
1303 }
1304
1305 static void findCB(Widget w, XtPointer clientData, XtPointer callData)
1306 {
1307     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1308             ((XmAnyCallbackStruct *)callData)->event);
1309     XtCallActionProc(((WindowInfo *)clientData)->lastFocus, "find_dialog",
1310             ((XmAnyCallbackStruct *)callData)->event,
1311             shiftKeyToDir(callData), 1);
1312 }
1313
1314 static void findSameCB(Widget w, XtPointer clientData, XtPointer callData)
1315 {
1316     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1317             ((XmAnyCallbackStruct *)callData)->event);
1318      XtCallActionProc(((WindowInfo *)clientData)->lastFocus, "find_again",
1319             ((XmAnyCallbackStruct *)callData)->event,
1320             shiftKeyToDir(callData), 1);
1321 }
1322
1323 static void findSelCB(Widget w, XtPointer clientData, XtPointer callData)
1324 {
1325     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1326             ((XmAnyCallbackStruct *)callData)->event);
1327     XtCallActionProc(((WindowInfo *)clientData)->lastFocus, "find_selection",
1328             ((XmAnyCallbackStruct *)callData)->event,
1329             shiftKeyToDir(callData), 1);
1330 }
1331
1332 static void findIncrCB(Widget w, XtPointer clientData, XtPointer callData)
1333 {
1334     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1335             ((XmAnyCallbackStruct *)callData)->event);
1336     XtCallActionProc(((WindowInfo *)clientData)->lastFocus,
1337             "start_incremental_find", ((XmAnyCallbackStruct *)callData)->event,
1338             shiftKeyToDir(callData), 1);
1339 }
1340
1341 static void replaceCB(Widget w, XtPointer clientData, XtPointer callData)
1342 {
1343     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1344             ((XmAnyCallbackStruct *)callData)->event);
1345     XtCallActionProc(((WindowInfo *)clientData)->lastFocus, "replace_dialog",
1346             ((XmAnyCallbackStruct *)callData)->event,
1347             shiftKeyToDir(callData), 1);
1348 }
1349
1350 static void replaceSameCB(Widget w, XtPointer clientData, XtPointer callData)
1351 {
1352     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1353             ((XmAnyCallbackStruct *)callData)->event);
1354     XtCallActionProc(((WindowInfo *)clientData)->lastFocus, "replace_again",
1355             ((XmAnyCallbackStruct *)callData)->event,
1356             shiftKeyToDir(callData), 1);
1357 }
1358
1359 static void replaceFindSameCB(Widget w, XtPointer clientData, XtPointer callData)
1360 {
1361     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1362             ((XmAnyCallbackStruct *)callData)->event);
1363     XtCallActionProc(((WindowInfo *)clientData)->lastFocus, "replace_find_same",
1364             ((XmAnyCallbackStruct *)callData)->event,
1365             shiftKeyToDir(callData), 1);
1366 }
1367
1368 static void markCB(Widget w, XtPointer clientData, XtPointer callData)
1369 {
1370     XEvent *event = ((XmAnyCallbackStruct *)callData)->event;
1371     WindowInfo *window = (WindowInfo *)clientData;
1372
1373     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1374             ((XmAnyCallbackStruct *)callData)->event);
1375     if (event->type == KeyPress || event->type == KeyRelease)
1376         BeginMarkCommand(window);
1377     else
1378         XtCallActionProc(window->lastFocus, "mark_dialog", event, NULL, 0);
1379 }
1380
1381 static void gotoMarkCB(Widget w, XtPointer clientData, XtPointer callData)
1382 {
1383     XEvent *event = ((XmAnyCallbackStruct *)callData)->event;
1384     WindowInfo *window = (WindowInfo *)clientData;
1385     int extend = event->xbutton.state & ShiftMask;
1386     static char *params[1] = {"extend"};
1387
1388     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1389             ((XmAnyCallbackStruct *)callData)->event);
1390     if (event->type == KeyPress || event->type == KeyRelease)
1391         BeginGotoMarkCommand(window, extend);
1392     else
1393         XtCallActionProc(window->lastFocus, "goto_mark_dialog", event, params,
1394                 extend ? 1 : 0);
1395 }
1396
1397 static void gotoMatchingCB(Widget w, XtPointer clientData, XtPointer callData)
1398 {
1399     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1400             ((XmAnyCallbackStruct *)callData)->event);
1401     XtCallActionProc(((WindowInfo *)clientData)->lastFocus,
1402             ((XmAnyCallbackStruct *)callData)->event->xbutton.state & ShiftMask
1403             ? "select_to_matching" : "goto_matching",
1404             ((XmAnyCallbackStruct *)callData)->event, NULL, 0);
1405 }
1406
1407 static void autoIndentOffCB(Widget w, WindowInfo *window, caddr_t callData)
1408 {
1409     static char *params[1] = {"off"};
1410     Widget menu = MENU_WIDGET(w);
1411 #ifdef SGI_CUSTOM
1412     if (shortPrefAskDefault(window->shell, w, "Auto Indent Off")) {
1413         autoIndentOffDefCB(w, window, callData);
1414         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1415     }
1416 #endif
1417     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1418             ((XmAnyCallbackStruct *)callData)->event);
1419     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_auto_indent",
1420             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1421 }
1422
1423 static void autoIndentCB(Widget w, WindowInfo *window, caddr_t callData)
1424 {
1425     static char *params[1] = {"on"};
1426     Widget menu = MENU_WIDGET(w);
1427 #ifdef SGI_CUSTOM
1428     if (shortPrefAskDefault(window->shell, w, "Auto Indent")) {
1429         autoIndentDefCB(w, window, callData);
1430         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1431     }
1432 #endif
1433     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1434             ((XmAnyCallbackStruct *)callData)->event);
1435     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_auto_indent",
1436             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1437 }
1438
1439 static void smartIndentCB(Widget w, WindowInfo *window, caddr_t callData)
1440 {
1441     static char *params[1] = {"smart"};
1442     Widget menu = MENU_WIDGET(w);
1443 #ifdef SGI_CUSTOM
1444     if (shortPrefAskDefault(window->shell, w, "Smart Indent")) {
1445         smartIndentDefCB(w, window, callData);
1446         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1447     }
1448 #endif
1449     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1450             ((XmAnyCallbackStruct *)callData)->event);
1451     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_auto_indent",
1452             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1453 }
1454
1455 static void autoSaveCB(Widget w, WindowInfo *window, caddr_t callData)
1456 {
1457     Widget menu = MENU_WIDGET(w);
1458 #ifdef SGI_CUSTOM
1459     if (shortPrefAskDefault(window->shell, w, "Incremental Backup")) {
1460         autoSaveDefCB(w, window, callData);
1461         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1462     }
1463 #endif
1464     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1465             ((XmAnyCallbackStruct *)callData)->event);
1466     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_incremental_backup",
1467             ((XmAnyCallbackStruct *)callData)->event, NULL, 0);
1468 }
1469
1470 static void preserveCB(Widget w, WindowInfo *window, caddr_t callData)
1471 {
1472     Widget menu = MENU_WIDGET(w);
1473 #ifdef SGI_CUSTOM
1474     if (shortPrefAskDefault(window->shell, w, "Make Backup Copy")) {
1475         preserveDefCB(w, window, callData);
1476         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1477     }
1478 #endif
1479     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1480             ((XmAnyCallbackStruct *)callData)->event);
1481     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_make_backup_copy",
1482             ((XmAnyCallbackStruct *)callData)->event, NULL, 0);
1483 }
1484
1485 static void showMatchingOffCB(Widget w, WindowInfo *window, caddr_t callData)
1486 {
1487     static char *params[1] = {NO_FLASH_STRING};
1488     Widget menu = MENU_WIDGET(w);
1489 #ifdef SGI_CUSTOM
1490     if (shortPrefAskDefault(window->shell, w, "Show Matching Off")) {
1491         showMatchingOffDefCB(w, window, callData);
1492         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1493     }
1494 #endif
1495     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1496             ((XmAnyCallbackStruct *)callData)->event);
1497     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_show_matching",
1498             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1499 }
1500
1501 static void showMatchingDelimitCB(Widget w, WindowInfo *window, caddr_t callData)
1502 {
1503     static char *params[1] = {FLASH_DELIMIT_STRING};
1504     Widget menu = MENU_WIDGET(w);
1505 #ifdef SGI_CUSTOM
1506     if (shortPrefAskDefault(window->shell, w, "Show Matching Delimiter")) {
1507         showMatchingDelimitDefCB(w, window, callData);
1508         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1509     }
1510 #endif
1511     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1512             ((XmAnyCallbackStruct *)callData)->event);
1513     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_show_matching",
1514             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1515 }
1516
1517 static void showMatchingRangeCB(Widget w, WindowInfo *window, caddr_t callData)
1518 {
1519     static char *params[1] = {FLASH_RANGE_STRING};
1520     Widget menu = MENU_WIDGET(w);
1521 #ifdef SGI_CUSTOM
1522     if (shortPrefAskDefault(window->shell, w, "Show Matching Range")) {
1523         showMatchingRangeDefCB(w, window, callData);
1524         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1525     }
1526 #endif
1527     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1528             ((XmAnyCallbackStruct *)callData)->event);
1529     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_show_matching",
1530             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1531 }
1532
1533 static void matchSyntaxBasedCB(Widget w, WindowInfo *window, caddr_t callData)
1534 {
1535     Widget menu = MENU_WIDGET(w);
1536 #ifdef SGI_CUSTOM
1537     if (shortPrefAskDefault(window->shell, w, "Match Syntax Based")) {
1538         matchSyntaxBasedDefCB(w, window, callData);
1539         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1540     }
1541 #endif
1542     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1543             ((XmAnyCallbackStruct *)callData)->event);
1544     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_match_syntax_based",
1545             ((XmAnyCallbackStruct *)callData)->event, NULL, 0);
1546 }
1547
1548 static void fontCB(Widget w, WindowInfo *window, caddr_t callData)
1549 {
1550     ChooseFonts(window, True);
1551 }
1552
1553 static void noWrapCB(Widget w, WindowInfo *window, caddr_t callData)
1554 {
1555     static char *params[1] = {"none"};
1556     Widget menu = MENU_WIDGET(w);
1557 #ifdef SGI_CUSTOM
1558     if (shortPrefAskDefault(window->shell, w, "No Wrap")) {
1559         noWrapDefCB(w, window, callData);
1560         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1561     }
1562 #endif
1563     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1564             ((XmAnyCallbackStruct *)callData)->event);
1565     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_wrap_text",
1566             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1567 }
1568
1569 static void newlineWrapCB(Widget w, WindowInfo *window, caddr_t callData)
1570 {
1571     static char *params[1] = {"auto"};
1572     Widget menu = MENU_WIDGET(w);
1573 #ifdef SGI_CUSTOM
1574     if (shortPrefAskDefault(window->shell, w, "Auto Newline Wrap")) {
1575         newlineWrapDefCB(w, window, callData);
1576         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1577     }
1578 #endif
1579     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1580             ((XmAnyCallbackStruct *)callData)->event);
1581     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_wrap_text",
1582             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1583 }
1584
1585 static void continuousWrapCB(Widget w, WindowInfo *window, caddr_t callData)
1586 {
1587     static char *params[1] = {"continuous"};
1588     Widget menu = MENU_WIDGET(w);
1589 #ifdef SGI_CUSTOM
1590     if (shortPrefAskDefault(window->shell, w, "Continuous Wrap")) {
1591         contWrapDefCB(w, window, callData);
1592         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1593     }
1594 #endif
1595     HidePointerOnKeyedEvent(WidgetToWindow(menu)->lastFocus,
1596             ((XmAnyCallbackStruct *)callData)->event);
1597     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_wrap_text",
1598             ((XmAnyCallbackStruct *)callData)->event, params, 1);
1599 }
1600
1601 static void wrapMarginCB(Widget w, WindowInfo *window, caddr_t callData)
1602 {
1603     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1604             ((XmAnyCallbackStruct *)callData)->event);
1605     WrapMarginDialog(window->shell, window);
1606 }
1607
1608 static void backlightCharsCB(Widget w, WindowInfo *window, caddr_t callData)
1609 {
1610     int applyBacklight = XmToggleButtonGetState(w);
1611     SetBacklightChars(window, applyBacklight?GetPrefBacklightCharTypes():NULL);
1612 }
1613
1614 static void tabsCB(Widget w, WindowInfo *window, caddr_t callData)
1615 {
1616     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1617             ((XmAnyCallbackStruct *)callData)->event);
1618     TabsPrefDialog(window->shell, window);
1619 }
1620
1621 static void statsCB(Widget w, WindowInfo *window, caddr_t callData)
1622 {
1623     Widget menu = MENU_WIDGET(w);
1624 #ifdef SGI_CUSTOM
1625     if (shortPrefAskDefault(window->shell, w, "Statistics Line")) {
1626         statsLineDefCB(w, window, callData);
1627         SaveNEditPrefs(window->shell, GetPrefShortMenus());
1628     }
1629 #endif
1630     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1631             ((XmAnyCallbackStruct *)callData)->event);
1632     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "set_statistics_line",
1633             ((XmAnyCallbackStruct *)callData)->event, NULL, 0);
1634 }
1635
1636 static void autoIndentOffDefCB(Widget w, WindowInfo *window, caddr_t callData)
1637 {
1638     WindowInfo *win;
1639
1640     /* Set the preference and make the other windows' menus agree */
1641     SetPrefAutoIndent(NO_AUTO_INDENT);
1642     for (win=WindowList; win!=NULL; win=win->next) {
1643         XmToggleButtonSetState(win->autoIndentOffDefItem, True, False);
1644         XmToggleButtonSetState(win->autoIndentDefItem, False, False);
1645         XmToggleButtonSetState(win->smartIndentDefItem, False, False);
1646     }
1647 }
1648
1649 static void autoIndentDefCB(Widget w, WindowInfo *window, caddr_t callData)
1650 {
1651     WindowInfo *win;
1652
1653     /* Set the preference and make the other windows' menus agree */
1654     SetPrefAutoIndent(AUTO_INDENT);
1655     for (win=WindowList; win!=NULL; win=win->next) {
1656         XmToggleButtonSetState(win->autoIndentDefItem, True, False);
1657         XmToggleButtonSetState(win->autoIndentOffDefItem, False, False);
1658         XmToggleButtonSetState(win->smartIndentDefItem, False, False);
1659     }
1660 }
1661
1662 static void smartIndentDefCB(Widget w, WindowInfo *window, caddr_t callData)
1663 {
1664     WindowInfo *win;
1665
1666     /* Set the preference and make the other windows' menus agree */
1667     SetPrefAutoIndent(SMART_INDENT);
1668     for (win=WindowList; win!=NULL; win=win->next) {
1669         XmToggleButtonSetState(win->smartIndentDefItem, True, False);
1670         XmToggleButtonSetState(win->autoIndentOffDefItem, False, False);
1671         XmToggleButtonSetState(win->autoIndentDefItem, False, False);
1672     }
1673 }
1674
1675 static void autoSaveDefCB(Widget w, WindowInfo *window, caddr_t callData)
1676 {
1677     WindowInfo *win;
1678     int state = XmToggleButtonGetState(w);
1679
1680     /* Set the preference and make the other windows' menus agree */
1681     SetPrefAutoSave(state);
1682     for (win=WindowList; win!=NULL; win=win->next)
1683         XmToggleButtonSetState(win->autoSaveDefItem, state, False);
1684 }
1685
1686 static void preserveDefCB(Widget w, WindowInfo *window, caddr_t callData)
1687 {
1688     WindowInfo *win;
1689     int state = XmToggleButtonGetState(w);
1690
1691     /* Set the preference and make the other windows' menus agree */
1692     SetPrefSaveOldVersion(state);
1693     for (win=WindowList; win!=NULL; win=win->next)
1694         XmToggleButtonSetState(win->saveLastDefItem, state, False);
1695 }
1696
1697 static void fontDefCB(Widget w, WindowInfo *window, caddr_t callData)
1698 {
1699     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1700             ((XmAnyCallbackStruct *)callData)->event);
1701     ChooseFonts(window, False);
1702 }
1703
1704 static void noWrapDefCB(Widget w, WindowInfo *window, caddr_t callData)
1705 {
1706     WindowInfo *win;
1707
1708     /* Set the preference and make the other windows' menus agree */
1709     SetPrefWrap(NO_WRAP);
1710     for (win=WindowList; win!=NULL; win=win->next) {
1711         XmToggleButtonSetState(win->noWrapDefItem, True, False);
1712         XmToggleButtonSetState(win->newlineWrapDefItem, False, False);
1713         XmToggleButtonSetState(win->contWrapDefItem, False, False);
1714     }
1715 }
1716
1717 static void newlineWrapDefCB(Widget w, WindowInfo *window, caddr_t callData)
1718 {
1719     WindowInfo *win;
1720
1721     /* Set the preference and make the other windows' menus agree */
1722     SetPrefWrap(NEWLINE_WRAP);
1723     for (win=WindowList; win!=NULL; win=win->next) {
1724         XmToggleButtonSetState(win->newlineWrapDefItem, True, False);
1725         XmToggleButtonSetState(win->contWrapDefItem, False, False);
1726         XmToggleButtonSetState(win->noWrapDefItem, False, False);
1727     }
1728 }
1729
1730 static void contWrapDefCB(Widget w, WindowInfo *window, caddr_t callData)
1731 {
1732     WindowInfo *win;
1733
1734     /* Set the preference and make the other windows' menus agree */
1735     SetPrefWrap(CONTINUOUS_WRAP);
1736     for (win=WindowList; win!=NULL; win=win->next) {
1737         XmToggleButtonSetState(win->contWrapDefItem, True, False);
1738         XmToggleButtonSetState(win->newlineWrapDefItem, False, False);
1739         XmToggleButtonSetState(win->noWrapDefItem, False, False);
1740     }
1741 }
1742
1743 static void wrapMarginDefCB(Widget w, WindowInfo *window, caddr_t callData)
1744 {
1745     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1746             ((XmAnyCallbackStruct *)callData)->event);
1747     WrapMarginDialog(window->shell, NULL);
1748 }
1749
1750 static void smartTagsDefCB(Widget w, XtPointer client_data, XtPointer callData)
1751 {
1752     WindowInfo *win;
1753
1754     SetPrefSmartTags(True);
1755     for (win=WindowList; win!=NULL; win=win->next) {
1756         XmToggleButtonSetState(win->smartTagsDefItem, True, False);
1757         XmToggleButtonSetState(win->allTagsDefItem, False, False);
1758     }
1759 }
1760
1761 static void showAllTagsDefCB(Widget w, XtPointer client_data, XtPointer callData)
1762 {
1763     WindowInfo *win;
1764
1765     SetPrefSmartTags(False);
1766     for (win=WindowList; win!=NULL; win=win->next) {
1767         XmToggleButtonSetState(win->smartTagsDefItem, False, False);
1768         XmToggleButtonSetState(win->allTagsDefItem, True, False);
1769     }
1770 }
1771
1772 static void tabsDefCB(Widget w, WindowInfo *window, caddr_t callData)
1773 {
1774     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1775             ((XmAnyCallbackStruct *)callData)->event);
1776     TabsPrefDialog(window->shell, NULL);
1777 }
1778
1779 static void showMatchingOffDefCB(Widget w, WindowInfo *window, caddr_t callData)
1780 {
1781     WindowInfo *win;
1782
1783     /* Set the preference and make the other windows' menus agree */
1784     SetPrefShowMatching(NO_FLASH);
1785     for (win=WindowList; win!=NULL; win=win->next) {
1786         XmToggleButtonSetState(win->showMatchingOffDefItem, True, False);
1787         XmToggleButtonSetState(win->showMatchingDelimitDefItem, False, False);
1788         XmToggleButtonSetState(win->showMatchingRangeDefItem, False, False);
1789     }
1790 }
1791
1792 static void showMatchingDelimitDefCB(Widget w, WindowInfo *window, caddr_t callData)
1793 {
1794     WindowInfo *win;
1795
1796     /* Set the preference and make the other windows' menus agree */
1797     SetPrefShowMatching(FLASH_DELIMIT);
1798     for (win=WindowList; win!=NULL; win=win->next) {
1799         XmToggleButtonSetState(win->showMatchingOffDefItem, False, False);
1800         XmToggleButtonSetState(win->showMatchingDelimitDefItem, True, False);
1801         XmToggleButtonSetState(win->showMatchingRangeDefItem, False, False);
1802     }
1803 }
1804
1805 static void showMatchingRangeDefCB(Widget w, WindowInfo *window, caddr_t callData)
1806 {
1807     WindowInfo *win;
1808
1809     /* Set the preference and make the other windows' menus agree */
1810     SetPrefShowMatching(FLASH_RANGE);
1811     for (win=WindowList; win!=NULL; win=win->next) {
1812         XmToggleButtonSetState(win->showMatchingOffDefItem, False, False);
1813         XmToggleButtonSetState(win->showMatchingDelimitDefItem, False, False);
1814         XmToggleButtonSetState(win->showMatchingRangeDefItem, True, False);
1815     }
1816 }
1817
1818 static void matchSyntaxBasedDefCB(Widget w, WindowInfo *window, caddr_t callData)
1819 {
1820     WindowInfo *win;
1821
1822     int state = XmToggleButtonGetState(w);
1823
1824     /* Set the preference and make the other windows' menus agree */
1825     SetPrefMatchSyntaxBased(state);
1826     for (win=WindowList; win!=NULL; win=win->next) {
1827         XmToggleButtonSetState(win->matchSyntaxBasedDefItem, state, False);
1828     }
1829 }
1830
1831 static void backlightCharsDefCB(Widget w, WindowInfo *window, caddr_t callData)
1832 {
1833     WindowInfo *win;
1834     int state = XmToggleButtonGetState(w);
1835
1836     /* Set the preference and make the other windows' menus agree */
1837     SetPrefBacklightChars(state);
1838     for (win=WindowList; win!=NULL; win=win->next)
1839       XmToggleButtonSetState(win->backlightCharsDefItem, state, False);
1840 }
1841
1842 static void backlightCharTypesDefCB(Widget w, WindowInfo *window,
1843       caddr_t callData)
1844 {
1845     BacklightUseCurrCharTypesAsPref(window, False);
1846 }
1847
1848 static void highlightOffDefCB(Widget w, WindowInfo *window, caddr_t callData)
1849 {
1850     WindowInfo *win;
1851
1852     /* Set the preference and make the other windows' menus agree */
1853     SetPrefHighlightSyntax(False);
1854     for (win=WindowList; win!=NULL; win=win->next) {
1855         XmToggleButtonSetState(win->highlightOffDefItem, True, False);
1856         XmToggleButtonSetState(win->highlightDefItem, False, False);
1857     }
1858 }
1859
1860 static void highlightDefCB(Widget w, WindowInfo *window, caddr_t callData)
1861 {
1862     WindowInfo *win;
1863
1864     /* Set the preference and make the other windows' menus agree */
1865     SetPrefHighlightSyntax(True);
1866     for (win=WindowList; win!=NULL; win=win->next) {
1867         XmToggleButtonSetState(win->highlightOffDefItem, False, False);
1868         XmToggleButtonSetState(win->highlightDefItem, True, False);
1869     }
1870 }
1871
1872 static void highlightingDefCB(Widget w, WindowInfo *window, caddr_t callData)
1873 {
1874     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1875             ((XmAnyCallbackStruct *)callData)->event);
1876     EditHighlightPatterns(window);
1877 }
1878
1879 static void smartMacrosDefCB(Widget w, WindowInfo *window, caddr_t callData)
1880 {
1881     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1882             ((XmAnyCallbackStruct *)callData)->event);
1883     EditSmartIndentMacros(window);
1884 }
1885
1886 static void stylesDefCB(Widget w, WindowInfo *window, caddr_t callData)
1887 {
1888     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1889             ((XmAnyCallbackStruct *)callData)->event);
1890     EditHighlightStyles(window->shell, NULL);
1891 }
1892
1893 static void languageDefCB(Widget w, WindowInfo *window, caddr_t callData)
1894 {
1895     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1896             ((XmAnyCallbackStruct *)callData)->event);
1897     EditLanguageModes(window->shell);
1898 }
1899
1900 #ifndef VMS
1901 static void shellDefCB(Widget w, WindowInfo *window, caddr_t callData)
1902 {
1903     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1904             ((XmAnyCallbackStruct *)callData)->event);
1905     EditShellMenu(window);
1906 }
1907 #endif /* VMS */
1908
1909 static void macroDefCB(Widget w, WindowInfo *window, caddr_t callData)
1910 {
1911     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1912             ((XmAnyCallbackStruct *)callData)->event);
1913     EditMacroMenu(window);
1914 }
1915
1916 static void bgMenuDefCB(Widget w, WindowInfo *window, caddr_t callData)
1917 {
1918     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1919             ((XmAnyCallbackStruct *)callData)->event);
1920     EditBGMenu(window);
1921 }
1922
1923 static void customizeTitleDefCB(Widget w, WindowInfo *window, caddr_t callData)
1924 {
1925     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
1926             ((XmAnyCallbackStruct *)callData)->event);
1927     EditCustomTitleFormat(window->shell, window);
1928 }
1929
1930 static void searchDlogsDefCB(Widget w, WindowInfo *window, caddr_t callData)
1931 {
1932     WindowInfo *win;
1933     int state = XmToggleButtonGetState(w);
1934
1935     /* Set the preference and make the other windows' menus agree */
1936     SetPrefSearchDlogs(state);
1937     for (win=WindowList; win!=NULL; win=win->next)
1938         XmToggleButtonSetState(win->searchDlogsDefItem, state, False);
1939 }
1940
1941 static void beepOnSearchWrapDefCB(Widget w, WindowInfo *window, caddr_t callData)
1942 {
1943     WindowInfo *win;
1944     int state = XmToggleButtonGetState(w);
1945
1946     /* Set the preference and make the other windows' menus agree */
1947     SetPrefBeepOnSearchWrap(state);
1948     for (win=WindowList; win!=NULL; win=win->next)
1949         XmToggleButtonSetState(win->beepOnSearchWrapDefItem, state, False);
1950 }
1951
1952 static void keepSearchDlogsDefCB(Widget w, WindowInfo *window, caddr_t callData)
1953 {
1954     WindowInfo *win;
1955     int state = XmToggleButtonGetState(w);
1956
1957     /* Set the preference and make the other windows' menus agree */
1958     SetPrefKeepSearchDlogs(state);
1959     for (win=WindowList; win!=NULL; win=win->next)
1960         XmToggleButtonSetState(win->keepSearchDlogsDefItem, state, False);
1961 }
1962
1963 static void searchWrapsDefCB(Widget w, WindowInfo *window, caddr_t callData)
1964 {
1965     WindowInfo *win;
1966     int state = XmToggleButtonGetState(w);
1967
1968     /* Set the preference and make the other windows' menus agree */
1969     SetPrefSearchWraps(state);
1970     for (win=WindowList; win!=NULL; win=win->next)
1971         XmToggleButtonSetState(win->searchWrapsDefItem, state, False);
1972 }
1973
1974 static void appendLFCB(Widget w, WindowInfo* window, caddr_t callData)
1975 {
1976     WindowInfo *win;
1977     int state = XmToggleButtonGetState(w);
1978
1979     SetPrefAppendLF(state);
1980     for (win = WindowList; win != NULL; win = win->next)
1981     {
1982         XmToggleButtonSetState(win->appendLFItem, state, False);
1983     }
1984 }
1985
1986 static void sortOpenPrevDefCB(Widget w, WindowInfo *window, caddr_t callData)
1987 {
1988     WindowInfo *win;
1989     int state = XmToggleButtonGetState(w);
1990
1991     /* Set the preference, make the other windows' menus agree,
1992        and invalidate their Open Previous menus */
1993     SetPrefSortOpenPrevMenu(state);
1994     for (win=WindowList; win!=NULL; win=win->next) {
1995         win->prevOpenMenuValid = False;
1996         XmToggleButtonSetState(win->sortOpenPrevDefItem, state, False);
1997     }
1998 }
1999
2000 static void reposDlogsDefCB(Widget w, WindowInfo *window, caddr_t callData)
2001 {
2002     WindowInfo *win;
2003     int state = XmToggleButtonGetState(w);
2004
2005     /* Set the preference and make the other windows' menus agree */
2006     SetPrefRepositionDialogs(state);
2007     SetPointerCenteredDialogs(state);
2008     for (win=WindowList; win!=NULL; win=win->next)
2009         XmToggleButtonSetState(win->reposDlogsDefItem, state, False);
2010 }
2011
2012 static void modWarnDefCB(Widget w, WindowInfo *window, caddr_t callData)
2013 {
2014     WindowInfo *win;
2015     int state = XmToggleButtonGetState(w);
2016
2017     /* Set the preference and make the other windows' menus agree */
2018     SetPrefWarnFileMods(state);
2019     for (win=WindowList; win!=NULL; win=win->next) {
2020         XmToggleButtonSetState(win->modWarnDefItem, state, False);
2021         XtSetSensitive(win->modWarnRealDefItem, state);
2022     }
2023 }
2024
2025 static void modWarnRealDefCB(Widget w, WindowInfo *window, caddr_t callData)
2026 {
2027     WindowInfo *win;
2028     int state = XmToggleButtonGetState(w);
2029
2030     /* Set the preference and make the other windows' menus agree */
2031     SetPrefWarnRealFileMods(state);
2032     for (win=WindowList; win!=NULL; win=win->next)
2033         XmToggleButtonSetState(win->modWarnRealDefItem, state, False);
2034 }
2035
2036 static void exitWarnDefCB(Widget w, WindowInfo *window, caddr_t callData)
2037 {
2038     WindowInfo *win;
2039     int state = XmToggleButtonGetState(w);
2040
2041     /* Set the preference and make the other windows' menus agree */
2042     SetPrefWarnExit(state);
2043     for (win=WindowList; win!=NULL; win=win->next)
2044         XmToggleButtonSetState(win->exitWarnDefItem, state, False);
2045 }
2046
2047 static void statsLineDefCB(Widget w, WindowInfo *window, caddr_t callData)
2048 {
2049     WindowInfo *win;
2050     int state = XmToggleButtonGetState(w);
2051
2052     /* Set the preference and make the other windows' menus agree */
2053     SetPrefStatsLine(state);
2054     for (win=WindowList; win!=NULL; win=win->next)
2055         XmToggleButtonSetState(win->statsLineDefItem, state, False);
2056 }
2057
2058 static void iSearchLineDefCB(Widget w, WindowInfo *window, caddr_t callData)
2059 {
2060     WindowInfo *win;
2061     int state = XmToggleButtonGetState(w);
2062
2063     /* Set the preference and make the other windows' menus agree */
2064     SetPrefISearchLine(state);
2065     for (win=WindowList; win!=NULL; win=win->next)
2066         XmToggleButtonSetState(win->iSearchLineDefItem, state, False);
2067 }
2068
2069 static void lineNumsDefCB(Widget w, WindowInfo *window, caddr_t callData)
2070 {
2071     WindowInfo *win;
2072     int state = XmToggleButtonGetState(w);
2073
2074     /* Set the preference and make the other windows' menus agree */
2075     SetPrefLineNums(state);
2076     for (win=WindowList; win!=NULL; win=win->next)
2077         XmToggleButtonSetState(win->lineNumsDefItem, state, False);
2078 }
2079
2080 static void pathInWindowsMenuDefCB(Widget w, WindowInfo *window, caddr_t callData)
2081 {
2082     WindowInfo *win;
2083     int state = XmToggleButtonGetState(w);
2084
2085     /* Set the preference and make the other windows' menus agree */
2086     SetPrefShowPathInWindowsMenu(state);
2087     for (win=WindowList; win!=NULL; win=win->next)
2088         XmToggleButtonSetState(win->pathInWindowsMenuDefItem, state, False);
2089 }
2090
2091 static void searchLiteralCB(Widget w, WindowInfo *window, caddr_t callData)
2092 {
2093     WindowInfo *win;
2094
2095     /* Set the preference and make the other windows' menus agree */
2096     if (XmToggleButtonGetState(w)) {
2097         SetPrefSearch(SEARCH_LITERAL);
2098         for (win=WindowList; win!=NULL; win=win->next){
2099             XmToggleButtonSetState(win->searchLiteralDefItem, True, False);
2100             XmToggleButtonSetState(win->searchCaseSenseDefItem, False, False);
2101             XmToggleButtonSetState(win->searchLiteralWordDefItem, False, False);
2102             XmToggleButtonSetState(win->searchCaseSenseWordDefItem, False, False);
2103             XmToggleButtonSetState(win->searchRegexDefItem, False, False);
2104             XmToggleButtonSetState(win->searchRegexNoCaseDefItem, False, False);
2105         }
2106     }
2107 }
2108
2109 static void searchCaseSenseCB(Widget w, WindowInfo *window, caddr_t callData)
2110 {
2111     WindowInfo *win;
2112
2113     /* Set the preference and make the other windows' menus agree */
2114     if (XmToggleButtonGetState(w)) {
2115         SetPrefSearch(SEARCH_CASE_SENSE);
2116         for (win=WindowList; win!=NULL; win=win->next) {
2117             XmToggleButtonSetState(win->searchLiteralDefItem, False, False);
2118             XmToggleButtonSetState(win->searchCaseSenseDefItem, True, False);
2119             XmToggleButtonSetState(win->searchLiteralWordDefItem, False, False);
2120             XmToggleButtonSetState(win->searchCaseSenseWordDefItem, False, False);
2121             XmToggleButtonSetState(win->searchRegexDefItem, False, False);
2122             XmToggleButtonSetState(win->searchRegexNoCaseDefItem, False, False);
2123         }
2124     }
2125 }
2126
2127 static void searchLiteralWordCB(Widget w, WindowInfo *window, caddr_t callData)
2128 {
2129     WindowInfo *win;
2130
2131     /* Set the preference and make the other windows' menus agree */
2132     if (XmToggleButtonGetState(w)) {
2133         SetPrefSearch(SEARCH_LITERAL_WORD);
2134         for (win=WindowList; win!=NULL; win=win->next){
2135             XmToggleButtonSetState(win->searchLiteralDefItem, False, False);
2136             XmToggleButtonSetState(win->searchCaseSenseDefItem, False, False);
2137             XmToggleButtonSetState(win->searchLiteralWordDefItem, True, False);
2138             XmToggleButtonSetState(win->searchCaseSenseWordDefItem, False, False);
2139             XmToggleButtonSetState(win->searchRegexDefItem, False, False);
2140             XmToggleButtonSetState(win->searchRegexNoCaseDefItem, False, False);
2141         }
2142     }
2143 }
2144
2145 static void searchCaseSenseWordCB(Widget w, WindowInfo *window, caddr_t callData)
2146 {
2147     WindowInfo *win;
2148
2149     /* Set the preference and make the other windows' menus agree */
2150     if (XmToggleButtonGetState(w)) {
2151         SetPrefSearch(SEARCH_CASE_SENSE_WORD);
2152         for (win=WindowList; win!=NULL; win=win->next) {
2153             XmToggleButtonSetState(win->searchLiteralDefItem, False, False);
2154             XmToggleButtonSetState(win->searchCaseSenseDefItem, False, False);
2155             XmToggleButtonSetState(win->searchLiteralWordDefItem, False, False);
2156             XmToggleButtonSetState(win->searchCaseSenseWordDefItem, True, False);
2157             XmToggleButtonSetState(win->searchRegexDefItem, False, False);
2158             XmToggleButtonSetState(win->searchRegexNoCaseDefItem, False, False);
2159         }
2160     }
2161 }
2162
2163 static void searchRegexCB(Widget w, WindowInfo *window, caddr_t callData)
2164 {
2165    WindowInfo *win;
2166
2167     /* Set the preference and make the other windows' menus agree */
2168     if (XmToggleButtonGetState(w)) {
2169         SetPrefSearch(SEARCH_REGEX);
2170         for (win=WindowList; win!=NULL; win=win->next){
2171             XmToggleButtonSetState(win->searchLiteralDefItem, False, False);
2172             XmToggleButtonSetState(win->searchCaseSenseDefItem, False, False);
2173             XmToggleButtonSetState(win->searchLiteralWordDefItem, False, False);
2174             XmToggleButtonSetState(win->searchCaseSenseWordDefItem, False, False);
2175             XmToggleButtonSetState(win->searchRegexDefItem, True, False);
2176             XmToggleButtonSetState(win->searchRegexNoCaseDefItem, False, False);
2177         }
2178     }
2179 }
2180
2181 static void searchRegexNoCaseCB(Widget w, WindowInfo *window, caddr_t callData)
2182 {
2183    WindowInfo *win;
2184
2185     /* Set the preference and make the other windows' menus agree */
2186     if (XmToggleButtonGetState(w)) {
2187         SetPrefSearch(SEARCH_REGEX_NOCASE);
2188         for (win=WindowList; win!=NULL; win=win->next){
2189             XmToggleButtonSetState(win->searchLiteralDefItem, False, False);
2190             XmToggleButtonSetState(win->searchCaseSenseDefItem, False, False);
2191             XmToggleButtonSetState(win->searchLiteralWordDefItem, False, False);
2192             XmToggleButtonSetState(win->searchCaseSenseWordDefItem, False, False);
2193             XmToggleButtonSetState(win->searchRegexDefItem, False, False);
2194             XmToggleButtonSetState(win->searchRegexNoCaseDefItem, True, False);
2195         }
2196     }
2197 }
2198
2199 #ifdef REPLACE_SCOPE
2200 static void replaceScopeWindowCB(Widget w, WindowInfo *window, caddr_t callData)
2201 {
2202    WindowInfo *win;
2203
2204     /* Set the preference and make the other windows' menus agree */
2205     if (XmToggleButtonGetState(w)) {
2206         SetPrefReplaceDefScope(REPL_DEF_SCOPE_WINDOW);
2207         for (win=WindowList; win!=NULL; win=win->next){
2208             XmToggleButtonSetState(win->replScopeWinDefItem, True, False);
2209             XmToggleButtonSetState(win->replScopeSelDefItem, False, False);
2210             XmToggleButtonSetState(win->replScopeSmartDefItem, False, False);
2211         }
2212     }
2213 }
2214
2215 static void replaceScopeSelectionCB(Widget w, WindowInfo *window, caddr_t callData)
2216 {
2217    WindowInfo *win;
2218
2219     /* Set the preference and make the other windows' menus agree */
2220     if (XmToggleButtonGetState(w)) {
2221         SetPrefReplaceDefScope(REPL_DEF_SCOPE_SELECTION);
2222         for (win=WindowList; win!=NULL; win=win->next){
2223             XmToggleButtonSetState(win->replScopeWinDefItem, False, False);
2224             XmToggleButtonSetState(win->replScopeSelDefItem, True, False);
2225             XmToggleButtonSetState(win->replScopeSmartDefItem, False, False);
2226         }
2227     }
2228 }
2229
2230 static void replaceScopeSmartCB(Widget w, WindowInfo *window, caddr_t callData)
2231 {
2232    WindowInfo *win;
2233
2234     /* Set the preference and make the other windows' menus agree */
2235     if (XmToggleButtonGetState(w)) {
2236         SetPrefReplaceDefScope(REPL_DEF_SCOPE_SMART);
2237         for (win=WindowList; win!=NULL; win=win->next){
2238             XmToggleButtonSetState(win->replScopeWinDefItem, False, False);
2239             XmToggleButtonSetState(win->replScopeSelDefItem, False, False);
2240             XmToggleButtonSetState(win->replScopeSmartDefItem, True, False);
2241         }
2242     }
2243 }
2244 #endif
2245
2246 static void size24x80CB(Widget w, WindowInfo *window, caddr_t callData)
2247 {
2248     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2249             ((XmAnyCallbackStruct *)callData)->event);
2250     setWindowSizeDefault(24, 80);
2251 }
2252
2253 static void size40x80CB(Widget w, WindowInfo *window, caddr_t callData)
2254 {
2255     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2256             ((XmAnyCallbackStruct *)callData)->event);
2257     setWindowSizeDefault(40, 80);
2258 }
2259
2260 static void size60x80CB(Widget w, WindowInfo *window, caddr_t callData)
2261 {
2262     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2263             ((XmAnyCallbackStruct *)callData)->event);
2264     setWindowSizeDefault(60, 80);
2265 }
2266
2267 static void size80x80CB(Widget w, WindowInfo *window, caddr_t callData)
2268 {
2269     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2270             ((XmAnyCallbackStruct *)callData)->event);
2271     setWindowSizeDefault(80, 80);
2272 }
2273
2274 static void sizeCustomCB(Widget w, WindowInfo *window, caddr_t callData)
2275 {
2276     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2277             ((XmAnyCallbackStruct *)callData)->event);
2278     RowColumnPrefDialog(window->shell);
2279     updateWindowSizeMenus();
2280 }
2281
2282 static void savePrefCB(Widget w, WindowInfo *window, caddr_t callData)
2283 {
2284     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2285             ((XmAnyCallbackStruct *)callData)->event);
2286     SaveNEditPrefs(window->shell, False);
2287 }
2288
2289 static void formFeedCB(Widget w, XtPointer clientData, XtPointer callData)
2290 {
2291     static char *params[1] = {"\f"};
2292
2293     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2294             ((XmAnyCallbackStruct *)callData)->event);
2295     XtCallActionProc(((WindowInfo *)clientData)->lastFocus, "insert_string",
2296             ((XmAnyCallbackStruct *)callData)->event, params, 1);
2297 }
2298
2299 static void cancelShellCB(Widget w, WindowInfo *window, XtPointer callData)
2300 {
2301 #ifndef VMS
2302     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2303             ((XmAnyCallbackStruct *)callData)->event);
2304     AbortShellCommand(window);
2305 #endif
2306 }
2307
2308 static void learnCB(Widget w, WindowInfo *window, caddr_t callData)
2309 {
2310     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2311             ((XmAnyCallbackStruct *)callData)->event);
2312     BeginLearn(window);
2313 }
2314
2315 static void finishLearnCB(Widget w, WindowInfo *window, caddr_t callData)
2316 {
2317     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2318             ((XmAnyCallbackStruct *)callData)->event);
2319     FinishLearn();
2320 }
2321
2322 static void cancelLearnCB(Widget w, WindowInfo *window, caddr_t callData)
2323 {
2324     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2325             ((XmAnyCallbackStruct *)callData)->event);
2326     CancelMacroOrLearn(window);
2327 }
2328
2329 static void replayCB(Widget w, WindowInfo *window, caddr_t callData)
2330 {
2331     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
2332             ((XmAnyCallbackStruct *)callData)->event);
2333     Replay(window);
2334 }
2335
2336 static void windowMenuCB(Widget w, WindowInfo *window, caddr_t callData)
2337 {
2338     if (!window->windowMenuValid) {
2339         updateWindowMenu(window);
2340         window->windowMenuValid = True;
2341     }
2342 }
2343
2344 static void prevOpenMenuCB(Widget w, WindowInfo *window, caddr_t callData)
2345 {
2346     if (!window->prevOpenMenuValid) {
2347         updatePrevOpenMenu(window);
2348         window->prevOpenMenuValid = True;
2349     }
2350 }
2351
2352 static void unloadTagsFileMenuCB(Widget w, WindowInfo *window, caddr_t callData)
2353 {
2354     updateTagsFileMenu(window);
2355 }
2356
2357 static void unloadTipsFileMenuCB(Widget w, WindowInfo *window, caddr_t callData)
2358 {
2359     updateTipsFileMenu(window);
2360 }
2361
2362 /*
2363 ** Action Procedures for menu item commands
2364 */
2365 static void newAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2366 {
2367     EditNewFile(NULL, False, NULL, WidgetToWindow(w)->path);
2368     CheckCloseDim();
2369 }
2370
2371 static void openDialogAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2372 {
2373     WindowInfo *window = WidgetToWindow(w);
2374     char fullname[MAXPATHLEN], *params[1];
2375     int response;
2376
2377     response = PromptForExistingFile(window, "File to Edit", fullname);
2378     if (response != GFN_OK)
2379         return;
2380     params[0] = fullname;
2381     XtCallActionProc(window->lastFocus, "open", event, params, 1);
2382     CheckCloseDim();
2383 }
2384
2385 static void openAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2386 {
2387     WindowInfo *window = WidgetToWindow(w);
2388     char filename[MAXPATHLEN], pathname[MAXPATHLEN];
2389
2390     if (*nArgs == 0) {
2391         fprintf(stderr, "NEdit: open action requires file argument\n");
2392         return;
2393     }
2394     if (ParseFilename(args[0], filename, pathname) != 0) {
2395         fprintf(stderr, "NEdit: invalid file name for open action: %s\n",
2396                 args[0]);
2397         return;
2398     }
2399     EditExistingFile(window, filename, pathname, 0, NULL, False, NULL);
2400     CheckCloseDim();
2401 }
2402
2403 static void openSelectedAP(Widget w, XEvent *event, String *args,
2404         Cardinal *nArgs)
2405 {
2406     OpenSelectedFile(WidgetToWindow(w), event->xbutton.time);
2407     CheckCloseDim();
2408 }
2409
2410 static void closeAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2411 {
2412     int preResponse = PROMPT_SBC_DIALOG_RESPONSE;
2413
2414     if (*nArgs > 0) {
2415         if (strcmp(args[0], "prompt") == 0) {
2416             preResponse = PROMPT_SBC_DIALOG_RESPONSE;
2417         }
2418         else if (strcmp(args[0], "save") == 0) {
2419             preResponse = YES_SBC_DIALOG_RESPONSE;
2420         }
2421         else if (strcmp(args[0], "nosave") == 0) {
2422             preResponse = NO_SBC_DIALOG_RESPONSE;
2423         }
2424     }
2425     CloseFileAndWindow(WidgetToWindow(w), preResponse);
2426     CheckCloseDim();
2427 }
2428
2429 static void saveAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2430 {
2431     WindowInfo *window = WidgetToWindow(w);
2432
2433     if (CheckReadOnly(window))
2434         return;
2435     SaveWindow(window);
2436 }
2437
2438 static void saveAsDialogAP(Widget w, XEvent *event, String *args,
2439         Cardinal *nArgs)
2440 {
2441     WindowInfo *window = WidgetToWindow(w);
2442     int response, addWrap, fileFormat;
2443     char fullname[MAXPATHLEN], *params[2];
2444
2445     response = PromptForNewFile(window, "Save File As", fullname,
2446             &fileFormat, &addWrap);
2447     if (response != GFN_OK)
2448         return;
2449     window->fileFormat = fileFormat;
2450     params[0] = fullname;
2451     params[1] = "wrapped";
2452     XtCallActionProc(window->lastFocus, "save_as", event, params, addWrap?2:1);
2453 }
2454
2455 static void saveAsAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2456 {
2457     if (*nArgs == 0) {
2458         fprintf(stderr, "NEdit: save_as action requires file argument\n");
2459         return;
2460     }
2461     SaveWindowAs(WidgetToWindow(w), args[0],
2462             *nArgs == 2 && !strCaseCmp(args[1], "wrapped"));
2463 }
2464
2465 static void revertDialogAP(Widget w, XEvent *event, String *args,
2466         Cardinal *nArgs)
2467 {
2468     WindowInfo *window = WidgetToWindow(w);
2469     int b;
2470
2471     /* re-reading file is irreversible, prompt the user first */
2472     if (window->fileChanged)
2473         b = DialogF(DF_QUES, window->shell, 2, "Discard changes to\n%s%s?",
2474                 "OK", "Cancel", window->path, window->filename);
2475     else
2476         b = DialogF(DF_QUES, window->shell, 2, "Re-load file\n%s%s?",
2477                 "Re-read", "Cancel", window->path, window->filename);
2478     if (b != 1)
2479         return;
2480     XtCallActionProc(window->lastFocus, "revert_to_saved", event, NULL, 0);
2481 }
2482
2483
2484 static void revertAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2485 {
2486     RevertToSaved(WidgetToWindow(w));
2487 }
2488
2489 static void includeDialogAP(Widget w, XEvent *event, String *args,
2490         Cardinal *nArgs)
2491 {
2492     WindowInfo *window = WidgetToWindow(w);
2493     char filename[MAXPATHLEN], *params[1];
2494     int response;
2495
2496     if (CheckReadOnly(window))
2497         return;
2498     response = PromptForExistingFile(window, "File to Include", filename);
2499     if (response != GFN_OK)
2500         return;
2501     params[0] = filename;
2502     XtCallActionProc(window->lastFocus, "include_file", event, params, 1);
2503 }
2504
2505 static void includeAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2506 {
2507     WindowInfo *window = WidgetToWindow(w);
2508
2509     if (CheckReadOnly(window))
2510         return;
2511     if (*nArgs == 0) {
2512         fprintf(stderr, "NEdit: include action requires file argument\n");
2513         return;
2514     }
2515     IncludeFile(WidgetToWindow(w), args[0]);
2516 }
2517
2518 static void loadMacroDialogAP(Widget w, XEvent *event, String *args,
2519         Cardinal *nArgs)
2520 {
2521     WindowInfo *window = WidgetToWindow(w);
2522     char filename[MAXPATHLEN], *params[1];
2523     int response;
2524
2525     response = PromptForExistingFile(window, "NEdit Macro File", filename);
2526     if (response != GFN_OK)
2527         return;
2528     params[0] = filename;
2529     XtCallActionProc(window->lastFocus, "load_macro_file", event, params, 1);
2530 }
2531
2532 static void loadMacroAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2533 {
2534     if (*nArgs == 0) {
2535         fprintf(stderr,"NEdit: load_macro_file action requires file argument\n");
2536         return;
2537     }
2538     ReadMacroFile(WidgetToWindow(w), args[0], True);
2539 }
2540
2541 static void loadTagsDialogAP(Widget w, XEvent *event, String *args,
2542         Cardinal *nArgs)
2543 {
2544     WindowInfo *window = WidgetToWindow(w);
2545     char filename[MAXPATHLEN], *params[1];
2546     int response;
2547
2548     response = PromptForExistingFile(window, "ctags File", filename);
2549     if (response != GFN_OK)
2550         return;
2551     params[0] = filename;
2552     XtCallActionProc(window->lastFocus, "load_tags_file", event, params, 1);
2553 }
2554
2555 static void loadTagsAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2556 {
2557     if (*nArgs == 0) {
2558         fprintf(stderr,"NEdit: load_tags_file action requires file argument\n");
2559         return;
2560     }
2561     if (!AddTagsFile(args[0], TAG)) {
2562         DialogF(DF_WARN, WidgetToWindow(w)->shell, 1,
2563                 "Error reading ctags file:\n'%s'\ntags not loaded", "Dismiss",
2564                 args[0]);
2565     }
2566 }
2567
2568 static void unloadTagsAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2569 {
2570     if (*nArgs == 0) {
2571         fprintf(stderr,
2572                 "NEdit: unload_tags_file action requires file argument\n");
2573         return;
2574     }
2575     DeleteTagsFile(args[0], TAG);
2576 }
2577
2578 static void loadTipsDialogAP(Widget w, XEvent *event, String *args,
2579         Cardinal *nArgs)
2580 {
2581     WindowInfo *window = WidgetToWindow(w);
2582     char filename[MAXPATHLEN], *params[1];
2583     int response;
2584
2585     response = PromptForExistingFile(window, "Calltips File", filename);
2586     if (response != GFN_OK)
2587         return;
2588     params[0] = filename;
2589     XtCallActionProc(window->lastFocus, "load_tips_file", event, params, 1);
2590 }
2591
2592 static void loadTipsAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2593 {
2594     if (*nArgs == 0) {
2595         fprintf(stderr,"NEdit: load_tips_file action requires file argument\n");
2596         return;
2597     }
2598     if (!AddTagsFile(args[0], TIP)) {
2599         DialogF(DF_WARN, WidgetToWindow(w)->shell, 1,
2600                 "Error reading tips file:\n'%s'\ntips not loaded", "Dismiss",
2601                 args[0]);
2602         }
2603 }
2604
2605 static void unloadTipsAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2606 {
2607     if (*nArgs == 0) {
2608         fprintf(stderr,
2609                 "NEdit: unload_tips_file action requires file argument\n");
2610         return;
2611     }
2612     DeleteTagsFile(args[0], TIP);
2613 }
2614
2615 static void printAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2616 {
2617     PrintWindow(WidgetToWindow(w), False);
2618 }
2619
2620 static void printSelAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2621 {
2622     PrintWindow(WidgetToWindow(w), True);
2623 }
2624
2625 static void exitAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2626 {
2627     WindowInfo *window = WidgetToWindow(w);
2628
2629     if (!CheckPrefsChangesSaved(window->shell))
2630         return;
2631
2632     /* If this is not the last window (more than one window is open),
2633        confirm with the user before exiting. */
2634     if (GetPrefWarnExit() && !(window == WindowList && window->next == NULL)) {
2635         int resp, titleLen, lineLen;
2636         char exitMsg[DF_MAX_MSG_LENGTH], *ptr, *title;
2637         WindowInfo *win;
2638
2639         /* List the windows being edited and make sure the
2640            user really wants to exit */
2641         ptr = exitMsg;
2642         lineLen = 0;
2643         strcpy(ptr, "Editing: "); ptr += 9; lineLen += 9;
2644         for (win=WindowList; win!=NULL; win=win->next) {
2645             XtVaGetValues(win->shell, XmNiconName, &title, NULL);
2646             titleLen = strlen(title);
2647             if (ptr - exitMsg + titleLen + 30 >= DF_MAX_MSG_LENGTH) {
2648                 strcpy(ptr, "..."); ptr += 3;
2649                 break;
2650             }
2651             if (lineLen + titleLen + (win->next==NULL?5:2) > 50) {
2652                 *ptr++ = '\n';
2653                 lineLen = 0;
2654             }
2655             if (win->next == NULL) {
2656                 sprintf(ptr, "and %s.", title);
2657                 ptr += 5 + titleLen;
2658                 lineLen += 5 + titleLen;
2659             } else {
2660                 sprintf(ptr, "%s, ", title);
2661                 ptr += 2 + titleLen;
2662                 lineLen += 2 + titleLen;
2663             }
2664         }
2665         sprintf(ptr, "\n\nExit NEdit?");
2666         resp = DialogF(DF_QUES, window->shell, 2, "%s", "Exit", "Cancel", exitMsg);
2667         if (resp == 2)
2668                 return;
2669     }
2670
2671     /* Close all files and exit when the last one is closed */
2672     if (CloseAllFilesAndWindows())
2673         exit(EXIT_SUCCESS);
2674 }
2675
2676 static void undoAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2677 {
2678     WindowInfo *window = WidgetToWindow(w);
2679
2680     if (CheckReadOnly(window))
2681         return;
2682     Undo(window);
2683 }
2684
2685 static void redoAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2686 {
2687     WindowInfo *window = WidgetToWindow(w);
2688
2689     if (CheckReadOnly(window))
2690         return;
2691     Redo(window);
2692 }
2693
2694 static void clearAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2695 {
2696     WindowInfo *window = WidgetToWindow(w);
2697
2698     if (CheckReadOnly(window))
2699         return;
2700     BufRemoveSelected(window->buffer);
2701 }
2702
2703 static void selAllAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2704 {
2705     WindowInfo *window = WidgetToWindow(w);
2706
2707     BufSelect(window->buffer, 0, window->buffer->length);
2708 }
2709
2710 static void shiftLeftAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2711 {
2712     WindowInfo *window = WidgetToWindow(w);
2713
2714     if (CheckReadOnly(window))
2715         return;
2716     ShiftSelection(window, SHIFT_LEFT, False);
2717 }
2718
2719 static void shiftLeftTabAP(Widget w, XEvent *event, String *args,
2720         Cardinal *nArgs)
2721 {
2722     WindowInfo *window = WidgetToWindow(w);
2723
2724     if (CheckReadOnly(window))
2725         return;
2726     ShiftSelection(window, SHIFT_LEFT, True);
2727 }
2728
2729 static void shiftRightAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2730 {
2731     WindowInfo *window = WidgetToWindow(w);
2732
2733     if (CheckReadOnly(window))
2734         return;
2735     ShiftSelection(window, SHIFT_RIGHT, False);
2736 }
2737
2738 static void shiftRightTabAP(Widget w, XEvent *event, String *args,
2739         Cardinal *nArgs)
2740 {
2741     WindowInfo *window = WidgetToWindow(w);
2742
2743     if (CheckReadOnly(window))
2744         return;
2745     ShiftSelection(window, SHIFT_RIGHT, True);
2746 }
2747
2748 static void findDialogAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2749 {
2750     DoFindDlog(WidgetToWindow(w), searchDirection(0, args, nArgs),
2751                searchType(0, args, nArgs), searchKeepDialogs(0, args, nArgs),
2752                event->xbutton.time);
2753 }
2754
2755 static void findAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2756 {
2757     if (*nArgs == 0) {
2758         fprintf(stderr, "NEdit: find action requires search string argument\n");
2759         return;
2760     }
2761     SearchAndSelect(WidgetToWindow(w), searchDirection(1, args, nArgs), args[0],
2762             searchType(1, args, nArgs), searchWrap(1, args, nArgs));
2763 }
2764
2765 static void findSameAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2766 {
2767     SearchAndSelectSame(WidgetToWindow(w), searchDirection(0, args, nArgs),
2768                 searchWrap(0, args, nArgs));
2769 }
2770
2771 static void findSelAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2772 {
2773     SearchForSelected(WidgetToWindow(w), searchDirection(0, args, nArgs),
2774             searchType(0, args, nArgs), searchWrap(0, args, nArgs),
2775             event->xbutton.time);
2776 }
2777
2778 static void startIncrFindAP(Widget w, XEvent *event, String *args,
2779         Cardinal *nArgs)
2780 {
2781     BeginISearch(WidgetToWindow(w), searchDirection(0, args, nArgs));
2782 }
2783
2784 static void findIncrAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2785 {
2786     int i, continued = FALSE;
2787     if (*nArgs == 0) {
2788         fprintf(stderr, "NEdit: find action requires search string argument\n");
2789         return;
2790     }
2791     for (i=1; i<(int)*nArgs; i++)
2792         if (!strCaseCmp(args[i], "continued"))
2793             continued = TRUE;
2794     SearchAndSelectIncremental(WidgetToWindow(w),
2795             searchDirection(1, args, nArgs), args[0],
2796             searchType(1, args, nArgs), searchWrap(1, args, nArgs), continued);
2797 }
2798
2799 static void replaceDialogAP(Widget w, XEvent *event, String *args,
2800         Cardinal *nArgs)
2801 {
2802     WindowInfo *window = WidgetToWindow(w);
2803
2804     if (CheckReadOnly(window))
2805         return;
2806     DoFindReplaceDlog(window, searchDirection(0, args, nArgs),
2807         searchType(0, args, nArgs), searchKeepDialogs(0, args, nArgs),
2808         event->xbutton.time);
2809 }
2810
2811 static void replaceAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2812 {
2813     WindowInfo *window = WidgetToWindow(w);
2814
2815     if (CheckReadOnly(window))
2816         return;
2817     if (*nArgs < 2) {
2818         fprintf(stderr,
2819         "NEdit: replace action requires search and replace string arguments\n");
2820         return;
2821     }
2822     SearchAndReplace(window, searchDirection(2, args, nArgs),
2823             args[0], args[1], searchType(2, args, nArgs), searchWrap(2, args, nArgs));
2824 }
2825
2826 static void replaceAllAP(Widget w, XEvent *event, String *args,
2827         Cardinal *nArgs)
2828 {
2829     WindowInfo *window = WidgetToWindow(w);
2830
2831     if (CheckReadOnly(window))
2832         return;
2833     if (*nArgs < 2) {
2834         fprintf(stderr,
2835     "NEdit: replace_all action requires search and replace string arguments\n");
2836         return;
2837     }
2838     ReplaceAll(window, args[0], args[1], searchType(2, args, nArgs));
2839 }
2840
2841 static void replaceInSelAP(Widget w, XEvent *event, String *args,
2842         Cardinal *nArgs)
2843 {
2844     WindowInfo *window = WidgetToWindow(w);
2845
2846     if (CheckReadOnly(window))
2847         return;
2848     if (*nArgs < 2) {
2849         fprintf(stderr,
2850   "NEdit: replace_in_selection requires search and replace string arguments\n");
2851         return;
2852     }
2853     ReplaceInSelection(window, args[0], args[1],
2854             searchType(2, args, nArgs));
2855 }
2856
2857 static void replaceSameAP(Widget w, XEvent *event, String *args,
2858         Cardinal *nArgs)
2859 {
2860     WindowInfo *window = WidgetToWindow(w);
2861
2862     if (CheckReadOnly(window))
2863         return;
2864     ReplaceSame(window, searchDirection(0, args, nArgs), searchWrap(0, args, nArgs));
2865 }
2866
2867 static void replaceFindAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2868 {
2869     WindowInfo *window = WidgetToWindow(w);
2870
2871     if (CheckReadOnly(window))
2872        return;
2873     if (*nArgs < 2) {
2874        DialogF(DF_WARN, window->shell, 1, "replace_find action requires search and replace string arguments", "OK");
2875        return;
2876     }
2877     ReplaceAndSearch(window, searchDirection(2, args, nArgs),
2878                      args[0], args[1], searchType(2, args, nArgs),
2879                      searchWrap(0, args, nArgs));
2880 }
2881
2882 static void replaceFindSameAP(Widget w, XEvent *event, String *args,
2883         Cardinal *nArgs)
2884 {
2885     WindowInfo *window = WidgetToWindow(w);
2886
2887     if (CheckReadOnly(window))
2888        return;
2889     ReplaceFindSame(window, searchDirection(0, args, nArgs), searchWrap(0, args, nArgs));
2890 }
2891
2892 static void gotoAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2893 {
2894     int lineNum, column, position, curCol;
2895
2896     if (*nArgs == 0 || StringToLineAndCol( args[0], &lineNum, &column ) == -1) {
2897         fprintf(stderr,"NEdit: goto_line_number action requires line and/or column number\n");
2898         return;
2899     }
2900     /* User specified column, but not line number */
2901     if ( lineNum == -1 ) {
2902         position = TextGetCursorPos(w);
2903         if (TextPosToLineAndCol(w, position, &lineNum,
2904                                  &curCol) == False) {
2905             return;
2906         }
2907     }
2908     /* User didn't specify a column */
2909     else if ( column == -1 ) {
2910     SelectNumberedLine(WidgetToWindow(w), lineNum);
2911         return;
2912     }
2913
2914     position = TextLineAndColToPos(w, lineNum, column );
2915     if ( position == -1 ) {
2916         return;
2917     }
2918     TextSetCursorPos(w, position);
2919     return;
2920 }
2921
2922 static void gotoDialogAP(Widget w, XEvent *event, String *args,
2923         Cardinal *nArgs)
2924 {
2925     GotoLineNumber(WidgetToWindow(w));
2926 }
2927
2928 static void gotoSelectedAP(Widget w, XEvent *event, String *args,
2929         Cardinal *nArgs)
2930 {
2931     GotoSelectedLineNumber(WidgetToWindow(w), event->xbutton.time);
2932 }
2933
2934 static void repeatDialogAP(Widget w, XEvent *event, String *args,
2935         Cardinal *nArgs)
2936 {
2937     RepeatDialog(WidgetToWindow(w));
2938 }
2939
2940 static void repeatMacroAP(Widget w, XEvent *event, String *args,
2941         Cardinal *nArgs)
2942 {
2943     int how;
2944
2945     if (*nArgs != 2) {
2946         fprintf(stderr, "NEdit: repeat_macro requires two arguments\n");
2947         return;
2948     }
2949     if (!strcmp(args[0], "in_selection"))
2950         how = REPEAT_IN_SEL;
2951     else if (!strcmp(args[0], "to_end"))
2952         how = REPEAT_TO_END;
2953     else if (sscanf(args[0], "%d", &how) != 1) {
2954         fprintf(stderr, "NEdit: repeat_macro requires method/count\n");
2955         return;
2956     }
2957     RepeatMacro(WidgetToWindow(w), args[1], how);
2958 }
2959
2960 static void markAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2961 {
2962     if (*nArgs == 0 || strlen(args[0]) != 1 ||
2963             !isalnum((unsigned char)args[0][0])) {
2964         fprintf(stderr,"NEdit: mark action requires a single-letter label\n");
2965         return;
2966     }
2967     AddMark(WidgetToWindow(w), w, args[0][0]);
2968 }
2969
2970 static void markDialogAP(Widget w, XEvent *event, String *args,
2971         Cardinal *nArgs)
2972 {
2973     MarkDialog(WidgetToWindow(w));
2974 }
2975
2976 static void gotoMarkAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
2977 {
2978     if (*nArgs == 0 || strlen(args[0]) != 1 ||
2979             !isalnum((unsigned char)args[0][0])) {
2980         fprintf(stderr,
2981                 "NEdit: goto_mark action requires a single-letter label\n");
2982         return;
2983     }
2984     GotoMark(WidgetToWindow(w), w, args[0][0], *nArgs > 1 &&
2985             !strcmp(args[1], "extend"));
2986 }
2987
2988 static void gotoMarkDialogAP(Widget w, XEvent *event, String *args,
2989         Cardinal *nArgs)
2990 {
2991     GotoMarkDialog(WidgetToWindow(w), *nArgs!=0 && !strcmp(args[0], "extend"));
2992 }
2993
2994 static void selectToMatchingAP(Widget w, XEvent *event, String *args,
2995         Cardinal *nArgs)
2996 {
2997     SelectToMatchingCharacter(WidgetToWindow(w));
2998 }
2999
3000 static void gotoMatchingAP(Widget w, XEvent *event, String *args,
3001         Cardinal *nArgs)
3002 {
3003     GotoMatchingCharacter(WidgetToWindow(w));
3004 }
3005
3006 static void findDefAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3007 {
3008     FindDefinition(WidgetToWindow(w), event->xbutton.time,
3009             *nArgs == 0 ? NULL : args[0]);
3010 }
3011
3012 static void showTipAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3013 {
3014     FindDefCalltip(WidgetToWindow(w), event->xbutton.time,
3015             *nArgs == 0 ? NULL : args[0]);
3016 }
3017
3018 static void splitWindowAP(Widget w, XEvent *event, String *args,
3019         Cardinal *nArgs)
3020 {
3021     WindowInfo *window = WidgetToWindow(w);
3022
3023     SplitWindow(window);
3024     XtSetSensitive(window->splitWindowItem, window->nPanes < MAX_PANES);
3025     XtSetSensitive(window->closePaneItem, window->nPanes > 0);
3026 }
3027
3028 static void closePaneAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3029 {
3030     WindowInfo *window = WidgetToWindow(w);
3031
3032     ClosePane(window);
3033     XtSetSensitive(window->splitWindowItem, window->nPanes < MAX_PANES);
3034     XtSetSensitive(window->closePaneItem, window->nPanes > 0);
3035 }
3036
3037 static void capitalizeAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3038 {
3039     WindowInfo *window = WidgetToWindow(w);
3040
3041     if (CheckReadOnly(window))
3042         return;
3043     UpcaseSelection(window);
3044 }
3045
3046 static void lowercaseAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3047 {
3048     WindowInfo *window = WidgetToWindow(w);
3049
3050     if (CheckReadOnly(window))
3051         return;
3052     DowncaseSelection(window);
3053 }
3054
3055 static void fillAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3056 {
3057     WindowInfo *window = WidgetToWindow(w);
3058
3059     if (CheckReadOnly(window))
3060         return;
3061     FillSelection(window);
3062 }
3063
3064 static void controlDialogAP(Widget w, XEvent *event, String *args,
3065         Cardinal *nArgs)
3066 {
3067     WindowInfo *window = WidgetToWindow(w);
3068     unsigned char charCodeString[2];
3069     char charCodeText[DF_MAX_PROMPT_LENGTH], dummy[DF_MAX_PROMPT_LENGTH];
3070     char *params[1];
3071     int charCode, nRead, response;
3072
3073     if (CheckReadOnly(window))
3074         return;
3075     response = DialogF(DF_PROMPT, window->shell, 2,
3076             "ASCII Character Code:", charCodeText, "OK", "Cancel");
3077     if (response == 2)
3078         return;
3079     /* If we don't scan for a trailing string invalid input
3080        would be accepted sometimes. */
3081     nRead = sscanf(charCodeText, "%i%s", &charCode, dummy);
3082     if (nRead != 1 || charCode < 0 || charCode > 255) {
3083         XBell(TheDisplay, 0);
3084         return;
3085     }
3086     charCodeString[0] = (unsigned char)charCode;
3087     charCodeString[1] = '\0';
3088     params[0] = (char *)charCodeString;
3089     if (!BufSubstituteNullChars((char *)charCodeString, 1, window->buffer)) {
3090         DialogF(DF_ERR, window->shell, 1, "Too much binary data","Dismiss");
3091         return;
3092     }
3093     XtCallActionProc(w, "insert_string", event, params, 1);
3094 }
3095
3096 #ifndef VMS
3097 static void filterDialogAP(Widget w, XEvent *event, String *args,
3098         Cardinal *nArgs)
3099 {
3100     WindowInfo *window = WidgetToWindow(w);
3101     char *params[1], cmdText[DF_MAX_PROMPT_LENGTH];
3102     int resp;
3103     static char **cmdHistory = NULL;
3104     static int nHistoryCmds = 0;
3105
3106     if (CheckReadOnly(window))
3107         return;
3108     if (!window->buffer->primary.selected) {
3109         XBell(TheDisplay, 0);
3110         return;
3111     }
3112
3113     SetDialogFPromptHistory(cmdHistory, nHistoryCmds);
3114     resp = DialogF(DF_PROMPT, window->shell, 2,
3115             "Shell command:   (use up arrow key to recall previous)",
3116             cmdText, "OK", "Cancel");
3117     if (resp == 2)
3118         return;
3119     AddToHistoryList(cmdText, &cmdHistory, &nHistoryCmds);
3120     params[0] = cmdText;
3121     XtCallActionProc(w, "filter_selection", event, params, 1);
3122 }
3123
3124 static void shellFilterAP(Widget w, XEvent *event, String *args,
3125         Cardinal *nArgs)
3126 {
3127     WindowInfo *window = WidgetToWindow(w);
3128
3129     if (CheckReadOnly(window))
3130         return;
3131     if (*nArgs == 0) {
3132         fprintf(stderr,
3133                 "NEdit: filter_selection requires shell command argument\n");
3134         return;
3135     }
3136     FilterSelection(window, args[0],
3137             event->xany.send_event == MACRO_EVENT_MARKER);
3138 }
3139
3140 static void execDialogAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3141 {
3142     WindowInfo *window = WidgetToWindow(w);
3143     char *params[1], cmdText[DF_MAX_PROMPT_LENGTH];
3144     int resp;
3145     static char **cmdHistory = NULL;
3146     static int nHistoryCmds = 0;
3147
3148     if (CheckReadOnly(window))
3149         return;
3150     SetDialogFPromptHistory(cmdHistory, nHistoryCmds);
3151     resp = DialogF(DF_PROMPT, window->shell, 2,
3152             "Shell command:   (use up arrow key to recall previous;\n" \
3153             "%% expands to current filename, # to line number)",
3154             cmdText, "OK", "Cancel");
3155     if (resp == 2)
3156         return;
3157     AddToHistoryList(cmdText, &cmdHistory, &nHistoryCmds);
3158     params[0] = cmdText;
3159     XtCallActionProc(w, "execute_command", event, params, 1);;
3160 }
3161
3162 static void execAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3163 {
3164     WindowInfo *window = WidgetToWindow(w);
3165
3166     if (CheckReadOnly(window))
3167         return;
3168     if (*nArgs == 0) {
3169         fprintf(stderr,
3170                 "NEdit: execute_command requires shell command argument\n");
3171         return;
3172     }
3173     ExecShellCommand(window, args[0],
3174             event->xany.send_event == MACRO_EVENT_MARKER);
3175 }
3176
3177 static void execLineAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3178 {
3179     WindowInfo *window = WidgetToWindow(w);
3180
3181     if (CheckReadOnly(window))
3182         return;
3183     ExecCursorLine(window, event->xany.send_event == MACRO_EVENT_MARKER);
3184 }
3185
3186 static void shellMenuAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3187 {
3188     if (*nArgs == 0) {
3189         fprintf(stderr,
3190                 "NEdit: shell_menu_command requires item-name argument\n");
3191         return;
3192     }
3193     HidePointerOnKeyedEvent(w, event);
3194     DoNamedShellMenuCmd(WidgetToWindow(w), args[0],
3195             event->xany.send_event == MACRO_EVENT_MARKER);
3196 }
3197 #endif
3198
3199 static void macroMenuAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3200 {
3201     if (*nArgs == 0) {
3202         fprintf(stderr,
3203                 "NEdit: macro_menu_command requires item-name argument\n");
3204         return;
3205     }
3206     /* Don't allow users to execute a macro command from the menu (or accel)
3207        if there's already a macro command executing, UNLESS the macro is
3208        directly called from another one.  NEdit can't handle
3209        running multiple, independent uncoordinated, macros in the same
3210        window.  Macros may invoke macro menu commands recursively via the
3211        macro_menu_command action proc, which is important for being able to
3212        repeat any operation, and to embed macros within eachother at any
3213        level, however, a call here with a macro running means that THE USER
3214        is explicitly invoking another macro via the menu or an accelerator,
3215        UNLESS the macro event marker is set */
3216     if (event->xany.send_event != MACRO_EVENT_MARKER) {
3217         if (WidgetToWindow(w)->macroCmdData != NULL) {
3218             XBell(TheDisplay, 0);
3219             return;
3220         }
3221     }
3222     HidePointerOnKeyedEvent(w, event);
3223     DoNamedMacroMenuCmd(WidgetToWindow(w), args[0]);
3224 }
3225
3226 static void bgMenuAP(Widget w, XEvent *event, String *args, Cardinal *nArgs)
3227 {
3228     if (*nArgs == 0) {
3229         fprintf(stderr,
3230                 "NEdit: bg_menu_command requires item-name argument\n");
3231         return;
3232     }
3233     /* Same remark as for macro menu commands (see above). */
3234     if (event->xany.send_event != MACRO_EVENT_MARKER) {
3235         if (WidgetToWindow(w)->macroCmdData != NULL) {
3236             XBell(TheDisplay, 0);
3237             return;
3238         }
3239     }
3240     HidePointerOnKeyedEvent(w, event);
3241     DoNamedBGMenuCmd(WidgetToWindow(w), args[0]);
3242 }
3243
3244 static void beginningOfSelectionAP(Widget w, XEvent *event, String *args,
3245         Cardinal *nArgs)
3246 {
3247     textBuffer *buf = TextGetBuffer(w);
3248     int start, end, isRect, rectStart, rectEnd;
3249
3250     if (!BufGetSelectionPos(buf, &start, &end, &isRect, &rectStart, &rectEnd))
3251         return;
3252     if (!isRect)
3253         TextSetCursorPos(w, start);
3254     else
3255         TextSetCursorPos(w, BufCountForwardDispChars(buf,
3256                 BufStartOfLine(buf, start), rectStart));
3257 }
3258
3259 static void endOfSelectionAP(Widget w, XEvent *event, String *args,
3260         Cardinal *nArgs)
3261 {
3262     textBuffer *buf = TextGetBuffer(w);
3263     int start, end, isRect, rectStart, rectEnd;
3264
3265     if (!BufGetSelectionPos(buf, &start, &end, &isRect, &rectStart, &rectEnd))
3266         return;
3267     if (!isRect)
3268         TextSetCursorPos(w, end);
3269     else
3270         TextSetCursorPos(w, BufCountForwardDispChars(buf,
3271                 BufStartOfLine(buf, end), rectEnd));
3272 }
3273
3274 static void raiseWindowAP(Widget w, XEvent *event, String *args,
3275     Cardinal *nArgs)
3276 {
3277     WindowInfo *window = WidgetToWindow(w);
3278     WindowInfo *nextWindow;
3279     WindowInfo *tmpWindow;
3280     int windowIndex;
3281
3282     if (*nArgs > 0) {
3283         if (strcmp(args[0], "last") == 0) {
3284             window = WindowList;
3285         }
3286         else if (strcmp(args[0], "first") == 0) {
3287             window = WindowList;
3288             if (window != NULL) {
3289                 nextWindow = window->next;
3290                 while (nextWindow != NULL) {
3291                     window = nextWindow;
3292                     nextWindow = nextWindow->next;
3293                 }
3294             }
3295         }
3296         else if (strcmp(args[0], "previous") == 0) {
3297             tmpWindow = window;
3298             window = WindowList;
3299             if (window != NULL) {
3300                 nextWindow = window->next;
3301                 while (nextWindow != NULL && nextWindow != tmpWindow) {
3302                     window = nextWindow;
3303                     nextWindow = nextWindow->next;
3304                 }
3305                 if (nextWindow == NULL && tmpWindow != WindowList) {
3306                     window = NULL;
3307                 }
3308             }
3309         }
3310         else if (strcmp(args[0], "next") == 0) {
3311             if (window != NULL) {
3312                 window = window->next;
3313                 if (window == NULL) {
3314                     window = WindowList;
3315                 }
3316             }
3317         }
3318         else {
3319             if (sscanf(args[0], "%d", &windowIndex) == 1) {
3320                 if (windowIndex > 0) {
3321                     for (window = WindowList; window != NULL && windowIndex > 1;
3322                         --windowIndex) {
3323                         window = window->next;
3324                     }
3325                 }
3326                 else if (windowIndex < 0) {
3327                     for (window = WindowList; window != NULL;
3328                         window = window->next) {
3329                         ++windowIndex;
3330                     }
3331                     if (windowIndex >= 0) {
3332                         for (window = WindowList; window != NULL &&
3333                             windowIndex > 0; window = window->next) {
3334                             --windowIndex;
3335                         }
3336                     }
3337                     else {
3338                         window = NULL;
3339                     }
3340                 }
3341                 else {
3342                     window = NULL;
3343                 }
3344             }
3345             else {
3346                 window = NULL;
3347             }
3348         }
3349     }
3350     if (window != NULL) {
3351         RaiseShellWindow(window->shell);
3352     }
3353     else {
3354         XBell(TheDisplay, 0);
3355     }
3356 }
3357
3358 static void focusPaneAP(Widget w, XEvent *event, String *args,
3359     Cardinal *nArgs)
3360 {
3361     WindowInfo *window = WidgetToWindow(w);
3362     Widget newFocusPane = NULL;
3363     int paneIndex;
3364
3365     if (*nArgs > 0) {
3366         if (strcmp(args[0], "first") == 0) {
3367             paneIndex = 0;
3368         }
3369         else if (strcmp(args[0], "last") == 0) {
3370             paneIndex = window->nPanes;
3371         }
3372         else if (strcmp(args[0], "next") == 0) {
3373             paneIndex = WidgetToPaneIndex(window, window->lastFocus) + 1;
3374             if (paneIndex > window->nPanes) {
3375                 paneIndex = 0;
3376             }
3377         }
3378         else if (strcmp(args[0], "previous") == 0) {
3379             paneIndex = WidgetToPaneIndex(window, window->lastFocus) - 1;
3380             if (paneIndex < 0) {
3381                 paneIndex = window->nPanes;
3382             }
3383         }
3384         else {
3385             if (sscanf(args[0], "%d", &paneIndex) == 1) {
3386                 if (paneIndex > 0) {
3387                     paneIndex = paneIndex - 1;
3388                 }
3389                 else if (paneIndex < 0) {
3390                     paneIndex = window->nPanes + (paneIndex + 1);
3391                 }
3392                 else {
3393                     paneIndex = -1;
3394                 }
3395             }
3396         }
3397         if (paneIndex >= 0 && paneIndex <= window->nPanes) {
3398             newFocusPane = GetPaneByIndex(window, paneIndex);
3399         }
3400         if (newFocusPane != NULL) {
3401             window->lastFocus = newFocusPane;
3402             XmProcessTraversal(window->lastFocus, XmTRAVERSE_CURRENT);
3403         }
3404         else {
3405             XBell(TheDisplay, 0);
3406         }
3407     }
3408     else {
3409         fprintf(stderr, "NEdit: focus_pane requires argument\n");
3410     }
3411 }
3412
3413 #define ACTION_BOOL_PARAM_OR_TOGGLE(newState, numArgs, argvVal, oValue, actionName) \
3414     if ((numArgs) > 0) { \
3415         int intState; \
3416         \
3417         if (sscanf(argvVal[0], "%d", &intState) == 1) { \
3418             (newState) = (intState != 0); \
3419         } \
3420         else { \
3421             fprintf(stderr, "NEdit: %s requires 0 or 1 argument\n", actionName); \
3422             return; \
3423         } \
3424     } \
3425     else { \
3426         (newState) = !(oValue); \
3427     }
3428
3429 static void setStatisticsLineAP(Widget w, XEvent *event, String *args,
3430     Cardinal *nArgs)
3431 {
3432     WindowInfo *window = WidgetToWindow(w);
3433     Boolean newState;
3434
3435     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->showStats, "set_statistics_line");
3436
3437     XmToggleButtonSetState(window->statsLineItem, newState, False);
3438     ShowStatsLine(window, newState);
3439 }
3440
3441 static void setIncrementalSearchLineAP(Widget w, XEvent *event, String *args,
3442     Cardinal *nArgs)
3443 {
3444     WindowInfo *window = WidgetToWindow(w);
3445     Boolean newState;
3446
3447     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->showISearchLine, "set_incremental_search_line");
3448
3449     XmToggleButtonSetState(window->iSearchLineItem, newState, False);
3450     ShowISearchLine(window, newState);
3451 }
3452
3453 static void setShowLineNumbersAP(Widget w, XEvent *event, String *args,
3454     Cardinal *nArgs)
3455 {
3456     WindowInfo *window = WidgetToWindow(w);
3457     Boolean newState;
3458
3459     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->showLineNumbers, "set_show_line_numbers");
3460
3461     XmToggleButtonSetState(window->lineNumsItem, newState, False);
3462     ShowLineNumbers(window, newState);
3463 }
3464
3465 static void setAutoIndentAP(Widget w, XEvent *event, String *args,
3466     Cardinal *nArgs)
3467 {
3468     WindowInfo *window = WidgetToWindow(w);
3469     if (*nArgs > 0) {
3470         if (strcmp(args[0], "off") == 0) {
3471             SetAutoIndent(window, NO_AUTO_INDENT);
3472         }
3473         else if (strcmp(args[0], "on") == 0) {
3474             SetAutoIndent(window, AUTO_INDENT);
3475         }
3476         else if (strcmp(args[0], "smart") == 0) {
3477             SetAutoIndent(window, SMART_INDENT);
3478         }
3479         else {
3480             fprintf(stderr, "NEdit: set_auto_indent invalid argument\n");
3481         }
3482     }
3483     else {
3484         fprintf(stderr, "NEdit: set_auto_indent requires argument\n");
3485     }
3486 }
3487
3488 static void setWrapTextAP(Widget w, XEvent *event, String *args,
3489     Cardinal *nArgs)
3490 {
3491     WindowInfo *window = WidgetToWindow(w);
3492     if (*nArgs > 0) {
3493         if (strcmp(args[0], "none") == 0) {
3494             SetAutoWrap(window, NO_WRAP);
3495         }
3496         else if (strcmp(args[0], "auto") == 0) {
3497             SetAutoWrap(window, NEWLINE_WRAP);
3498         }
3499         else if (strcmp(args[0], "continuous") == 0) {
3500             SetAutoWrap(window, CONTINUOUS_WRAP);
3501         }
3502         else {
3503             fprintf(stderr, "NEdit: set_wrap_text invalid argument\n");
3504         }
3505     }
3506     else {
3507         fprintf(stderr, "NEdit: set_wrap_text requires argument\n");
3508     }
3509 }
3510
3511 static void setWrapMarginAP(Widget w, XEvent *event, String *args,
3512     Cardinal *nArgs)
3513 {
3514     WindowInfo *window = WidgetToWindow(w);
3515
3516     if (*nArgs > 0) {
3517         int newMargin = 0;
3518         if (sscanf(args[0], "%d", &newMargin) == 1 &&
3519             newMargin >= 0 &&
3520             newMargin < 1000) {
3521             int i;
3522
3523             XtVaSetValues(window->textArea, textNwrapMargin, newMargin, NULL);
3524             for (i = 0; i < window->nPanes; ++i) {
3525                 XtVaSetValues(window->textPanes[i], textNwrapMargin, newMargin, NULL);
3526             }
3527         }
3528         else {
3529             fprintf(stderr,
3530                 "NEdit: set_wrap_margin requires integer argument >= 0 and < 1000\n");
3531         }
3532     }
3533     else {
3534         fprintf(stderr, "NEdit: set_wrap_margin requires argument\n");
3535     }
3536 }
3537
3538 static void setHighlightSyntaxAP(Widget w, XEvent *event, String *args,
3539     Cardinal *nArgs)
3540 {
3541     WindowInfo *window = WidgetToWindow(w);
3542     Boolean newState;
3543
3544     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->highlightSyntax, "set_highlight_syntax");
3545
3546     XmToggleButtonSetState(window->highlightItem, newState, False);
3547     window->highlightSyntax = newState;
3548     if (window->highlightSyntax) {
3549         StartHighlighting(window, True);
3550     } else {
3551         StopHighlighting(window);
3552     }
3553 }
3554
3555 static void setMakeBackupCopyAP(Widget w, XEvent *event, String *args,
3556     Cardinal *nArgs)
3557 {
3558     WindowInfo *window = WidgetToWindow(w);
3559     Boolean newState;
3560
3561     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->saveOldVersion, "set_make_backup_copy");
3562
3563     XmToggleButtonSetState(window->saveLastItem, newState, False);
3564     window->saveOldVersion = newState;
3565 }
3566
3567 static void setIncrementalBackupAP(Widget w, XEvent *event, String *args,
3568     Cardinal *nArgs)
3569 {
3570     WindowInfo *window = WidgetToWindow(w);
3571     Boolean newState;
3572
3573     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->autoSave, "set_incremental_backup");
3574
3575     XmToggleButtonSetState(window->autoSaveItem, newState, False);
3576     window->autoSave = newState;
3577 }
3578
3579 static void setShowMatchingAP(Widget w, XEvent *event, String *args,
3580     Cardinal *nArgs)
3581 {
3582     WindowInfo *window = WidgetToWindow(w);
3583     if (*nArgs > 0) {
3584         if (strcmp(args[0], NO_FLASH_STRING) == 0) {
3585             SetShowMatching(window, NO_FLASH);
3586         }
3587         else if (strcmp(args[0], FLASH_DELIMIT_STRING) == 0) {
3588             SetShowMatching(window, FLASH_DELIMIT);
3589         }
3590         else if (strcmp(args[0], FLASH_RANGE_STRING) == 0) {
3591             SetShowMatching(window, FLASH_RANGE);
3592         }
3593         /* For backward compatibility with pre-5.2 versions, we also
3594            accept 0 and 1 as aliases for NO_FLASH and FLASH_DELIMIT.
3595            It is quite unlikely, though, that anyone ever used this
3596            action procedure via the macro language or a key binding,
3597            so this can probably be left out safely. */
3598         else if (strcmp(args[0], "0") == 0) {
3599            SetShowMatching(window, NO_FLASH);
3600         }
3601         else if (strcmp(args[0], "1") == 0) {
3602            SetShowMatching(window, FLASH_DELIMIT);
3603         }
3604         else {
3605             fprintf(stderr, "NEdit: Invalid argument for set_show_matching\n");
3606         }
3607     }
3608     else {
3609         fprintf(stderr, "NEdit: set_show_matching requires argument\n");
3610     }
3611 }
3612
3613 static void setMatchSyntaxBasedAP(Widget w, XEvent *event, String *args,
3614     Cardinal *nArgs)
3615 {
3616     WindowInfo *window = WidgetToWindow(w);
3617     Boolean newState;
3618
3619     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->matchSyntaxBased, "set_match_syntax_based");
3620
3621     XmToggleButtonSetState(window->matchSyntaxBasedItem, newState, False);
3622     window->matchSyntaxBased = newState;
3623 }
3624
3625 static void setOvertypeModeAP(Widget w, XEvent *event, String *args,
3626     Cardinal *nArgs)
3627 {
3628     WindowInfo *window = WidgetToWindow(w);
3629     Boolean newState;
3630
3631     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->overstrike, "set_overtype_mode");
3632
3633     XmToggleButtonSetState(window->overtypeModeItem, newState, False);
3634     SetOverstrike(window, newState);
3635 }
3636
3637 static void setLockedAP(Widget w, XEvent *event, String *args,
3638     Cardinal *nArgs)
3639 {
3640     WindowInfo *window = WidgetToWindow(w);
3641     Boolean newState;
3642
3643     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, IS_USER_LOCKED(window->lockReasons), "set_locked");
3644
3645     SET_USER_LOCKED(window->lockReasons, newState);
3646     XmToggleButtonSetState(window->readOnlyItem, IS_ANY_LOCKED(window->lockReasons), False);
3647     UpdateWindowTitle(window);
3648     UpdateWindowReadOnly(window);
3649 }
3650
3651 static void setTabDistAP(Widget w, XEvent *event, String *args,
3652     Cardinal *nArgs)
3653 {
3654     WindowInfo *window = WidgetToWindow(w);
3655
3656     if (*nArgs > 0) {
3657         int newTabDist = 0;
3658         if (sscanf(args[0], "%d", &newTabDist) == 1 &&
3659             newTabDist > 0 &&
3660             newTabDist <= MAX_EXP_CHAR_LEN) {
3661             SetTabDist(window, newTabDist);
3662         }
3663         else {
3664             fprintf(stderr,
3665                 "NEdit: set_tab_dist requires integer argument > 0 and <= %d\n",
3666                 MAX_EXP_CHAR_LEN);
3667         }
3668     }
3669     else {
3670         fprintf(stderr, "NEdit: set_tab_dist requires argument\n");
3671     }
3672 }
3673
3674 static void setEmTabDistAP(Widget w, XEvent *event, String *args,
3675     Cardinal *nArgs)
3676 {
3677     WindowInfo *window = WidgetToWindow(w);
3678
3679     if (*nArgs > 0) {
3680         int newEmTabDist = 0;
3681         if (sscanf(args[0], "%d", &newEmTabDist) == 1 &&
3682             newEmTabDist >= -1 &&
3683             newEmTabDist < 1000) {
3684             if (newEmTabDist < 0) {
3685                 newEmTabDist = 0;
3686             }
3687             SetEmTabDist(window, newEmTabDist);
3688         }
3689         else {
3690             fprintf(stderr,
3691                 "NEdit: set_em_tab_dist requires integer argument >= -1 and < 1000\n");
3692         }
3693     }
3694     else {
3695         fprintf(stderr, "NEdit: set_em_tab_dist requires argument\n");
3696     }
3697 }
3698
3699 static void setUseTabsAP(Widget w, XEvent *event, String *args,
3700     Cardinal *nArgs)
3701 {
3702     WindowInfo *window = WidgetToWindow(w);
3703     Boolean newState;
3704
3705     ACTION_BOOL_PARAM_OR_TOGGLE(newState, *nArgs, args, window->buffer->useTabs, "set_use_tabs");
3706
3707     window->buffer->useTabs = newState;
3708 }
3709
3710 static void setFontsAP(Widget w, XEvent *event, String *args,
3711     Cardinal *nArgs)
3712 {
3713     WindowInfo *window = WidgetToWindow(w);
3714     if (*nArgs >= 4) {
3715         SetFonts(window, args[0], args[1], args[2], args[3]);
3716     }
3717     else {
3718         fprintf(stderr, "NEdit: set_fonts requires 4 arguments\n");
3719     }
3720 }
3721
3722 static void setLanguageModeAP(Widget w, XEvent *event, String *args,
3723     Cardinal *nArgs)
3724 {
3725     WindowInfo *window = WidgetToWindow(w);
3726
3727     if (*nArgs > 0) {
3728         SetLanguageMode(window, FindLanguageMode(args[0]), FALSE);
3729     }
3730     else {
3731         fprintf(stderr, "NEdit: set_language_mode requires argument\n");
3732     }
3733 }
3734
3735 /*
3736 ** Same as AddSubMenu from libNUtil.a but 1) mnemonic is optional (NEdit
3737 ** users like to be able to re-arrange the mnemonics so they can set Alt
3738 ** key combinations as accelerators), 2) supports the short/full option
3739 ** of SGI_CUSTOM mode, 3) optionally returns the cascade button widget
3740 ** in "cascadeBtn" if "cascadeBtn" is non-NULL.
3741 */
3742 static Widget createMenu(Widget parent, char *name, char *label,
3743         char mnemonic, Widget *cascadeBtn, int mode)
3744 {
3745     Widget menu, cascade;
3746     XmString st1;
3747
3748     menu = CreatePulldownMenu(parent, name, NULL, 0);
3749     cascade = XtVaCreateWidget(name, xmCascadeButtonWidgetClass, parent,
3750         XmNlabelString, st1=XmStringCreateSimple(label),
3751         XmNsubMenuId, menu, NULL);
3752     XmStringFree(st1);
3753     if (mnemonic != 0)
3754         XtVaSetValues(cascade, XmNmnemonic, mnemonic, NULL);
3755 #ifdef SGI_CUSTOM
3756     if (mode == SHORT || !GetPrefShortMenus())
3757         XtManageChild(cascade);
3758     if (mode == FULL)
3759         addToToggleShortList(cascade);
3760 #else
3761     XtManageChild(cascade);
3762 #endif
3763     if (cascadeBtn != NULL)
3764         *cascadeBtn = cascade;
3765     return menu;
3766 }
3767
3768 /*
3769 ** Same as AddMenuItem from libNUtil.a without setting the accelerator
3770 ** (these are set in the fallback app-defaults so users can change them),
3771 ** and with the short/full option required in SGI_CUSTOM mode.
3772 */
3773 static Widget createMenuItem(Widget parent, char *name, char *label,
3774         char mnemonic, menuCallbackProc callback, void *cbArg, int mode)
3775 {
3776     Widget button;
3777     XmString st1;
3778
3779
3780     button = XtVaCreateWidget(name, xmPushButtonWidgetClass, parent,
3781             XmNlabelString, st1=XmStringCreateSimple(label),
3782             XmNmnemonic, mnemonic, NULL);
3783     XtAddCallback(button, XmNactivateCallback, (XtCallbackProc)callback, cbArg);
3784     XmStringFree(st1);
3785 #ifdef SGI_CUSTOM
3786     if (mode == SHORT || !GetPrefShortMenus())
3787         XtManageChild(button);
3788     if (mode == FULL)
3789         addToToggleShortList(button);
3790     XtVaSetValues(button, XmNuserData, PERMANENT_MENU_ITEM, NULL);
3791 #else
3792     XtManageChild(button);
3793 #endif
3794     return button;
3795 }
3796
3797 /*
3798 ** "fake" menu items allow accelerators to be attached, but don't show up
3799 ** in the menu.  They are necessary to process the shifted menu items because
3800 ** Motif does not properly process the event descriptions in accelerator
3801 ** resources, and you can't specify "shift key is optional"
3802 */
3803 static Widget createFakeMenuItem(Widget parent, char *name,
3804         menuCallbackProc callback, void *cbArg)
3805 {
3806     Widget button;
3807     XmString st1;
3808
3809     button = XtVaCreateManagedWidget(name, xmPushButtonWidgetClass, parent,
3810             XmNlabelString, st1=XmStringCreateSimple(""),
3811             XmNshadowThickness, 0,
3812             XmNmarginHeight, 0,
3813             XmNheight, 0, NULL);
3814     XtAddCallback(button, XmNactivateCallback, (XtCallbackProc)callback, cbArg);
3815     XmStringFree(st1);
3816     XtVaSetValues(button, XmNtraversalOn, False, NULL);
3817
3818     return button;
3819 }
3820
3821 /*
3822 ** Add a toggle button item to an already established pull-down or pop-up
3823 ** menu, including mnemonics, accelerators and callbacks.
3824 */
3825 static Widget createMenuToggle(Widget parent, char *name, char *label,
3826         char mnemonic, menuCallbackProc callback, void *cbArg, int set,
3827         int mode)
3828 {
3829     Widget button;
3830     XmString st1;
3831
3832     button = XtVaCreateWidget(name, xmToggleButtonWidgetClass, parent,
3833             XmNlabelString, st1=XmStringCreateSimple(label),
3834             XmNmnemonic, mnemonic,
3835             XmNset, set, NULL);
3836     XtAddCallback(button, XmNvalueChangedCallback, (XtCallbackProc)callback,
3837             cbArg);
3838     XmStringFree(st1);
3839 #ifdef SGI_CUSTOM
3840     if (mode == SHORT || !GetPrefShortMenus())
3841         XtManageChild(button);
3842     if (mode == FULL)
3843         addToToggleShortList(button);
3844     XtVaSetValues(button, XmNuserData, PERMANENT_MENU_ITEM, NULL);
3845 #else
3846     XtManageChild(button);
3847 #endif
3848     return button;
3849 }
3850
3851 /*
3852 ** Create a toggle button with a diamond (radio-style) appearance
3853 */
3854 static Widget createMenuRadioToggle(Widget parent, char *name, char *label,
3855         char mnemonic, menuCallbackProc callback, void *cbArg, int set,
3856         int mode)
3857 {
3858     Widget button;
3859     button = createMenuToggle(parent, name, label, mnemonic, callback, cbArg,
3860             set, mode);
3861     XtVaSetValues(button, XmNindicatorType, XmONE_OF_MANY, NULL);
3862     return button;
3863 }
3864
3865 static Widget createMenuSeparator(Widget parent, char *name, int mode)
3866 {
3867     Widget button;
3868
3869     button = XmCreateSeparator(parent, name, NULL, 0);
3870 #ifdef SGI_CUSTOM
3871     if (mode == SHORT || !GetPrefShortMenus())
3872         XtManageChild(button);
3873     if (mode == FULL)
3874         addToToggleShortList(button);
3875     XtVaSetValues(button, XmNuserData, PERMANENT_MENU_ITEM, NULL);
3876 #else
3877     XtManageChild(button);
3878 #endif
3879     return button;
3880 }
3881
3882 /*
3883 ** Make sure the close menu item is dimmed appropriately for the current
3884 ** set of windows.  It should be dim only for the last Untitled, unmodified,
3885 ** editor window, and sensitive otherwise.
3886 */
3887 void CheckCloseDim(void)
3888 {
3889     WindowInfo *window;
3890
3891     if (WindowList == NULL)
3892         return;
3893     if (WindowList->next==NULL &&
3894             !WindowList->filenameSet && !WindowList->fileChanged) {
3895         XtSetSensitive(WindowList->closeItem, FALSE);
3896         return;
3897     }
3898
3899     for (window=WindowList; window!=NULL; window=window->next)
3900         XtSetSensitive(window->closeItem, True);
3901 }
3902
3903 /*
3904 ** Invalidate the Window menus of all NEdit windows to but don't change
3905 ** the menus until they're needed (Originally, this was "UpdateWindowMenus",
3906 ** but creating and destroying manu items for every window every time a
3907 ** new window was created or something changed, made things move very
3908 ** slowly with more than 10 or so windows).
3909 */
3910 void InvalidateWindowMenus(void)
3911 {
3912     WindowInfo *w;
3913
3914     /* Mark the window menus invalid (to be updated when the user pulls one
3915        down), unless the menu is torn off, meaning it is visible to the user
3916        and should be updated immediately */
3917     for (w=WindowList; w!=NULL; w=w->next) {
3918         if (!XmIsMenuShell(XtParent(w->windowMenuPane)))
3919             updateWindowMenu(w);
3920         else
3921             w->windowMenuValid = False;
3922     }
3923 }
3924
3925 /*
3926 ** Mark the Previously Opened Files menus of all NEdit windows as invalid.
3927 ** Since actually changing the menus is slow, they're just marked and updated
3928 ** when the user pulls one down.
3929 */
3930 static void invalidatePrevOpenMenus(void)
3931 {
3932     WindowInfo *w;
3933
3934     /* Mark the menus invalid (to be updated when the user pulls one
3935        down), unless the menu is torn off, meaning it is visible to the user
3936        and should be updated immediately */
3937     for (w=WindowList; w!=NULL; w=w->next) {
3938         if (!XmIsMenuShell(XtParent(w->prevOpenMenuPane)))
3939             updatePrevOpenMenu(w);
3940         else
3941             w->prevOpenMenuValid = False;
3942     }
3943 }
3944
3945 /*
3946 ** Add a file to the list of previously opened files for display in the
3947 ** File menu.
3948 */
3949 void AddToPrevOpenMenu(const char *filename)
3950 {
3951     int i;
3952     char *nameCopy;
3953     WindowInfo *w;
3954
3955     /* If the Open Previous command is disabled, just return */
3956     if (GetPrefMaxPrevOpenFiles() == 0)
3957         return;
3958
3959     /* If the name is already in the list, move it to the start */
3960     for (i=0; i<NPrevOpen; i++) {
3961         if (!strcmp(filename, PrevOpen[i])) {
3962             nameCopy = PrevOpen[i];
3963             memmove(&PrevOpen[1], &PrevOpen[0], sizeof(char *) * i);
3964             PrevOpen[0] = nameCopy;
3965             invalidatePrevOpenMenus();
3966             WriteNEditDB();
3967             return;
3968         }
3969     }
3970
3971     /* If the list is already full, make room */
3972     if (NPrevOpen == GetPrefMaxPrevOpenFiles())
3973         XtFree(PrevOpen[--NPrevOpen]);
3974
3975     /* Add it to the list */
3976     nameCopy = XtMalloc(strlen(filename) + 1);
3977     strcpy(nameCopy, filename);
3978     memmove(&PrevOpen[1], &PrevOpen[0], sizeof(char *) * NPrevOpen);
3979     PrevOpen[0] = nameCopy;
3980     NPrevOpen++;
3981
3982     /* Mark the Previously Opened Files menu as invalid in all windows */
3983     invalidatePrevOpenMenus();
3984
3985     /* Undim the menu in all windows if it was previously empty */
3986     if (NPrevOpen == 1)
3987         for (w=WindowList; w!=NULL; w=w->next)
3988             XtSetSensitive(w->prevOpenMenuItem, True);
3989
3990     /* Write the menu contents to disk to restore in later sessions */
3991     WriteNEditDB();
3992 }
3993
3994 static char* getWindowsMenuEntry(const WindowInfo* thisWindow, const WindowInfo* window)
3995 {
3996     static char fullTitle[MAXPATHLEN * 2 + 3+ 1];
3997     const char *title;
3998
3999     XtVaGetValues(window->shell, XmNiconName, &title, NULL);
4000 #ifdef SGI_CUSTOM
4001     title = title + SGI_WINDOW_TITLE_LEN;
4002 #endif
4003     strcpy(fullTitle, title);
4004     if (thisWindow->showPathInWindowsMenu && window->filenameSet)
4005     {
4006        strcat(fullTitle, " - ");
4007        strcat(fullTitle, window->path);
4008     }
4009
4010     return(fullTitle);
4011 }
4012
4013 /*
4014 ** Update the Window menu of a single window to reflect the current state of
4015 ** all NEdit windows as determined by the global WindowList.
4016 */
4017 static void updateWindowMenu(const WindowInfo *window)
4018 {
4019     WindowInfo *w;
4020     WidgetList items;
4021     Cardinal nItems;
4022     int i, n, nWindows, windowIndex;
4023     WindowInfo **windows;
4024
4025     /* Make a sorted list of windows */
4026     for (w=WindowList, nWindows=0; w!=NULL; w=w->next, nWindows++);
4027     windows = (WindowInfo **)XtMalloc(sizeof(WindowInfo *) * nWindows);
4028     for (w=WindowList, i=0; w!=NULL; w=w->next, i++)
4029         windows[i] = w;
4030     qsort(windows, nWindows, sizeof(WindowInfo *), compareWindowNames);
4031
4032     /* While it is not possible on some systems (ibm at least) to substitute
4033        a new menu pane, it is possible to substitute menu items, as long as
4034        at least one remains in the menu at all times. This routine assumes
4035        that the menu contains permanent items marked with the value
4036        PERMANENT_MENU_ITEM in the userData resource, and adds and removes items
4037        which it marks with the value TEMPORARY_MENU_ITEM */
4038
4039     /* Go thru all of the items in the menu and rename them to
4040        match the window list.  Delete any extras */
4041     XtVaGetValues(window->windowMenuPane, XmNchildren, &items,
4042             XmNnumChildren, &nItems, NULL);
4043     windowIndex = 0;
4044     for (n=0; n<(int)nItems; n++) {
4045         XtPointer userData;
4046         XtVaGetValues(items[n], XmNuserData, &userData, NULL);
4047         if (userData == TEMPORARY_MENU_ITEM) {
4048             if (windowIndex >= nWindows) {
4049                 /* unmanaging before destroying stops parent from displaying */
4050                 XtUnmanageChild(items[n]);
4051                 XtDestroyWidget(items[n]);
4052             } else {
4053                 XmString st1;
4054                 char* title = getWindowsMenuEntry(window, windows[windowIndex]);
4055                 XtVaSetValues(items[n], XmNlabelString,
4056                         st1=XmStringCreateSimple(title), NULL);
4057                 XtRemoveAllCallbacks(items[n], XmNactivateCallback);
4058                 XtAddCallback(items[n], XmNactivateCallback,
4059                         (XtCallbackProc)raiseCB, windows[windowIndex]);
4060                 XmStringFree(st1);
4061                 windowIndex++;
4062             }
4063         }
4064     }
4065
4066     /* Add new items for the titles of the remaining windows to the menu */
4067     for (; windowIndex<nWindows; windowIndex++) {
4068         XmString st1;
4069         char* title = getWindowsMenuEntry(window, windows[windowIndex]);
4070         Widget btn = XtVaCreateManagedWidget("win", xmPushButtonWidgetClass,
4071                 window->windowMenuPane,
4072                 XmNlabelString, st1=XmStringCreateSimple(title),
4073                 XmNmarginHeight, 0,
4074                 XmNuserData, TEMPORARY_MENU_ITEM, NULL);
4075         XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)raiseCB,
4076                 windows[windowIndex]);
4077         XmStringFree(st1);
4078     }
4079     XtFree((char *)windows);
4080 }
4081
4082 /*
4083 ** Update the Previously Opened Files menu of a single window to reflect the
4084 ** current state of the list as retrieved from GetPrevOpenFiles.
4085 ** Thanks to Markus Schwarzenberg for the sorting part.
4086 */
4087 static void updatePrevOpenMenu(WindowInfo *window)
4088 {
4089     Widget btn;
4090     WidgetList items;
4091     Cardinal nItems;
4092     int n, index;
4093     XmString st1;
4094     char **prevOpenSorted;
4095
4096     /* Sort the previously opened file list if requested */
4097     prevOpenSorted = (char **)XtMalloc(NPrevOpen * sizeof(char*));
4098     memcpy(prevOpenSorted, PrevOpen, NPrevOpen * sizeof(char*));
4099     if (GetPrefSortOpenPrevMenu())
4100         qsort(prevOpenSorted, NPrevOpen, sizeof(char*), cmpStrPtr);
4101
4102     /* Go thru all of the items in the menu and rename them to match the file
4103        list.  In older Motifs (particularly ibm), it was dangerous to replace
4104        a whole menu pane, which would be much simpler.  However, since the
4105        code was already written for the Windows menu and is well tested, I'll
4106        stick with this weird method of re-naming the items */
4107     XtVaGetValues(window->prevOpenMenuPane, XmNchildren, &items,
4108             XmNnumChildren, &nItems, NULL);
4109     index = 0;
4110     for (n=0; n<(int)nItems; n++) {
4111         if (index >= NPrevOpen) {
4112             /* unmanaging before destroying stops parent from displaying */
4113             XtUnmanageChild(items[n]);
4114             XtDestroyWidget(items[n]);
4115         } else {
4116             XtVaSetValues(items[n], XmNlabelString,
4117                     st1=XmStringCreateSimple(prevOpenSorted[index]), NULL);
4118             XtRemoveAllCallbacks(items[n], XmNactivateCallback);
4119             XtAddCallback(items[n], XmNactivateCallback,
4120                     (XtCallbackProc)openPrevCB, prevOpenSorted[index]);
4121             XmStringFree(st1);
4122             index++;
4123         }
4124     }
4125
4126     /* Add new items for the remaining file names to the menu */
4127     for (; index<NPrevOpen; index++) {
4128         btn = XtVaCreateManagedWidget("win", xmPushButtonWidgetClass,
4129                 window->prevOpenMenuPane,
4130                 XmNlabelString, st1=XmStringCreateSimple(prevOpenSorted[index]),
4131                 XmNmarginHeight, 0,
4132                 XmNuserData, TEMPORARY_MENU_ITEM, NULL);
4133         XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)openPrevCB,
4134                 prevOpenSorted[index]);
4135         XmStringFree(st1);
4136     }
4137
4138     XtFree((char*)prevOpenSorted);
4139 }
4140
4141 /*
4142 ** This function manages the display of the Tags File Menu, which is displayed
4143 ** when the user selects Un-load Tags File.
4144 */
4145 static void updateTagsFileMenu(WindowInfo *window)
4146 {
4147     tagFile *tf;
4148     Widget btn;
4149     WidgetList items;
4150     Cardinal nItems;
4151     int n;
4152     XmString st1;
4153
4154     /* Go thru all of the items in the menu and rename them to match the file
4155        list.  In older Motifs (particularly ibm), it was dangerous to replace
4156        a whole menu pane, which would be much simpler.  However, since the
4157        code was already written for the Windows menu and is well tested, I'll
4158        stick with this weird method of re-naming the items */
4159     XtVaGetValues(window->unloadTagsMenuPane, XmNchildren, &items,
4160             XmNnumChildren, &nItems, NULL);
4161     tf = TagsFileList;
4162     for (n=0; n<(int)nItems; n++) {
4163         if (!tf) {
4164             /* unmanaging before destroying stops parent from displaying */
4165             XtUnmanageChild(items[n]);
4166             XtDestroyWidget(items[n]);
4167         } else {
4168             XtVaSetValues(items[n], XmNlabelString,
4169                     st1=XmStringCreateSimple(tf->filename), NULL);
4170             XtRemoveAllCallbacks(items[n], XmNactivateCallback);
4171             XtAddCallback(items[n], XmNactivateCallback,
4172                     (XtCallbackProc)unloadTagsFileCB, tf->filename);
4173             XmStringFree(st1);
4174             tf = tf->next;
4175         }
4176     }
4177
4178     /* Add new items for the remaining file names to the menu */
4179     while (tf) {
4180         btn = XtVaCreateManagedWidget("win", xmPushButtonWidgetClass,
4181                 window->unloadTagsMenuPane, XmNlabelString,
4182                 st1=XmStringCreateSimple(tf->filename),XmNmarginHeight, 0,
4183                 XmNuserData, TEMPORARY_MENU_ITEM, NULL);
4184         XtAddCallback(btn, XmNactivateCallback,
4185                 (XtCallbackProc)unloadTagsFileCB, tf->filename);
4186         XmStringFree(st1);
4187         tf = tf->next;
4188     }
4189 }
4190
4191 /*
4192 ** This function manages the display of the Tips File Menu, which is displayed
4193 ** when the user selects Un-load Calltips File.
4194 */
4195 static void updateTipsFileMenu(WindowInfo *window)
4196 {
4197     tagFile *tf;
4198     Widget btn;
4199     WidgetList items;
4200     Cardinal nItems;
4201     int n;
4202     XmString st1;
4203
4204     /* Go thru all of the items in the menu and rename them to match the file
4205        list.  In older Motifs (particularly ibm), it was dangerous to replace
4206        a whole menu pane, which would be much simpler.  However, since the
4207        code was already written for the Windows menu and is well tested, I'll
4208        stick with this weird method of re-naming the items */
4209     XtVaGetValues(window->unloadTipsMenuPane, XmNchildren, &items,
4210             XmNnumChildren, &nItems, NULL);
4211     tf = TipsFileList;
4212     for (n=0; n<(int)nItems; n++) {
4213         if (!tf) {
4214             /* unmanaging before destroying stops parent from displaying */
4215             XtUnmanageChild(items[n]);
4216             XtDestroyWidget(items[n]);
4217         } else {
4218             XtVaSetValues(items[n], XmNlabelString,
4219                     st1=XmStringCreateSimple(tf->filename), NULL);
4220             XtRemoveAllCallbacks(items[n], XmNactivateCallback);
4221             XtAddCallback(items[n], XmNactivateCallback,
4222                     (XtCallbackProc)unloadTipsFileCB, tf->filename);
4223             XmStringFree(st1);
4224             tf = tf->next;
4225         }
4226     }
4227
4228     /* Add new items for the remaining file names to the menu */
4229     while (tf) {
4230         btn = XtVaCreateManagedWidget("win", xmPushButtonWidgetClass,
4231                 window->unloadTipsMenuPane, XmNlabelString,
4232                 st1=XmStringCreateSimple(tf->filename),XmNmarginHeight, 0,
4233                 XmNuserData, TEMPORARY_MENU_ITEM, NULL);
4234         XtAddCallback(btn, XmNactivateCallback,
4235                 (XtCallbackProc)unloadTipsFileCB, tf->filename);
4236         XmStringFree(st1);
4237         tf = tf->next;
4238     }
4239 }
4240
4241 /*
4242 ** Comparison function for sorting file names for the Open Previous submenu
4243 */
4244 static int cmpStrPtr(const void *strA, const void *strB)
4245 {
4246     return strcmp(*((char**)strA), *((char**)strB));
4247 }
4248
4249 /*
4250 ** Write dynamic database of file names for "Open Previous".  Eventually,
4251 ** this may hold window positions, and possibly file marks, in which case,
4252 ** it should be moved to a different module, but for now it's just a list
4253 ** of previously opened files.
4254 */
4255 void WriteNEditDB(void)
4256 {
4257     const char* fullName = GetRCFileName(NEDIT_HISTORY);
4258     FILE *fp;
4259     int i;
4260     static char fileHeader[] =
4261             "# File name database for NEdit Open Previous command\n";
4262
4263     /* If the Open Previous command is disabled, just return */
4264     if (GetPrefMaxPrevOpenFiles() == 0)
4265         return;
4266
4267     /* open the file */
4268     if ((fp = fopen(fullName, "w")) == NULL)
4269         return;
4270
4271     /* write the file header text to the file */
4272     fprintf(fp, "%s", fileHeader);
4273
4274     /* Write the list of file names */
4275     for (i=0; i<NPrevOpen; i++)
4276         fprintf(fp, "%s\n", PrevOpen[i]);
4277
4278     /* Close the file */
4279     fclose(fp);
4280 }
4281
4282 /*
4283 ** Read dynamic database of file names for "Open Previous".  Eventually,
4284 ** this may hold window positions, and possibly file marks, in which case,
4285 ** it should be moved to a different module, but for now it's just a list
4286 ** of previously opened files.  This routine should only be called once,
4287 ** at startup time, before any windows are open.
4288 */
4289 void ReadNEditDB(void)
4290 {
4291     const char* fullName = GetRCFileName(NEDIT_HISTORY);
4292     char line[MAXPATHLEN];
4293     char *nameCopy;
4294     FILE *fp;
4295     int lineLen;
4296 #ifdef VMS
4297     static char badFilenameChars[] = "\n\t*?()[]{}!@#%^&:;' ";
4298 #else
4299     static char badFilenameChars[] = "\n\t*?()[]{}";
4300 #endif
4301
4302     /* If the Open Previous command is disabled, just return */
4303     if (GetPrefMaxPrevOpenFiles() == 0)
4304         return;
4305
4306     /* Initialize the files list and allocate a (permanent) block memory
4307        of the size prescribed by the maxPrevOpenFiles resource */
4308     PrevOpen = (char **)XtMalloc(sizeof(char *) * GetPrefMaxPrevOpenFiles());
4309     NPrevOpen = 0;
4310
4311     /* open the file */
4312     if ((fp = fopen(fullName, "r")) == NULL)
4313         return;
4314
4315     /* read lines of the file, lines beginning with # are considered to be
4316        comments and are thrown away.  Lines are subject to cursory checking,
4317        then just copied to the Open Previous file menu list */
4318     while (True) {
4319         if (fgets(line, (int)MAXPATHLEN, fp) == NULL) {
4320             fclose(fp);
4321             return;                                      /* end of file */
4322         }
4323         if (line[0] == '#')
4324             continue;
4325         lineLen = strlen(line);                              /* comment */
4326         if (line[lineLen-1] != '\n') {
4327             fprintf(stderr, ".neditdb line too long\n");
4328             fclose(fp);
4329             return;                   /* no newline, probably truncated */
4330         }
4331         line[--lineLen] = '\0';
4332         if (lineLen == 0)
4333             continue;           /* blank line */
4334         if ((int)strcspn(line, badFilenameChars) != lineLen) {
4335             fprintf(stderr, ".neditdb file is corrupted\n");
4336             fclose(fp);
4337             return;                          /* non-filename characters */
4338         }
4339         nameCopy = XtMalloc(lineLen+1);
4340         strcpy(nameCopy, line);
4341         PrevOpen[NPrevOpen++] = nameCopy;
4342         if (NPrevOpen >= GetPrefMaxPrevOpenFiles()) {
4343             fclose(fp);
4344             return;                                 /* too many entries */
4345         }
4346     }
4347 }
4348
4349 static void setWindowSizeDefault(int rows, int cols)
4350 {
4351     SetPrefRows(rows);
4352     SetPrefCols(cols);
4353     updateWindowSizeMenus();
4354 }
4355
4356 static void updateWindowSizeMenus(void)
4357 {
4358     WindowInfo *win;
4359
4360     for (win=WindowList; win!=NULL; win=win->next)
4361         updateWindowSizeMenu(win);
4362 }
4363
4364 static void updateWindowSizeMenu(WindowInfo *win)
4365 {
4366     int rows = GetPrefRows(), cols = GetPrefCols();
4367     char title[50];
4368     XmString st1;
4369
4370     XmToggleButtonSetState(win->size24x80DefItem, rows==24&&cols==80,False);
4371     XmToggleButtonSetState(win->size40x80DefItem, rows==40&&cols==80,False);
4372     XmToggleButtonSetState(win->size60x80DefItem, rows==60&&cols==80,False);
4373     XmToggleButtonSetState(win->size80x80DefItem, rows==80&&cols==80,False);
4374     if ((rows!=24 && rows!=40 && rows!=60 && rows!=80) || cols!=80) {
4375         XmToggleButtonSetState(win->sizeCustomDefItem, True, False);
4376         sprintf(title, "Custom... (%d x %d)", rows, cols);
4377         XtVaSetValues(win->sizeCustomDefItem,
4378                 XmNlabelString, st1=XmStringCreateSimple(title), NULL);
4379         XmStringFree(st1);
4380     } else {
4381         XmToggleButtonSetState(win->sizeCustomDefItem, False, False);
4382         XtVaSetValues(win->sizeCustomDefItem,
4383                 XmNlabelString, st1=XmStringCreateSimple("Custom..."), NULL);
4384         XmStringFree(st1);
4385     }
4386 }
4387
4388 /*
4389 ** Scans action argument list for arguments "forward" or "backward" to
4390 ** determine search direction for search and replace actions.  "ignoreArgs"
4391 ** tells the routine how many required arguments there are to ignore before
4392 ** looking for keywords
4393 */
4394 static int searchDirection(int ignoreArgs, String *args, Cardinal *nArgs)
4395 {
4396     int i;
4397
4398     for (i=ignoreArgs; i<(int)*nArgs; i++) {
4399         if (!strCaseCmp(args[i], "forward"))
4400             return SEARCH_FORWARD;
4401         if (!strCaseCmp(args[i], "backward"))
4402             return SEARCH_BACKWARD;
4403     }
4404     return SEARCH_FORWARD;
4405 }
4406
4407 /*
4408 ** Scans action argument list for arguments "keep" or "nokeep" to
4409 ** determine whether to keep dialogs up for search and replace.  "ignoreArgs"
4410 ** tells the routine how many required arguments there are to ignore before
4411 ** looking for keywords
4412 */
4413 static int searchKeepDialogs(int ignoreArgs, String *args, Cardinal *nArgs)
4414 {
4415     int i;
4416
4417     for (i=ignoreArgs; i<(int)*nArgs; i++) {
4418         if (!strCaseCmp(args[i], "keep"))
4419             return TRUE;
4420         if (!strCaseCmp(args[i], "nokeep"))
4421             return FALSE;
4422     }
4423     return GetPrefKeepSearchDlogs();
4424 }
4425
4426 /*
4427 ** Scans action argument list for arguments "wrap" or "nowrap" to
4428 ** determine search direction for search and replace actions.  "ignoreArgs"
4429 ** tells the routine how many required arguments there are to ignore before
4430 ** looking for keywords
4431 */
4432 static int searchWrap(int ignoreArgs, String *args, Cardinal *nArgs)
4433 {
4434     int i;
4435
4436     for (i=ignoreArgs; i<(int)*nArgs; i++) {
4437         if (!strCaseCmp(args[i], "wrap"))
4438             return(TRUE);
4439         if (!strCaseCmp(args[i], "nowrap"))
4440             return(FALSE);
4441     }
4442     return GetPrefSearchWraps();
4443 }
4444
4445 /*
4446 ** Scans action argument list for arguments "literal", "case" or "regex" to
4447 ** determine search type for search and replace actions.  "ignoreArgs"
4448 ** tells the routine how many required arguments there are to ignore before
4449 ** looking for keywords
4450 */
4451 static int searchType(int ignoreArgs, String *args, Cardinal *nArgs)
4452 {
4453     int i, tmpSearchType;
4454
4455     for (i=ignoreArgs; i<(int)*nArgs; i++) {
4456         if (StringToSearchType(args[i], &tmpSearchType))
4457             return tmpSearchType;
4458     }
4459     return GetPrefSearch();
4460 }
4461
4462 /*
4463 ** Return a pointer to the string describing search direction for search action
4464 ** routine parameters given a callback XmAnyCallbackStruct pointed to by
4465 ** "callData", by checking if the shift key is pressed (for search callbacks).
4466 */
4467 static char **shiftKeyToDir(XtPointer callData)
4468 {
4469     static char *backwardParam[1] = {"backward"};
4470     static char *forwardParam[1] = {"forward"};
4471     if (((XmAnyCallbackStruct *)callData)->event->xbutton.state & ShiftMask)
4472         return backwardParam;
4473     return forwardParam;
4474 }
4475
4476 static void raiseCB(Widget w, WindowInfo *window, caddr_t callData)
4477 {
4478     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
4479             ((XmAnyCallbackStruct *)callData)->event);
4480     RaiseShellWindow(window->shell);
4481 }
4482
4483 static void openPrevCB(Widget w, char *name, caddr_t callData)
4484 {
4485     char *params[1];
4486     Widget menu = MENU_WIDGET(w);
4487
4488     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
4489             ((XmAnyCallbackStruct *)callData)->event);
4490     params[0] = name;
4491     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "open",
4492             ((XmAnyCallbackStruct *)callData)->event, params, 1);
4493     CheckCloseDim();
4494 }
4495
4496 static void unloadTagsFileCB(Widget w, char *name, caddr_t callData)
4497 {
4498     char *params[1];
4499     Widget menu = MENU_WIDGET(w);
4500
4501     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
4502             ((XmAnyCallbackStruct *)callData)->event);
4503     params[0] = name;
4504     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "unload_tags_file",
4505             ((XmAnyCallbackStruct *)callData)->event, params, 1);
4506 }
4507
4508 static void unloadTipsFileCB(Widget w, char *name, caddr_t callData)
4509 {
4510     char *params[1];
4511 #if XmVersion >= 1002
4512     Widget menu = XmGetPostedFromWidget(XtParent(w)); /* If menu is torn off */
4513 #else
4514     Widget menu = w;
4515 #endif
4516
4517     params[0] = name;
4518     XtCallActionProc(WidgetToWindow(menu)->lastFocus, "unload_tips_file",
4519             ((XmAnyCallbackStruct *)callData)->event, params, 1);
4520 }
4521
4522 /*
4523 ** strCaseCmp compares its arguments and returns 0 if the two strings
4524 ** are equal IGNORING case differences.  Otherwise returns 1.
4525 */
4526 static int strCaseCmp(const char *str1, const char *str2)
4527 {
4528     const char *c1, *c2;
4529
4530     for (c1=str1, c2=str2; *c1!='\0' && *c2!='\0'; c1++, c2++)
4531         if (toupper((unsigned char)*c1) != toupper((unsigned char)*c2))
4532             return 1;
4533     if (*c1 == *c2) {
4534         return(0);
4535          }
4536     else {
4537         return(1);
4538          }
4539 }
4540
4541 /*
4542 ** Comparison function for sorting windows by title for the window menu.
4543 ** Windows are sorted by Untitled and then alphabetically by filename and
4544 ** then alphabetically by path.
4545 */
4546 static int compareWindowNames(const void *windowA, const void *windowB)
4547 {
4548     int rc;
4549     const WindowInfo *a = *((WindowInfo**)windowA);
4550     const WindowInfo *b = *((WindowInfo**)windowB);
4551     /* Untitled first */
4552     rc = a->filenameSet ==  b->filenameSet ? 0 :
4553          a->filenameSet && !b->filenameSet ? 1 : -1;
4554     if (rc != 0)
4555          return rc;
4556     rc = strcmp(a->filename, b->filename);
4557     if (rc != 0)
4558          return rc;
4559     rc = strcmp(a->path, b->path);
4560     return rc;
4561 }
4562
4563 /*
4564 ** Create popup for right button programmable menu
4565 */
4566 Widget CreateBGMenu(WindowInfo *window)
4567 {
4568     Arg args[1];
4569
4570     /* There is still some mystery here.  It's important to get the XmNmenuPost
4571        resource set to the correct menu button, or the menu will not post
4572        properly, but there's also some danger that it will take over the entire
4573        button and interfere with text widget translations which use the button
4574        with modifiers.  I don't entirely understand why it works properly now
4575        when it failed often in development, and certainly ignores the ~ syntax
4576        in translation event specifications. */
4577     XtSetArg(args[0], XmNmenuPost, GetPrefBGMenuBtn());
4578     return CreatePopupMenu(window->textArea, "bgMenu", args, 1);
4579 }
4580
4581 /*
4582 ** Add a translation to the text widget to trigger the background menu using
4583 ** the mouse-button + modifier combination specified in the resource:
4584 ** nedit.bgMenuBtn.
4585 */
4586 void AddBGMenuAction(Widget widget)
4587 {
4588     static XtTranslations table = NULL;
4589
4590     if (table == NULL) {
4591         char translations[MAX_ACCEL_LEN + 25];
4592         sprintf(translations, "%s: post_window_bg_menu()\n",GetPrefBGMenuBtn());
4593         table = XtParseTranslationTable(translations);
4594     }
4595     XtOverrideTranslations(widget, table);
4596 }
4597
4598 static void bgMenuPostAP(Widget w, XEvent *event, String *args,
4599         Cardinal *nArgs)
4600 {
4601     WindowInfo *window = WidgetToWindow(w);
4602
4603     /* The Motif popup handling code BLOCKS events while the menu is posted,
4604        including the matching btn-up events which complete various dragging
4605        operations which it may interrupt.  Cancel to head off problems */
4606     XtCallActionProc(window->lastFocus, "process_cancel", event, NULL, 0);
4607
4608     /* Pop up the menu */
4609     XmMenuPosition(window->bgMenuPane, (XButtonPressedEvent *)event);
4610     XtManageChild(window->bgMenuPane);
4611
4612     /*
4613        These statements have been here for a very long time, but seem
4614        unnecessary and are even dangerous: when any of the lock keys are on,
4615        Motif thinks it shouldn't display the background menu, but this
4616        callback is called anyway. When we then grab the focus and force the
4617        menu to be drawn, bad things can happen (like a total lockup of the X
4618        server).
4619
4620        XtPopup(XtParent(window->bgMenuPane), XtGrabNonexclusive);
4621        XtMapWidget(XtParent(window->bgMenuPane));
4622        XtMapWidget(window->bgMenuPane);
4623     */
4624 }
4625
4626 #ifdef SGI_CUSTOM
4627 static void shortMenusCB(Widget w, WindowInfo *window, caddr_t callData)
4628 {
4629     WindowInfo *win;
4630     int i, state = XmToggleButtonGetState(w);
4631     Widget parent;
4632
4633     HidePointerOnKeyedEvent(WidgetToWindow(MENU_WIDGET(w))->lastFocus,
4634             ((XmAnyCallbackStruct *)callData)->event);
4635     /* Set the preference */
4636     SetPrefShortMenus(state);
4637
4638     /* Re-create the menus for all windows */
4639     for (win=WindowList; win!=NULL; win=win->next) {
4640         for (i=0; i<win->nToggleShortItems; i++) {
4641             if (state)
4642                 XtUnmanageChild(win->toggleShortItems[i]);
4643             else
4644                 XtManageChild(win->toggleShortItems[i]);
4645         }
4646     }
4647     if (GetPrefShortMenus())
4648         SaveNEditPrefs(window->shell, True);
4649 }
4650
4651 static void addToToggleShortList(Widget w)
4652 {
4653     if (ShortMenuWindow->nToggleShortItems >= MAX_SHORTENED_ITEMS) {
4654         fprintf(stderr,"NEdit, internal error: increase MAX_SHORTENED_ITEMS\n");
4655         return;
4656     }
4657     ShortMenuWindow->toggleShortItems[ShortMenuWindow->nToggleShortItems++] = w;
4658 }
4659
4660 /*
4661 ** Present the user a dialog for specifying whether or not a short
4662 ** menu mode preference should be applied toward the default setting.
4663 ** Return True if user requested to reset and save the default value.
4664 ** If operation was canceled, will return toggle widget "w" to it's
4665 ** original (opposite) state.
4666 */
4667 static int shortPrefAskDefault(Widget parent, Widget w, const char *settingName)
4668 {
4669     char msg[100] = "";
4670
4671     if (!GetPrefShortMenus()) {
4672         return False;
4673     }
4674
4675     sprintf(msg, "%s: %s\nSave as default for future windows as well?",
4676             settingName, XmToggleButtonGetState(w) ? "On" : "Off");
4677     switch(DialogF (DF_QUES, parent, 3, msg, "Yes", "No", "Cancel")) {
4678         case 1: /* yes */
4679             return True;
4680         case 2: /* no */
4681            return False;
4682         case 3: /* cancel */
4683             XmToggleButtonSetState(w, !XmToggleButtonGetState(w), False);
4684             return False;
4685     }
4686     return False; /* not reached */
4687 }
4688 #endif