cde/programs/dtpad/dtpad.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $TOG: dtpad.c /main/14 1999/09/15 15:15:02 mgreess $ */
  24 /**********************************<+>*************************************
  25 ***************************************************************************
  26 **
  27 **  File:        dtpad.c
  28 **
  29 **  Project:     DT dtpad, a memo maker type editor based on the Dt Editor
  30 **               widget.
  31 **
  32 **  Description:
  33 **  -----------
  34 **
  35 **      This file contains routines that create the dtpad menu bar widget
  36 **      and the Dt Editor widget.
  37 **
  38 *******************************************************************
  39 **  (c) Copyright Hewlett-Packard Company, 1990, 1991, 1992, 1993.
  40 **  All rights are
  41 **  reserved.  Copying or other reproduction of this program
  42 **  except for archival purposes is prohibited without prior
  43 **  written consent of Hewlett-Packard Company.
  44 ********************************************************************
  45 **
  46 ********************************************************************
  47 **  (c) Copyright 1993, 1994 Hewlett-Packard Company
  48 **  (c) Copyright 1993, 1994 International Business Machines Corp.
  49 **  (c) Copyright 1993, 1994 Sun Microsystems, Inc.
  50 **  (c) Copyright 1993, 1994 Novell, Inc.
  51 ********************************************************************
  52 **
  53 **
  54 **************************************************************************
  55 **********************************<+>*************************************/
  56 #include "dtpad.h"
  57 #include "signal.h"
  58 #include "X11/Xutil.h"
  59 #include <X11/StringDefs.h>
  60
  61 #ifndef NO_MESSAGE_CATALOG
  62 # define TRUE 1
  63 # define FALSE 0
  64 # include <nl_types.h>
  65 #endif
  66
  67 extern Editor *pPadList; /* declared in main.c */
  68 extern int numActivePads; /* declared in main.c */
  69 extern Widget topLevelWithWmCommand; /* declared in main.c */
  70
  71
  72 /************************************************************************
  73  * CreateDefaultImage - create a default image for the warning symbol.
  74  *
  75  ************************************************************************/
  76 void
  77 CreateDefaultImage(
  78         char *bits,
  79         int width,
  80         int height,
  81         char *name )
  82 {
  83     XImage *image;      /* image for warning pixmap */
  84
  85     image = (XImage *) XtMalloc (sizeof (XImage));
  86     image->width = width;
  87     image->height = height;
  88     image->data = bits;
  89     image->depth = 1;
  90     image->xoffset = 0;
  91     image->format = XYBitmap;
  92     image->byte_order = LSBFirst;
  93     image->bitmap_unit = 8;
  94     image->bitmap_bit_order = LSBFirst;
  95     image->bitmap_pad = 8;
  96     image->bytes_per_line = (width+7)/8;
  97     XmInstallImage (image, name);
  98 }
  99
 100
 101 /*
 102  * The following functions are multibyte-aware string handling routines,
 103  * including MbStrchr, MbStrrchr, and MbBasename.  These routines are
 104  * used as substitutes for the single-byte-only strchr and strrchr routines.
 105  *
 106  *
 107  * [SuG 5/12/95] Added MbStrchri which does exactly MbStrchr, but also returns
 108  * index.
 109  */
 110
 111 /************************************************************************
 112  * MbStrchr -
 113  ************************************************************************/
 114 char *
 115 MbStrchr(
 116         char *str,
 117         int ch)
 118 {
 119     size_t mbCurMax = MB_CUR_MAX;
 120     wchar_t targetChar, curChar;
 121     char tmpChar;
 122     int i, numBytes, byteLen;
 123
 124     if(mbCurMax <= 1) return strchr(str, ch);
 125
 126     tmpChar = (char)ch;
 127     mbtowc(&targetChar, &tmpChar, mbCurMax);
 128     for(i = 0, numBytes = 0, byteLen = strlen(str); i < byteLen; i += numBytes)
 129     {
 130         numBytes = mbtowc(&curChar, &str[i], mbCurMax);
 131         if(curChar == targetChar) return &str[i];
 132     }
 133     return (char *)NULL;
 134 }
 135
 136 /************************************************************************
 137  * MbStrchri -
 138  ************************************************************************/
 139 char *
 140 MbStrchri(
 141     char *str,
 142     int ch, int* in)
 143 {
 144     size_t mbCurMax = MB_CUR_MAX;
 145     wchar_t targetChar, curChar;
 146     char tmpChar;
 147     int i, j, numBytes, byteLen;
 148
 149     /*if(mbCurMax <= 1) return strchr(str, ch);*/
 150
 151     tmpChar = (char)ch;
 152     mbtowc(&targetChar, &tmpChar, mbCurMax);
 153     for(i = 0, j = 0, numBytes = 0, byteLen = strlen(str); i < byteLen;
 154         i += numBytes, j++)
 155     {
 156         numBytes = mbtowc(&curChar, &str[i], mbCurMax);
 157         if(curChar == targetChar) {
 158             *in = j;
 159             return &str[i];
 160         }
 161     }
 162         *in = -1;
 163     return (char *)NULL;
 164 }
 165
 166 /************************************************************************
 167  * MbStrrchr -
 168  ************************************************************************/
 169 char *
 170 MbStrrchr(
 171         char *str,
 172         int ch)
 173 {
 174     size_t mbCurMax = MB_CUR_MAX;
 175     wchar_t targetChar, curChar;
 176     char tmpChar, *lastChar;
 177     int i, numBytes, byteLen;
 178
 179     if(mbCurMax <= 1) return strrchr(str, ch);
 180
 181     tmpChar = (char)ch;
 182     mbtowc(&targetChar, &tmpChar, mbCurMax);
 183     for(i = 0, numBytes = 0, lastChar = (char *)NULL, byteLen = strlen(str);
 184           i < byteLen; i += numBytes)
 185     {
 186         numBytes = mbtowc(&curChar, &str[i], mbCurMax);
 187         if(curChar == targetChar) lastChar = &str[i];
 188     }
 189
 190     return lastChar;
 191 }
 192
 193
 194 /************************************************************************
 195  * MbBasename -
 196  ************************************************************************/
 197 char *
 198 MbBasename(
 199         char *str)
 200 {
 201     char *lastSlash;
 202
 203     lastSlash = MbStrrchr(str, '/');
 204
 205     if(lastSlash != (char *)NULL)
 206         return lastSlash + 1;
 207     else
 208         return str;
 209 }
 210
 211
 212 /************************************************************************
 213  *  ChangeMainWindowTitle - If necessary, put file name in window title
 214  ************************************************************************/
 215 void
 216 ChangeMainWindowTitle(
 217         Editor *pPad)
 218 {
 219     Arg al[5];
 220     char *name;
 221     char *title;
 222     Boolean freeName = False;
 223     XTextProperty textProp;
 224
 225     /* Should happen only when creating a new view */
 226     if (!XtIsRealized(pPad->app_shell))
 227        return;
 228
 229     if (pPad->ttEditReq.contract &&
 230             (pPad->ttEditReq.docName && *pPad->ttEditReq.docName)) {
 231         name = pPad->ttEditReq.docName;
 232     } else if (pPad->fileStuff.fileName && *pPad->fileStuff.fileName) {
 233         name = MbBasename(pPad->fileStuff.fileName);
 234     } else {
 235         name = strdup(UNNAMED_TITLE);
 236         freeName = True;
 237     }
 238     title = (char *)XtMalloc(strlen(DialogTitle(pPad)) + strlen(name) + 1);
 239     sprintf(title, "%s%s", DialogTitle(pPad), name);
 240
 241     XmbTextListToTextProperty(pPad->display, &name, 1, XStdICCTextStyle,
 242                               &textProp);
 243     XSetWMIconName(pPad->display, XtWindow(pPad->app_shell), &textProp);
 244     XFree(textProp.value);
 245
 246     XtSetArg(al[0], XmNtitle, title);
 247     XtSetArg(al[1], XmNtitleEncoding, None);
 248     XtSetValues(pPad->app_shell, al, 2);
 249
 250     if(freeName == True)
 251         free(name);
 252     XtFree(title);
 253 }
 254
 255
 256 /************************************************************************
 257  * SetSaveAsLabelAndDialog - set the File menu [Save As] button label and
 258  *      mnemonic, and the SaveAs dialog title based on whether or not the
 259  *      file name can change.
 260  ************************************************************************/
 261 void
 262 SetSaveAsLabelAndDialog(
 263         Editor *pPad)
 264 {
 265     char buf[256];
 266     Arg al[10];
 267     int ac, count = 0;
 268     char      *mnemonic;
 269     XmString tmpStr;
 270
 271     if (pPad->fileStuff.fileWidgets.saveAsBtn) {
 272         if (pPad->xrdb.nameChange) {
 273             mnemonic = strdup(((char *)GETMESSAGE(11, 25, "A")));
 274             tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 26, "Save As...")));
 275         } else {
 276             mnemonic = strdup(((char *)GETMESSAGE(11, 109, "F")));
 277             tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 110, "Copy To File...")));
 278         }
 279         ac = 0;
 280         XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 281         XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 282         XtSetValues(pPad->fileStuff.fileWidgets.saveAsBtn, al, ac);
 283         free(mnemonic);
 284         XmStringFree(tmpStr);
 285     }
 286
 287     if (pPad->fileStuff.fileWidgets.saveAs.saveAs_form) {
 288         strcpy(buf, DialogTitle(pPad));
 289         if (pPad->xrdb.nameChange) {
 290             strcat(buf, (char *)GETMESSAGE(5, 7, "Save As"));
 291         } else {
 292             strcat(buf, (char *)GETMESSAGE(5, 43, "Copy To File"));
 293         }
 294         tmpStr = XmStringCreateLocalized(buf);
 295         XtSetArg(al[0], XmNdialogTitle, tmpStr);
 296         XtSetValues(pPad->fileStuff.fileWidgets.saveAs.saveAs_form, al, 1);
 297         XmStringFree(tmpStr);
 298     }
 299
 300 }
 301
 302
 303
 304 /************************************************************************
 305  * CreateHelpMenu - Create the Help pulldown menu
 306  *
 307  *      Overview
 308  *      ----------
 309  *      Tasks
 310  *      Table of Contents
 311  *      Reference
 312  *      On Item
 313  *      ----------
 314  *      Using Help
 315  *      ----------
 316  *      About Text Editor
 317  *
 318  ************************************************************************/
 319 static void
 320 CreateHelpMenu(
 321         Editor *pPad)
 322 {
 323     Widget help_pane, cascade, WidgList[12];
 324     Arg al[10];
 325     int ac, count = 0;
 326     char      *mnemonic;
 327     XmString tmpStr;
 328
 329     /* -----> create "Help" PulldownMenu */
 330     ac = 0;
 331     help_pane = XmCreatePulldownMenu (pPad->menu_bar, "helpMenu", al, ac);
 332     XtAddCallback(help_pane, XmNhelpCallback,
 333                   (XtCallbackProc)HelpHelpCB, pPad);
 334     mnemonic = strdup(((char *)GETMESSAGE(11, 81, "H")));
 335     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 82, "Help")));
 336     ac = 0;
 337     XtSetArg (al[ac], XmNsubMenuId, help_pane);  ac++;
 338     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 339     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 340     cascade = XmCreateCascadeButtonGadget(pPad->menu_bar, "Help", al, ac);
 341     XtAddCallback(cascade, XmNhelpCallback,(XtCallbackProc)HelpHelpCB, pPad);
 342     XtManageChild(cascade);
 343     free(mnemonic);
 344     XmStringFree(tmpStr);
 345
 346     ac = 0;
 347     XtSetArg(al[ac], XmNmenuHelpWidget, cascade); ac++;
 348     XtSetValues (pPad->menu_bar, al, ac);
 349
 350     /* -----> create "Overview" push button */
 351     mnemonic = strdup(((char *)GETMESSAGE(11, 83, "v")));
 352     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 84, "Overview")));
 353     ac = 0;
 354     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 355     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 356     WidgList[count++]= XmCreatePushButtonGadget(help_pane, "overview", al, ac );
 357     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 358                    (XtCallbackProc)HelpOverviewCB, (XtPointer) pPad);
 359     free(mnemonic);
 360     XmStringFree(tmpStr);
 361
 362     /* -----> craete Separator */
 363     ac = 0;
 364     WidgList[count++] = XmCreateSeparatorGadget (help_pane, "sep1", al, ac);
 365
 366     /* -----> create "Tasks" push button */
 367     mnemonic = strdup(((char *)GETMESSAGE(11, 85, "T")));
 368     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 86, "Tasks")));
 369     ac = 0;
 370     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 371     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 372     WidgList[count++]= XmCreatePushButtonGadget(help_pane, "tasks", al, ac );
 373     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 374                    (XtCallbackProc)HelpTasksCB, (XtPointer) pPad);
 375     free(mnemonic);
 376     XmStringFree(tmpStr);
 377
 378     /* -----> create "Table of Contents" push button */
 379     mnemonic = strdup(((char *)GETMESSAGE(11, 87, "C")));
 380     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 88, "Table of Contents")));
 381     ac = 0;
 382     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 383     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 384     WidgList[count++]= XmCreatePushButtonGadget(help_pane, "TOC", al, ac );
 385     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 386                    (XtCallbackProc)HelpTOCCB, (XtPointer) pPad);
 387     free(mnemonic);
 388     XmStringFree(tmpStr);
 389
 390     /* -----> create "Reference" push button */
 391     mnemonic = strdup(((char *)GETMESSAGE(11, 89, "R")));
 392     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 90, "Reference")));
 393     ac = 0;
 394     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 395     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 396     WidgList[count++]= XmCreatePushButtonGadget(help_pane, "reference", al, ac );
 397     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 398                    (XtCallbackProc)HelpReferenceCB, (XtPointer) pPad);
 399     free(mnemonic);
 400     XmStringFree(tmpStr);
 401
 402     /* -----> create "On Item" push button */
 403     mnemonic = strdup(((char *)GETMESSAGE(11, 91, "O")));
 404     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 92, "On Item")));
 405     ac = 0;
 406     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 407     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 408     WidgList[count++]= XmCreatePushButtonGadget(help_pane, "onItem", al, ac );
 409     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 410                    (XtCallbackProc)HelpOnItemCB, (XtPointer) pPad);
 411     free(mnemonic);
 412     XmStringFree(tmpStr);
 413
 414     /* -----> create Separator*/
 415     ac = 0;
 416     WidgList[count++] = XmCreateSeparatorGadget (help_pane, "sep2", al, ac);
 417
 418     /* -----> create "Using Help" push button */
 419     mnemonic = strdup(((char *)GETMESSAGE(11, 93, "U")));
 420     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 94, "Using Help")));
 421     ac = 0;
 422     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 423     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 424     WidgList[count++]= XmCreatePushButtonGadget(help_pane, "usingHelp", al, ac );
 425     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 426                    (XtCallbackProc)HelpUsingHelpCB, (XtPointer) pPad);
 427     free(mnemonic);
 428     XmStringFree(tmpStr);
 429
 430     /* -----> create Separator */
 431     ac = 0;
 432     WidgList[count++] = XmCreateSeparatorGadget (help_pane, "sep3", al, ac);
 433
 434     /* -----> create "About Text Editor" push button */
 435     mnemonic = strdup(((char *)GETMESSAGE(11, 95, "A")));
 436     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 96, "About Text Editor")));
 437     ac = 0;
 438     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 439     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 440     WidgList[count++]= XmCreatePushButtonGadget(help_pane, "about", al, ac );
 441     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 442                    (XtCallbackProc)HelpAboutCB, (XtPointer) pPad);
 443     free(mnemonic);
 444     XmStringFree(tmpStr);
 445
 446     XtManageChildren(WidgList, count);
 447 }
 448
 449
 450 /************************************************************************
 451  * CreateFileMenu - Create the "File" pulldown menu
 452  *
 453  *      New
 454  *      Open...
 455  *      Include...
 456  *      ----------
 457  *      Save            or [Save (needed)]
 458  *      Save As...
 459  *      Print...
 460  *      ----------
 461  *      Close
 462  *
 463  ************************************************************************/
 464 static void
 465 CreateFileMenu(
 466         Editor *pPad)
 467 {
 468     Widget file_pane, cascade, WidgList[12];
 469     Arg al[10];
 470     int ac, count = 0;
 471     char      *mnemonic;
 472     XmString tmpStr;
 473     FileWidgets *pWidg = &pPad->fileStuff.fileWidgets;
 474
 475     /* -----> create "File" PulldownMenu */
 476     ac = 0;
 477     file_pane = XmCreatePulldownMenu (pPad->menu_bar, "fileMenu", al, ac);
 478     XtAddCallback(file_pane, XmNhelpCallback,
 479                   (XtCallbackProc)HelpFileCB, pPad);
 480     mnemonic = strdup(((char *)GETMESSAGE(11, 15, "F")));
 481     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 16, "File")));
 482     ac = 0;
 483     XtSetArg (al[ac], XmNsubMenuId, file_pane);  ac++;
 484     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 485     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 486     cascade = XmCreateCascadeButtonGadget (pPad->menu_bar, "File", al, ac);
 487     XtAddCallback (cascade, XmNcascadingCallback,
 488                    (XtCallbackProc)FileCascadingCB, (XtPointer) pPad);
 489     XtAddCallback(cascade, XmNhelpCallback, (XtCallbackProc)HelpFileCB, pPad);
 490     XtManageChild (cascade);
 491     free(mnemonic);
 492     XmStringFree(tmpStr);
 493
 494     /* -----> create "New" push button */
 495     mnemonic = strdup(((char *)GETMESSAGE(11, 17, "N")));
 496     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 18, "New")));
 497     ac = 0;
 498     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 499     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 500     WidgList[count++] = XmCreatePushButtonGadget (file_pane, "new", al, ac);
 501     pWidg->newBtn = WidgList[count-1];
 502     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 503                    (XtCallbackProc)FileNewCB, (XtPointer) pPad);
 504     free(mnemonic);
 505     XmStringFree(tmpStr);
 506
 507     /* -----> create "Open..." push button */
 508     mnemonic = strdup(((char *)GETMESSAGE(11, 19, "O")));
 509     tmpStr=XmStringCreateLocalized(((char *)GETMESSAGE(11, 20, "Open...")));
 510     ac = 0;
 511     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 512     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 513     WidgList[count++] = XmCreatePushButtonGadget (file_pane, "open", al, ac);
 514     pWidg->openBtn = WidgList[count - 1];
 515     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 516                    (XtCallbackProc) FileOpenCB, (XtPointer) pPad);
 517     free(mnemonic);
 518     XmStringFree(tmpStr);
 519
 520     /* -----> create "Include..." push button */
 521     mnemonic = strdup(((char *)GETMESSAGE(11, 21, "I")));
 522     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 22, "Include...")));
 523     ac = 0;
 524     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 525     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 526     WidgList[count++] = XmCreatePushButtonGadget (file_pane, "include", al, ac);
 527     pWidg->includeBtn = WidgList[count - 1];
 528     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 529                    (XtCallbackProc) FileIncludeCB, (XtPointer) pPad);
 530     free(mnemonic);
 531     XmStringFree(tmpStr);
 532
 533     /* -----> create save/print separator */
 534     ac = 0;
 535     WidgList[count++] = XmCreateSeparatorGadget (file_pane, "SvSp", al, ac);
 536
 537     /* -----> create "Save" push button */
 538     mnemonic = strdup(((char *)GETMESSAGE(11, 23, "S")));
 539     /* Note: The "Save" label is set in FileCascadingCB() when the File menu
 540      *       is displayed based on whether or not there are unsaved changes */
 541     pPad->fileStuff.saveBtnLabel =
 542       XmStringCreateLocalized(((char *)GETMESSAGE(11, 24, "Save")));
 543     pPad->fileStuff.saveNeededBtnLabel =
 544       XmStringCreateLocalized(((char *)GETMESSAGE(11, 73, "Save (needed)")));
 545     ac = 0;
 546     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 547     WidgList[count++] = XmCreatePushButtonGadget (file_pane, "save", al, ac);
 548     pWidg->saveBtn = WidgList[count - 1];
 549     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 550                    (XtCallbackProc) FileSaveCB, (XtPointer) pPad);
 551     free(mnemonic);
 552
 553     /* -----> create "Save As..." push button
 554      *        (its label/mnemonic are set later in SetSaveAsLabelAndDialog()
 555      *        based on xrdb.nameChange) */
 556     ac = 0;
 557     WidgList[count++] = XmCreatePushButtonGadget (file_pane, "saveAs", al, ac);
 558     pWidg->saveAsBtn = WidgList[count - 1];
 559     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 560                    (XtCallbackProc) FileSaveAsCB, (XtPointer) pPad);
 561
 562     /* -----> create "Print..." push button */
 563     mnemonic = strdup(((char *)GETMESSAGE(11, 27, "P")));
 564     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 28, "Print...")));
 565     ac = 0;
 566     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 567     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 568     WidgList[count++] = XmCreatePushButtonGadget (file_pane, "print", al, ac);
 569     pWidg->printBtn = WidgList[count - 1];
 570     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 571                    (XtCallbackProc) FileXpPrintCB, (XtPointer) pPad);
 572     free(mnemonic);
 573     XmStringFree(tmpStr);
 574
 575     /* -----> create close/exit separator */
 576     ac = 0;
 577     WidgList[count++] = XmCreateSeparatorGadget (file_pane, "ExSp", al, ac);
 578
 579     /* -----> create "Close" (Exit) push button */
 580     mnemonic = strdup(((char *)GETMESSAGE(11, 29, "C")));
 581     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 30, "Close")));
 582     ac = 0;
 583     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 584     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 585     WidgList[count++] = XmCreatePushButtonGadget (file_pane, "close", al, ac);
 586     pPad->ExitWid = WidgList[count-1];
 587     pWidg->exitBtn = WidgList[count - 1];
 588     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 589                    (XtCallbackProc) FileExitCB, (XtPointer) pPad);
 590     free(mnemonic);
 591     XmStringFree(tmpStr);
 592
 593     /* -----> manage the all "File" menu buttons */
 594     XtManageChildren(WidgList, count);
 595 }
 596
 597
 598 /************************************************************************
 599  * CreateEditMenu - Create the "Edit" pulldown menu
 600  *
 601  *      Undo
 602  *      ----------
 603  *      Cut
 604  *      Copy
 605  *      Paste
 606  *      Clear
 607  *      Delete
 608  *      Select All
 609  *      ----------
 610  *      Find/Change...
 611  *      Check Spellilng...
 612  *
 613  ************************************************************************/
 614 static void
 615 CreateEditMenu(
 616         Editor *pPad)
 617 {
 618     Widget edit_pane, cascade, WidgList[12];
 619     Arg al[10];
 620     int ac, count = 0;
 621     char *mnemonic;
 622     XmString tmpStr;
 623     EditWidgets *pWidg = &pPad->editStuff.widgets;
 624
 625     /* -----> create "Edit" PulldownMenu */
 626     ac = 0;
 627     edit_pane = XmCreatePulldownMenu (pPad->menu_bar, "editMenu", al, ac);
 628     XtAddCallback(edit_pane, XmNhelpCallback,
 629                   (XtCallbackProc)HelpEditCB, pPad);
 630     mnemonic = strdup(((char *)GETMESSAGE(11, 31, "E")));
 631     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 32, "Edit")));
 632     ac = 0;
 633     XtSetArg(al[ac], XmNsubMenuId, edit_pane); ac++;
 634     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 635     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 636     cascade= XmCreateCascadeButtonGadget(pPad->menu_bar, "Edit", al, ac);
 637     XtAddCallback(cascade, XmNhelpCallback,(XtCallbackProc)HelpEditCB, pPad);
 638     XtManageChild(cascade);
 639     free(mnemonic);
 640     XmStringFree(tmpStr);
 641
 642     /* -----> create "Undo" push button */
 643     mnemonic = strdup(((char *)GETMESSAGE(11, 33, "U")));
 644     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 34, "Undo")));
 645     ac = 0;
 646     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 647     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 648     WidgList[count++] = XmCreatePushButtonGadget(edit_pane, "undo", al, ac);
 649     pWidg->undoBtn = WidgList[count - 1];
 650     XtAddCallback(WidgList[count-1], XmNactivateCallback,
 651                   (XtCallbackProc) EditUndoCB, (XtPointer) pPad);
 652     free(mnemonic);
 653     XmStringFree(tmpStr);
 654
 655     /* -----> create undo separator */
 656     ac = 0;
 657     WidgList[count++] = XmCreateSeparatorGadget(edit_pane, "CtSp", al, ac);
 658
 659     /* -----> create "Cut" push button */
 660     mnemonic = strdup(((char *)GETMESSAGE(11, 35, "t")));
 661     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 36, "Cut")));
 662     ac = 0;
 663     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 664     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 665     WidgList[count++] = XmCreatePushButtonGadget(edit_pane, "cut", al, ac);
 666     pWidg->cutBtn = WidgList[count - 1];
 667     XtAddCallback(WidgList[count-1], XmNactivateCallback,
 668                   (XtCallbackProc) EditCutCB, (XtPointer) pPad);
 669     free(mnemonic);
 670     XmStringFree(tmpStr);
 671
 672     /* -----> create "Copy" push button */
 673     mnemonic = strdup(((char *)GETMESSAGE(11, 37, "C")));
 674     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 38, "Copy")));
 675     ac = 0;
 676     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 677     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 678     WidgList[count++] = XmCreatePushButtonGadget(edit_pane, "copy", al, ac);
 679     pWidg->copyBtn = WidgList[count - 1];
 680     XtAddCallback(WidgList[count-1], XmNactivateCallback,
 681                   (XtCallbackProc) EditCopyCB, (XtPointer) pPad);
 682     free(mnemonic);
 683     XmStringFree(tmpStr);
 684
 685     /* -----> create "Paste" push button */
 686     mnemonic = strdup(((char *)GETMESSAGE(11, 39, "P")));
 687     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 40, "Paste")));
 688     ac = 0;
 689     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 690     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 691     WidgList[count++] = XmCreatePushButtonGadget(edit_pane, "paste", al, ac);
 692     pWidg->pasteBtn = WidgList[count - 1];
 693     XtAddCallback(WidgList[count-1], XmNactivateCallback,
 694                   (XtCallbackProc) EditPasteCB, (XtPointer) pPad);
 695     free(mnemonic);
 696     XmStringFree(tmpStr);
 697
 698     /* -----> create "Clear" push button */
 699     mnemonic = strdup(((char *)GETMESSAGE(11, 41, "e")));
 700     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 42, "Clear")));
 701     ac = 0;
 702     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 703     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 704     WidgList[count++] = XmCreatePushButtonGadget(edit_pane, "clear", al, ac);
 705     pWidg->clearBtn = WidgList[count - 1];
 706     XtAddCallback(WidgList[count-1], XmNactivateCallback,
 707                   (XtCallbackProc) EditClearCB, (XtPointer) pPad);
 708     free(mnemonic);
 709     XmStringFree(tmpStr);
 710
 711     /* -----> create "Delete" push button */
 712     mnemonic = strdup(((char *)GETMESSAGE(11, 43, "D")));
 713     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 44,"Delete")));
 714     ac = 0;
 715     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 716     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 717     WidgList[count++] = XmCreatePushButtonGadget (edit_pane, "delete", al, ac);
 718     pWidg->deleteBtn = WidgList[count - 1];
 719     XtAddCallback(WidgList[count-1], XmNactivateCallback,
 720                   (XtCallbackProc) EditDeleteCB, (XtPointer) pPad);
 721     free(mnemonic);
 722     XmStringFree(tmpStr);
 723
 724     /* -----> XXX - create "Select All" push button */
 725     mnemonic = strdup(((char *)GETMESSAGE(11, 101, "S")));
 726     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 102, "Select All")));
 727     ac = 0;
 728     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 729     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 730     WidgList[count++] = XmCreatePushButtonGadget(edit_pane, "selectAll", al, ac);
 731     pWidg->selectAllBtn = WidgList[count - 1];
 732     XtAddCallback(WidgList[count-1], XmNactivateCallback,
 733                   (XtCallbackProc) SelectAllCB, (XtPointer) pPad);
 734     free(mnemonic);
 735     XmStringFree(tmpStr);
 736
 737     /* -----> create find/change separator */
 738     ac = 0;
 739     WidgList[count++] = XmCreateSeparatorGadget (edit_pane, "FSSp", al, ac);
 740
 741     /* -----> create "Find/Change" push button */
 742     mnemonic = strdup(((char *)GETMESSAGE(11, 103, "F")));
 743     tmpStr =XmStringCreateLocalized(((char *)GETMESSAGE(11, 104,"Find/Change...")));
 744     ac = 0;
 745     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 746     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 747     WidgList[count++] =
 748                 XmCreatePushButtonGadget(edit_pane, "findChange", al, ac);
 749     pWidg->findChangeBtn = WidgList[count - 1];
 750     XtAddCallback(WidgList[count-1], XmNactivateCallback,
 751                   (XtCallbackProc) FindChangeCB, (XtPointer) pPad);
 752     free(mnemonic);
 753     XmStringFree(tmpStr);
 754
 755     /* -----> create "Check Spelling" push button  */
 756     mnemonic = strdup(((char *)GETMESSAGE(11, 105, "k")));
 757     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 106, "Check Spelling...")));
 758     ac = 0;
 759     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 760     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 761     WidgList[count++] = XmCreatePushButtonGadget(edit_pane, "checkSpelling",
 762                                                      al, ac);
 763     pWidg->checkSpellingBtn = WidgList[count - 1];
 764     XtAddCallback(WidgList[count-1], XmNactivateCallback,
 765                       (XtCallbackProc) CheckSpellingCB, (XtPointer) pPad);
 766     free(mnemonic);
 767     XmStringFree(tmpStr);
 768
 769     /* -----> manage all the "Edit" menu buttons */
 770     XtManageChildren(WidgList, count);
 771 }
 772
 773
 774 /************************************************************************
 775  * CreateFormatMenu - Create the "Format" pulldown menu
 776  *
 777  *      Settings...
 778  *      Paragraph
 779  *      All
 780  *
 781  ************************************************************************/
 782 static void
 783 CreateFormatMenu(
 784         Editor *pPad)
 785 {
 786     Widget format_pane, cascade, WidgList[12];
 787     Arg al[10];
 788     int ac, count = 0;
 789     char *mnemonic;
 790     XmString tmpStr;
 791
 792     /* -----> create "Format" PulldownMenu */
 793     ac = 0;
 794     format_pane = XmCreatePulldownMenu (pPad->menu_bar, "formatMenu", al, ac);
 795     XtAddCallback(format_pane, XmNhelpCallback,
 796                   (XtCallbackProc)HelpFormatCB, pPad);
 797     mnemonic = strdup(((char *)GETMESSAGE(11, 51, "r")));
 798     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 52, "Format")));
 799     ac = 0;
 800     XtSetArg (al[ac], XmNsubMenuId, format_pane);  ac++;
 801     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 802     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 803     cascade= XmCreateCascadeButtonGadget (pPad->menu_bar, "format", al, ac);
 804     XtAddCallback(cascade, XmNhelpCallback,(XtCallbackProc)HelpFormatCB, pPad);
 805     pPad->formatStuff.widgets.formatBtn = cascade;
 806     XtManageChild (cascade);
 807     free(mnemonic);
 808     XmStringFree(tmpStr);
 809
 810     /* -----> create "Settings..." button */
 811     mnemonic = strdup(((char *)GETMESSAGE(11, 53, "S")));
 812     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 54, "Settings...")));
 813     ac = 0;
 814     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 815     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 816     WidgList[count++] =
 817                    XmCreatePushButtonGadget (format_pane, "settings", al, ac);
 818     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 819                    (XtCallbackProc) FormatCB, (XtPointer) pPad);
 820     free(mnemonic);
 821     XmStringFree(tmpStr);
 822
 823     /* -----> create "Paragraph" button */
 824     mnemonic = strdup(((char *)GETMESSAGE(11, 55, "P")));
 825     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 56, "Paragraph")));
 826     ac = 0;
 827     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 828     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 829     WidgList[count++] =
 830                   XmCreatePushButtonGadget (format_pane, "paragraph", al, ac);
 831     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 832                    (XtCallbackProc) FormatParaCB, (XtPointer) pPad);
 833     free(mnemonic);
 834     XmStringFree(tmpStr);
 835
 836     /* -----> create "All" button */
 837     mnemonic = strdup(((char *)GETMESSAGE(11, 57, "l")));
 838     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 58, "All")));
 839     ac = 0;
 840     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 841     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 842     WidgList[count++] = XmCreatePushButtonGadget (format_pane, "all", al, ac);
 843     XtAddCallback (WidgList[count-1], XmNactivateCallback,
 844                    (XtCallbackProc) FormatAllCB, (XtPointer) pPad);
 845     free(mnemonic);
 846     XmStringFree(tmpStr);
 847
 848     /* -----> manage the all "Format" menu buttons */
 849     XtManageChildren(WidgList, count);
 850 }
 851
 852
 853 /************************************************************************
 854  * CreateOptionsMenu - Create the "Options" pulldown menu
 855  *
 856  *      Overstrike
 857  *      Wrap To Fit
 858  *      Status Line
 859  *
 860  ************************************************************************/
 861 static void
 862 CreateOptionsMenu(
 863         Editor *pPad)
 864 {
 865     Widget options_pane, cascade, WidgList[12];
 866     Arg al[10];
 867     int ac, count = 0;
 868     char *mnemonic;
 869     XmString tmpStr;
 870     OptionsMenuWidgets *pWidg = &pPad->optionsStuff.widgets;
 871
 872     /* -----> create "Options" PulldownMenu */
 873     ac = 0;
 874     options_pane = XmCreatePulldownMenu (pPad->menu_bar, "optionsMenu", al, ac);
 875     XtAddCallback(options_pane, XmNhelpCallback,
 876                   (XtCallbackProc)HelpOptionsCB, pPad);
 877     mnemonic = strdup(((char *)GETMESSAGE(11, 59, "O")));
 878     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 60, "Options")));
 879     ac = 0;
 880     XtSetArg(al[ac], XmNsubMenuId, options_pane);  ac++;
 881     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 882     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 883     cascade= XmCreateCascadeButtonGadget (pPad->menu_bar, "options", al, ac);
 884     XtAddCallback(cascade, XmNhelpCallback,(XtCallbackProc)HelpOptionsCB, pPad);
 885     pPad->optionsStuff.widgets.optionsBtn = cascade;
 886     XtManageChild (cascade);
 887     free(mnemonic);
 888     XmStringFree(tmpStr);
 889
 890     /* -----> create "Overstrike" toggle button */
 891     mnemonic = strdup(((char *)GETMESSAGE(11, 61, "O")));
 892     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 62, "Overstrike")));
 893     ac = 0;
 894     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 895     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 896     XtSetArg(al[ac], XmNvisibleWhenOff, True); ac++;
 897     XtSetArg(al[ac], XmNset, pPad->xrdb.overstrike); ac++;
 898     WidgList[count++] = XmCreateToggleButton (options_pane, "overstrike", al, ac);
 899     pWidg->overstrikeBtn = WidgList[count - 1];
 900     XtAddCallback (WidgList[count-1], XmNvalueChangedCallback,
 901                    (XtCallbackProc) OverstrikeCB, (XtPointer) pPad);
 902     free(mnemonic);
 903     XmStringFree(tmpStr);
 904
 905     /* -----> create "Wrap To Fit" toggle button */
 906     mnemonic = strdup(((char *)GETMESSAGE(11, 111, "W")));
 907     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 112, "Wrap To Fit")));
 908     ac = 0;
 909     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 910     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 911     XtSetArg(al[ac], XmNvisibleWhenOff, True); ac++;
 912     XtSetArg(al[ac], XmNset, pPad->xrdb.wordWrap); ac++;
 913     WidgList[count++] = XmCreateToggleButton (options_pane, "wordWrap", al, ac);
 914     pWidg->wordWrapBtn = WidgList[count - 1];
 915     XtAddCallback (WidgList[count-1], XmNvalueChangedCallback,
 916                    (XtCallbackProc) WordWrapCB, (XtPointer) pPad);
 917     free(mnemonic);
 918     XmStringFree(tmpStr);
 919
 920     /* -----> create "Status Line" toggle button */
 921     mnemonic = strdup(((char *)GETMESSAGE(11, 65, "S")));
 922     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 66, "Status Line")));
 923     ac = 0;
 924     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
 925     XtSetArg(al[ac], XmNmnemonic, mnemonic[0]); ac++;
 926     XtSetArg(al[ac], XmNvisibleWhenOff, True); ac++;
 927     XtSetArg(al[ac], XmNset, pPad->xrdb.statusLine); ac++;
 928     WidgList[count++] = XmCreateToggleButton (options_pane, "statusLine", al, ac);
 929     pWidg->statusLineBtn = WidgList[count - 1];
 930     XtAddCallback (WidgList[count-1], XmNvalueChangedCallback,
 931                    (XtCallbackProc) StatusLineCB, (XtPointer) pPad);
 932     free(mnemonic);
 933     XmStringFree(tmpStr);
 934
 935     XtManageChildren(WidgList, count);
 936
 937 }
 938
 939
 940 /************************************************************************
 941  * CreateMenuBar - Create MenuBar in MainWindow
 942  *
 943  ************************************************************************/
 944 void
 945 CreateMenuBar( Editor *pPad )
 946 {
 947     pPad->menu_bar = XmCreateMenuBar (pPad->mainWindow, "bar", NULL, 0);
 948     XtAddCallback(pPad->menu_bar, XmNhelpCallback,
 949                   (XtCallbackProc)HelpMenubarCB, pPad);
 950
 951     CreateFileMenu(pPad);
 952     CreateEditMenu(pPad);
 953     CreateFormatMenu(pPad);
 954     CreateOptionsMenu(pPad);
 955     CreateHelpMenu(pPad);
 956 }
 957
 958
 959 /************************************************************************
 960  * CreateEditorWidget - creates the Dt Editor widget
 961  ************************************************************************/
 962 void
 963 CreateEditorWidget(
 964         Editor *pPad)
 965 {
 966     Widget parent = pPad->mainWindow;
 967     Arg al[10];         /* arg list */
 968     register int ac;    /* arg count */
 969     Pixel background, foreground, top_shadow, bottom_shadow, selectColor;
 970     Colormap colormap;
 971     XmString dialogTitleStr = XmStringCreateLocalized(DialogTitle(pPad));
 972
 973     /* create the DtEditor widget */
 974     ac = 0;
 975     XtSetArg(al[ac], DtNrows, DEFAULT_ROWS);  ac++;
 976     XtSetArg(al[ac], DtNcolumns, DEFAULT_COLS);  ac++;
 977     XtSetArg(al[ac], DtNdialogTitle, dialogTitleStr);  ac++;
 978     pPad->editor = DtCreateEditor(parent, "editor", al, ac);
 979     XmStringFree(dialogTitleStr);
 980
 981     /* add the DtEditor callbacks */
 982     XtAddCallback(pPad->editor, XmNhelpCallback,
 983                    (XtCallbackProc) HelpEditorWidgetCB,
 984                    (XtPointer) pPad);
 985     XtAddCallback(pPad->editor, DtNtextSelectCallback,
 986                    (XtCallbackProc) TextSelectedCB,
 987                    (XtPointer) pPad);
 988     XtAddCallback(pPad->editor, DtNtextDeselectCallback,
 989                    (XtCallbackProc) TextDeselectedCB,
 990                    (XtPointer) pPad);
 991
 992     /* get id of status line text field widget */
 993     pPad->statusLineMsg = DtEditorGetMessageTextFieldID(pPad->editor);
 994
 995 }
 996
 997
 998 /************************************************************************
 999  * FindOrCreatePad - finds an unused entry in the list of Editors or,
1000  *      if none can be found, creates a new entry with some defaults
1001  *      obtain from the last entry that was created.
1002  *
1003  *      Returns True if an existing, unused entry is "reused" or False
1004  *      if a new entry is created.  Also updates the current entry
1005  *      (whose address is passed as a parameter) to point to the
1006  *      found/created entry.
1007  *
1008  *       Note:  The first entry in the list of Editors is created by
1009  *              CreatedFirstPad().  This routine is used to create
1010  *              all subsequent entries.
1011  *
1012  ************************************************************************/
1013 Boolean
1014 FindOrCreatePad(
1015     Editor **ppPad)
1016 {
1017     Boolean foundPad = False;
1018     Editor *pPad;
1019     Arg al[10];
1020     register int ac;
1021
1022     /* -----> Reuse unused entries (corresponding to closed editor windows)
1023      *        before creating new ones. */
1024     for (pPad = pPadList; pPad != (Editor *)NULL; pPad = pPad->pNextPad){
1025         if (pPad->inUse == False) {
1026             pPad->inUse = True;
1027             foundPad = True;
1028             numActivePads++;
1029             break;
1030         }
1031     }
1032
1033     /* -----> Create a new entry if an unused one can not be found. */
1034     if (foundPad == False) {
1035         int argc_l, i;
1036         char **argv_l, **c_argv_l;
1037         char *pProgName;
1038         Display *display;
1039         unsigned short group_id,
1040                        user_id;
1041
1042         /* -----> Save some defaults from the last entry that was created. */
1043         Boolean exitOnLastClose = pPadList->xrdb.exitOnLastClose;
1044         pProgName = pPadList->progname;
1045         group_id = pPadList->group_id;
1046         user_id = pPadList->user_id;
1047         display = pPadList->display;
1048
1049         /* -----> Create a new entry and point pPad and the global, pPadList
1050          *        to it. */
1051         CreatePad(&pPad);
1052         pPad->inUse = True;
1053
1054         /* -----> Set some defaults from the last entry that was created. */
1055         pPad->display = display;
1056         pPad->progname = pProgName;
1057         pPad->group_id = group_id;
1058         pPad->user_id = user_id;
1059         pPad->xrdb.exitOnLastClose = exitOnLastClose;
1060
1061         /* -----> Create the application shell for the new Editor entry. */
1062         ac = 0;
1063         XtSetArg(al[ac], XmNargv, &argv_l); ac++;
1064         XtSetArg(al[ac], XmNargc, &argc_l); ac++;
1065         XtGetValues(topLevelWithWmCommand, al, ac);
1066
1067         c_argv_l = (char **) XtMalloc(argc_l * sizeof(char*));
1068         for (i=0; i<argc_l; i++)
1069           c_argv_l[i] = strdup(argv_l[i]);
1070
1071         ac = 0;
1072         XtSetArg(al[ac], XmNargv, argv_l); ac++;
1073         XtSetArg(al[ac], XmNargc, argc_l); ac++;
1074         pPad->app_shell = XtAppCreateShell(pPad->progname, DTPAD_CLASS_NAME,
1075                                            applicationShellWidgetClass,
1076                                            pPad->display, al, ac);
1077         pPad->app_context = XtWidgetToApplicationContext(pPad->app_shell);
1078
1079         /* -----> Set all resources to initial server values */
1080         RestoreInitialServerResources(pPad);
1081
1082     }
1083
1084     /* -----> update the pointer to the current entry and return whether or
1085      *        not an existing entry was reused */
1086     *ppPad = pPad;
1087     return foundPad;
1088 }
1089
1090
1091 /************************************************************************
1092  * SetWorkSpaceHints -
1093  *
1094  ************************************************************************/
1095 void
1096 SetWorkSpaceHints(
1097         Widget shell,
1098         char *workspaces )
1099 {
1100   char * ptr;
1101   Atom * workspace_atoms = NULL;
1102   int num_workspaces=0;
1103
1104   if (workspaces)
1105   {
1106     do
1107     {
1108       ptr = MbStrchr (workspaces, ' ');
1109
1110       if (ptr != NULL) *ptr = NULL;
1111
1112       workspace_atoms = (Atom *) XtRealloc ((char *)workspace_atoms,
1113                         sizeof (Atom) * (num_workspaces + 1));
1114       workspace_atoms[num_workspaces] =
1115                            XmInternAtom (XtDisplay(shell), workspaces, True);
1116
1117       num_workspaces++;
1118
1119       if (ptr != NULL)
1120       {
1121         *ptr = ' ';
1122         workspaces = ptr + 1;
1123       }
1124     } while (ptr != NULL);
1125
1126     DtWsmSetWorkspacesOccupied(XtDisplay(shell), XtWindow (shell),
1127                         workspace_atoms, num_workspaces);
1128
1129     XtFree ((char *) workspace_atoms);
1130     workspace_atoms = NULL;
1131   }
1132   else
1133   {
1134      Window   rootWindow;
1135      Atom     pCurrent;
1136      Screen   *currentScreen;
1137      int      screen;
1138      char     *workspace_name;
1139
1140      screen = XDefaultScreen(XtDisplay(shell));
1141      currentScreen = XScreenOfDisplay(XtDisplay(shell), screen);
1142      rootWindow = RootWindowOfScreen(currentScreen);
1143
1144      if(DtWsmGetCurrentWorkspace(XtDisplay(shell), rootWindow,
1145                                                       &pCurrent) == Success)
1146      {
1147         DtWsmSetWorkspacesOccupied(XtDisplay(shell), XtWindow (shell),
1148                                 &pCurrent, 1);
1149      }
1150   }
1151 }
1152
1153
1154 /************************************************************************
1155  * ClearStatusMessage - clears the message (XmTextField) portion of the
1156  *      DtEditor widget's status line.
1157  ************************************************************************/
1158 /* ARGSUSED */
1159 void
1160 ClearStatusMessage(
1161         Editor *pPad)
1162 {
1163     XmTextFieldSetString(pPad->statusLineMsg, "");
1164 }
1165
1166
1167 /************************************************************************
1168  * SetStatusMessage - sets the message (XmTextField) portion of the
1169  *      DtEditor widget's status line to the specified string.
1170  ************************************************************************/
1171 /* ARGSUSED */
1172 void
1173 SetStatusMessage(
1174         Editor *pPad,
1175         char *str)
1176 {
1177     XmTextFieldSetString(pPad->statusLineMsg, str);
1178 }
1179
1180
1181 #ifdef POPUP
1182 /*
1183  * CreatePopupMenu - Create popup menu in editor window
1184  */
1185
1186 void
1187 CreatePopupMenu( Editor *pPad )
1188 {
1189     Arg al[5];
1190     int ac;
1191     Widget popupCascade, popupBtns[10];
1192     Widget fileMenu, editMenu, optionMenu, helpMenu;
1193     XmString tmpStr;
1194     char *mnemonic;
1195     int i = 0;
1196
1197     pPad->popup = XmCreatePopupMenu(pPad->editor, "popupMenu", NULL, 0);
1198     XtAddEventHandler(parent, ButtonPressMask, False, PopupHandler,
1199                                                         (XtPointer)popupMenu);
1200
1201     /* Create text editor title */
1202     popupBtns[i] =
1203             (Widget)XmCreateLabelGadget(pPad->popup, "popupTitle", NULL, 0);
1204
1205
1206     /* Create title separators */
1207     popupBtns[i++] = XmCreateSeparatorGadget(pPad->popup, "sep2", NULL, 0);
1208
1209     fileMenu = XmCreatePulldownMenu (pPad->popup, "fileMenu", NULL, 0);
1210
1211     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 16, "File")));
1212     mnemonic = strdup(((char *)GETMESSAGE(11, 15, "F")));
1213
1214     ac = 0;
1215     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
1216     XtSetArg(al[ac], XmNsubMenuId, fileMenu); ac++;
1217     XtSetArg(al[ac], XmNmnemonic, mnemonic); ac++;
1218     popupBtns[i++] = XmCreateCascadeButtonGadget(pPad->popup, "File", al, ac);
1219     free(mnemonic);
1220     XmStringFree(tmpStr);
1221
1222     mnemonic = strdup(((char *)GETMESSAGE(11, 17, "N")));
1223     tmpStr = XmStringCreateLocalized(((char *)GETMESSAGE(11, 18, "New")));
1224     ac = 0;
1225     XtSetArg(al[ac], XmNlabelString, tmpStr); ac++;
1226     XtSetArg(al[ac], XmNmnemonic, mnemonic); ac++;
1227     popupBtns[i] = XmCreatePushButtonGadget(pPad->popup, "New", al, ac);
1228     XtAddCallback(button, XmNactivateCallback, callback, callData);
1229     XtAddCallback (popupBtns[i], XmNactivateCallback,
1230                    (XtCallbackProc)FileNewCB, (XtPointer) pPad);
1231     free(mnemonic);
1232     XmStringFree(tmpStr);
1233     i++;
1234
1235     CreateButton(fileMenu, "Open...", 'O', DisplayFsbCb, (XtPointer)LOAD_DATA);
1236     CreateButton(fileMenu, "Include...", 'I', DisplayFsbCb,
1237                                                         (XtPointer)INSERT_DATA);
1238     CreateButton(fileMenu, "Save As...", 'A', DisplayFsbCb, (XtPointer)SAVE_DATA
1239 );
1240     CreateButton(fileMenu, "New", 'N', ResetEditorCb, NULL);
1241
1242     editMenu = XmCreatePulldownMenu (popupMenu, "editMenu", NULL, 0);
1243     CreateCascade(popupMenu, "Edit", 'E', editMenu);
1244     CreateButton(editMenu, "Undo", 'U', UndoCb, (XtPointer)LOAD_DATA);
1245     ad.cutPopupButton = CreateButton(editMenu, "Cut", 't', CutCb, NULL);
1246     ad.copyPopupButton = CreateButton(editMenu, "Copy", 'C', CopyCb, NULL);
1247     CreateButton(editMenu, "Paste", 'P', PasteCb, NULL);
1248
1249     CreateButton(popupMenu, "Find/Change...", 'F', FindCb, (XtPointer)ad.editor)
1250 ;
1251
1252     return (popupMenu);
1253 }
1254
1255 static void PopupHandler(Widget w, XtPointer cd, XEvent *event, Boolean *ctd)
1256 {
1257     if (((XButtonEvent *)event)->button != Button3) return;
1258
1259     XmMenuPosition((Widget)cd, (XButtonEvent *)event);
1260     XtManageChild ((Widget)cd);
1261 }
1262 #endif