cde/programs/dtcalc/motif.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: motif.c /main/28 1998/07/21 16:17:00 samborn $ */
  24 /*
  25  * (c) Copyright 1997, The Open Group
  26  */
  27 /*                                                                      *
  28  *  motif.c                                                             *
  29  *   Contains the user interface portion of the Desktop                 *
  30  *   Calculator.                                                        *
  31  *                                                                      *
  32  * (c) Copyright 1993, 1994 Hewlett-Packard Company                     *
  33  * (c) Copyright 1993, 1994 International Business Machines Corp.       *
  34  * (c) Copyright 1993, 1994 Sun Microsystems, Inc.                      *
  35  * (c) Copyright 1993, 1994 Novell, Inc.                                *
  36  */
  37
  38 #include <stdio.h>
  39 #include <string.h>
  40 #include <stdlib.h>
  41 #include <unistd.h>
  42 #include <signal.h>
  43 #include <sys/param.h>
  44 #include <sys/stat.h>
  45 #include "calctool.h"
  46 #include <X11/Xlib.h>
  47 #include <X11/keysym.h>
  48 #include <X11/Xatom.h>
  49
  50 /*
  51   #include <wchar.h>
  52   #include <mbstr.h>
  53   */
  54
  55 /* #ifdef hpux */
  56 #ifdef HP_EXTENSIONS
  57 #include <X11/XHPlib.h>
  58 #include <X11/HPkeysym.h>
  59 #include <X11/Xutil.h>
  60 #endif
  61
  62 #include <Xm/XmP.h>
  63 #include <Xm/Xm.h>
  64 #include <Xm/DrawingA.h>
  65 #include <Xm/DrawingAP.h>
  66 #include <Xm/MessageB.h>
  67 #include <Xm/RowColumn.h>
  68 #include <Xm/MwmUtil.h>
  69 #include <Xm/ManagerP.h>
  70 #include <Xm/Text.h>
  71 #include <Xm/ColorObjP.h>
  72 #include <Xm/MainW.h>
  73 #include <Xm/MenuShell.h>
  74 #include <Xm/Form.h>
  75 #include <Xm/Frame.h>
  76 #include <Xm/PushBP.h>
  77 #include <Xm/PushBG.h>
  78 #include <Xm/CascadeB.h>
  79 #include <Xm/CascadeBG.h>
  80 #include <Xm/MwmUtil.h>
  81 #include <Xm/Protocols.h>
  82 #include <Xm/VendorSEP.h>
  83 /* Copied from BaseClassI.h */
  84 extern XmWidgetExtData _XmGetWidgetExtData(
  85                         Widget widget,
  86 #if NeedWidePrototypes
  87                         unsigned int extType) ;
  88 #else
  89                         unsigned char extType) ;
  90 #endif /* NeedWidePrototypes */
  91
  92 #include <X11/CoreP.h>
  93 #include <X11/Core.h>
  94 #include <X11/ShellP.h>
  95 #include <X11/Shell.h>
  96 #include <X11/IntrinsicP.h>
  97 #include <X11/Intrinsic.h>
  98 #include <X11/Shell.h>
  99 #include <X11/Xatom.h>
 100 #include <Xm/Protocols.h>
 101 #include <X11/keysymdef.h>
 102
 103 #include <Dt/Session.h>
 104 #include <Dt/Dt.h>
 105 #include <Dt/Connect.h>
 106 #include <Dt/FileM.h>
 107 #include <Dt/Indicator.h>
 108 #include <Dt/Lock.h>
 109 #include <Dt/Message.h>
 110 #include <Dt/Wsm.h>
 111 #include <Dt/CommandM.h>
 112 #include <Dt/EnvControlP.h>
 113
 114 #ifdef HAVE_EDITRES
 115 #include <X11/Xmu/Editres.h>
 116 #endif
 117
 118 #include "motif.h"
 119
 120 #include "ds_widget.h"
 121 #include "ds_common.h"
 122 #include "ds_popup.h"
 123 #include "ds_xlib.h"
 124
 125 Boolean colorSrv;
 126
 127 static XtResource resources[] =
 128 {
 129    {
 130      "postMenuBar", "PostMenuBar", XmRBoolean, sizeof (Boolean),
 131      XtOffset (ApplicationArgsPtr, menuBar), XmRImmediate, (XtPointer) True,
 132    },
 133
 134    {
 135      "accuracy", "Accuracy", XmRInt, sizeof (int),
 136      XtOffset (ApplicationArgsPtr, accuracy), XmRImmediate, (XtPointer) 2,
 137    },
 138
 139    {
 140      "base", "Base", XmRString, sizeof (char *),
 141      XtOffset (ApplicationArgsPtr, base), XmRImmediate, (XtPointer) "decimal",
 142    },
 143
 144    {
 145      "displayNotation", "DisplayNotation", XmRString, sizeof (char *),
 146      XtOffset (ApplicationArgsPtr, display), XmRImmediate, (XtPointer) "fixed",
 147    },
 148
 149    {
 150      "mode", "Mode", XmRString, sizeof (char *),
 151      XtOffset (ApplicationArgsPtr, mode), XmRImmediate, (XtPointer)"scientific",
 152    },
 153
 154    {
 155      "trigType", "TrigType", XmRString, sizeof (char *),
 156      XtOffset (ApplicationArgsPtr, trigType), XmRImmediate,
 157      (XtPointer)"degrees",
 158    },
 159 };
 160
 161 char DTCALC_CLASS_NAME[] = "Dtcalc";
 162
 163 extern char *opts[] ;           /* Command line option strings. */
 164
 165 Widget modeArry[3];
 166 XmPixelSet    pixels[XmCO_MAX_NUM_COLORS];
 167 Pixel white_pixel;
 168 Pixel black_pixel;
 169 Boolean BlackWhite = False;
 170
 171 char * dt_path = NULL;
 172
 173 static Widget funBtn = NULL;
 174 static Widget constBtn = NULL;
 175 static Widget accBtn = NULL;
 176 static Widget stoBtn = NULL;
 177 static Widget rclBtn = NULL;
 178 static Widget exchBtn = NULL;
 179
 180 static Atom saveatom ;
 181 static Atom command_atom ;
 182 static Atom wm_state_atom;
 183
 184 Boolean ignore_event = False;
 185 XtIntervalId timerId = NULL;
 186
 187 static int lastArmed[10];
 188 static int countArmed = 0;
 189
 190 /*  Structure used on a save session to see if a dt is iconic  */
 191 typedef struct
 192 {
 193    int state;
 194    Window icon;
 195 } WM_STATE;
 196
 197 void menu_proc        P((Widget, XtPointer, XtPointer)) ;
 198 void show_ascii       P((Widget, XtPointer, XtPointer)) ;
 199 void write_cf_value   P((Widget, XtPointer, XtPointer)) ;
 200 void close_cf         P((Widget, XtPointer, XtPointer)) ;
 201 void close_ascii      P((Widget, XtPointer, XtPointer)) ;
 202 void move_cf          P((Widget, XtPointer, XtPointer)) ;
 203 void FocusInCB        P((Widget, XtPointer, XtPointer)) ;
 204 void map_popup        P((Widget, XtPointer, XtPointer)) ;
 205
 206 /* #ifdef hpux */
 207 #ifdef HP_EXTENSIONS
 208 static int GetKeyboardID           P(()) ;
 209 #endif
 210
 211 static int event_is_keypad         P((XEvent *)) ;
 212 static int get_next_event          P((Widget, int, XEvent *)) ;
 213 static int is_window_showing       P((Widget)) ;
 214
 215 static KeySym keypad_keysym        P((XEvent *)) ;
 216
 217 static void modelineValueChanged   P((Widget, XtPointer, XtPointer)) ;
 218 static void dtcalc_kkeyboard_create   P((Widget)) ;
 219 static void dtcalc_kpanel_create      P((Widget)) ;
 220 static void confirm_callback     P((Widget, XtPointer, XtPointer)) ;
 221 static void create_cfframe       P(()) ;
 222 static void create_menu          P((enum menu_type, Widget, int)) ;
 223 static void do_button            P((Widget, XtPointer, XtPointer)) ;
 224 static void do_confirm_notice    P((Widget, char *)) ;
 225 static void do_continue_notice   P((Widget, char *)) ;
 226 static void close_reg            P((Widget, XtPointer, XtPointer)) ;
 227 static void event_proc           P((Widget, XtPointer, XEvent *, Boolean *)) ;
 228 static void frame_interpose      P((Widget, XtPointer, XEvent *, Boolean *)) ;
 229 static void menu_handler         P((Widget, XtPointer, XEvent *, Boolean *)) ;
 230 static void popupHandler         P((Widget, XtPointer, XEvent *, Boolean *)) ;
 231 static void make_mode_frame      P((enum mode_type)) ;
 232 static void new_cf_value         P((Widget, XtPointer, XtPointer)) ;
 233 static void do_memory            P((Widget, XtPointer, XtPointer)) ;
 234 static void switch_mode          P((enum mode_type)) ;
 235 static void update_cf_value      P(()) ;
 236 static void xerror_interpose     P((Display *, XErrorEvent *)) ;
 237
 238 static Widget button_create      P((Widget, int, int, int, int)) ;
 239 static void save_state           P((Widget, XtPointer, XtPointer)) ;
 240 static void SaveSession          P(( char *, char * )) ;
 241 static void setCalcHints         P(()) ;
 242
 243 static char * _DtcalcStripSpaces P(( char * )) ;
 244
 245 static void ProcessMotifSelection(Widget);
 246
 247 extern char **environ ;
 248
 249 extern char *base_str[] ;       /* Strings for each base value. */
 250 extern char *calc_res[] ;       /* Calctool X resources. */
 251 extern char *dtype_str[] ;      /* Strings for each display mode value. */
 252 extern char *lstrs[] ;          /* Labels for various Motif items. */
 253 extern char *mess[] ;           /* Message strings. */
 254 extern char *mode_str[] ;       /* Strings for each mode value. */
 255 extern char *pstrs[] ;          /* Property sheet strings. */
 256 extern char *ttype_str[] ;      /* Strings for each trig type value. */
 257 extern char *vstrs[] ;          /* Various strings. */
 258
 259 extern struct button buttons[] ;           /* Calculator button values. */
 260 extern struct button mode_buttons[] ;      /* Calculator mode button values. */
 261 extern struct menu cmenus[] ;              /* Calculator menus. */
 262 extern struct menu_entry menu_entries[] ;  /* All the menu strings. */
 263
 264 extern Vars v ;                 /* Calctool variables and options. */
 265
 266 char translations_return[] = "<Key>Return:ManagerGadgetSelect()";
 267 static Boolean NoDisplay=False;
 268
 269 int
 270 main(argc, argv)
 271 int argc ;
 272 char **argv ;
 273 {
 274   char bind_home[MAXPATHLEN], **new_environ ;
 275   Pixmap pixmap;
 276   int i, j ;
 277
 278   XtSetLanguageProc(NULL, NULL, NULL);
 279   _DtEnvControl(DT_ENV_SET);
 280   signal (SIGHUP, SIG_IGN);
 281 #ifdef __osf__
 282   signal (SIGFPE, SIG_IGN);
 283 #endif /* __osf__ */
 284
 285   X       = (XVars) LINT_CAST(calloc(1, sizeof(XObject))) ;
 286   X->home = getenv("HOME") ;
 287
 288   X->kframe = XtVaAppInitialize (&X->app,
 289                                  DTCALC_CLASS_NAME,     /* app class */
 290                                  NULL,                  /* options list */
 291                                  0,                     /* num options */
 292                                  &argc,
 293                                  argv,
 294                                  NULL,                  /* fallback resources */
 295                                  XtNiconName,   "dtcalc",
 296                                  XtNiconPixmap, X->icon,
 297                                  XtNiconMask,   X->iconmask,
 298                                  NULL) ;
 299
 300   X->dpy = XtDisplay (X->kframe);
 301
 302   if (!X->dpy)
 303     {
 304       char *msg, *tmpStr;
 305
 306       tmpStr = GETMESSAGE(2, 31, "Could not open display.\n");
 307       msg = XtNewString(tmpStr);
 308       FPRINTF(stderr, msg) ;
 309       exit(1) ;
 310     }
 311
 312   X->screen = DefaultScreen(X->dpy) ;
 313   X->root   = RootWindow(X->dpy, X->screen) ;
 314   white_pixel = WhitePixel(X->dpy, X->screen);
 315   black_pixel = BlackPixel(X->dpy, X->screen);
 316
 317   X->dval  = NULL;
 318   X->vval  = NULL;
 319   X->cfval = NULL;
 320   X->helpMapped = False;
 321
 322   if (DtInitialize (X->dpy, X->kframe, argv[0], DTCALC_CLASS_NAME) == False)
 323   {
 324      /* Fatal Error: could not connect to the messaging system. */
 325      /* DtInitialize() has already logged an appropriate error msg */
 326      exit(-1);
 327   }
 328
 329   /*  Get the application defined resources */
 330   XtGetApplicationResources(X->kframe, &application_args, resources, 6, NULL,0);
 331
 332   v = (Vars) LINT_CAST(calloc(1, sizeof(CalcVars))) ;
 333
 334   /*  Get the dt path created and initialized  */
 335   dt_path = _DtCreateDtDirs (X->dpy);
 336
 337 /* #ifdef hpux */
 338 #ifdef HP_EXTENSIONS
 339   v->keybdID = GetKeyboardID();
 340 #endif
 341
 342   init_colors() ;             /* get the pixels for the default colors in DT */
 343   if(pixels[0].bg == white_pixel || pixels[0].bg == black_pixel)
 344     BlackWhite = True;
 345
 346   if(colorSrv && !BlackWhite)
 347   {
 348      /* first get the Calculator's Icon */
 349      pixmap = XmGetPixmap (DefaultScreenOfDisplay(X->dpy), CALC_ICON_NAME,
 350                                                  pixels[1].fg, pixels[1].bg);
 351      if( pixmap != XmUNSPECIFIED_PIXMAP)
 352          X->icon = pixmap;
 353      else
 354          X->icon = XmUNSPECIFIED_PIXMAP;
 355
 356      /* now let's get the mask for the Calculator */
 357      pixmap = _DtGetMask (DefaultScreenOfDisplay(X->dpy), CALC_ICON_NAME);
 358      if( pixmap != XmUNSPECIFIED_PIXMAP)
 359         X->iconmask = pixmap;
 360      else
 361          X->iconmask = XmUNSPECIFIED_PIXMAP;
 362   }
 363   else
 364   {
 365      /* first get the Calculator's Icon */
 366      pixmap = XmGetPixmap (DefaultScreenOfDisplay(X->dpy), CALC_ICON_NAME_BM,
 367                                                  white_pixel, black_pixel);
 368      if( pixmap != XmUNSPECIFIED_PIXMAP)
 369          X->icon = pixmap;
 370      else
 371          X->icon = XmUNSPECIFIED_PIXMAP;
 372
 373      /* now let's get the mask for the Calculator */
 374      pixmap = _DtGetMask (DefaultScreenOfDisplay(X->dpy), CALC_ICON_NAME_BM);
 375      if( pixmap != XmUNSPECIFIED_PIXMAP)
 376         X->iconmask = pixmap;
 377      else
 378          X->iconmask = XmUNSPECIFIED_PIXMAP;
 379   }
 380
 381   do_dtcalc(argc, argv) ;
 382   exit(0) ;
 383 /*NOTREACHED*/
 384 }
 385
 386 void
 387 beep()
 388 {
 389   ds_beep(X->dpy) ;
 390 }
 391
 392
 393 static Widget
 394 button_create(owner, row, column, maxrows, maxcols)
 395 Widget owner ;
 396 int row, column, maxrows, maxcols ;
 397 {
 398   int n = row * maxcols + column ;
 399   int val ;
 400   enum menu_type mtype = buttons[n].mtype ;
 401   Widget button ;
 402   XmString lstr ;
 403   int result;
 404   Pixel bg;
 405
 406   get_label(n) ;
 407   lstr = XmStringCreateLocalized(v->pstr) ;
 408
 409   if(colorSrv)
 410   {
 411      if (row < 3)
 412         bg = pixels[5].bg;
 413      else if(row >= 3  && row < 6)
 414         bg = pixels[7].bg;
 415      else if(((row == 7 && column == 3) || (row == 13 && column == 3)) &&
 416                                                                    !BlackWhite)
 417         bg = pixels[0].bg;
 418      else if((row >= 6  && row < 8) || (row >= 8  && row < 13 && column == 3) ||
 419                                          (row == 13 && column == 2))
 420         bg = pixels[6].bg;
 421      else
 422         bg = pixels[2].bg;
 423
 424      button = XtVaCreateManagedWidget(buttons[n].resname,
 425                       xmPushButtonWidgetClass,
 426                       owner,
 427                       XmNtopAttachment,    XmATTACH_POSITION,
 428                       XmNtopPosition,      row * maxcols,
 429                       XmNleftAttachment,   XmATTACH_POSITION,
 430                       XmNleftPosition,     column * maxrows,
 431                       XmNrightAttachment,  XmATTACH_POSITION,
 432                       XmNrightPosition,    (column+1) * maxrows,
 433                       XmNbottomAttachment, XmATTACH_POSITION,
 434                       XmNbottomPosition,   (row+1) * maxcols,
 435                       XmNlabelString,      lstr,
 436                       XmNbackground,       bg,
 437                       XmNtraversalOn,      TRUE,
 438                       XmNalignment,        XmALIGNMENT_CENTER,
 439                       XmNrecomputeSize,    False,
 440                       XmNnavigationType,   XmNONE,
 441                       NULL) ;
 442   }
 443   else
 444      button = XtVaCreateManagedWidget(buttons[n].resname,
 445                       xmPushButtonWidgetClass,
 446                       owner,
 447                       XmNtopAttachment,    XmATTACH_POSITION,
 448                       XmNtopPosition,      row * maxcols,
 449                       XmNleftAttachment,   XmATTACH_POSITION,
 450                       XmNleftPosition,     column * maxrows,
 451                       XmNrightAttachment,  XmATTACH_POSITION,
 452                       XmNrightPosition,    (column+1) * maxrows,
 453                       XmNbottomAttachment, XmATTACH_POSITION,
 454                       XmNbottomPosition,   (row+1) * maxcols,
 455                       XmNlabelString,      lstr,
 456                       XmNtraversalOn,      TRUE,
 457                       XmNalignment,        XmALIGNMENT_CENTER,
 458                       XmNrecomputeSize,    False,
 459                       XmNnavigationType,   XmNONE,
 460                       NULL) ;
 461
 462   XmStringFree(lstr) ;
 463
 464   if (mtype != M_NONE) create_menu(mtype, button, n) ;
 465   val = (v->curwin << 16) + n ;
 466   XtAddCallback(button, XmNactivateCallback, do_button,  (XtPointer) val) ;
 467   XtAddCallback(button, XmNhelpCallback,   HelpRequestCB, (XtPointer) val) ;
 468   XtAddEventHandler(button, KeyPressMask | KeyReleaseMask,
 469                     FALSE, event_proc, NULL) ;
 470
 471   if( funBtn == NULL && strcmp(v->pstr, GETMESSAGE(3, 5, "Functions")) == 0)
 472      funBtn = button;
 473   else if( constBtn == NULL && strcmp(v->pstr,
 474                                       GETMESSAGE(3, 6, "Constants")) == 0)
 475      constBtn = button;
 476   else if( accBtn == NULL && strcmp(v->pstr,
 477                                     GETMESSAGE(3, 12, "Accuracy")) == 0)
 478      accBtn = button;
 479   else if( stoBtn == NULL && strcmp(v->pstr, GETMESSAGE(3, 13, "Store")) == 0)
 480      stoBtn = button;
 481   else if( rclBtn == NULL && strcmp(v->pstr, GETMESSAGE(3, 14, "Recall")) == 0)
 482      rclBtn = button;
 483   else if( exchBtn == NULL && strcmp(v->pstr,
 484                                      GETMESSAGE(3, 15, "Exchange")) == 0)
 485      exchBtn = button;
 486
 487   return(button) ;
 488 }
 489
 490
 491 static void
 492 dtcalc_initialize_rframe(owner, type)
 493 Widget owner ;
 494 int type ;
 495 {
 496   char str[MAXLINE] ;
 497   int i ;
 498   Arg args[15];
 499   XmString label_string;
 500   Widget sep, button, frame, form;
 501
 502   if(type == MEM)
 503   {
 504      if (X->rframe) return ;
 505
 506      X->rframe = XmCreateFormDialog(owner, "rframe", NULL, 0) ;
 507
 508      /*  Adjust the decorations for the dialog shell of the dialog  */
 509      XtSetArg (args[0], XmNmwmFunctions, MWM_FUNC_MOVE);
 510      XtSetArg (args[1], XmNmwmDecorations, MWM_DECOR_BORDER | MWM_DECOR_TITLE);
 511      XtSetValues (XtParent(X->rframe), args, 2);
 512
 513      set_title(FCP_REG, lstrs[(int) L_MEMT]) ;
 514
 515      frame = XmCreateFrame(X->rframe, "frame", NULL, 0);
 516      XtManageChild(frame);
 517      form = (Widget) XmCreateForm(frame, "form", NULL, 0) ;
 518      XtManageChild(form);
 519
 520      XtVaSetValues(form,
 521                    XmNmarginWidth,      5,
 522                    XmNmarginHeight,     5,
 523                    XmNallowShellResize, TRUE,
 524                    XmNdefaultPosition,  FALSE,
 525                    NULL) ;
 526
 527      SPRINTF(str, "register%1d", 0) ;
 528      X->registers[0] = XtVaCreateManagedWidget(str,
 529                                    xmLabelWidgetClass,
 530                                    form,
 531                                    XmNtopAttachment, XmATTACH_FORM,
 532                                    XmNtopOffset, 2,
 533                                    XmNleftAttachment, XmATTACH_FORM,
 534                                    XmNleftOffset, 2,
 535                                    XmNmarginWidth,      5,
 536                                    XmNmarginHeight,     1,
 537                                    NULL) ;
 538
 539      for (i = 1; i < MAXREGS; i++)
 540        {
 541          SPRINTF(str, "register%1d", i) ;
 542          X->registers[i] = XtVaCreateManagedWidget(str,
 543                                        xmLabelWidgetClass,
 544                                        form,
 545                                        XmNtopAttachment, XmATTACH_WIDGET,
 546                                        XmNtopWidget,   X->registers[i - 1],
 547                                        XmNtopOffset, 2,
 548                                        XmNleftAttachment, XmATTACH_FORM,
 549                                        XmNleftOffset, 2,
 550                                        XmNmarginWidth,      5,
 551                                        XmNmarginHeight,     1,
 552                                        NULL) ;
 553        }
 554
 555      XtSetArg (args[0], XmNtopAttachment, XmATTACH_WIDGET);
 556      XtSetArg (args[1], XmNtopWidget, X->registers[i - 1]);
 557      XtSetArg (args[2], XmNtopOffset, 3);
 558      XtSetArg (args[3], XmNleftAttachment, XmATTACH_FORM);
 559      XtSetArg (args[4], XmNrightAttachment, XmATTACH_FORM);
 560      sep = XmCreateSeparator(form, "sep", args, 5);
 561      XtManageChild(sep);
 562
 563      label_string = XmStringCreateLocalized (GETMESSAGE(2, 32, "Close") );
 564      XtSetArg (args[0], XmNmarginHeight, 0);
 565      XtSetArg (args[1], XmNmarginWidth, 10);
 566      XtSetArg (args[2], XmNlabelString, label_string);
 567      XtSetArg (args[3], XmNtopAttachment, XmATTACH_WIDGET);
 568      XtSetArg (args[4], XmNtopWidget, sep);
 569      XtSetArg (args[5], XmNtopOffset, 5);
 570      XtSetArg (args[6], XmNleftAttachment, XmATTACH_POSITION);
 571      XtSetArg (args[7], XmNleftPosition, 25);
 572      XtSetArg (args[8], XmNbottomAttachment, XmATTACH_FORM);
 573      XtSetArg (args[9], XmNbottomOffset, 5);
 574      XtSetArg (args[10], XmNshowAsDefault, True);
 575      button = XmCreatePushButton(form, "button", args, 11);
 576      XmStringFree(label_string);
 577
 578      XtAddCallback(button, XmNactivateCallback, close_reg, (XtPointer)type) ;
 579
 580      XtSetArg (args[0], XmNcancelButton, button);
 581      XtSetArg (args[1], XmNdefaultButton, button);
 582      XtSetValues (X->rframe, args, 2);
 583
 584      XtManageChild(button);
 585   }
 586   else
 587   {
 588      if (X->frframe) return ;
 589      X->frframe = XmCreateFormDialog(owner, "frframe", NULL, 0) ;
 590
 591      /*  Adjust the decorations for the dialog shell of the dialog  */
 592      XtSetArg (args[0], XmNmwmFunctions, MWM_FUNC_MOVE);
 593      XtSetArg (args[1], XmNmwmDecorations, MWM_DECOR_BORDER | MWM_DECOR_TITLE);
 594      XtSetValues (XtParent(X->frframe), args, 2);
 595
 596      set_title(FCP_FIN_REG, GETMESSAGE(2, 18, lstrs[(int) L_FINMEMT] ));
 597
 598      frame = XmCreateFrame(X->frframe, "frame", NULL, 0);
 599      XtManageChild(frame);
 600      form = (Widget) XmCreateForm(frame, "form", NULL, 0) ;
 601      XtManageChild(form);
 602
 603      XtVaSetValues(form,
 604                    XmNmarginWidth,      5,
 605                    XmNmarginHeight,     5,
 606                    XmNallowShellResize, TRUE,
 607                    XmNdefaultPosition,  FALSE,
 608                    NULL) ;
 609
 610      SPRINTF(str, "fregister%1d", 0) ;
 611      X->fregisters[0] = XtVaCreateManagedWidget(str,
 612                                    xmLabelWidgetClass,
 613                                    form,
 614                                    XmNtopAttachment, XmATTACH_FORM,
 615                                    XmNtopOffset, 2,
 616                                    XmNleftAttachment, XmATTACH_FORM,
 617                                    XmNleftOffset, 2,
 618                                    XmNmarginWidth,      5,
 619                                    XmNmarginHeight,     1,
 620                                    NULL) ;
 621
 622      for (i = 1; i < FINREGS; i++)
 623        {
 624          SPRINTF(str, "fregister%1d", i) ;
 625          X->fregisters[i] = XtVaCreateManagedWidget(str,
 626                                        xmLabelWidgetClass,
 627                                        form,
 628                                        XmNtopAttachment, XmATTACH_WIDGET,
 629                                        XmNtopWidget,   X->fregisters[i - 1],
 630                                        XmNtopOffset, 2,
 631                                        XmNleftAttachment, XmATTACH_FORM,
 632                                        XmNleftOffset, 2,
 633                                        XmNmarginWidth,      5,
 634                                        XmNmarginHeight,     1,
 635                                        NULL) ;
 636        }
 637
 638      SPRINTF(str, "fregistervals%1d", 0) ;
 639      X->fregistersvals[0] = XtVaCreateManagedWidget(str,
 640                                    xmLabelWidgetClass,
 641                                    form,
 642                                    XmNtopAttachment, XmATTACH_FORM,
 643                                    XmNtopOffset, 2,
 644                                    XmNleftAttachment, XmATTACH_WIDGET,
 645                                    XmNleftWidget, X->fregisters[0],
 646                                    XmNleftOffset, 0,
 647                                    XmNrightAttachment, XmATTACH_FORM,
 648                                    XmNrightOffset, 2,
 649                                    XmNmarginWidth,      5,
 650                                    XmNmarginHeight,     1,
 651                                    NULL) ;
 652
 653      for (i = 1; i < FINREGS; i++)
 654        {
 655          SPRINTF(str, "fregistervals%1d", i) ;
 656          X->fregistersvals[i] = XtVaCreateManagedWidget(str,
 657                                        xmLabelWidgetClass,
 658                                        form,
 659                                        XmNtopAttachment, XmATTACH_WIDGET,
 660                                        XmNtopWidget,   X->fregistersvals[i - 1],
 661                                        XmNtopOffset, 2,
 662                                        XmNleftAttachment, XmATTACH_WIDGET,
 663                                        XmNleftWidget, X->fregisters[i],
 664                                        XmNleftOffset, 0,
 665                                        XmNrightAttachment, XmATTACH_FORM,
 666                                        XmNrightOffset, 2,
 667                                        XmNmarginWidth,      5,
 668                                        XmNmarginHeight,     1,
 669                                        NULL) ;
 670        }
 671
 672      XtSetArg (args[0], XmNtopAttachment, XmATTACH_WIDGET);
 673      XtSetArg (args[1], XmNtopWidget, X->fregisters[i - 1]);
 674      XtSetArg (args[2], XmNtopOffset, 3);
 675      XtSetArg (args[3], XmNleftAttachment, XmATTACH_FORM);
 676      XtSetArg (args[4], XmNrightAttachment, XmATTACH_FORM);
 677      sep = XmCreateSeparator(form, "sep", args, 5);
 678      XtManageChild(sep);
 679
 680      label_string = XmStringCreateLocalized (GETMESSAGE(2, 32, "Close") );
 681      XtSetArg (args[0], XmNmarginHeight, 0);
 682      XtSetArg (args[1], XmNmarginWidth, 10);
 683      XtSetArg (args[2], XmNlabelString, label_string);
 684      XtSetArg (args[3], XmNtopAttachment, XmATTACH_WIDGET);
 685      XtSetArg (args[4], XmNtopWidget, sep);
 686      XtSetArg (args[5], XmNtopOffset, 5);
 687      XtSetArg (args[6], XmNleftAttachment, XmATTACH_POSITION);
 688      XtSetArg (args[7], XmNleftPosition, 30);
 689      XtSetArg (args[8], XmNbottomAttachment, XmATTACH_FORM);
 690      XtSetArg (args[9], XmNbottomOffset, 5);
 691      XtSetArg (args[10], XmNshowAsDefault, True);
 692      button = XmCreatePushButton(form, "button", args, 11);
 693      XmStringFree(label_string);
 694
 695      XtSetArg (args[0], XmNcancelButton, button);
 696      XtSetArg (args[1], XmNdefaultButton, button);
 697      XtSetValues (X->frframe, args, 2);
 698
 699      XtAddCallback(button, XmNactivateCallback, close_reg, NULL) ;
 700
 701      XtManageChild(button);
 702   }
 703 }
 704
 705
 706 static void
 707 dtcalc_kkeyboard_create(owner)
 708 Widget owner ;
 709 {
 710   int column, row ;
 711   Widget buttonFrame;
 712
 713   buttonFrame = XtVaCreateManagedWidget("buttonFrame",
 714                                        xmFrameWidgetClass,
 715                                        owner,
 716                                        XmNshadowThickness, 0,
 717                                        XmNmarginWidth, 0,
 718                                        XmNmarginHeight, 0,
 719                                        XmNtopAttachment,      XmATTACH_WIDGET,
 720                                        XmNtopWidget,          X->modeFrame,
 721                                        XmNrightAttachment,    XmATTACH_FORM,
 722                                        XmNleftAttachment,     XmATTACH_FORM,
 723                                        XmNbottomAttachment,   XmATTACH_FORM,
 724                                        NULL) ;
 725
 726   X->kkeyboard = XtVaCreateManagedWidget("kkeyboard",
 727                                          xmFormWidgetClass,
 728                                          buttonFrame,
 729                                          XmNfractionBase, BROWS * BCOLS,
 730                                          XmNnavigationType,  XmSTICKY_TAB_GROUP,
 731                                          NULL) ;
 732
 733   v->curwin = FCP_KEY ;
 734   for (row = 0; row < BROWS; row++)
 735     for (column = 0; column < BCOLS; column++)
 736       {
 737         X->kbuttons[row][column] = button_create(X->kkeyboard, row, column,
 738                                                  BROWS, BCOLS) ;
 739         XtManageChild(X->kbuttons[row][column]) ;
 740       }
 741   grey_buttons(v->base) ;
 742 }
 743
 744
 745 static void
 746 dtcalc_kpanel_create(owner)
 747 Widget owner ;
 748 {
 749   static char *mnames[] = { "base", "ttype", "num", "hyp",
 750                             "inv",  "op",  "mode" } ;
 751   int i, n, val;
 752   Widget basePulldown, numPulldown, modePulldown, trigPulldown, dummyText;
 753   Arg args[10];
 754   XmString label_string;
 755   Pixel tmp_pixelbg, tmp_pixelfg;
 756   XtTranslations trans_table;
 757
 758   trans_table = XtParseTranslationTable(translations_return);
 759
 760   if(colorSrv)
 761   {
 762     if(BlackWhite)
 763     {
 764        if(pixels[2].bg == black_pixel)
 765        {
 766           tmp_pixelbg = black_pixel;
 767           tmp_pixelfg = white_pixel;
 768        }
 769        else
 770        {
 771           tmp_pixelbg = white_pixel;
 772           tmp_pixelfg = black_pixel;
 773        }
 774     }
 775     else
 776     {
 777        tmp_pixelbg = pixels[6].bg;
 778        tmp_pixelfg = white_pixel;
 779     }
 780   }
 781   else
 782   {
 783     tmp_pixelbg = white_pixel;
 784     tmp_pixelfg = black_pixel;
 785   }
 786
 787   X->mainWin = XtVaCreateManagedWidget("mainWin",
 788                                       xmMainWindowWidgetClass,
 789                                       owner,
 790                                       NULL) ;
 791
 792 #ifdef HAVE_EDITRES
 793     XtAddEventHandler(owner, 0, True,
 794                       (XtEventHandler) _XEditResCheckMessages,
 795                       (XtPointer) NULL);
 796 #endif
 797
 798   if(application_args.menuBar)
 799      create_menu_bar(X->mainWin);
 800
 801   X->kFrame = XtVaCreateManagedWidget("kFrame", xmFrameWidgetClass,
 802                                       X->mainWin,
 803                                       XmNshadowThickness, 1,
 804                                       XmNshadowType, XmSHADOW_OUT,
 805                                       XmNmarginWidth, 5,
 806                                       XmNmarginHeight, 5,
 807                                       NULL) ;
 808
 809   X->kpanel = XtVaCreateManagedWidget("kpanel",
 810                                       xmFormWidgetClass,
 811                                       X->kFrame,
 812                                       XmNshadowThickness, 0,
 813                                       XmNbackground,         tmp_pixelbg,
 814                                       XmNforeground,         tmp_pixelfg,
 815                                       NULL) ;
 816
 817   create_popup(X->kpanel);
 818
 819   X->textFrame = XtVaCreateManagedWidget("textFrame",
 820                                       xmFrameWidgetClass,
 821                                       X->kpanel,
 822                                       XmNshadowThickness, 2,
 823                                       XmNshadowType, XmSHADOW_IN,
 824                                       XmNmarginWidth, 0,
 825                                       XmNmarginHeight, 0,
 826                                       XmNtopAttachment,      XmATTACH_FORM,
 827                                       XmNrightAttachment,    XmATTACH_FORM,
 828                                       XmNleftAttachment,     XmATTACH_FORM,
 829                                       XmNnavigationType,     XmTAB_GROUP,
 830                                       NULL) ;
 831   XtAddCallback(X->textFrame, XmNhelpCallback, HelpRequestCB,
 832                                                  (XtPointer)HELP_DISPLAY) ;
 833
 834   X->textForm = XtVaCreateManagedWidget("textForm",
 835                                       xmFormWidgetClass,
 836                                       X->textFrame,
 837                                       XmNshadowThickness, 0,
 838                                       XmNbackground,         tmp_pixelbg,
 839                                       XmNforeground,         tmp_pixelfg,
 840                                       NULL) ;
 841   XtAddCallback(X->textForm, XmNhelpCallback, HelpRequestCB,
 842                                                  (XtPointer)HELP_DISPLAY) ;
 843
 844   X->modevals[(int) DISPLAYITEM] = XtVaCreateManagedWidget("display",
 845                                        xmTextWidgetClass,
 846                                        X->textForm,
 847                                        XmNtopAttachment,      XmATTACH_FORM,
 848                                        XmNrightAttachment,    XmATTACH_FORM,
 849                                        XmNbottomAttachment,   XmATTACH_FORM,
 850                                        XmNresizeWidth,        TRUE,
 851                                        XmNshadowThickness,    0,
 852                                        XmNhighlightThickness, 0,
 853                                        XmNeditable,           FALSE,
 854                                        XmNverifyBell,         FALSE,
 855                                        XmNbackground,         tmp_pixelbg,
 856                                        XmNforeground,         tmp_pixelfg,
 857                                        NULL) ;
 858   XtAddCallback(X->modevals[(int) DISPLAYITEM], XmNhelpCallback, HelpRequestCB,
 859                                                     (XtPointer) HELP_DISPLAY) ;
 860   XtAddEventHandler(X->modevals[(int) DISPLAYITEM],
 861                 KeyPressMask | KeyReleaseMask, FALSE, event_proc, NULL) ;
 862
 863
 864   X->modeFrame = XtVaCreateManagedWidget("modeFrame",
 865                                       xmFrameWidgetClass,
 866                                       X->kpanel,
 867                                       XmNshadowThickness, 0,
 868                                       XmNmarginWidth, 0,
 869                                       XmNmarginHeight, 0,
 870                                       XmNtopAttachment,      XmATTACH_WIDGET,
 871                                       XmNtopWidget,          X->textFrame,
 872                                       XmNrightAttachment,    XmATTACH_FORM,
 873                                       XmNleftAttachment,     XmATTACH_FORM,
 874                                       XmNnavigationType,     XmTAB_GROUP,
 875                                       NULL) ;
 876   XtAddCallback(X->modeFrame, XmNhelpCallback,   HelpRequestCB,
 877                                                    (XtPointer) HELP_MODELINE) ;
 878
 879   X->modeline = XtVaCreateManagedWidget("modeline",
 880                     xmFormWidgetClass,
 881                     X->modeFrame,
 882                     XmNshadowThickness, 0,
 883                     NULL) ;
 884   XtAddCallback(X->modeline, XmNhelpCallback,   HelpRequestCB,
 885                                                     (XtPointer) HELP_MODELINE) ;
 886
 887   label_string = XmStringCreateLocalized ("                        ");
 888   i = (int) OPITEM;
 889   X->modevals[i] = XtVaCreateManagedWidget(mnames[i],
 890                        xmLabelWidgetClass,
 891                        X->modeline,
 892                        XmNtopAttachment, XmATTACH_FORM,
 893                        XmNrightAttachment, XmATTACH_FORM,
 894                        XmNrecomputeSize, False,
 895                        XmNalignment, XmALIGNMENT_CENTER,
 896                        XmNlabelString, label_string,
 897                        NULL) ;
 898   XtAddCallback(X->modevals[i], XmNhelpCallback,   HelpRequestCB,
 899                                                     (XtPointer) HELP_MODELINE) ;
 900
 901   i = (int) HYPITEM;
 902   X->modevals[i] = XtVaCreateManagedWidget(mnames[i],
 903                        xmLabelWidgetClass,
 904                        X->modeline,
 905                        XmNrightAttachment, XmATTACH_WIDGET,
 906                        XmNrightWidget,  X->modevals[(int) OPITEM],
 907                        XmNtopAttachment, XmATTACH_FORM,
 908                        XmNrecomputeSize, False,
 909                        XmNalignment, XmALIGNMENT_CENTER,
 910                        XmNlabelString, label_string,
 911                        NULL) ;
 912   XtAddCallback(X->modevals[i], XmNhelpCallback,   HelpRequestCB,
 913                                                     (XtPointer) HELP_MODELINE) ;
 914
 915   i = (int) INVITEM;
 916   X->modevals[i] = XtVaCreateManagedWidget(mnames[i],
 917                        xmLabelWidgetClass,
 918                        X->modeline,
 919                        XmNrightAttachment, XmATTACH_WIDGET,
 920                        XmNrightWidget,  X->modevals[(int) HYPITEM],
 921                        XmNtopAttachment, XmATTACH_FORM,
 922                        XmNrecomputeSize, False,
 923                        XmNalignment, XmALIGNMENT_CENTER,
 924                        XmNlabelString, label_string,
 925                        NULL) ;
 926   XtAddCallback(X->modevals[i], XmNhelpCallback,   HelpRequestCB,
 927                                                     (XtPointer) HELP_MODELINE) ;
 928   XmStringFree(label_string);
 929
 930   {
 931     i = (int) MODEITEM;
 932     modePulldown = XmCreatePulldownMenu(X->modeline, "modePD", args, 0);
 933
 934     XtSetArg(args[0], XmNmarginHeight, 0);
 935     XtSetArg(args[1], XmNmarginWidth, 0);
 936     val = (v->curwin << 16) +
 937              menu_entries[cmenus[(int) M_MODE].mindex + 1].val ;
 938     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 9, "Financial") );
 939     XtSetArg(args[2], XmNlabelString, label_string);
 940     XtSetArg(args[3], XmNuserData, val);
 941     modeArry[0] = XmCreatePushButtonGadget(modePulldown, "fin", args, 4);
 942     XmStringFree(label_string);
 943     XtAddCallback(modeArry[0], XmNactivateCallback, modelineValueChanged,
 944                                                           (XtPointer) M_MODE);
 945
 946     val = (v->curwin << 16) +
 947              menu_entries[cmenus[(int) M_MODE].mindex + 2].val ;
 948     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 10, "Logical") );
 949     XtSetArg(args[2], XmNlabelString, label_string);
 950     XtSetArg(args[3], XmNuserData, val);
 951     modeArry[1] = XmCreatePushButtonGadget(modePulldown, "logic", args, 4);
 952     XmStringFree(label_string);
 953     XtAddCallback(modeArry[1], XmNactivateCallback, modelineValueChanged,
 954                                                           (XtPointer) M_MODE);
 955
 956     val = (v->curwin << 16) +
 957              menu_entries[cmenus[(int) M_MODE].mindex + 3].val ;
 958     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 11, "Scientific") );
 959     XtSetArg(args[2], XmNlabelString, label_string);
 960     XtSetArg(args[3], XmNuserData, val);
 961     modeArry[2] = XmCreatePushButtonGadget(modePulldown, "Sci", args, 4);
 962     XmStringFree(label_string);
 963     XtAddCallback(modeArry[2], XmNactivateCallback, modelineValueChanged,
 964                                                           (XtPointer) M_MODE);
 965
 966     XtManageChildren(modeArry, 3);
 967
 968     /* create the Option Menu and attach it to the Pulldown MenuPane */
 969     n = 0;
 970     XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);            n++;
 971     XtSetArg (args[n], XmNtopWidget, X->modevals[(int)HYPITEM]);      n++;
 972     XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);           n++;
 973     XtSetArg(args[n], XmNsubMenuId, modePulldown);                    n++;
 974     XtSetArg(args[n], XmNmenuHistory, modeArry[(int)v->modetype]);    n++;
 975     X->modevals[i] = XmCreateOptionMenu(X->modeline, "mode", args, n);
 976     XtManageChild (X->modevals[i]);
 977     XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
 978                                                        (XtPointer) HELP_MODE) ;
 979
 980     XtOverrideTranslations(X->modevals[i], trans_table);
 981
 982     XtAddEventHandler(X->modevals[i], KeyPressMask | KeyReleaseMask,
 983                       FALSE, event_proc, NULL) ;
 984
 985     i = (int) BASEITEM;
 986     basePulldown = XmCreatePulldownMenu(X->modeline, "basePD", args, 0);
 987
 988     val = (v->curwin << 16) +
 989              menu_entries[cmenus[(int) M_BASE].mindex].val ;
 990     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 1, "Bin") );
 991     XtSetArg(args[0], XmNmarginHeight, 0);
 992     XtSetArg(args[1], XmNmarginWidth, 0);
 993     XtSetArg(args[2], XmNlabelString, label_string);
 994     XtSetArg(args[3], XmNuserData, val);
 995     X->baseWidgArry[0] = XmCreatePushButtonGadget(basePulldown, "bin", args, 4);
 996     XmStringFree(label_string);
 997     XtAddCallback(X->baseWidgArry[0], XmNactivateCallback,
 998                          modelineValueChanged, (XtPointer) M_BASE);
 999
1000     val = (v->curwin << 16) +
1001              menu_entries[cmenus[(int) M_BASE].mindex + 1].val ;
1002     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 2, "Oct") );
1003     XtSetArg(args[2], XmNlabelString, label_string);
1004     XtSetArg(args[3], XmNuserData, val);
1005     X->baseWidgArry[1] = XmCreatePushButtonGadget(basePulldown, "oct", args, 4);
1006     XmStringFree(label_string);
1007     XtAddCallback(X->baseWidgArry[1], XmNactivateCallback,
1008                          modelineValueChanged, (XtPointer) M_BASE);
1009
1010     val = (v->curwin << 16) +
1011              menu_entries[cmenus[(int) M_BASE].mindex + 2].val ;
1012     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 3, "Dec") );
1013     XtSetArg(args[2], XmNlabelString, label_string);
1014     XtSetArg(args[3], XmNuserData, val);
1015     X->baseWidgArry[2] = XmCreatePushButtonGadget(basePulldown, "dec", args, 4);
1016     XmStringFree(label_string);
1017     XtAddCallback(X->baseWidgArry[2], XmNactivateCallback,
1018                          modelineValueChanged, (XtPointer) M_BASE);
1019
1020     val = (v->curwin << 16) +
1021              menu_entries[cmenus[(int) M_BASE].mindex + 3].val ;
1022     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 4, "Hex") );
1023     XtSetArg(args[2], XmNlabelString, label_string);
1024     XtSetArg(args[3], XmNuserData, val);
1025     X->baseWidgArry[3] = XmCreatePushButtonGadget(basePulldown, "hex", args, 4);
1026     XmStringFree(label_string);
1027     XtAddCallback(X->baseWidgArry[3], XmNactivateCallback,
1028                          modelineValueChanged, (XtPointer) M_BASE);
1029
1030     XtManageChildren(X->baseWidgArry, 4);
1031
1032     /* create the Option Menu and attach it to the Pulldown MenuPane */
1033     n = 0;
1034     XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);            n++;
1035     XtSetArg (args[n], XmNtopWidget, X->modevals[(int)HYPITEM]);      n++;
1036     XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);           n++;
1037     XtSetArg(args[n], XmNsubMenuId, basePulldown);                    n++;
1038     XtSetArg(args[n], XmNmenuHistory, X->baseWidgArry[(int)v->base]); n++;
1039     X->modevals[i] = XmCreateOptionMenu(X->modeline, "base", args, n);
1040     XtManageChild (X->modevals[i]);
1041     XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
1042                                                       (XtPointer) HELP_BASE) ;
1043
1044     XtOverrideTranslations(X->modevals[i], trans_table);
1045   XtAddEventHandler(X->modevals[i], KeyPressMask | KeyReleaseMask,
1046                     FALSE, event_proc, NULL) ;
1047
1048
1049     i = (int) NUMITEM;
1050     numPulldown = XmCreatePulldownMenu(X->modeline, "numPD", args, 0);
1051
1052     val = (v->curwin << 16) +
1053              menu_entries[cmenus[(int) M_NUM].mindex].val ;
1054     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 5, "Eng") );
1055     XtSetArg(args[0], XmNmarginHeight, 0);
1056     XtSetArg(args[1], XmNmarginWidth, 0);
1057     XtSetArg(args[2], XmNlabelString, label_string);
1058     XtSetArg(args[3], XmNuserData, val);
1059     X->numWidgArry[0] = XmCreatePushButtonGadget(numPulldown, "eng", args, 4);
1060     XmStringFree(label_string);
1061     XtAddCallback(X->numWidgArry[0], XmNactivateCallback, modelineValueChanged,
1062                                                           (XtPointer) M_NUM);
1063
1064     val = (v->curwin << 16) +
1065              menu_entries[cmenus[(int) M_NUM].mindex + 1].val ;
1066     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 6, "Fix") );
1067     XtSetArg(args[2], XmNlabelString, label_string);
1068     XtSetArg(args[3], XmNuserData, val);
1069     X->numWidgArry[1] = XmCreatePushButtonGadget(numPulldown, "fix", args, 4);
1070     XmStringFree(label_string);
1071     XtAddCallback(X->numWidgArry[1], XmNactivateCallback, modelineValueChanged,
1072                                                           (XtPointer) M_NUM);
1073
1074     val = (v->curwin << 16) +
1075              menu_entries[cmenus[(int) M_NUM].mindex + 2].val ;
1076     label_string = XmStringCreateLocalized ( GETMESSAGE(2, 7, "Sci") );
1077     XtSetArg(args[2], XmNlabelString, label_string);
1078     XtSetArg(args[3], XmNuserData, val);
1079     X->numWidgArry[2] = XmCreatePushButtonGadget(numPulldown, "sci", args, 4);
1080     XmStringFree(label_string);
1081     XtAddCallback(X->numWidgArry[2], XmNactivateCallback, modelineValueChanged,
1082                                                           (XtPointer) M_NUM);
1083
1084     XtManageChildren(X->numWidgArry, 3);
1085
1086     /* create the Option Menu and attach it to the Pulldown MenuPane */
1087     n = 0;
1088     XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);             n++;
1089     XtSetArg (args[n], XmNtopWidget, X->modevals[(int)HYPITEM]);       n++;
1090     XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);            n++;
1091     XtSetArg(args[n], XmNsubMenuId, numPulldown);                      n++;
1092     XtSetArg(args[n], XmNmenuHistory, X->numWidgArry[(int)v->dtype]);  n++;
1093     X->modevals[i] = XmCreateOptionMenu(X->modeline, "num", args, n);
1094     XtManageChild (X->modevals[i]);
1095     XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
1096                                                    (XtPointer) HELP_NOTATION) ;
1097
1098     XtOverrideTranslations(X->modevals[i], trans_table);
1099   XtAddEventHandler(X->modevals[i], KeyPressMask | KeyReleaseMask,
1100                     FALSE, event_proc, NULL) ;
1101
1102
1103     i = (int) TTYPEITEM;
1104     trigPulldown = XmCreatePulldownMenu(X->modeline, "trigPD", args, 0);
1105
1106     XtSetArg(args[0], XmNmarginHeight, 0);
1107     XtSetArg(args[1], XmNmarginWidth, 0);
1108     val = (v->curwin << 16) +
1109              menu_entries[cmenus[(int) M_TRIG].mindex].val ;
1110     label_string = XmStringCreateLocalized ( ttype_str[(int) DEG] );
1111     XtSetArg(args[2], XmNlabelString, label_string);
1112     XtSetArg(args[3], XmNuserData, val);
1113     X->ttypeWidgArry[0] =
1114                      XmCreatePushButtonGadget(trigPulldown, "deg", args, 4);
1115     XmStringFree(label_string);
1116     XtAddCallback(X->ttypeWidgArry[0], XmNactivateCallback,
1117                          modelineValueChanged, (XtPointer) M_TRIG);
1118
1119     val = (v->curwin << 16) +
1120              menu_entries[cmenus[(int) M_TRIG].mindex + 1].val ;
1121     label_string = XmStringCreateLocalized ( ttype_str[(int) GRAD] );
1122     XtSetArg(args[2], XmNlabelString, label_string);
1123     XtSetArg(args[3], XmNuserData, val);
1124     X->ttypeWidgArry[1] =
1125                 XmCreatePushButtonGadget(trigPulldown, "grd", args, 4);
1126     XmStringFree(label_string);
1127     XtAddCallback(X->ttypeWidgArry[1], XmNactivateCallback,
1128                           modelineValueChanged, (XtPointer) M_TRIG);
1129
1130     val = (v->curwin << 16) +
1131              menu_entries[cmenus[(int) M_TRIG].mindex + 2].val ;
1132     label_string = XmStringCreateLocalized ( ttype_str[(int) RAD] );
1133     XtSetArg(args[2], XmNlabelString, label_string);
1134     XtSetArg(args[3], XmNuserData, val);
1135     X->ttypeWidgArry[2] =
1136                  XmCreatePushButtonGadget(trigPulldown, "rad", args, 4);
1137     XmStringFree(label_string);
1138     XtAddCallback(X->ttypeWidgArry[2], XmNactivateCallback,
1139                            modelineValueChanged, (XtPointer) M_TRIG);
1140
1141     XtManageChildren(X->ttypeWidgArry, 3);
1142
1143     /* create the Option Menu and attach it to the Pulldown MenuPane */
1144     n = 0;
1145     XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);              n++;
1146     XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);              n++;
1147     XtSetArg (args[n], XmNtopWidget, X->modevals[(int) HYPITEM]);       n++;
1148     XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);             n++;
1149     XtSetArg(args[n], XmNsubMenuId, trigPulldown);                      n++;
1150     XtSetArg(args[n], XmNmenuHistory, X->ttypeWidgArry[(int)v->ttype]); n++;
1151     X->modevals[i] = XmCreateOptionMenu(X->modeline, "trig", args, n);
1152     XtManageChild (X->modevals[i]);
1153     XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
1154                                                       (XtPointer) HELP_TRIG) ;
1155
1156     XtOverrideTranslations(X->modevals[i], trans_table);
1157     XtSetSensitive(X->modevals[i], True);
1158
1159     XtSetArg (args[0], XmNrightAttachment, XmATTACH_WIDGET);
1160     XtSetArg (args[1], XmNrightWidget, X->modevals[(int)BASEITEM]);
1161     XtSetValues (X->modevals[(int)MODEITEM], args, 2);
1162
1163     XtSetArg (args[0], XmNrightAttachment, XmATTACH_WIDGET);
1164     XtSetArg (args[1], XmNrightWidget, X->modevals[(int)NUMITEM]);
1165     XtSetValues (X->modevals[(int)BASEITEM], args, 2);
1166
1167     XtSetArg (args[0], XmNrightAttachment, XmATTACH_WIDGET);
1168     XtSetArg (args[1], XmNrightWidget, X->modevals[(int)TTYPEITEM]);
1169     XtSetValues (X->modevals[(int)NUMITEM], args, 2);
1170
1171
1172   XtAddEventHandler(X->modevals[i], KeyPressMask | KeyReleaseMask,
1173                     FALSE, event_proc, NULL) ;
1174
1175   }
1176 }
1177
1178 /*ARGSUSED*/
1179 static void
1180 confirm_callback(widget, client_data, call_data)
1181 Widget widget ;
1182 XtPointer client_data, call_data ;
1183 {
1184    update_cf_value();
1185 }
1186
1187
1188 static void
1189 create_cfframe()    /* Create auxiliary frame for CON/FUN key. */
1190 {
1191   int j;
1192   XmString tstr ;
1193   Arg args[15];
1194   Widget sep, frame, form;
1195   XmString label_string;
1196
1197   X->CFframe = (Widget) XmCreateFormDialog(X->kframe, "cfframe", NULL, 0) ;
1198   tstr = XmStringCreateLocalized(lstrs[(int) L_NEWCON]) ;
1199   XtVaSetValues(X->CFframe,
1200                 XmNdialogTitle,     tstr,
1201                 XmNautoUnmanage,    FALSE,
1202                 XmNallowShellResize, FALSE,
1203                 XmNdefaultPosition, FALSE,
1204                 NULL) ;
1205   XmStringFree(tstr) ;
1206
1207   /*  Adjust the decorations for the dialog shell of the dialog  */
1208   j = 0;
1209   XtSetArg (args[j], XmNmwmFunctions, MWM_FUNC_MOVE); j++;
1210   XtSetArg (args[j], XmNmwmDecorations, MWM_DECOR_BORDER | MWM_DECOR_TITLE); j++;
1211   XtSetValues (XtParent(X->CFframe), args, j);
1212
1213   frame = (Widget) XmCreateFrame(X->CFframe, "frame", NULL, 0) ;
1214   XtManageChild(frame);
1215   form = (Widget) XmCreateForm(frame, "form", NULL, 0) ;
1216   XtManageChild(form);
1217
1218
1219   X->CFpi_cftext = make_textW(form, lstrs[(int) L_CONNO]) ;
1220   X->CFpi_dtext  = make_textW(form, lstrs[(int) L_DESC]) ;
1221   X->CFpi_vtext  = make_textW(form, lstrs[(int) L_VALUE]) ;
1222
1223   j = 0;
1224   XtSetArg (args[j], XmNtopAttachment, XmATTACH_FORM); j++;
1225   XtSetArg (args[j], XmNtopOffset, 5); j++;
1226   XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1227   XtSetArg (args[j], XmNrightOffset, 5); j++;
1228   XtSetValues(X->CFpi_cftext->manager, args, j);
1229
1230   j = 0;
1231   XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1232   XtSetArg (args[j], XmNtopWidget, X->CFpi_cftext->manager); j++;
1233   XtSetArg (args[j], XmNtopOffset, 5); j++;
1234   XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1235   XtSetArg (args[j], XmNrightOffset, 5); j++;
1236   XtSetValues(X->CFpi_dtext->manager, args, j);
1237
1238   j = 0;
1239   XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1240   XtSetArg (args[j], XmNtopWidget, X->CFpi_dtext->manager); j++;
1241   XtSetArg (args[j], XmNtopOffset, 5); j++;
1242   XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1243   XtSetArg (args[j], XmNrightOffset, 5); j++;
1244   XtSetValues(X->CFpi_vtext->manager, args, j);
1245
1246   j = 0;
1247   XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1248   XtSetArg (args[j], XmNtopWidget, X->CFpi_vtext->manager); j++;
1249   XtSetArg (args[j], XmNtopOffset, 3); j++;
1250   XtSetArg (args[j], XmNleftAttachment, XmATTACH_FORM); j++;
1251   XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1252   sep = XmCreateSeparator(form, "sep", args, j);
1253   XtManageChild(sep);
1254
1255   j = 0;
1256   label_string = XmStringCreateLocalized ( GETMESSAGE(4, 4, "OK") );
1257   XtSetArg (args[j], XmNmarginHeight, 2); j++;
1258   XtSetArg (args[j], XmNmarginWidth, 15); j++;
1259   XtSetArg (args[j], XmNlabelString, label_string); j++;
1260   XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1261   XtSetArg (args[j], XmNtopWidget, sep); j++;
1262   XtSetArg (args[j], XmNtopOffset, 5); j++;
1263   XtSetArg (args[j], XmNleftAttachment, XmATTACH_FORM); j++;
1264   XtSetArg (args[j], XmNleftOffset, 15); j++;
1265   XtSetArg (args[j], XmNbottomAttachment, XmATTACH_FORM); j++;
1266   XtSetArg (args[j], XmNbottomOffset, 5); j++;
1267   XtSetArg (args[j], XmNshowAsDefault, True); j++;
1268   XtSetArg (args[j], XmNtraversalOn, True); j++;
1269   X->CFpi_butOK = XmCreatePushButton(form, "button", args, j);
1270   XmStringFree(label_string);
1271   XtManageChild(X->CFpi_butOK);
1272
1273   j = 0;
1274   label_string = XmStringCreateLocalized ( GETMESSAGE(3, 361, "Cancel") );
1275   XtSetArg (args[j], XmNmarginHeight, 2); j++;
1276   XtSetArg (args[j], XmNmarginWidth, 10); j++;
1277   XtSetArg (args[j], XmNlabelString, label_string); j++;
1278   XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1279   XtSetArg (args[j], XmNtopWidget, sep); j++;
1280   XtSetArg (args[j], XmNtopOffset, 10); j++;
1281   XtSetArg (args[j], XmNleftAttachment, XmATTACH_WIDGET); j++;
1282   XtSetArg (args[j], XmNleftWidget, X->CFpi_butOK); j++;
1283   XtSetArg (args[j], XmNleftOffset, 33); j++;
1284   XtSetArg (args[j], XmNbottomAttachment, XmATTACH_FORM); j++;
1285   XtSetArg (args[j], XmNbottomOffset, 10); j++;
1286   XtSetArg (args[j], XmNtraversalOn, True); j++;
1287   X->CFpi_butClose = XmCreatePushButton(form, "button", args, j);
1288   XmStringFree(label_string);
1289   XtManageChild(X->CFpi_butClose);
1290
1291   j = 0;
1292   label_string = XmStringCreateLocalized ( GETMESSAGE(2, 18, "Help") );
1293   XtSetArg (args[j], XmNmarginHeight, 2); j++;
1294   XtSetArg (args[j], XmNmarginWidth, 10); j++;
1295   XtSetArg (args[j], XmNlabelString, label_string); j++;
1296   XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1297   XtSetArg (args[j], XmNtopWidget, sep); j++;
1298   XtSetArg (args[j], XmNtopOffset, 10); j++;
1299   XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1300   XtSetArg (args[j], XmNrightOffset, 15); j++;
1301   XtSetArg (args[j], XmNleftAttachment, XmATTACH_WIDGET); j++;
1302   XtSetArg (args[j], XmNleftWidget, X->CFpi_butClose); j++;
1303   XtSetArg (args[j], XmNleftOffset, 33); j++;
1304   XtSetArg (args[j], XmNbottomAttachment, XmATTACH_FORM); j++;
1305   XtSetArg (args[j], XmNbottomOffset, 10); j++;
1306   XtSetArg (args[j], XmNtraversalOn, True); j++;
1307   X->CFpi_butHelp = XmCreatePushButton(form, "button", args, j);
1308   XmStringFree(label_string);
1309   XtManageChild(X->CFpi_butHelp);
1310
1311   XtAddCallback(X->CFpi_butOK, XmNactivateCallback, write_cf_value,
1312                                                    (XtPointer) X->CFpi_butOK) ;
1313   XtAddCallback(X->CFpi_butClose, XmNactivateCallback, close_cf,
1314                                                           (XtPointer) NULL) ;
1315
1316   XtAddCallback(X->CFpi_cftext->textfield, XmNactivateCallback, move_cf,
1317                                                    (XtPointer) X->CFpi_butOK) ;
1318   XtAddCallback(X->CFpi_dtext->textfield, XmNactivateCallback, move_cf,
1319                                                    (XtPointer) X->CFpi_butOK) ;
1320   XtAddCallback(X->CFpi_vtext->textfield, XmNactivateCallback, move_cf,
1321                                                    (XtPointer) X->CFpi_butOK) ;
1322
1323   XtAddCallback(X->CFpi_cftext->textfield, XmNfocusCallback, FocusInCB,
1324                                                    (XtPointer) NULL) ;
1325   XtAddCallback(X->CFpi_dtext->textfield, XmNactivateCallback, FocusInCB,
1326                                                    (XtPointer) NULL) ;
1327   j = 0;
1328   XtSetArg (args[j], XmNcancelButton, X->CFpi_butClose); j++;
1329   XtSetValues (X->CFframe, args, j);
1330
1331   j = 0;
1332   XtSetArg (args[j], XmNdefaultButton, X->CFpi_butOK); j++;
1333   XtSetValues (form, args, j);
1334
1335   /* Make the first prompt automatically get the focus. */
1336    XmProcessTraversal(X->CFpi_cftext->textfield, XmTRAVERSE_CURRENT);
1337 }
1338
1339
1340 static void
1341 create_menu(mtype, button, n)   /* Create popup menu for dtcalc button. */
1342 enum menu_type mtype ;
1343 Widget button ;
1344 int n ;
1345 {
1346   char *mstr, *tmpStr, *ptr ;
1347   int i, invalid, val ;
1348   Widget menu, mi ;
1349   Boolean isAFunction = False;
1350
1351   if ((mtype != M_CON && mtype != M_FUN) &&
1352       X->menus[(int) mtype] != NULL) return ;       /* Already created? */
1353
1354   X->menus[(int) mtype] = menu = XmCreatePopupMenu(button,
1355                                                    "menu", NULL, 0) ;
1356
1357   X->mrec[(int) mtype] = n ;
1358
1359   XtCreateManagedWidget(cmenus[(int) mtype].title, xmLabelWidgetClass,
1360                         menu, NULL, 0) ;
1361   XtCreateManagedWidget("separator", xmSeparatorWidgetClass, menu, NULL, 0) ;
1362   XtCreateManagedWidget("separator", xmSeparatorWidgetClass, menu, NULL, 0) ;
1363
1364
1365   for (i = 0; i < cmenus[(int) mtype].total; i++)
1366     {
1367       invalid = 0 ;
1368       switch (mtype)
1369         {
1370           case M_CON : if (strlen(v->con_names[i]))        /* Constants. */
1371                          mstr = v->con_names[i] ;
1372                        else invalid = 1 ;
1373                        break ;
1374           case M_FUN : if (strlen(v->fun_names[i]))        /* Functions. */
1375                        {
1376                          isAFunction = True;
1377                          mstr = v->fun_names[i] ;
1378                        }
1379                        else invalid = 1 ;
1380                        break ;
1381           default    : mstr = menu_entries[cmenus[(int) mtype].mindex + i].str ;
1382         }
1383       if (!invalid)
1384         {
1385
1386            tmpStr = GETMESSAGE(3, 45, ".");
1387            if(strcmp(tmpStr, ".") != 0)
1388            {
1389               /* if it's not a "." let's go change it to what it should be */
1390               ptr = DtStrchr(mstr, '.');
1391               if(ptr != NULL)
1392                  ptr[0] = tmpStr[0];
1393            }
1394           mi = XtCreateManagedWidget(mstr, xmPushButtonWidgetClass,
1395                                      menu, NULL, 0) ;
1396           val = (v->curwin << 16) +
1397                 menu_entries[cmenus[(int) mtype].mindex + i].val ;
1398           XtAddCallback(mi, XmNactivateCallback, menu_proc, (XtPointer) val) ;
1399         }
1400     }
1401     if( !isAFunction && mtype == M_FUN)
1402     {
1403        mi = XtCreateManagedWidget(GETMESSAGE(2, 35, "No Functions Defined"),
1404                                       xmPushButtonWidgetClass, menu, NULL, 0) ;
1405     }
1406 }
1407
1408
1409 /*ARGSUSED*/
1410 static void
1411 do_button(widget, client_data, call_data)
1412 Widget widget ;
1413 XtPointer client_data, call_data ;
1414 {
1415   char *str;
1416   XmString cstr ;
1417   Arg args[3];
1418   int n = ((int) client_data) & 0xFFFF ;
1419
1420   XtSetArg(args[0], XmNlabelString, &cstr);
1421   XtGetValues(X->modevals[OPITEM], args, 1);
1422
1423   str = (char *) _XmStringUngenerate(cstr,
1424                                      XmFONTLIST_DEFAULT_TAG,
1425                                      XmCHARSET_TEXT, XmCHARSET_TEXT);
1426
1427   if(strcmp(vstrs[(int) V_CLR], str) == 0 &&
1428               (buttons[n].value !=  KEY_CLR && buttons[n].value !=  KEY_QUIT))
1429   {
1430      beep();
1431      return;
1432   }
1433
1434   ProcessMotifSelection(X->modevals[(int) DISPLAYITEM]);
1435   v->curwin = ((int) client_data) >> 16 ;
1436   if (v->pending)
1437     {
1438       v->current = buttons[n].value ;
1439       do_pending() ;
1440     }
1441   else if (n >= 0 && n <= NOBUTTONS) process_item(n) ;
1442   v->error = FALSE;
1443 }
1444
1445
1446 /*ARGSUSED*/
1447 static void
1448 do_continue_notice(parent, str)
1449 Widget parent ;
1450 char *str ;
1451 {
1452   XmString contstr, message, cstr ;
1453   char *tmpStr;
1454
1455   X->notice = (Widget) XmCreateInformationDialog(X->kframe, "continue",
1456                                                  NULL, 0) ;
1457   contstr = XmStringCreateLocalized(vstrs[(int) V_CONTINUE]) ;
1458   message = XmStringCreateLocalized( str );
1459   XtVaSetValues(X->notice,
1460                 XmNautoUnmanage,      FALSE,
1461                 XmNcancelLabelString, contstr,
1462                 XmNmessageString,     message,
1463                 XmNdialogStyle,       XmDIALOG_FULL_APPLICATION_MODAL,
1464                 0) ;
1465   XmStringFree(contstr) ;
1466   XmStringFree(message) ;
1467   XtUnmanageChild((Widget) XmMessageBoxGetChild(X->notice,
1468                                                 XmDIALOG_OK_BUTTON)) ;
1469   XtUnmanageChild((Widget) XmMessageBoxGetChild(X->notice,
1470                                                 XmDIALOG_HELP_BUTTON)) ;
1471
1472   tmpStr = GETMESSAGE(2, 36, "Continue Notice");
1473   cstr = XmStringCreateLocalized(tmpStr) ;
1474   XtVaSetValues(X->notice, XmNdialogTitle, cstr, 0) ;
1475   XmStringFree(cstr) ;
1476
1477   XtManageChild(X->notice) ;
1478 }
1479
1480
1481 /*ARGSUSED*/
1482 static void
1483 do_confirm_notice(parent, str)
1484 Widget parent ;
1485 char *str ;
1486 {
1487   XmString confirm, cancel, message, cstr ;
1488   char *tmpStr;
1489
1490
1491   X->notice = (Widget) XmCreateInformationDialog(X->kframe, "continue",
1492                                                     NULL, 0) ;
1493   confirm = XmStringCreateLocalized(vstrs[(int) V_CONFIRM]) ;
1494   cancel  = XmStringCreateLocalized(vstrs[(int) V_CANCEL]) ;
1495   message = XmStringCreateLocalized( str );
1496   XtVaSetValues(X->notice,
1497                 XmNautoUnmanage,      FALSE,
1498                 XmNcancelLabelString, cancel,
1499                 XmNokLabelString,     confirm,
1500                 XmNmessageString,     message,
1501                 XmNdialogStyle,       XmDIALOG_APPLICATION_MODAL,
1502                 0) ;
1503   XmStringFree(confirm) ;
1504   XmStringFree(cancel) ;
1505   XmStringFree(message) ;
1506   XtUnmanageChild((Widget) XmMessageBoxGetChild(X->notice,
1507                                                 XmDIALOG_HELP_BUTTON)) ;
1508   XtAddCallback(X->notice, XmNokCallback, confirm_callback, NULL) ;
1509
1510   tmpStr = GETMESSAGE(2, 37, "Confirmation Notice");
1511   cstr = XmStringCreateLocalized(tmpStr) ;
1512   XtVaSetValues(X->notice, XmNdialogTitle, cstr, 0) ;
1513   XmStringFree(cstr) ;
1514
1515   XtManageChild(X->notice) ;
1516
1517 }
1518
1519
1520 /*ARGSUSED*/
1521 static void
1522 close_reg(widget, client_data, call_data)
1523 Widget widget ;
1524 XtPointer client_data, call_data ;
1525 {
1526   int type = (int)client_data;
1527
1528   if(type == MEM)
1529   {
1530      XtUnmanageChild(X->rframe);
1531      XtUnmapWidget(XtParent(X->rframe));
1532      v->rstate = 0 ;
1533   }
1534   else
1535   {
1536      XtUnmanageChild(X->frframe);
1537      XtUnmapWidget(XtParent(X->frframe));
1538      v->frstate = 0 ;
1539   }
1540 }
1541
1542
1543 /*ARGSUSED*/
1544 /* draw_button()
1545  *  This routine causes the calculator buttons to looked depressed (armed)
1546  *  and undepressed (disarmed) when the user uses the keyboard to select a
1547  *  button on the keyboard.  It's pretty straight forward:
1548  *    The user pressess a key from the keyboard
1549  *    The routine event_proc() gets called.
1550  *    It determines whether the key from the keyboard is a valid key.
1551  *    If it is, it sends that key to process_event()
1552  *    This routines then determines whether the key is an active key.
1553  *    If it is then it calls this routine to set the key to either armed
1554  *     or disarmed.  This state is determined by whether it is a keyboard
1555  *     up event or a keyboard down event.
1556  *  There is some special case code in here also.  There was a bug where
1557  *  if a user pressed a CNTL character key, the event order could cause
1558  *  the key to stay depressed.  The typical order is:
1559  *     Control key down
1560  *     KEY key down
1561  *     KEY key up
1562  *     Control key up
1563  *  When this typical order was pressed things worked fine.  But the problem
1564  *  arose when the order was:
1565  *     Control key down
1566  *     KEY key down
1567  *     Control key up
1568  *     KEY key up
1569  *  The problem was that when the last "KEY key up" was processed it is not
1570  *  recognized as a control key, so the calculator thought is was a "normal"
1571  *  key and disarmed that "normal" key button rather then the Control
1572  *  key button.  This is what the lastArmed and count static variables are
1573  *  used for.  They check to see if the last "KEY key up" corresponds to
1574  *  the last "Control key down" button that was armed.  If it doesn't then
1575  *  we know we need to disarm the "Control key" button rather then the
1576  *  "normal" button that was passed in.
1577  *
1578  */
1579 void
1580 draw_button(n, fcptype, row, column, inverted)
1581 int n;
1582 enum fcp_type fcptype ;
1583 int row, column, inverted ;
1584 {
1585   char str[10] ;
1586   Widget widget ;
1587   XmPushButtonWidget pb;
1588   int i, j, row2, column2;
1589   static XtIntervalId timerId = 0;
1590
1591   if(inverted)
1592   {
1593      widget = X->kbuttons[row][column] ;
1594      lastArmed[countArmed] = n;
1595      countArmed++;
1596   }
1597   else
1598   {
1599      if(countArmed == 0)
1600         return;
1601      for(i = 0; i < countArmed; i++)
1602      {
1603         if(lastArmed[i] == n)
1604            break;
1605      }
1606      if(countArmed == i && countArmed != 0)
1607         i = 0;
1608
1609      row2 = lastArmed[i] / MAXCOLS ;
1610      column2 = lastArmed[i] - (row2 * MAXCOLS) ;
1611      widget = X->kbuttons[row2][column2] ;
1612      for(j = i; j < countArmed; j++)
1613         lastArmed[j] = lastArmed[j + 1];
1614      countArmed--;
1615   }
1616
1617   if (inverted)
1618      strcpy(str, "Arm");
1619   else
1620      strcpy(str, "Disarm");
1621
1622   /* go call the correct arm/disarm function from Motif */
1623   XtCallActionProc(widget, str, X->event, NULL, 0) ;
1624
1625 }
1626
1627
1628 static int
1629 event_is_keypad(xevent)
1630 XEvent *xevent ;
1631 {
1632   if (xevent->type != KeyPress && xevent->type != KeyRelease) return(0) ;
1633   return(X->kparray[xevent->xkey.keycode - X->kcmin] > 0) ;
1634 }
1635
1636
1637 /*
1638  * event_proc()
1639  *  This routine is called any time a key on the keyboard is pressed.  It
1640  *  then determines whether the key is a valid key or whether it is to
1641  *  be ignore.  If it is a valid key it passes it on to be processed.
1642  *
1643  */
1644 /*ARGSUSED*/
1645 static void
1646 event_proc(widget, client_data, event, continue_to_dispatch)
1647 Widget widget ;
1648 XtPointer client_data ;
1649 XEvent *event ;
1650 Boolean *continue_to_dispatch ;
1651 {
1652   Widget w;
1653   Arg args[3];
1654   XmString label;
1655   String str ;
1656   int index;
1657   static char count = 0;
1658
1659   /* If the ASCII convert dialog, or the Help dialog
1660      is up and managed, we don't want the keystrokes to go to the calculator
1661      main, just those dialogs
1662      if ((X->Aframe != NULL && XtIsManaged(X->Aframe)) ||
1663      (X->helpDialog != NULL && X->helpMapped))
1664      {
1665      return;
1666      }
1667   */
1668
1669   if(ignore_event)
1670   {
1671      if(count == 0)
1672        count++;
1673      else {
1674         count = 0;
1675         ignore_event = False;
1676         XtRemoveTimeOut(timerId);
1677      }
1678      return;
1679   }
1680
1681   X->event = event ;
1682   v->event_type = get_next_event(widget, 0, event) ;
1683
1684   /* first check to see if there is an error condition, if there is we
1685      want to beep and return.
1686   */
1687
1688   XtSetArg(args[0], XmNlabelString, &label);
1689   XtGetValues(X->modevals[OPITEM], args, 1);
1690
1691   str = (char *) _XmStringUngenerate(label,
1692                                      XmFONTLIST_DEFAULT_TAG,
1693                                      XmCHARSET_TEXT, XmCHARSET_TEXT);
1694
1695   if(strcmp(vstrs[(int) V_CLR], str) == 0 &&
1696                       (v->cur_ch !=  KEY_CLR && v->cur_ch !=  KEY_QUIT))
1697   {
1698      if(v->event_type == KEYBOARD_DOWN)
1699         beep();
1700      else
1701      {
1702          index = get_index(v->cur_ch);
1703          if(index != TITEMS)
1704              draw_button(index, v->curwin, v->row, v->column, FALSE);
1705      }
1706      return;
1707   }
1708
1709   /* Now lets check to see if the input was for the Constants/Functions
1710      dialog.  If it was process it.
1711   */
1712   if(X->CFframe != NULL && XtIsManaged(X->CFframe))
1713   {
1714      w = XmGetFocusWidget(X->CFframe);
1715      if(w == X->CFpi_butOK)
1716      {
1717         if(v->cur_ch == KEY_EQ)
1718         {
1719            XtCallCallbacks(X->CFpi_butOK, XmNarmCallback, (XtPointer) NULL);
1720            XtCallCallbacks(X->CFpi_butOK, XmNactivateCallback,
1721                                                             (XtPointer) NULL);
1722         }
1723         if(v->event_type == ARROW || v->event_type == TAB)
1724         {
1725            XtSetArg(args[0], XmNdefaultButton, X->CFpi_butOK);
1726            XtSetValues(X->CFframe, args, 1);
1727         }
1728
1729         return;
1730      }
1731      else if(w == X->CFpi_butClose)
1732      {
1733         if(v->cur_ch == KEY_EQ)
1734         {
1735            XtCallCallbacks(X->CFpi_butClose, XmNarmCallback, (XtPointer) NULL);
1736            XtCallCallbacks(X->CFpi_butClose, XmNactivateCallback,
1737                                                             (XtPointer) NULL);
1738         }
1739         if(v->event_type == ARROW || v->event_type == TAB)
1740         {
1741            XtSetArg(args[0], XmNdefaultButton, NULL);
1742            XtSetValues(X->CFframe, args, 1);
1743         }
1744
1745         return;
1746      }
1747      else if(w == X->CFpi_butHelp)
1748      {
1749         if(v->cur_ch == KEY_EQ)
1750         {
1751            XtCallCallbacks(X->CFpi_butHelp, XmNarmCallback, (XtPointer) NULL);
1752            XtCallCallbacks(X->CFpi_butHelp, XmNactivateCallback,
1753                                                    (XtPointer) HELP_CONSTANT);
1754         }
1755         if(v->event_type == ARROW || v->event_type == TAB)
1756         {
1757            XtSetArg(args[0], XmNdefaultButton, NULL);
1758            XtSetValues(X->CFframe, args, 1);
1759         }
1760
1761         return;
1762      }
1763   }
1764
1765   index = get_index(v->cur_ch);
1766   if (index != TITEMS)
1767       draw_button(index, v->curwin, v->row, v->column, FALSE);
1768
1769   /* don't worry about this if there is something pending */
1770   if (v->pending == 0) {
1771      /* if the key is an "inactive" key (i.e. desensitized) then we want to
1772         ignore it. */
1773      switch(v->base)
1774      {
1775         case BIN:
1776            if(v->cur_ch == KEY_2 ||
1777               v->cur_ch == KEY_3 ||
1778               v->cur_ch == KEY_4 ||
1779               v->cur_ch == KEY_5 ||
1780               v->cur_ch == KEY_6 ||
1781               v->cur_ch == KEY_7)
1782                return;
1783         case OCT:
1784            if(v->cur_ch == KEY_8 ||
1785               v->cur_ch == KEY_9)
1786                return;
1787         case DEC:
1788            if(v->cur_ch == KEY_A ||
1789               v->cur_ch == KEY_B ||
1790               v->cur_ch == KEY_C ||
1791               v->cur_ch == KEY_D ||
1792               v->cur_ch == KEY_E ||
1793               v->cur_ch == KEY_F)
1794                return;
1795       }
1796    }
1797
1798   /* finally, check to see if it is a key we wish to ignore and motif
1799      will handle.
1800   */
1801   if(v->event_type == F4_PRESS || v->event_type == ARROW ||
1802      v->event_type == TAB || v->event_type == CONTROL ||
1803      v->event_type == SHIFT || v->event_type == SPACE ||
1804      v->event_type == ESCAPE || v->event_type == META || v->event_type == ALT)
1805       return;
1806   else if(v->event_type == NUM_LOCK)
1807   {
1808       v->num_lock = !v->num_lock;
1809   }
1810   else if (v->cur_ch == CTL('/'))
1811      return;
1812   else
1813   {
1814       ProcessMotifSelection(X->modevals[(int) DISPLAYITEM]);
1815       process_event(v->event_type);
1816   }
1817
1818   v->error = False;
1819   if (v->num_lock == True)
1820   {
1821       draw_button(0, v->curwin, 0, 0, TRUE);
1822   }
1823
1824   return;
1825 }
1826
1827 /* ------------------------------------------------------------- */
1828 /*  Primarily handles the selection in the display text widget.  */
1829 /*  Update the display before the event is processed for dtcalc. */
1830 /* ------------------------------------------------------------- */
1831
1832 static void
1833 ProcessMotifSelection(Widget W)
1834 {
1835     char key;
1836     int index;
1837     long i, bound;
1838     char *display = NULL;
1839     XmTextPosition left, right;
1840
1841     if (XmTextGetSelectionPosition (W, &left, &right) == True)
1842     {
1843         XmTextRemove(W);
1844         display = XmTextGetString(W);
1845
1846         bound = ( (long)strlen(display) - right + 1);
1847
1848         for (i = 0; i < bound; i++)
1849         {
1850             display[i+left] = display[i+right];
1851         }
1852
1853         index = get_index(v->cur_ch);
1854         key = buttons[index].value;
1855
1856         /* ------------------------------------------------------------ */
1857         /*  Append an extra character to be handled by do_delete func.  */
1858         /* ------------------------------------------------------------ */
1859
1860         if (key == '\b')
1861         {
1862             display[i] = 'a';
1863             display[i+1] = '\0';
1864         }
1865
1866         STRCPY(v->display, display);
1867         XtFree(display);
1868     }
1869
1870     return;
1871 }
1872
1873
1874 /*ARGSUSED*/
1875 static void
1876 frame_interpose(widget, clientData, event, continue_to_dispatch)
1877 Widget widget ;
1878 XtPointer clientData ;
1879 XEvent *event ;
1880 Boolean *continue_to_dispatch ;
1881 {
1882   if (!v->started) return ;
1883   if (event->type == MapNotify)
1884     {
1885       if (v->rstate)            win_display(FCP_REG,  TRUE) ;
1886       else if (v->frstate)      win_display(FCP_FIN_REG,  TRUE) ;
1887       v->iconic = FALSE ;
1888     }
1889   else if (event->type == UnmapNotify) v->iconic = TRUE ;
1890 }
1891
1892
1893 /*ARGSUSED*/
1894 static int
1895 get_next_event(widget, ev_action, xevent)
1896 Widget widget ;
1897 int ev_action ;
1898 XEvent *xevent ;
1899 {
1900   char *tmpStr, chs[2] ;
1901   int cval, down, nextc, up ;
1902   KeySym ksym;
1903   XKeyPressedEvent *key_event ;
1904
1905   if (!v->started) return(LASTEVENTPLUSONE) ;
1906   nextc = xevent->type ;
1907
1908   down    = xevent->type == ButtonPress   || xevent->type == KeyPress ;
1909   up      = xevent->type == ButtonRelease || xevent->type == KeyRelease ;
1910
1911   if (nextc == KeyPress || nextc == KeyRelease)
1912     {
1913       key_event = (XKeyPressedEvent *) xevent ;
1914       chs[0] = chs[1] = (char)0;
1915       /*
1916        * If the user enters a multibyte character, XLookupString()
1917        * will return zero because it only handles Latin-1 characters.
1918        * We can just return then because we're only looking for
1919        * Latin-1 characters anyway (see CDExc15419).
1920        */
1921       if (!XLookupString(key_event, chs, 1, &ksym,
1922                          (XComposeStatus *) NULL))
1923       {
1924           if (key_event->keycode == NUM_LOCK)
1925               return(NUM_LOCK);
1926           else
1927               return(LASTEVENTPLUSONE);
1928       }
1929
1930       /*
1931         Here's how the fix solves the problem:
1932
1933         When you press ctrl-space, the input method converts your composed
1934         input to a Kanji character and sends a keyboard event to dtcalc with
1935         a keycode of 0.  The keycode of 0 is the X convention that the
1936         application should call XmbLookupString() to get the Kanji character
1937         from the input method.
1938
1939         dtcalc calls XLookupString() instead though, which being a much older
1940         interface, doesn't know about this convention.  XLookupString() isn't
1941         able to map the keycode to anything and just returns 0.
1942
1943         The fix catches this and returns immediately.  Otherwise, the code
1944         would go on to call event_is_keypad() to see if the event was a keypad
1945         event like '+', '=', etc.  That function would core dump at the
1946         following line because of the negative array index:
1947
1948               return(X->kparray[xevent->xkey.keycode - X->kcmin] > 0) ;
1949
1950         Returning immediately from get_next_event() avoids the core dump and
1951         doesn't hurt anything because dtcalc doesn't actually use any Kanji
1952         characters for its keypad characters, just ASCII ones.
1953
1954         An alternative fix would be to use XmbLookupString() instead of
1955         XLookupString().  That fix would be more complex though, and as
1956         CDExc15419 points out, XLookupString() is fine here (as long as you
1957         check its return value).
1958         */
1959
1960       /*
1961       XLookupString(key_event, chs, 1, &ksym, (XComposeStatus *) NULL) ;
1962       */
1963       if (ksym == XK_F4 && down) return(F4_PRESS) ;
1964       else if (ksym == XK_F4 && up) return(F4_PRESS) ;
1965       else if (ksym == XK_Right  && down)
1966       {
1967           if (!event_is_keypad(xevent))
1968               return(ARROW);
1969       }
1970       else if (ksym == XK_Left  && down)
1971       {
1972          if (!event_is_keypad(xevent))
1973             return(ARROW);
1974       }
1975       else if (ksym == XK_Up  && down)
1976       {
1977          if (!event_is_keypad(xevent))
1978             return(ARROW);
1979       }
1980       else if (ksym == XK_Down  && down)
1981       {
1982          if (!event_is_keypad(xevent))
1983             return(ARROW);
1984       }
1985       else if (ksym == XK_F10  && down) return(F4_PRESS);
1986       else if (ksym == XK_F10  && up) return(F4_PRESS);
1987       else if (ksym == XK_Tab  && down) return(TAB);
1988       else if (ksym == XK_Tab  && up) return(TAB);
1989 /* #ifdef hpux */
1990 #ifdef HP_EXTENSIONS
1991       else if (ksym == XK_BackTab  && down) return(SHIFT);
1992       else if (ksym == XK_BackTab  && up) return(SHIFT);
1993       else if (ksym == hpXK_DeleteChar  && down) cval = 127;
1994       else if (ksym == hpXK_DeleteChar  && up) cval = 127;
1995 #endif
1996       else if (ksym == XK_Return && down) cval = KEY_EQ;
1997       else if (ksym == XK_Return && up) cval = KEY_EQ;
1998       else if (ksym == XK_Escape && down) return(ESCAPE);
1999       else if (ksym == XK_Escape && up) return(ESCAPE);
2000       else if (ksym == XK_Control_L  && down) return(CONTROL);
2001       else if (ksym == XK_Control_L  && up) return(CONTROL);
2002       else if (ksym == XK_Control_R  && down) return(CONTROL);
2003       else if (ksym == XK_Control_R  && up) return(CONTROL);
2004       else if (ksym == XK_Meta_L  && down) return(META);
2005       else if (ksym == XK_Meta_R  && up) return(META);
2006       else if (ksym == XK_Meta_L  && down) return(META);
2007       else if (ksym == XK_Meta_R  && up) return(META);
2008       else if (ksym == XK_Alt_L  && down) return(ALT);
2009       else if (ksym == XK_Alt_R  && up) return(ALT);
2010       else if (ksym == XK_Alt_L  && down) return(ALT);
2011       else if (ksym == XK_Alt_R  && up) return(ALT);
2012       else if (ksym == XK_Select  && down) return(SPACE);
2013       else if (ksym == XK_Select  && up) return(SPACE);
2014       else if (ksym == XK_space  && down) return(SPACE);
2015       else if (ksym == XK_space  && up) return(SPACE);
2016       else if (ksym == XK_Shift_L || ksym == XK_Shift_R)
2017         return(LASTEVENTPLUSONE) ;
2018       else cval = chs[0] ;
2019     }
2020
2021   tmpStr = GETMESSAGE(3, 45, ".");
2022   if (event_is_keypad(xevent))
2023     {
2024 #ifdef _AIX
2025       /*
2026        * In keypad_keysym(), KeySym associated with xevent->xkey.keycode
2027        * is extracted by calling XKeycodeToKeysym(). But the current
2028        * implementation doesn't care of the modifires state. In this moment,
2029        * we can still use ksym which is got in the above XLookupString().
2030        * Sun's implementation seems to need an attention for this. But AIX
2031        * doesn't.
2032        * Still JP kbd NumLock state cannot be handled correctly.
2033        */
2034       switch (ksym)
2035 #else /* _AIX */
2036       switch (keypad_keysym(xevent))
2037 #endif /* _AIX */
2038         {
2039           case XK_KP_0        : v->cur_ch = '0' ;
2040                                 break ;
2041           case XK_KP_1        : v->cur_ch = '1' ;
2042                                 break ;
2043           case XK_KP_2        : v->cur_ch = '2' ;
2044                                 break ;
2045           case XK_KP_3        : v->cur_ch = '3' ;
2046                                 break ;
2047           case XK_KP_4        : v->cur_ch = '4' ;
2048                                 break ;
2049           case XK_KP_5        : v->cur_ch = '5' ;
2050                                 break ;
2051           case XK_KP_6        : v->cur_ch = '6' ;
2052                                 break ;
2053           case XK_KP_7        : v->cur_ch = '7' ;
2054                                 break ;
2055           case XK_KP_8        : v->cur_ch = '8' ;
2056                                 break ;
2057           case XK_KP_9        : v->cur_ch = '9' ;
2058                                 break ;
2059           case XK_KP_Add      : v->cur_ch = '+' ;
2060                                 break ;
2061           case XK_KP_Subtract : v->cur_ch = '-' ;
2062                                 break ;
2063           case XK_KP_Multiply : v->cur_ch = 'x' ;
2064                                 break ;
2065           case XK_KP_Divide   : v->cur_ch = '/' ;
2066                                 break ;
2067           case XK_KP_Equal    :
2068           case XK_KP_Enter    : v->cur_ch = '=' ;
2069                                 break ;
2070           case XK_KP_Decimal  : v->cur_ch = tmpStr[0] ;
2071         }
2072            if (down) return(KEYBOARD_DOWN) ;
2073       else if (up)   return(KEYBOARD_UP) ;
2074     }
2075   else if ((nextc == KeyPress || nextc == KeyRelease) &&
2076           (IS_KEY(cval, KEY_BSP) || IS_KEY(cval, KEY_CLR)))
2077     {
2078       v->cur_ch = cval ;        /* Delete and Back Space keys. */
2079            if (down) return(KEYBOARD_DOWN) ;
2080       else if (up)   return(KEYBOARD_UP) ;
2081     }
2082
2083   if ((nextc == KeyPress || nextc == KeyRelease) && cval >= 0 && cval <= 127)
2084     {
2085
2086 /*  If this is a '*' or Return key press, then map to their better known
2087  *  equivalents, so that button highlighting works correctly.
2088  */
2089
2090       if (cval == '*')      cval = KEY_MUL ;
2091
2092 /*  All the rest of the ASCII characters. */
2093
2094       v->cur_ch = cval ;
2095            if (down) return(KEYBOARD_DOWN) ;
2096       else if (up)   return(KEYBOARD_UP) ;
2097     }
2098
2099   return(LASTEVENTPLUSONE) ;
2100 }
2101
2102
2103 char *
2104 get_resource(rtype)      /* Get dtcalc resource from merged database. */
2105 enum res_type rtype ;
2106 {
2107   char str[MAXLINE] ;
2108
2109   STRCPY(str, calc_res[(int) rtype]) ;
2110   return(ds_get_resource(X->rDB, v->appname, str)) ;
2111 }
2112
2113
2114 void
2115 grey_button(row, column, state)
2116 int row, column, state ;
2117 {
2118   XtSetSensitive(X->kbuttons[row][column], !state) ;
2119 }
2120
2121
2122 void
2123 init_graphics()
2124 {
2125   char *tmpStr, *tmpStr1;
2126
2127   tmpStr = GETMESSAGE(2, 12, "Calculator");
2128   tmpStr1 = XtNewString(tmpStr);
2129   XtVaSetValues(X->kframe,
2130                 XmNiconName, tmpStr1,
2131                 XmNtitle,    tmpStr1,
2132                 0) ;
2133   dtcalc_kpanel_create(X->kframe) ;
2134   dtcalc_kkeyboard_create(X->kpanel) ;
2135   make_modewin();
2136   XtSetMappedWhenManaged(X->kframe, False);
2137   XtRealizeWidget(X->kframe) ;
2138   XSync(X->dpy, False);
2139   setCalcHints();
2140   XtSetMappedWhenManaged(X->kframe, True);
2141   XtMapWidget( X->kframe );
2142   XSync(X->dpy, False);
2143   XtFree(tmpStr1);
2144
2145   X->Aframe  = NULL ;
2146   X->CFframe = NULL ;
2147   X->Pframe  = NULL ;
2148 }
2149
2150
2151 static int
2152 is_window_showing(widget)
2153 Widget widget ;
2154 {
2155   return(XtIsManaged(widget)) ;
2156 }
2157
2158
2159 void
2160 key_init()
2161 {
2162   int i, j ;
2163   KeySym *tmp ;
2164   KeySym ks ;
2165
2166   XDisplayKeycodes(X->dpy, &X->kcmin, &X->kcmax) ;
2167   tmp = XGetKeyboardMapping(X->dpy, X->kcmin, 1, &X->keysyms_per_key) ;
2168   XFree((char *) tmp) ;
2169
2170   X->kparray = (unsigned char *) malloc(X->kcmax - X->kcmin + 1) ;
2171
2172 /*  For each key, run through its list of keysyms.  If this keysym is a
2173  *  keypad keysym, we know this key is on the keypad.  Mark it as such in
2174  *  kparray[].
2175  */
2176
2177   for (i = X->kcmin; i <= X->kcmax; ++i)
2178     {
2179       X->kparray[i - X->kcmin] = 0 ;
2180       for (j = 0; j < X->keysyms_per_key; ++j)
2181         {
2182           ks = XKeycodeToKeysym(X->dpy, i, j) ;
2183           if (IsKeypadKey(ks))
2184             {
2185               X->kparray[i - X->kcmin] = 1 ;
2186               break ;
2187             }
2188         }
2189     }
2190 }
2191
2192
2193 static KeySym
2194 keypad_keysym(xevent)
2195 XEvent *xevent ;
2196 {
2197   int i ;
2198   int keycode = xevent->xkey.keycode ;
2199   KeySym ks ;
2200
2201   for (i = 0; i < X->keysyms_per_key; ++i)
2202     {
2203       ks = XKeycodeToKeysym(X->dpy, keycode, i) ;
2204       if (IsKeypadKey(ks))
2205       {
2206 #ifdef sun
2207          if(ks != XK_KP_Insert)
2208 #endif
2209             return(ks) ;
2210       }
2211     }
2212   return(NoSymbol) ;
2213 }
2214
2215 void
2216 load_resources()
2217 {
2218   X->rDB = ds_load_resources(X->dpy) ;
2219 }
2220
2221
2222 void
2223 make_frames()
2224 {
2225   char *tool_label = NULL ;
2226   int depth ;
2227
2228   if (v->titleline == NULL)
2229     {
2230       tool_label = (char *) calloc(1, strlen(lstrs[(int) L_UCALC]) + 3);
2231
2232       SPRINTF(tool_label, "%s", lstrs[(int) L_UCALC]);
2233     }
2234   else read_str(&tool_label, v->titleline) ;
2235
2236   X->clipboard   = XInternAtom(X->dpy, "CLIPBOARD", FALSE) ;
2237   X->length_atom = XInternAtom(X->dpy, "LENGTH",    FALSE) ;
2238   XtAddEventHandler(X->kframe, StructureNotifyMask, FALSE,
2239                     frame_interpose, NULL) ;
2240   XtVaSetValues(X->kframe,
2241                 XmNtitle, tool_label,
2242                 0) ;
2243
2244   XtVaGetValues(X->kframe,
2245                 XmNdepth, &depth,
2246                 0) ;
2247
2248   if(v->titleline == NULL)
2249     free(tool_label);
2250 }
2251
2252 void
2253 make_modewin()             /* Draw special mode frame plus buttons. */
2254 {
2255   switch_mode(v->modetype) ;
2256 }
2257
2258 void
2259 make_registers(type)           /* Calculate memory register frame values. */
2260 int type;
2261 {
2262   char line[MAXLINE] ;     /* Current memory register line. */
2263   char *ptr, *tmp, *tmpStr;
2264   int i, savAcc ;
2265   XmString str, numStr ;
2266   int MPtemp[MP_SIZE];
2267
2268   if(type == MEM)
2269   {
2270      if (!v->rstate) return ;
2271   }
2272   else if(type == FIN)
2273   {
2274      if (!v->frstate) return ;
2275   }
2276
2277   dtcalc_initialize_rframe(X->kframe, type) ;
2278
2279   tmpStr = GETMESSAGE(3, 45, ".");
2280   if(type == MEM)
2281   {
2282      for (i = 0; i < MAXREGS; i++)
2283        {
2284          SPRINTF(line, "%s:   %s", menu_entries[i + 10].str,
2285                                       make_number(v->MPmvals[i], FALSE))  ;
2286
2287          {
2288             /* if it's not a "." let's go change it to what it should be */
2289             ptr = DtStrrchr(line, '.');
2290             if(ptr != NULL)
2291                ptr[0] = tmpStr[0];
2292          }
2293          str = XmStringCreateLocalized(line) ;
2294          XtVaSetValues(X->registers[i], XmNlabelString, str, 0) ;
2295          XmStringFree(str) ;
2296        }
2297   }
2298   else
2299   {
2300      for (i = 0; i < FINREGS; i++)
2301        {
2302          if( i == 5)
2303          {
2304             mpcdm(&(v->MPfvals[i]), MPtemp);
2305             tmp = make_number(MPtemp, FALSE);
2306             ptr = DtStrchr(tmp, 'e');
2307             if(ptr == NULL)
2308             {
2309                ptr = DtStrchr(tmp, '.');
2310                if(ptr == NULL)
2311                {
2312                   ptr = DtStrchr(tmp, ',');
2313                   if(ptr != NULL)
2314                      *ptr = '\0';
2315                }
2316                else
2317                   *ptr = '\0';
2318             }
2319          }
2320          /*
2321            else if ( i == 1 )
2322            {
2323            savAcc = v->accuracy;
2324            v->accuracy = 2;
2325            mpcdm(&(v->MPfvals[i]), MPtemp);
2326            tmp = make_number(MPtemp, FALSE);
2327            v->accuracy = savAcc;
2328            }
2329          */
2330          else
2331          {
2332             mpcdm(&(v->MPfvals[i]), MPtemp);
2333             tmp = make_number(MPtemp, FALSE);
2334          }
2335          if(strcmp(tmpStr, ".") != 0)
2336          {
2337             /* if it's not a "." let's go change it to what it should be */
2338             ptr = DtStrrchr(tmp, '.');
2339             if(ptr != NULL)
2340                ptr[0] = tmpStr[0];
2341          }
2342          str = XmStringCreateLocalized(menu_entries[i + 34].str) ;
2343          numStr = XmStringCreateLocalized(tmp);
2344          XtVaSetValues(X->fregisters[i], XmNlabelString, str, 0) ;
2345          XtVaSetValues(X->fregistersvals[i], XmNlabelString, numStr,
2346                                             XmNalignment, XmALIGNMENT_END, 0) ;
2347          XmStringFree(str) ;
2348          XmStringFree(numStr) ;
2349        }
2350   }
2351 }
2352
2353
2354 /*ARGSUSED*/
2355 static void
2356 menu_handler(widget, client_data, event, continue_to_dispatch)
2357 Widget widget ;
2358 XtPointer client_data ;
2359 XEvent *event ;
2360 Boolean *continue_to_dispatch ;
2361 {
2362   int button ;
2363   Widget menu ;
2364
2365   X->mtype = (enum menu_type) client_data ;
2366   menu = X->menus[(int) X->mtype] ;
2367   XtVaGetValues(menu, XmNwhichButton, &button, 0) ;
2368   if (event->xbutton.button == button)
2369     {
2370       XmMenuPosition(menu, (XButtonPressedEvent *) event) ;
2371       XtManageChild(menu) ;
2372     }
2373 }
2374
2375
2376 /*ARGSUSED*/
2377 void
2378 menu_proc(widget, client_data, call_data)
2379 Widget widget ;
2380 XtPointer client_data, call_data ;
2381 {
2382   int choice = ((int) client_data) & 0xFFFF ;
2383
2384   v->curwin = ((int) client_data) >> 16 ;
2385   handle_menu_selection(X->mrec[(int) X->mtype], choice) ;
2386 }
2387
2388
2389 /*ARGSUSED*/
2390 static void
2391 new_cf_value(widget, client_data, call_data)
2392 Widget widget ;
2393 XtPointer client_data, call_data ;
2394 {
2395     /*
2396       for hard testing when there is no Input Method available
2397     wchar_t *wch = (wchar_t *)  "wide";
2398     mbchar_t *mbch = (mbchar_t *) "MBYTE";
2399       */
2400
2401   enum menu_type mtype = (enum menu_type) client_data;
2402   XmString cstr ;
2403
2404   if (X->CFframe == NULL) create_cfframe() ;
2405   if (mtype ==  M_CON)
2406     {
2407       X->CFtype = M_CON ;
2408       set_text_str(X->CFpi_cftext, T_LABEL, lstrs[(int) L_CONNO]) ;
2409
2410       cstr = XmStringCreateLocalized(lstrs[(int) L_NEWCON]) ;
2411       XtVaSetValues(X->CFframe, XmNdialogTitle, cstr, 0) ;
2412       XmStringFree(cstr) ;
2413
2414       XtRemoveAllCallbacks(X->CFpi_butHelp, XmNactivateCallback);
2415       XtAddCallback(X->CFpi_butHelp, XmNactivateCallback, HelpRequestCB,
2416                                                     (XtPointer) HELP_CONSTANT);
2417     }
2418   else
2419     {
2420       X->CFtype = M_FUN ;
2421       set_text_str(X->CFpi_cftext, T_LABEL, lstrs[(int) L_FUNNO]) ;
2422
2423       cstr = XmStringCreateLocalized(lstrs[(int) L_NEWFUN]) ;
2424       XtVaSetValues(X->CFframe, XmNdialogTitle, cstr, 0) ;
2425       XmStringFree(cstr) ;
2426
2427       XtRemoveAllCallbacks(X->CFpi_butHelp, XmNactivateCallback);
2428       XtAddCallback(X->CFpi_butHelp, XmNactivateCallback, HelpRequestCB,
2429                                                     (XtPointer) HELP_FUNCTION);
2430     }
2431
2432 /* Clear text fields. */
2433
2434   set_text_str(X->CFpi_cftext, T_VALUE, "") ;
2435   set_text_str(X->CFpi_dtext,  T_VALUE, "") ;
2436   set_text_str(X->CFpi_vtext,  T_VALUE, "") ;
2437
2438   /*
2439           for hard testing when there is no Input Method available
2440   XmTextFieldSetStringWcs(X->CFpi_vtext->textfield, wch);
2441   XmTextFieldSetStringWcs(X->CFpi_vtext->textfield, mbch);
2442     */
2443
2444   XmProcessTraversal(X->CFpi_cftext->textfield, XmTRAVERSE_CURRENT) ;
2445
2446   if (!is_window_showing(X->CFframe))
2447     _DtGenericMapWindow (X->kframe, X->CFframe);
2448
2449   XtManageChild(X->CFframe) ;
2450
2451   /* lets set the focus in the first text widget */
2452   XmProcessTraversal(X->CFpi_cftext->textfield, XmTRAVERSE_CURRENT);
2453   ignore_event = True;
2454   timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
2455                              TimerEvent, (XtPointer) NULL);
2456 }
2457
2458
2459 void
2460 put_resource(rtype, value)   /* Put calc resource into database. */
2461 enum res_type rtype ;
2462 char *value ;
2463 {
2464   ds_put_resource(&(X->dtcalcDB), v->appname, calc_res[(int) rtype], value) ;
2465 }
2466
2467
2468 void
2469 redraw_buttons()
2470 {
2471   enum fcp_type scurwin ;
2472   int column, n, row ;
2473   XmString lstr ;
2474
2475   scurwin   = v->curwin ;
2476   v->curwin = FCP_KEY ;
2477   for (row = 0; row < BROWS; row++)
2478     for (column = 0; column < BCOLS; column++)
2479       {
2480         n = row * MAXCOLS + column ;
2481         get_label(n);
2482         lstr = XmStringCreateLocalized(v->pstr) ;
2483         XtVaSetValues(X->kbuttons[row][column], XmNlabelString, lstr, NULL);
2484         XmStringFree(lstr) ;
2485       }
2486   v->curwin = scurwin ;
2487 }
2488
2489
2490 void
2491 save_cmdline(argc, argv)
2492 int argc ;
2493 char *argv[] ;
2494 {
2495   ds_save_cmdline(X->dpy, XtWindow(X->kframe), argc, argv) ;
2496 }
2497
2498
2499 void
2500 save_resources(filename)
2501 char *filename;
2502 {
2503   int reply = ds_save_resources(X->dtcalcDB, filename) ;
2504
2505   if (reply) _DtSimpleError (v->appname, DtWarning, NULL, vstrs[(int) V_NORSAVE]);
2506 }
2507
2508 void
2509 ErrorDialog(string)
2510 char *string;
2511 {
2512    ErrDialog(string, X->mainWin);
2513 }
2514
2515 void
2516 set_item(itemno, str)
2517 enum item_type itemno ;
2518 char *str ;
2519 {
2520   Widget w ;
2521   XmString cstr ;
2522   char *tmpStr, *ptr, displayStr[50];
2523
2524   if (itemno == DISPLAYITEM)
2525     {
2526       if(!NoDisplay)
2527       {
2528          if(str != NULL && (strcmp(str, "") != 0))
2529          {
2530             /* Let's get the decimal point, in some languages it's a , */
2531             strcpy(displayStr, str);
2532             tmpStr = GETMESSAGE(3, 45, ".");
2533             if(strcmp(tmpStr, ".") != 0)
2534             {
2535                /* if it's not a "." let's go change it to what it should be */
2536                ptr = DtStrrchr(displayStr, '.');
2537                if(ptr != NULL)
2538                   ptr[0] = tmpStr[0];
2539             }
2540             w = X->modevals[(int) DISPLAYITEM] ;
2541             XmTextSetString(w, displayStr) ;
2542             XmTextSetInsertionPosition(w, XmTextGetLastPosition(w)) ;
2543             XSync(X->dpy, False);
2544          }
2545       }
2546       return ;
2547     }
2548   else
2549     {
2550        if(str != NULL)
2551        {
2552           cstr = XmStringCreateLocalized(str) ;
2553           XtVaSetValues(X->modevals[(int) itemno], XmNlabelString, cstr, 0) ;
2554           XmStringFree(cstr) ;
2555        }
2556     }
2557 }
2558
2559 void
2560 set_title(fcptype, str)     /* Set new title for a window. */
2561 enum fcp_type fcptype ;
2562 char *str ;
2563 {
2564   Widget w ;
2565   XmString cstr ;
2566
2567
2568   if (fcptype == FCP_KEY)
2569     w = X->kframe ;
2570   else if (fcptype == FCP_REG)
2571     w = X->rframe ;
2572   else if (fcptype == FCP_FIN_REG)
2573     w = X->frframe ;
2574   else if (fcptype == FCP_MODE)
2575     w = X->mframe[(int) v->modetype] ;
2576
2577   if (fcptype == FCP_KEY)
2578     XtVaSetValues(w, XmNtitle, str, 0) ;
2579   else
2580     {
2581       cstr = XmStringCreateLocalized(str) ;
2582       XtVaSetValues(w, XmNdialogTitle, cstr, 0) ;
2583       XmStringFree(cstr) ;
2584     }
2585
2586 }
2587
2588 /*ARGSUSED*/
2589 void
2590 show_ascii(widget, client_data, call_data)
2591 Widget widget ;
2592 XtPointer client_data, call_data ;
2593 {
2594   char *str ;
2595   int val ;
2596
2597   str = XmTextFieldGetString(X->Api_text->textfield);
2598   val = str[strlen(str) - 1] ;
2599   mpcim(&val, v->MPdisp_val) ;
2600   show_display(v->MPdisp_val) ;
2601   XtFree(str);
2602 }
2603
2604
2605 void
2606 show_ascii_frame()      /* Display ASCII popup. */
2607 {
2608   int j;
2609   XmString tstr ;
2610   Widget sep, frame, form;
2611   Arg args[15];
2612   XmString label_string;
2613
2614   if (X->Aframe == NULL)
2615     {
2616       X->Aframe = (Widget) XmCreateFormDialog(X->kframe, "aframe", NULL, 0) ;
2617       tstr = XmStringCreateLocalized(pstrs[(int) P_ASCIIT]) ;
2618       XtVaSetValues(X->Aframe,
2619                     XmNdialogTitle,     tstr,
2620                     XmNautoUnmanage,    FALSE,
2621                     XmNallowShellResize, TRUE,
2622                     XmNdefaultPosition, FALSE,
2623                     NULL) ;
2624       XmStringFree(tstr) ;
2625
2626       /*  Adjust the decorations for the dialog shell of the dialog  */
2627       XtSetArg (args[0], XmNmwmFunctions, MWM_FUNC_MOVE);
2628       XtSetArg (args[1], XmNmwmDecorations, MWM_DECOR_BORDER | MWM_DECOR_TITLE);
2629       XtSetValues (XtParent(X->Aframe), args, 2);
2630
2631       X->Api_text = make_textW(X->Aframe, pstrs[(int) P_CHAR]) ;
2632
2633       XtSetArg (args[0], XmNtopAttachment, XmATTACH_FORM);
2634       XtSetArg (args[1], XmNtopOffset, 5);
2635       XtSetArg (args[2], XmNleftAttachment, XmATTACH_FORM);
2636       XtSetArg (args[3], XmNleftOffset, 5);
2637       XtSetValues(X->Api_text->manager, args, 4);
2638
2639       XtSetArg (args[0], XmNmaxLength, 1);
2640       XtSetValues(X->Api_text->textfield, args, 1);
2641
2642       XtSetArg (args[0], XmNtopAttachment, XmATTACH_WIDGET);
2643       XtSetArg (args[1], XmNtopWidget, X->Api_text->manager);
2644       XtSetArg (args[2], XmNtopOffset, 3);
2645       XtSetArg (args[3], XmNleftAttachment, XmATTACH_FORM);
2646       XtSetArg (args[4], XmNrightAttachment, XmATTACH_FORM);
2647       sep = XmCreateSeparator(X->Aframe, "sep", args, 5);
2648       XtManageChild(sep);
2649
2650       label_string = XmStringCreateLocalized ( GETMESSAGE(2, 33, "Apply") );
2651       XtSetArg (args[0], XmNmarginHeight, 2);
2652       XtSetArg (args[1], XmNmarginWidth, 15);
2653       XtSetArg (args[2], XmNlabelString, label_string);
2654       XtSetArg (args[3], XmNtopAttachment, XmATTACH_WIDGET);
2655       XtSetArg (args[4], XmNtopWidget, sep);
2656       XtSetArg (args[5], XmNtopOffset, 5);
2657       XtSetArg (args[6], XmNleftAttachment, XmATTACH_FORM);
2658       XtSetArg (args[7], XmNleftOffset, 10);
2659       XtSetArg (args[8], XmNbottomAttachment, XmATTACH_FORM);
2660       XtSetArg (args[9], XmNbottomOffset, 5);
2661       X->Api_butOK = XmCreatePushButton(X->Aframe, "button", args, 10);
2662       XmStringFree(label_string);
2663       XtManageChild(X->Api_butOK);
2664
2665       label_string = XmStringCreateLocalized ( GETMESSAGE(2, 32, "Close") );
2666       XtSetArg (args[0], XmNmarginHeight, 2);
2667       XtSetArg (args[1], XmNmarginWidth, 10);
2668       XtSetArg (args[2], XmNlabelString, label_string);
2669       XtSetArg (args[3], XmNtopAttachment, XmATTACH_WIDGET);
2670       XtSetArg (args[4], XmNtopWidget, sep);
2671       XtSetArg (args[5], XmNtopOffset, 5);
2672       XtSetArg (args[6], XmNleftAttachment, XmATTACH_WIDGET);
2673       XtSetArg (args[7], XmNleftWidget, X->Api_butOK);
2674       XtSetArg (args[8], XmNleftOffset, 10);
2675       XtSetArg (args[9], XmNbottomAttachment, XmATTACH_FORM);
2676       XtSetArg (args[10], XmNbottomOffset, 5);
2677       X->Api_butClose = XmCreatePushButton(X->Aframe, "button", args, 11);
2678       XmStringFree(label_string);
2679       XtManageChild(X->Api_butClose);
2680
2681       label_string = XmStringCreateLocalized ( GETMESSAGE(2, 18, "Help") );
2682       XtSetArg (args[0], XmNmarginHeight, 2);
2683       XtSetArg (args[1], XmNmarginWidth, 10);
2684       XtSetArg (args[2], XmNlabelString, label_string);
2685       XtSetArg (args[3], XmNtopAttachment, XmATTACH_WIDGET);
2686       XtSetArg (args[4], XmNtopWidget, sep);
2687       XtSetArg (args[5], XmNtopOffset, 5);
2688       XtSetArg (args[6], XmNleftAttachment, XmATTACH_WIDGET);
2689       XtSetArg (args[7], XmNleftWidget, X->Api_butClose);
2690       XtSetArg (args[8], XmNleftOffset, 10);
2691       XtSetArg (args[9], XmNrightAttachment, XmATTACH_FORM);
2692       XtSetArg (args[10], XmNrightOffset, 10);
2693       XtSetArg (args[11], XmNbottomAttachment, XmATTACH_FORM);
2694       XtSetArg (args[12], XmNbottomOffset, 5);
2695       X->Api_butHelp = XmCreatePushButton(X->Aframe, "button", args, 13);
2696       XmStringFree(label_string);
2697       XtManageChild(X->Api_butHelp);
2698
2699       XtAddCallback(X->Api_text->textfield, XmNactivateCallback,
2700                                                        show_ascii, NULL) ;
2701       XtAddCallback(X->Api_butOK,  XmNactivateCallback, show_ascii, NULL) ;
2702       XtAddCallback(X->Api_butClose, XmNactivateCallback, close_ascii,
2703                                                           (XtPointer) NULL) ;
2704       XtAddCallback(X->Api_butHelp, XmNactivateCallback, HelpRequestCB,
2705                                                     (XtPointer) HELP_ASCII) ;
2706
2707       j = 0;
2708       XtSetArg (args[j], XmNcancelButton, X->Api_butClose); j++;
2709       XtSetArg (args[j], XmNdefaultButton, X->Api_butOK); j++;
2710       XtSetValues (X->Aframe, args, j);
2711     }
2712
2713   if (!is_window_showing(X->Aframe))
2714     _DtGenericMapWindow (X->kframe, X->Aframe);
2715
2716   XtManageChild(X->Aframe) ;
2717
2718   XmProcessTraversal(X->Api_text->textfield, XmTRAVERSE_CURRENT);
2719   ignore_event = True;
2720   timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
2721                              TimerEvent, (XtPointer) NULL);
2722 }
2723
2724
2725 void
2726 start_tool()
2727 {
2728   saveatom = XmInternAtom(X->dpy, "WM_SAVE_YOURSELF", FALSE) ;
2729   command_atom = XA_WM_COMMAND;
2730   wm_state_atom = XmInternAtom (X->dpy, "WM_STATE", False);
2731
2732   XmAddWMProtocols(X->kframe, &saveatom, 1) ;
2733   XmAddWMProtocolCallback(X->kframe, saveatom, save_state, (XtPointer)NULL) ;
2734
2735   v->started = 1 ;
2736   XSetErrorHandler((int (*)())xerror_interpose) ;
2737   XtAddEventHandler(X->kframe, KeyPressMask | KeyReleaseMask,
2738                     FALSE, event_proc, NULL) ;
2739   XmProcessTraversal( X->kbuttons[0][0], XmTRAVERSE_CURRENT );
2740
2741   do_clear();
2742
2743   XtAppMainLoop(X->app) ;
2744 }
2745
2746 void
2747 clear_buttons( start )
2748 int start;
2749 {
2750   int i, n;
2751   int row, column;
2752   Arg args[8];
2753   XmString lstr ;
2754   static Boolean first = True;
2755
2756   if(first)
2757   {
2758      i = 0;
2759      if(buttons[i].str != NULL)
2760      {
2761         XtFree(buttons[i].str);
2762         XtFree(buttons[i].str2);
2763         XtFree(buttons[i].resname);
2764      }
2765      buttons[i].str = XtNewString("");
2766      buttons[i].str2 = XtNewString("");
2767      buttons[i].resname = XtNewString("blank");
2768      buttons[i].value = 0;
2769      buttons[i].opdisp = OP_SET;
2770      buttons[i].mtype = M_NONE;
2771
2772      n = 0;
2773      lstr = XmStringCreateLocalized(buttons[i].str);
2774      XtSetArg (args[n], XmNlabelString, lstr); n++;
2775      if(colorSrv)
2776      {
2777         XtSetArg (args[n], XmNbackground, pixels[1].bg); n++;
2778         XtSetArg (args[n], XmNforeground, pixels[1].fg); n++;
2779         XtSetArg (args[n], XmNtopShadowColor, pixels[1].ts); n++;
2780         XtSetArg (args[n], XmNbottomShadowColor, pixels[1].bs); n++;
2781         XtSetArg (args[n], XmNarmColor, pixels[1].sc); n++;
2782      }
2783      XtSetValues( X->kbuttons[0][0], args, n);
2784      XmStringFree(lstr) ;
2785      first = False;
2786   }
2787
2788   row = (start / BCOLS) + 3;
2789   column = start % BCOLS;
2790   for(i = start + 12; i < 24; i++)
2791   {
2792      XtFree(buttons[i].str);
2793      XtFree(buttons[i].resname);
2794      buttons[i].str = XtNewString("");
2795      buttons[i].resname = XtNewString("blank");
2796      buttons[i].value = 0;
2797      buttons[i].opdisp = OP_SET;
2798      buttons[i].mtype = M_NONE;
2799
2800      n = 0;
2801      lstr = XmStringCreateLocalized(buttons[i].str);
2802      XtSetArg (args[n], XmNlabelString, lstr); n++;
2803      if(colorSrv)
2804      {
2805         XtSetArg (args[n], XmNbackground, pixels[1].bg); n++;
2806         XtSetArg (args[n], XmNforeground, pixels[1].fg); n++;
2807         XtSetArg (args[n], XmNtopShadowColor, pixels[1].ts); n++;
2808         XtSetArg (args[n], XmNbottomShadowColor, pixels[1].bs); n++;
2809         XtSetArg (args[n], XmNarmColor, pixels[1].sc); n++;
2810      }
2811      XtSetValues( X->kbuttons[row][column], args, n);
2812      XmStringFree(lstr) ;
2813
2814      column++;
2815      if(column % BCOLS == 0)
2816      {
2817         row++;
2818         column = 0;
2819      }
2820   }
2821 }
2822
2823 void
2824 make_buttons_fin()
2825 {
2826   int i, n;
2827   int row, column;
2828   Arg args[8];
2829   XmString lstr ;
2830
2831   row = 3;
2832   column = 0;
2833   for(i = 12; i < 24; i++)
2834   {
2835      if(buttons[i].str != NULL)
2836      {
2837         XtFree(buttons[i].str);
2838         XtFree(buttons[i].str2);
2839         XtFree(buttons[i].resname);
2840      }
2841      buttons[i].str = XtNewString(mode_buttons[i - 12].str);
2842      buttons[i].str2 = XtNewString(mode_buttons[i - 12].str2);
2843      buttons[i].resname = XtNewString(mode_buttons[i - 12].resname);
2844      buttons[i].value = mode_buttons[i - 12].value;
2845      buttons[i].opdisp = mode_buttons[i - 12].opdisp;
2846      buttons[i].mtype = mode_buttons[i - 12].mtype;
2847      buttons[i].func = mode_buttons[i - 12].func;
2848
2849      n = 0;
2850      if(v->tstate)
2851         lstr = XmStringCreateLocalized(buttons[i].str2);
2852      else
2853         lstr = XmStringCreateLocalized(buttons[i].str);
2854      XtSetArg (args[n], XmNlabelString, lstr); n++;
2855      if(colorSrv)
2856      {
2857         XtSetArg (args[n], XmNbackground, pixels[7].bg); n++;
2858         XtSetArg (args[n], XmNforeground, pixels[7].fg); n++;
2859         XtSetArg (args[n], XmNtopShadowColor, pixels[7].ts); n++;
2860         XtSetArg (args[n], XmNbottomShadowColor, pixels[7].bs); n++;
2861         XtSetArg (args[n], XmNarmColor, pixels[7].sc); n++;
2862      }
2863      XtSetValues( X->kbuttons[row][column], args, n);
2864      XmStringFree(lstr) ;
2865
2866      column++;
2867      if(column % BCOLS == 0)
2868      {
2869         row++;
2870         column = 0;
2871      }
2872   }
2873   clear_buttons(11);
2874 }
2875
2876 void
2877 make_buttons_log()
2878 {
2879   int i, n;
2880   int row, column;
2881   Arg args[8];
2882   XmString lstr ;
2883
2884   row = 3;
2885   column = 0;
2886   for(i = 12; i < 24; i++)
2887   {
2888      if(buttons[i].str != NULL)
2889      {
2890         XtFree(buttons[i].str);
2891         XtFree(buttons[i].str2);
2892         XtFree(buttons[i].resname);
2893      }
2894      buttons[i].str = XtNewString(mode_buttons[i + 4].str);
2895      buttons[i].str2 = XtNewString(mode_buttons[i + 4].str2);
2896      buttons[i].resname = XtNewString(mode_buttons[i + 4].resname);
2897      buttons[i].value = mode_buttons[i + 4].value;
2898      buttons[i].opdisp = mode_buttons[i + 4].opdisp;
2899      buttons[i].mtype = mode_buttons[i + 4].mtype;
2900      buttons[i].func = mode_buttons[i + 4].func;
2901
2902      n = 0;
2903      if(v->tstate)
2904         lstr = XmStringCreateLocalized(buttons[i].str2);
2905      else
2906         lstr = XmStringCreateLocalized(buttons[i].str);
2907      XtSetArg (args[n], XmNlabelString, lstr);  n++;
2908      if(colorSrv)
2909      {
2910         XtSetArg (args[n], XmNbackground, pixels[7].bg); n++;
2911         XtSetArg (args[n], XmNforeground, pixels[7].fg); n++;
2912         XtSetArg (args[n], XmNtopShadowColor, pixels[7].ts); n++;
2913         XtSetArg (args[n], XmNbottomShadowColor, pixels[7].bs); n++;
2914         XtSetArg (args[n], XmNarmColor, pixels[7].sc); n++;
2915      }
2916      XtSetValues( X->kbuttons[row][column], args, n);
2917      XmStringFree(lstr) ;
2918
2919      column++;
2920      if(column % BCOLS == 0)
2921      {
2922         row++;
2923         column = 0;
2924      }
2925   }
2926   clear_buttons(9);
2927 }
2928
2929 void
2930 make_buttons_sci()
2931 {
2932   int i, n;
2933   int row, column;
2934   Arg args[8];
2935   XmString lstr ;
2936
2937   row = 3;
2938   column = 0;
2939   for(i = 12; i < 24; i++)
2940   {
2941      if(buttons[i].str != NULL)
2942      {
2943         XtFree(buttons[i].str);
2944         XtFree(buttons[i].str2);
2945         XtFree(buttons[i].resname);
2946      }
2947      buttons[i].str = XtNewString(mode_buttons[i + 20].str);
2948      buttons[i].str2 = XtNewString(mode_buttons[i + 20].str2);
2949      buttons[i].resname = XtNewString(mode_buttons[i + 20].resname);
2950      buttons[i].value = mode_buttons[i + 20].value;
2951      buttons[i].opdisp = mode_buttons[i + 20].opdisp;
2952      buttons[i].mtype = mode_buttons[i + 20].mtype;
2953      buttons[i].func = mode_buttons[i + 20].func;
2954
2955      n = 0;
2956      if(v->tstate)
2957         lstr = XmStringCreateLocalized(buttons[i].str2);
2958      else
2959         lstr = XmStringCreateLocalized(buttons[i].str);
2960      XtSetArg (args[n], XmNlabelString, lstr); n++;
2961      if(colorSrv)
2962      {
2963         XtSetArg (args[n], XmNbackground, pixels[7].bg); n++;
2964         XtSetArg (args[n], XmNforeground, pixels[7].fg); n++;
2965         XtSetArg (args[n], XmNtopShadowColor, pixels[7].ts); n++;
2966         XtSetArg (args[n], XmNbottomShadowColor, pixels[7].bs); n++;
2967         XtSetArg (args[n], XmNarmColor, pixels[7].sc); n++;
2968      }
2969      XtSetValues( X->kbuttons[row][column], args, n);
2970      XmStringFree(lstr) ;
2971
2972      column++;
2973      if(column % BCOLS == 0)
2974      {
2975         row++;
2976         column = 0;
2977      }
2978   }
2979   clear_buttons(12);
2980 }
2981
2982
2983 static void
2984 switch_mode(curmode)
2985 enum mode_type curmode ;
2986 {
2987   int i ;
2988   XmString lstr;
2989   Arg args[2];
2990
2991   v->modetype = curmode ;
2992   XtSetArg(args[0], XmNmenuHistory, modeArry[(int)curmode]);
2993   XtSetValues( X->modevals[(int)MODEITEM], args, 1);
2994   if((int)curmode == (int)FINANCIAL)
2995   {
2996      make_buttons_fin();
2997      XtSetSensitive(X->modevals[(int)TTYPEITEM], False);
2998      set_item(HYPITEM, "    ") ;
2999      set_item(INVITEM, "    ") ;
3000      return;
3001   }
3002   else if((int)curmode == (int)LOGICAL)
3003   {
3004      make_buttons_log();
3005      XtSetSensitive(X->modevals[(int)TTYPEITEM], False);
3006      set_item(HYPITEM, "    ") ;
3007      set_item(INVITEM, "    ") ;
3008   }
3009   else
3010   {
3011      make_buttons_sci();
3012      XtSetSensitive(X->modevals[(int)TTYPEITEM], True);
3013      set_item(HYPITEM, "    ") ;
3014      set_item(INVITEM, "    ") ;
3015   }
3016
3017 }
3018
3019
3020 static void
3021 update_cf_value()
3022 {
3023   char message[MAXLINE] ;
3024   char str[MAXLINE] ;          /* Temporary buffer for various strings. */
3025   char result[MAXLINE] ;
3026   char *ptr, *tmpStr;
3027   double tmp ;                 /* For converting constant value. */
3028   int i, len, inc ;
3029   int n ;                      /* Set to 1, if constant value is valid. */
3030   char cur_op, current, display[MAXLINE], old_cal_value, fnum[MAX_DIGITS+1];
3031   int cur_ch, toclear, tstate, pending, accuracy;
3032   int MPdisp_val[MP_SIZE], MPlast_input[MP_SIZE], MPresult[MP_SIZE] ;
3033
3034   switch (X->CFtype)
3035     {
3036       case M_CON : tmpStr = GETMESSAGE(3, 45, ".");
3037                    if(strcmp(tmpStr, ".") != 0)
3038                    {
3039                       /* if it's not a "." let's go change it to what it
3040                          should be */
3041                       ptr = DtStrchr(X->vval, tmpStr[0]);
3042                       while(ptr != NULL)
3043                       {
3044                          ptr[0] = '.';
3045                          ptr = DtStrchr(X->vval, tmpStr[0]);
3046                       }
3047                    }
3048                    /* need to run a "compute" of what was typed in */
3049                    len = strlen(X->vval) ;
3050                    STRCPY(str, X->vval);
3051                    if(X->vval[len - 1] != '=')
3052                    {
3053                       /* need to add an '=' at the end of the string so it
3054                          computes correctly */
3055                       strcat(str, "=");
3056                       len = strlen(str);
3057                    }
3058
3059                    if(strncmp(str, "-", 1) == 0)
3060                    {
3061                      inc = 1;
3062                      for(i=0; i < len -1; i++)
3063                      {
3064                         str[i] = str[i+inc];
3065                         if(inc == 0 || isdigit((int)str[i]) || str[i] == '.')
3066                           continue;
3067                         else
3068                         {
3069                           str[i] = 'C';
3070                           inc = 0;
3071                         }
3072                      }
3073                    }
3074                    /* now let's compute it, first save off some state */
3075                    cur_op = v->cur_op;
3076                    current = v->current;
3077                    old_cal_value = v->old_cal_value;
3078                    cur_ch = v->cur_ch;
3079                    toclear = v->toclear;
3080                    tstate = v->tstate;
3081                    pending = v->pending;
3082                    STRCPY(display, v->display);
3083                    STRCPY(fnum, v->fnum);
3084                    mpstr(v->MPdisp_val, MPdisp_val);
3085                    mpstr(v->MPlast_input, MPlast_input);
3086                    mpstr(v->MPresult, MPresult);
3087                    i = 0 ;
3088                    mpcim(&i, v->MPdisp_val) ;
3089                    mpcim(&i, v->MPlast_input) ;
3090                    mpcim(&i, v->MPresult) ;
3091                    v->cur_op = '?';
3092
3093                    NoDisplay = True;
3094                    process_str(str, M_CON);
3095                    NoDisplay = False;
3096
3097                    /* get the computed value */
3098                    accuracy = v->accuracy;
3099                    v->accuracy = 9 ;
3100                    STRCPY(result, make_number(v->MPresult, FALSE)) ;
3101                    v->accuracy = accuracy ;
3102
3103                    /* return to previous state */
3104                    v->cur_op = cur_op;
3105                    v->current = current;
3106                    v->old_cal_value = old_cal_value;
3107                    v->cur_ch = cur_ch;
3108                    v->toclear = toclear;
3109                    v->tstate = tstate;
3110                    v->pending = pending;
3111                    STRCPY(v->display, display);
3112                    STRCPY(v->fnum, fnum);
3113                    mpstr(MPdisp_val, v->MPdisp_val);
3114                    mpstr(MPlast_input, v->MPlast_input);
3115                    mpstr(MPresult, v->MPresult);
3116
3117                    set_item(DISPLAYITEM, v->display);
3118
3119                    n = sscanf(result, "%lf", &tmp) ;
3120                    ptr = DtStrchr(result, 'e');
3121                    if (n != 1 || ptr != NULL || v->error == TRUE)
3122                      {
3123                        SPRINTF(message, "%s\n%s", vstrs[(int) V_INVCON],
3124                                vstrs[(int) V_NOCHANGE]) ;
3125                        do_continue_notice(X->CFframe, message) ;
3126                        set_item(OPITEM, "") ;
3127                        if(v->cur_op != '?')
3128                           set_item(OPITEM, buttons[get_index(v->cur_op)].str);
3129                        v->error = FALSE;
3130                        return ;
3131                      }
3132
3133                    if(v->cur_op != '?')
3134                        set_item(OPITEM, buttons[get_index(v->cur_op)].str);
3135
3136                    /* now let's compute it, first save off some state */
3137                    if(strncmp(result, "-", 1) == 0)
3138                    {
3139                       len = strlen(result);
3140
3141                       STRCPY(str, result);
3142                       for(i=0; i < len; i++)
3143                          str[i] = str[i+1];
3144                       MPstr_to_num(str, DEC, v->MPcon_vals[X->cfno]) ;
3145                       mpneg(v->MPcon_vals[X->cfno], v->MPcon_vals[X->cfno]) ;
3146                    }
3147                    else
3148                       MPstr_to_num(result, DEC, v->MPcon_vals[X->cfno]) ;
3149
3150                    if(strncmp(result, "0.", 2) == 0 ||
3151                                    strncmp(result, "-0.", 3) == 0 )
3152                    {
3153                       len = strlen(result);
3154                       while(result[len - 1] == '0')
3155                       {
3156                           result[len - 1] = '\0';
3157                           len--;
3158                       }
3159                    }
3160                    SPRINTF(v->con_names[X->cfno], "%1d: %s [%s]",
3161                            X->cfno, result, X->dval) ;
3162                    break ;
3163       case M_FUN : tmpStr = GETMESSAGE(3, 45, ".");
3164                    if(strcmp(tmpStr, ".") != 0)
3165                    {
3166                       /* if it's not a "." let's go change it to what it
3167                          should be */
3168                       ptr = DtStrchr(X->vval, tmpStr[0]);
3169                       while(ptr != NULL)
3170                       {
3171                          ptr[0] = '.';
3172                          ptr = DtStrchr(X->vval, tmpStr[0]);
3173                       }
3174                    }
3175                    STRCPY(v->fun_vals[X->cfno], convert(X->vval)) ;
3176                    if(strcmp(X->vval, "") != 0)
3177                    {
3178                       SPRINTF(v->fun_names[X->cfno], "%1d: %s [%s]",
3179                               X->cfno, X->vval, X->dval) ;
3180                    }
3181                    else
3182                       STRCPY(v->fun_names[X->cfno], "");
3183     }
3184
3185   XtDestroyWidget(X->menus[(int) X->CFtype]) ;
3186   for (i = 0; i < NOBUTTONS; i++)
3187     if (buttons[i].mtype == X->CFtype)
3188       create_menu(X->CFtype, X->kbuttons[i / BCOLS][i % BCOLS], i) ;
3189   switch (X->CFtype)
3190     {
3191       case M_CON :
3192                    write_rcfile(X->CFtype, X->cfexists, X->cfno,
3193                                                         result, X->dval) ;
3194                    break ;
3195       case M_FUN :
3196                    write_rcfile(X->CFtype, X->cfexists, X->cfno,
3197                                                         X->vval, X->dval) ;
3198     }
3199
3200   ignore_event = True;
3201   timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3202                              TimerEvent, (XtPointer) NULL);
3203
3204 }
3205
3206
3207 void
3208 win_display(fcptype, state)
3209 enum fcp_type fcptype ;
3210 int state ;
3211 {
3212   Widget widget ;
3213   Position newX, newY;
3214   Arg args[3];
3215
3216        if (fcptype == FCP_REG)  widget = X->rframe ;
3217   else if (fcptype == FCP_MODE) widget = X->mframe[(int) v->modetype] ;
3218   else if (fcptype == FCP_FIN_REG) widget = X->frframe;
3219
3220   if (widget == NULL)
3221      return ;
3222
3223   if (state && !is_window_showing(widget))
3224   {
3225        if (fcptype == FCP_REG || fcptype == FCP_FIN_REG)
3226        {
3227           XtSetMappedWhenManaged(XtParent(widget), False);
3228           XSync(X->dpy, False);
3229
3230           XtManageChild(widget) ;
3231
3232           _DtChildPosition(widget, X->kframe, &newX, &newY);
3233           XtSetArg(args[0], XmNx, newX);
3234           XtSetArg(args[1], XmNy, newY);
3235           XtSetValues(widget, args, 2);
3236
3237           XtSetMappedWhenManaged(XtParent(widget), True);
3238           XSync(X->dpy, False);
3239
3240           XtMapWidget(XtParent(widget));
3241        }
3242        else if (fcptype == FCP_MODE)
3243           _DtGenericMapWindow (X->kframe, widget);
3244   }
3245   if (state) XtManageChild(widget) ;
3246   else       XtUnmanageChild(widget) ;
3247 }
3248
3249
3250 /*ARGSUSED*/
3251 void
3252 write_cf_value(widget, client_data, call_data)
3253 Widget widget ;
3254 XtPointer client_data, call_data ;
3255 {
3256   char message[MAXLINE] ;
3257   char str[MAXLINE] ;          /* Temporary buffer for various strings. */
3258   Widget focus_widget;
3259   Arg args[1];
3260
3261   focus_widget = XmGetFocusWidget(widget);
3262
3263   /*
3264   if(focus_widget != X->CFpi_vtext->textfield && focus_widget != X->CFpi_butOK)
3265       return;
3266   */
3267
3268   if(focus_widget == X->CFpi_vtext->textfield)
3269   {
3270      X->vval = XmTextFieldGetString(X->CFpi_vtext->textfield);
3271      if(strcmp(X->vval, "") == 0)
3272         return;
3273   }
3274
3275   if(X->dval != NULL)
3276      XtFree(X->dval);
3277   if(X->vval != NULL)
3278      XtFree(X->vval);
3279   if(X->cfval != NULL)
3280      XtFree(X->cfval);
3281   X->dval = XmTextFieldGetString(X->CFpi_dtext->textfield);
3282   if(strlen(X->dval) > 41)
3283      X->dval[40] = '\0';
3284   X->vval = XmTextFieldGetString(X->CFpi_vtext->textfield);
3285   X->cfval = XmTextFieldGetString(X->CFpi_cftext->textfield);
3286   SSCANF(X->cfval, "%d", &X->cfno) ;
3287   if ((strcmp(X->cfval, "") == 0) || X->cfval[0] < '0' || X->cfval[0] > '9' ||
3288                                      X->cfno < 0 || X->cfno > 9)
3289     {
3290       SPRINTF(str, (X->CFtype == M_CON) ? vstrs[(int) V_LCON]
3291                                    : vstrs[(int) V_LFUN]) ;
3292       SPRINTF(message, "%s\n%s", str, vstrs[(int) V_RANGE]) ;
3293       do_continue_notice(X->CFframe, message) ;
3294       return ;
3295     }
3296
3297   X->vval = (char *)_DtcalcStripSpaces((char *)X->vval);
3298   X->cfexists = 0 ;
3299   switch (X->CFtype)
3300     {
3301       case M_CON : X->cfexists = 1 ;    /* Always the default constants. */
3302                    break ;
3303       case M_FUN : if (strlen(v->fun_vals[X->cfno])) X->cfexists = 1 ;
3304     }
3305   if (X->cfexists)
3306     {
3307       SPRINTF(str, mess[(int) MESS_CON],
3308                    (X->CFtype == M_CON) ? vstrs[(int) V_UCON]
3309                                         : vstrs[(int) V_UFUN], X->cfno) ;
3310       SPRINTF(message, "%s\n%s", str, vstrs[(int) V_OWRITE]) ;
3311       XtUnmanageChild(X->CFframe) ;
3312       do_confirm_notice(X->CFframe, message) ;
3313     }
3314   else
3315   {
3316      update_cf_value() ;
3317      XtUnmanageChild(X->CFframe) ;
3318   }
3319
3320   XtSetArg (args[0], XmNdefaultButton, NULL);
3321   XtSetValues (X->CFframe, args, 1);
3322 }
3323
3324
3325 static void
3326 xerror_interpose(display, error)
3327 Display *display ;
3328 XErrorEvent *error ;
3329 {
3330   char msg1[80];
3331   char msg[1024];
3332
3333   XGetErrorText(display, error->error_code, msg1, 80) ;
3334   sprintf(msg, "\nX Error (intercepted): %s\nMajor Request Code   : %d\nMinor Request Code   : %d\nResource ID (XID)    : %lu\nError Serial Number  : %lu\n", msg1, error->request_code, error->minor_code, error->resourceid, error->serial);
3335   _DtSimpleError (v->appname, DtError, NULL, msg);
3336   abort() ;
3337 }
3338
3339 static void
3340 modelineValueChanged(widget, client_data, call_data)
3341 Widget widget ;
3342 XtPointer client_data, call_data ;
3343 {
3344   Arg args[1];
3345   int position, val, choice;
3346
3347   X->mtype = (enum menu_type) client_data ;
3348   XtSetArg (args[0], XmNuserData, &val);
3349   XtGetValues (widget, args, 1);
3350
3351   choice =  val & 0xFFFF ;
3352   v->curwin = ((int) val) >> 16 ;
3353   if(X->mtype == M_BASE)
3354      handle_menu_selection(56, choice) ;
3355   else if(X->mtype == M_NUM)
3356      handle_menu_selection(57, choice) ;
3357   else if(X->mtype == M_MODE)
3358      handle_menu_selection(58, choice) ;
3359   else
3360      handle_menu_selection(59, choice) ;
3361 }
3362
3363 create_menu_bar(parent)
3364 Widget parent;
3365 {
3366    register int n;
3367    int i, j, val, count;
3368    Widget WidgList[10];
3369    Arg args[5];
3370    char *mnemonic;
3371    XmString labelString;
3372    Widget child, mem_reg;
3373    Widget lastCascadeButtonGadget;
3374    Widget lastCascadeButton;
3375    Widget lastMenuPane;
3376    Widget helpPulldown;
3377    Widget lastCascadeMenuPane;
3378
3379
3380    /*  Create the pulldown menu  */
3381    n = 0;
3382    XtSetArg(args[n], XmNorientation, XmHORIZONTAL);     n++;
3383    XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
3384    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);        n++;
3385    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);  n++;
3386    X->menubar = XmCreateMenuBar(parent, "mainMenu", args, n);
3387    XtManageChild(X->menubar);
3388    XtAddCallback(X->menubar, XmNhelpCallback, HelpRequestCB,
3389                  (XtPointer)HELP_MENUBAR);
3390
3391    mnemonic = GETMESSAGE(2, 13, "O");
3392    mnemonic = XtNewString(mnemonic);
3393    n = 0;
3394    labelString = XmStringCreateLocalized ( GETMESSAGE(2, 14, "Options") );
3395    XtSetArg(args[n], XmNlabelString, labelString);   n++;
3396    XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3397    XtSetArg(args[n], XmNmarginWidth, 6);   n++;
3398    lastCascadeButtonGadget =
3399             XmCreateCascadeButtonGadget(X->menubar, "options", args, n);
3400    XtManageChild(lastCascadeButtonGadget);
3401    XmStringFree(labelString);
3402    XtFree(mnemonic);
3403
3404    lastMenuPane = XmCreatePulldownMenu(X->menubar, "optionMenu", NULL, 0);
3405
3406    XtSetArg(args[0], XmNsubMenuId, lastMenuPane);
3407    XtSetValues(lastCascadeButtonGadget, args, 1);
3408
3409    mnemonic = GETMESSAGE(2, 40, "R");
3410    mnemonic = XtNewString(mnemonic);
3411    labelString =
3412             XmStringCreateLocalized( GETMESSAGE(2, 15, "Memory Registers") );
3413    XtSetArg(args[0], XmNlabelString, labelString );
3414    XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3415    mem_reg = XmCreatePushButtonGadget (lastMenuPane, "memR", args, 2);
3416    XtManageChild(mem_reg);
3417    XmStringFree(labelString);
3418    XtAddCallback(mem_reg, XmNactivateCallback, (XtCallbackProc)do_memory,
3419                                                                (XtPointer)MEM);
3420
3421    mnemonic = GETMESSAGE(2, 45, "g");
3422    mnemonic = XtNewString(mnemonic);
3423    labelString =
3424         XmStringCreateLocalized ( GETMESSAGE(3, 138, "Financial Registers") );
3425    XtSetArg(args[0], XmNlabelString, labelString );
3426    XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3427    mem_reg = XmCreatePushButtonGadget (lastMenuPane, "finR", args, 2);
3428    XtManageChild(mem_reg);
3429    XmStringFree(labelString);
3430    XtAddCallback(mem_reg, XmNactivateCallback, (XtCallbackProc)do_memory,
3431                                                                (XtPointer)FIN);
3432
3433    mnemonic = GETMESSAGE(2, 41, "A");
3434    mnemonic = XtNewString(mnemonic);
3435    labelString=XmStringCreateLocalized ( GETMESSAGE(2, 16, "ASCII Convert") );
3436    XtSetArg(args[0], XmNlabelString, labelString );
3437    XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3438    child = XmCreatePushButtonGadget (lastMenuPane, "asc", args, 2);
3439    XtManageChild(child);
3440    XmStringFree(labelString);
3441    XtAddCallback(child, XmNactivateCallback, (XtCallbackProc)do_ascii,
3442                                                          (XtPointer)NULL);
3443
3444   if(_DtNl_is_multibyte)
3445      XtSetSensitive(child, False);
3446
3447    child = (Widget)XmCreateSeparatorGadget(lastMenuPane, "separator",args,0);
3448    XtManageChild(child);
3449
3450    mnemonic = GETMESSAGE(2, 42, "F");
3451    mnemonic = XtNewString(mnemonic);
3452    labelString = XmStringCreateLocalized ( vstrs[(int) V_FUNWNAME] );
3453    XtSetArg(args[0], XmNlabelString, labelString );
3454    XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3455    child = XmCreatePushButtonGadget (lastMenuPane, "enterFunc", args, 2);
3456    XtManageChild(child);
3457    XmStringFree(labelString);
3458    XtAddCallback(child, XmNactivateCallback, (XtCallbackProc)new_cf_value,
3459                                                       (XtPointer)(int)M_FUN);
3460
3461    mnemonic = GETMESSAGE(2, 43, "C");
3462    mnemonic = XtNewString(mnemonic);
3463    labelString = XmStringCreateLocalized ( vstrs[(int) V_CONWNAME] );
3464    XtSetArg(args[0], XmNlabelString, labelString );
3465    XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3466    child = XmCreatePushButtonGadget (lastMenuPane, "enterCons", args, 2);
3467    XtManageChild(child);
3468    XmStringFree(labelString);
3469    XtAddCallback(child, XmNactivateCallback, (XtCallbackProc)new_cf_value,
3470                                                       (XtPointer)(int)M_CON);
3471
3472    child = (Widget)XmCreateSeparatorGadget(lastMenuPane, "separator",args,0);
3473    XtManageChild(child);
3474
3475    mnemonic = GETMESSAGE(2, 44, "x");
3476    mnemonic = XtNewString(mnemonic);
3477    labelString = XmStringCreateLocalized ( GETMESSAGE(3, 403, "Exit") );
3478    XtSetArg(args[0], XmNlabelString, labelString );
3479    XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3480    child = XmCreatePushButtonGadget (lastMenuPane, "exit", args, 2);
3481    XtManageChild(child);
3482    XmStringFree(labelString);
3483    XtAddCallback(child, XmNactivateCallback, (XtCallbackProc)do_frame,
3484                                                           (XtPointer) NULL);
3485
3486    n = 0;
3487    mnemonic = GETMESSAGE(2, 17, "H");
3488    mnemonic = XtNewString(mnemonic);
3489    labelString = XmStringCreateLocalized ( GETMESSAGE(2, 18, "Help") );
3490    XtSetArg(args[n], XmNlabelString, labelString);   n++;
3491    XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3492    XtSetArg(args[n], XmNmarginWidth, 6);   n++;
3493    lastCascadeButtonGadget =
3494             XmCreateCascadeButtonGadget(X->menubar, "help", args, n);
3495    XmStringFree(labelString);
3496    XtFree(mnemonic);
3497
3498    helpPulldown = XmCreatePulldownMenu(X->menubar, "helpMenu", NULL, 0);
3499
3500    XtSetArg(args[0], XmNsubMenuId, helpPulldown);
3501    XtSetValues(lastCascadeButtonGadget, args, 1);
3502
3503    XtSetArg(args[0], XmNmenuHelpWidget, lastCascadeButtonGadget);
3504    XtSetValues (X->menubar, args, 1);
3505
3506    XtManageChild(lastCascadeButtonGadget);
3507
3508    count =0;
3509
3510    n = 0;
3511    mnemonic = GETMESSAGE(2, 19, "v");
3512    mnemonic = XtNewString(mnemonic);
3513    XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3514    labelString = XmStringCreateLocalized ( GETMESSAGE(2, 20, "Overview") );
3515    XtSetArg(args[n], XmNlabelString, labelString); n++;
3516    WidgList[count++]=
3517        XmCreatePushButton(helpPulldown, "introduction", args, n );
3518    XtAddCallback(WidgList[count-1], XmNactivateCallback,
3519        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_INTRODUCTION);
3520    XmStringFree(labelString);
3521    XtFree(mnemonic);
3522
3523    WidgList[count++]= (Widget)XmCreateSeparatorGadget(helpPulldown,
3524                                                        "separator",args,0);
3525
3526    n = 0;
3527    mnemonic = GETMESSAGE(2, 38, "C");
3528    mnemonic = XtNewString(mnemonic);
3529    XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3530    labelString =
3531             XmStringCreateLocalized ( GETMESSAGE(2,39,"Table of Contents") );
3532    XtSetArg(args[n], XmNlabelString, labelString);  n++;
3533    WidgList[count++]= XmCreatePushButton(helpPulldown, "toc", args, n );
3534    XtAddCallback(WidgList[count-1], XmNactivateCallback,
3535        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TABLEOFCONTENTS);
3536    XmStringFree(labelString);
3537    XtFree(mnemonic);
3538
3539    n = 0;
3540    mnemonic = GETMESSAGE(2, 21, "T");
3541    mnemonic = XtNewString(mnemonic);
3542    XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3543    labelString = XmStringCreateLocalized ( GETMESSAGE(2, 22, "Tasks") );
3544    XtSetArg(args[n], XmNlabelString, labelString);  n++;
3545    WidgList[count++]= XmCreatePushButton(helpPulldown, "tasks", args, n );
3546    XtAddCallback(WidgList[count-1], XmNactivateCallback,
3547        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TASKS);
3548    XmStringFree(labelString);
3549    XtFree(mnemonic);
3550
3551    n = 0;
3552    mnemonic = GETMESSAGE(2, 23, "R");
3553    mnemonic = XtNewString(mnemonic);
3554    XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3555    labelString = XmStringCreateLocalized ( GETMESSAGE(2, 24, "Reference") );
3556    XtSetArg(args[n], XmNlabelString, labelString);  n++;
3557    WidgList[count++]= XmCreatePushButton(helpPulldown, "reference", args, n );
3558    XtAddCallback(WidgList[count-1], XmNactivateCallback,
3559        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_REFERENCE);
3560    XmStringFree(labelString);
3561    XtFree(mnemonic);
3562
3563    n = 0;
3564    mnemonic = GETMESSAGE(2, 25, "O");
3565    mnemonic = XtNewString(mnemonic);
3566    XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3567    labelString = XmStringCreateLocalized ( GETMESSAGE(2, 26, "On Item") );
3568    XtSetArg(args[n], XmNlabelString, labelString);  n++;
3569    WidgList[count++]= XmCreatePushButton(helpPulldown, "onItem", args, n );
3570    XtAddCallback(WidgList[count-1], XmNactivateCallback,
3571        (XtCallbackProc)HelpModeCB, (XtPointer)NULL);
3572    XmStringFree(labelString);
3573    XtFree(mnemonic);
3574
3575    WidgList[count++]= (Widget)XmCreateSeparatorGadget(helpPulldown,
3576                                                        "separator",args,0);
3577
3578    n = 0;
3579    mnemonic = GETMESSAGE(2, 27, "U");
3580    mnemonic = XtNewString(mnemonic);
3581    XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3582    labelString = XmStringCreateLocalized ( GETMESSAGE(2, 28, "Using Help") );
3583    XtSetArg(args[n], XmNlabelString, labelString); n++;
3584    WidgList[count++]=
3585        XmCreatePushButton(helpPulldown, "usingHelp", args, n );
3586    XtAddCallback(WidgList[count-1], XmNactivateCallback,
3587        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_USING);
3588    XmStringFree(labelString);
3589    XtFree(mnemonic);
3590
3591    WidgList[count++]= (Widget)XmCreateSeparatorGadget(helpPulldown,
3592                                                        "separator",args,0);
3593
3594    n = 0;
3595    mnemonic = GETMESSAGE(2, 29, "A");
3596    mnemonic = XtNewString(mnemonic);
3597    XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3598    labelString =
3599             XmStringCreateLocalized ( GETMESSAGE(2, 30, "About Calculator") );
3600    XtSetArg(args[n], XmNlabelString, labelString); n++;
3601    WidgList[count++]= XmCreatePushButton(helpPulldown, "about", args, n );
3602    XtAddCallback(WidgList[count-1], XmNactivateCallback,
3603        (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_VERSION);
3604    XmStringFree(labelString);
3605    XtFree(mnemonic);
3606
3607    XtManageChildren(WidgList, count);
3608
3609    /* Fine tune the menubar */
3610    XtSetArg(args[0], XmNmarginWidth, 2);
3611    XtSetArg(args[1], XmNmarginHeight, 2);
3612    XtSetValues(X->menubar, args, 2);
3613
3614 }
3615
3616
3617 init_colors()
3618 {
3619     int         colorUse;
3620     short       act, inact, prim, second;
3621
3622     XmeGetPixelData (X->screen, &colorUse, pixels, &act, &inact,
3623                      &prim, &second);
3624
3625     if(pixels[0].bg == pixels[1].bg && pixels[1].bg == pixels[2].bg &&
3626        pixels[2].bg == pixels[3].bg && pixels[3].bg == pixels[4].bg &&
3627        pixels[4].bg == pixels[5].bg && pixels[5].bg == pixels[6].bg &&
3628        pixels[6].bg == pixels[7].bg && pixels[7].bg == 0)
3629          colorSrv = False;
3630     else
3631          colorSrv = True;
3632
3633 }
3634
3635 static void
3636 do_memory( w, client_data, call_data )
3637 Widget w ;
3638 XtPointer client_data ;
3639 XtPointer call_data ;
3640 {
3641   int type = (int)client_data;
3642
3643   if(type == MEM)
3644   {
3645      if (!v->rstate)
3646        {
3647          v->rstate = 1 ;
3648          make_registers(MEM) ;
3649        }
3650      win_display(FCP_REG, TRUE) ;
3651   }
3652   else
3653   {
3654      if (!v->frstate)
3655        {
3656          v->frstate = 1 ;
3657          make_registers(FIN) ;
3658        }
3659      win_display(FCP_FIN_REG, TRUE) ;
3660   }
3661   ignore_event = True;
3662   timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3663                              TimerEvent, (XtPointer) NULL);
3664 }
3665
3666 void
3667 read_resources()    /* Read all possible resources from the database. */
3668 {
3669   int boolval, i, intval ;
3670   char str[MAXLINE] ;
3671   char *msg;
3672
3673   /* set the accuracy variable */
3674   if(application_args.accuracy > 9)
3675      v->accuracy = 9;
3676   else if(application_args.accuracy < 0)
3677      v->accuracy = 0;
3678   else
3679      v->accuracy = application_args.accuracy;
3680
3681   /* set the base */
3682   if(strcmp(application_args.base, "binary") == 0 ||
3683          strcmp(application_args.base, "bin") == 0)
3684      v->base = (enum base_type) 0 ;
3685   else if(strcmp(application_args.base, "octal") == 0 ||
3686                   strcmp(application_args.base, "oct") == 0)
3687      v->base = (enum base_type) 1 ;
3688   else if(strcmp(application_args.base, "decimal") == 0 ||
3689                   strcmp(application_args.base, "dec") == 0)
3690      v->base = (enum base_type) 2 ;
3691   else if(strcmp(application_args.base, "hexadecimal") == 0 ||
3692                   strcmp(application_args.base, "hex") == 0)
3693      v->base = (enum base_type) 3 ;
3694   else
3695   {
3696      msg = (char *) XtMalloc(strlen( opts[(int) O_BASE]) + 3);
3697      sprintf(msg, opts[(int) O_BASE]);
3698      _DtSimpleError (v->appname, DtWarning, NULL, msg);
3699      XtFree(msg);
3700      v->base = (enum base_type) 2;
3701   }
3702
3703   /* set the display numeration */
3704   if(strcmp(application_args.display, "fixed") == 0)
3705      v->dtype = (enum base_type) 1 ;
3706   else if(strcmp(application_args.display, "eng") == 0 ||
3707                   strcmp(application_args.display, "engineering") == 0)
3708      v->dtype = (enum base_type) 0 ;
3709   else if(strcmp(application_args.display, "scientific") == 0 ||
3710                   strcmp(application_args.display, "sci") == 0)
3711      v->dtype = (enum base_type) 2 ;
3712   else
3713   {
3714      msg = (char *) XtMalloc(strlen( opts[(int) O_DISPLAY]) + strlen(str) + 3);
3715      sprintf(msg, opts[(int) O_DISPLAY], str);
3716      _DtSimpleError (v->appname, DtWarning, NULL, msg);
3717      XtFree(msg);
3718      v->dtype = (enum base_type) 1;
3719   }
3720
3721   /* set the mode */
3722   if(strcmp(application_args.mode, "scientific") == 0)
3723      v->modetype = (enum base_type) 2 ;
3724   else if(strcmp(application_args.mode, "financial") == 0)
3725      v->modetype = (enum base_type) 0 ;
3726   else if(strcmp(application_args.mode, "logical") == 0)
3727      v->modetype = (enum base_type) 1 ;
3728   else
3729   {
3730      msg = (char *) XtMalloc(strlen( opts[(int) O_MODE]) + strlen(str) + 3);
3731      sprintf(msg, opts[(int) O_MODE], str);
3732      _DtSimpleError (v->appname, DtWarning, NULL, msg);
3733      XtFree(msg);
3734      v->modetype = (enum base_type) 2;
3735   }
3736
3737   /* set the display numeration */
3738   if(strcmp(application_args.trigType, "deg") == 0 ||
3739                   strcmp(application_args.trigType, "degrees") == 0)
3740      v->ttype = (enum base_type) 0 ;
3741   else if(strcmp(application_args.trigType, "rad") == 0 ||
3742                   strcmp(application_args.trigType, "radians") == 0)
3743      v->ttype = (enum base_type) 2 ;
3744   else if(strcmp(application_args.trigType, "grad") == 0 ||
3745                   strcmp(application_args.trigType, "gradients") == 0)
3746      v->ttype = (enum base_type) 1 ;
3747   else
3748   {
3749      msg = (char *) XtMalloc(strlen( opts[(int) O_TRIG]) + strlen(str) + 3);
3750      sprintf(msg, opts[(int) O_TRIG], str);
3751      _DtSimpleError (v->appname, DtWarning, NULL, msg);
3752      XtFree(msg);
3753      v->ttype = (enum base_type) 0;
3754   }
3755
3756 }
3757
3758 void
3759 close_cf(widget, client_data, call_data)
3760 Widget widget ;
3761 XtPointer client_data, call_data ;
3762 {
3763   Arg args[1];
3764
3765   XtSetArg (args[0], XmNdefaultButton, NULL);
3766   XtSetValues (X->CFframe, args, 1);
3767
3768   XtUnmanageChild(X->CFframe) ;
3769   ignore_event = True;
3770   timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3771                              TimerEvent, (XtPointer) NULL);
3772 }
3773
3774 void
3775 close_ascii(widget, client_data, call_data)
3776 Widget widget ;
3777 XtPointer client_data, call_data ;
3778 {
3779   XtUnmanageChild(X->Aframe) ;
3780   ignore_event = True;
3781   timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3782                              TimerEvent, (XtPointer) NULL);
3783 }
3784
3785 void
3786 FocusInCB(widget, client_data, call_data)
3787 Widget widget ;
3788 XtPointer client_data, call_data ;
3789 {
3790   Arg args[1];
3791
3792   XtSetArg (args[0], XmNdefaultButton, NULL);
3793   XtSetValues (X->CFframe, args, 1);
3794
3795   XtSetArg(args[0], XmNshowAsDefault, True);
3796   XtSetValues(X->CFpi_butOK, args, 1);
3797 }
3798
3799 void
3800 move_cf(widget, client_data, call_data)
3801 Widget widget ;
3802 XtPointer client_data, call_data ;
3803 {
3804   char *input;
3805   int value;
3806   Arg args[3];
3807
3808   value = 0;
3809   if(widget == X->CFpi_cftext->textfield)
3810   {
3811      XtSetArg (args[0], XmNdefaultButton, NULL);
3812      XtSetValues (X->CFframe, args, 1);
3813
3814      XtSetArg(args[0], XmNshowAsDefault, True);
3815      XtSetValues(X->CFpi_butOK, args, 1);
3816
3817      input = XmTextFieldGetString(X->CFpi_cftext->textfield);
3818      if(strcmp(input, "") != 0)
3819         XmProcessTraversal(X->CFpi_dtext->textfield, XmTRAVERSE_CURRENT);
3820   }
3821   else if(widget == X->CFpi_dtext->textfield)
3822   {
3823      XtSetArg (args[0], XmNdefaultButton, NULL);
3824      XtSetValues (X->CFframe, args, 1);
3825
3826      XtSetArg(args[0], XmNshowAsDefault, True);
3827      XtSetValues(X->CFpi_butOK, args, 1);
3828
3829      XmProcessTraversal(X->CFpi_vtext->textfield, XmTRAVERSE_CURRENT);
3830      value = 1;
3831   }
3832   else if(widget == X->CFpi_vtext->textfield)
3833   {
3834      input = XmTextFieldGetString(X->CFpi_vtext->textfield);
3835   }
3836   ignore_event = True;
3837   timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3838                              TimerEvent, (XtPointer) value);
3839 }
3840
3841 create_popup(parent)
3842 Widget parent;
3843 {
3844   int n;
3845   char *mnemonic;
3846   Arg args[10];
3847   XmString label;
3848   Widget dummyHelp1, dummyHelp2, memRegs;
3849   Widget help, helpI, helpToc, helpT, helpR, helpO, helpU, helpV;
3850
3851   X->popupMenu = XmCreatePopupMenu(parent, "popup", NULL, 0) ;
3852   XtCreateManagedWidget(GETMESSAGE(2, 46,"Calculator Popup"),
3853                         xmLabelWidgetClass, X->popupMenu, NULL, 0) ;
3854   XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3855                         X->popupMenu, NULL, 0) ;
3856   XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3857                         X->popupMenu, NULL, 0) ;
3858
3859
3860 /*  The popup menu contains the following entries ......................*/
3861 /* 1.  Memory Registers ...  */
3862   memRegs = XtVaCreateManagedWidget( "memRegs1",
3863                                     xmPushButtonWidgetClass,
3864                                     X->popupMenu,
3865                                     XmNlabelString, XmStringCreateLocalized(
3866                                        GETMESSAGE(2, 15, "Memory Registers") ),
3867                                     XmNmnemonic, XStringToKeysym(
3868                                                       GETMESSAGE(2, 40, "R") ),
3869                                     NULL);
3870   XtAddCallback(memRegs, XmNactivateCallback, (XtCallbackProc)do_memory,
3871                                                                (XtPointer)MEM);
3872
3873 /* 2.  Finacial Registers ...  */
3874   memRegs = XtVaCreateManagedWidget( "memRegs2",
3875                                     xmPushButtonWidgetClass,
3876                                     X->popupMenu,
3877                                     XmNlabelString, XmStringCreateLocalized(
3878                                    GETMESSAGE(3, 138, "Financial Registers") ),
3879                                     XmNmnemonic, XStringToKeysym(
3880                                                 GETMESSAGE( 2, 45, "g" ) ),
3881                                     NULL);
3882   XtAddCallback(memRegs, XmNactivateCallback, (XtCallbackProc)do_memory,
3883                                                                (XtPointer)FIN);
3884
3885 /* 3.  Ascii Converter ...  */
3886   X->asciiConv = XtVaCreateManagedWidget("asciiConv",
3887                                          xmPushButtonWidgetClass,
3888                                          X->popupMenu,
3889                                          XmNlabelString,
3890                  XmStringCreateLocalized( GETMESSAGE(2, 16, "ASCII Convert") ),
3891                                          XmNmnemonic, XStringToKeysym(
3892                                                       GETMESSAGE(2, 41, "A") ),
3893                                          NULL);
3894   XtAddCallback(X->asciiConv, XmNactivateCallback, (XtCallbackProc)do_ascii,
3895                                                          (XtPointer)NULL);
3896
3897   if(_DtNl_is_multibyte)
3898      XtSetSensitive(X->asciiConv, False);
3899
3900   XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3901                                                   X->popupMenu, NULL, 0) ;
3902
3903 /* 4.  Enter Functions ...  */
3904   X->enterFun = XtVaCreateManagedWidget("enterFun",
3905                                         xmPushButtonWidgetClass,
3906                                         X->popupMenu,
3907                                         XmNlabelString,
3908                             XmStringCreateLocalized( vstrs[(int) V_FUNWNAME] ),
3909                                         XmNmnemonic, XStringToKeysym(
3910                                                       GETMESSAGE(2, 42, "F") ),
3911                                 NULL);
3912   XtAddCallback(X->enterFun, XmNactivateCallback, (XtCallbackProc)new_cf_value,
3913                                                       (XtPointer)(int)M_FUN);
3914
3915 /* 5.  Enter Constants ...  */
3916   X->enterConst = XtVaCreateManagedWidget("enterConst",
3917                                           xmPushButtonWidgetClass,
3918                                           X->popupMenu,
3919                                           XmNlabelString,
3920                             XmStringCreateLocalized( vstrs[(int) V_CONWNAME] ),
3921                                           XmNmnemonic, XStringToKeysym(
3922                                                       GETMESSAGE(2, 43, "C") ),
3923                                           NULL);
3924   XtAddCallback(X->enterConst, XmNactivateCallback,(XtCallbackProc)new_cf_value,
3925                                                       (XtPointer)(int)M_CON);
3926
3927   XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3928                                                   X->popupMenu, NULL, 0) ;
3929
3930
3931 /* 6.   Help ... */
3932
3933   dummyHelp1 = XtVaCreatePopupShell ("dummyHelp1",
3934                 xmMenuShellWidgetClass,
3935                 X->popupMenu,
3936                 XmNwidth, 10,
3937                 XmNheight, 10,
3938                 NULL);
3939
3940   dummyHelp2 = XtVaCreateWidget("dummyHelp2",
3941                 xmRowColumnWidgetClass, dummyHelp1,
3942                 XmNrowColumnType, XmMENU_PULLDOWN,
3943                 NULL);
3944
3945
3946   label = XmStringCreateLocalized ( GETMESSAGE(2, 20, "Overview") );
3947   helpI = XtVaCreateManagedWidget ("introduction",
3948                 xmPushButtonGadgetClass, dummyHelp2,
3949                 XmNlabelString, label,
3950                 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 19, "v") ),
3951                 NULL);
3952
3953
3954   XtAddCallback(helpI, XmNactivateCallback,
3955                  (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_INTRODUCTION);
3956   XmStringFree (label);
3957
3958   XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3959                         dummyHelp2, NULL, 0);
3960
3961   label = XmStringCreateLocalized ( GETMESSAGE(2, 39, "Table of Contents") );
3962   helpToc = XtVaCreateManagedWidget ("toc",
3963                 xmPushButtonGadgetClass, dummyHelp2,
3964                 XmNlabelString, label,
3965                 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 38, "C") ),
3966                 NULL);
3967
3968   XtAddCallback(helpToc, XmNactivateCallback,
3969                 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TABLEOFCONTENTS);
3970
3971   XmStringFree(label);
3972
3973
3974   label = XmStringCreateLocalized ( GETMESSAGE(2, 22, "Tasks") );
3975   helpT = XtVaCreateManagedWidget ("tasks",
3976                 xmPushButtonGadgetClass, dummyHelp2,
3977                 XmNlabelString, label,
3978                 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 21, "T") ),
3979                 NULL);
3980
3981   XtAddCallback(helpT, XmNactivateCallback,
3982                  (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TASKS);
3983
3984   XmStringFree(label);
3985
3986
3987   label = XmStringCreateLocalized ( GETMESSAGE(2, 24, "Reference") );
3988   helpR = XtVaCreateManagedWidget ("reference",
3989                 xmPushButtonGadgetClass, dummyHelp2,
3990                 XmNlabelString, label,
3991                 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 23, "R" ) ),
3992                 NULL);
3993
3994
3995   XtAddCallback(helpR, XmNactivateCallback,
3996                  (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_REFERENCE);
3997
3998   XmStringFree(label);
3999
4000   label = XmStringCreateLocalized ( GETMESSAGE(2, 26, "On Item") );
4001
4002   helpO = XtVaCreateManagedWidget ("onItem",
4003                 xmPushButtonGadgetClass, dummyHelp2,
4004                 XmNlabelString, label,
4005                 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 25, "O") ),
4006                 NULL);
4007
4008   XtAddCallback(helpO, XmNactivateCallback,
4009                  (XtCallbackProc)HelpModeCB, (XtPointer)NULL);
4010
4011   XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
4012                         dummyHelp2, NULL, 0);
4013   XmStringFree (label);
4014
4015   label = XmStringCreateLocalized ( GETMESSAGE(2, 28, "Using Help") );
4016   helpU = XtVaCreateManagedWidget ("useHelp",
4017                 xmPushButtonGadgetClass, dummyHelp2,
4018                 XmNlabelString, label,
4019                 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 27, "U") ),
4020                 NULL);
4021
4022
4023   XtAddCallback(helpU, XmNactivateCallback,
4024                  (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_USING);
4025
4026   XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
4027                         dummyHelp2, NULL, 0);
4028
4029   XmStringFree(label);
4030
4031   label = XmStringCreateLocalized (GETMESSAGE(2, 30, "About Calculator") );
4032   helpV = XtVaCreateManagedWidget ("version",
4033                 xmPushButtonGadgetClass, dummyHelp2,
4034                 XmNlabelString, label,
4035                 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 29, "A" ) ),
4036                 NULL);
4037
4038   XtAddCallback(helpV, XmNactivateCallback,
4039                  (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_VERSION);
4040
4041   XmStringFree(label);
4042
4043
4044   mnemonic = GETMESSAGE(2, 17, "H");
4045   label = XmStringCreateLocalized ( GETMESSAGE(2, 18, "Help") );
4046   help = XtVaCreateManagedWidget("help",
4047                 xmCascadeButtonGadgetClass,  X->popupMenu,
4048                 XmNsubMenuId,               dummyHelp2,
4049                 XmNmnemonic,                XStringToKeysym( mnemonic ),
4050                 XmNlabelString,             label,
4051                 NULL);
4052   XmStringFree(label);
4053
4054   XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
4055                         X->popupMenu, NULL, 0);
4056
4057 /* 7.  Exit */
4058   label = XmStringCreateLocalized ( GETMESSAGE(3, 403, "Exit") );
4059   X->Close = XtVaCreateManagedWidget("close",
4060                                 xmPushButtonWidgetClass,
4061                                 X->popupMenu,
4062                                 XmNlabelString,             label,
4063                                 XmNmnemonic,
4064                                       XStringToKeysym(GETMESSAGE(2, 44, "X" )),
4065                                 NULL);
4066   XmStringFree(label);
4067   XtAddCallback(X->Close, XmNactivateCallback,(XtCallbackProc)do_frame,
4068                                                       (XtPointer)(int)M_FUN);
4069
4070   XtAddEventHandler(parent, ButtonPressMask, FALSE,
4071                                      popupHandler, (XtPointer) NULL) ;
4072   XtAddCallback(X->popupMenu, XmNmapCallback,(XtCallbackProc)map_popup,
4073                                                       (XtPointer)NULL);
4074 }
4075
4076 static void
4077 popupHandler(widget, client_data, event, continue_to_dispatch)
4078 Widget widget ;
4079 XtPointer client_data ;
4080 XEvent *event ;
4081 Boolean *continue_to_dispatch ;
4082 {
4083   XButtonPressedEvent *bevent;
4084
4085   bevent = (XButtonPressedEvent *)event;
4086
4087   if (event->type == ButtonPress && event->xbutton.button == Button3)
4088   {
4089      if(bevent->x >= funBtn->core.x &&
4090         bevent->x <= funBtn->core.x + funBtn->core.width &&
4091         bevent->y >= funBtn->core.y +
4092                      X->modeline->core.height + X->textForm->core.height &&
4093         bevent->y <= funBtn->core.y +funBtn->core.height +
4094                      X->modeline->core.height + X->textForm->core.height)
4095      {
4096         menu_handler(widget, (XtPointer)M_FUN, event, continue_to_dispatch);
4097      }
4098      else if(bevent->x >= constBtn->core.x &&
4099         bevent->x <= constBtn->core.x + constBtn->core.width &&
4100         bevent->y >= constBtn->core.y +
4101                      X->modeline->core.height + X->textForm->core.height &&
4102         bevent->y <= constBtn->core.y + constBtn->core.height +
4103                      X->modeline->core.height + X->textForm->core.height)
4104      {
4105         menu_handler(widget, (XtPointer)M_CON, event, continue_to_dispatch);
4106      }
4107      else if(bevent->x >= accBtn->core.x &&
4108         bevent->x <= accBtn->core.x + accBtn->core.width &&
4109         bevent->y >= accBtn->core.y +
4110                      X->modeline->core.height + X->textForm->core.height &&
4111         bevent->y <= accBtn->core.y + accBtn->core.height +
4112                      X->modeline->core.height + X->textForm->core.height)
4113      {
4114         menu_handler(widget, (XtPointer)M_ACC, event, continue_to_dispatch);
4115      }
4116      else if(bevent->x >= rclBtn->core.x &&
4117         bevent->x <= rclBtn->core.x + rclBtn->core.width &&
4118         bevent->y >= rclBtn->core.y +
4119                      X->modeline->core.height + X->textForm->core.height &&
4120         bevent->y <= rclBtn->core.y + rclBtn->core.height +
4121                      X->modeline->core.height + X->textForm->core.height)
4122      {
4123         menu_handler(widget, (XtPointer)M_RCL, event, continue_to_dispatch);
4124      }
4125      else if(bevent->x >= stoBtn->core.x &&
4126         bevent->x <= stoBtn->core.x + stoBtn->core.width &&
4127         bevent->y >= stoBtn->core.y +
4128                      X->modeline->core.height + X->textForm->core.height &&
4129         bevent->y <= stoBtn->core.y + stoBtn->core.height +
4130                      X->modeline->core.height + X->textForm->core.height)
4131      {
4132         menu_handler(widget, (XtPointer)M_STO, event, continue_to_dispatch);
4133      }
4134      else if(bevent->x >= exchBtn->core.x &&
4135         bevent->x <= exchBtn->core.x + exchBtn->core.width &&
4136         bevent->y >= exchBtn->core.y +
4137                      X->modeline->core.height + X->textForm->core.height &&
4138         bevent->y <= exchBtn->core.y + exchBtn->core.height +
4139                      X->modeline->core.height + X->textForm->core.height)
4140      {
4141         menu_handler(widget, (XtPointer)M_EXCH, event, continue_to_dispatch);
4142      }
4143      else
4144      {
4145         XmMenuPosition(X->popupMenu, (XButtonPressedEvent *) event) ;
4146         XtManageChild(X->popupMenu) ;
4147      }
4148   }
4149 }
4150
4151 void
4152 set_option_menu(type, base)
4153 int type;
4154 int base;
4155 {
4156     Arg args[1];
4157
4158     if(type == BASEITEM)
4159        XtSetArg(args[0], XmNmenuHistory, X->baseWidgArry[base]);
4160     else if(type == NUMITEM)
4161        XtSetArg(args[0], XmNmenuHistory, X->numWidgArry[base]);
4162     else
4163        XtSetArg(args[0], XmNmenuHistory, X->ttypeWidgArry[base]);
4164     XtSetValues( X->modevals[type], args, 1);
4165 }
4166
4167 void
4168 map_popup(widget, client_data, call_data)
4169 Widget widget ;
4170 XtPointer client_data, call_data ;
4171 {
4172    XmAnyCallbackStruct * callback;
4173    XEvent * event;
4174    XKeyPressedEvent *key_event ;
4175
4176    callback = (XmAnyCallbackStruct *) call_data;
4177    event = (XEvent *) callback->event;
4178    key_event = (XKeyPressedEvent *) event ;
4179
4180    if(event->type != KeyRelease)
4181       return;
4182
4183    if (v->event_type == F4_PRESS)
4184       XmMenuPosition(widget, (XButtonPressedEvent *) event) ;
4185 }
4186
4187 /*ARGSUSED*/
4188 static void
4189 save_state(widget, client_data, call_data)
4190 Widget widget ;
4191 XtPointer client_data ;
4192 XtPointer call_data ;
4193 {
4194    char *full_path = NULL;
4195    char *file_name = NULL;
4196    char *strPtr;
4197    char *sessionFileName;
4198
4199    char **restart_argv = NULL;
4200    static char **start_argv = NULL;
4201
4202    int i, restart_argc;
4203    static int start_argc = 0;
4204
4205    Boolean status = False;
4206    static Boolean first = True;
4207
4208    status = DtSessionSavePath(widget, &full_path, &file_name);
4209
4210    if (status)
4211      sessionFileName = file_name;
4212    else
4213    {
4214      XtFree( (char *)full_path);
4215      full_path = (char *) XtMalloc (sizeof (char) * MAX_PATH);
4216      sprintf( full_path, "%s/%s", dt_path, DTCALC_CLASS_NAME);
4217      sessionFileName = full_path;
4218    }
4219
4220    SaveSession(full_path, file_name);
4221
4222    /* --------------------------------------------------------------- */
4223    /*  Original commandline arguments were saved on the top window    */
4224    /*  They get reset here, take original and append them to restart  */
4225    /* --------------------------------------------------------------- */
4226
4227    if (first == True)
4228    {
4229        first = False;
4230        XGetCommand(X->dpy, XtWindow(X->kframe), &start_argv, &start_argc);
4231    }
4232
4233    /*  Generate the restart command and add it as the property value */
4234
4235    restart_argc = start_argc + 3;
4236    restart_argv = (char **) XtMalloc(restart_argc * sizeof(char *));
4237
4238    if (restart_argv == NULL)
4239        return;
4240
4241    restart_argv[0] = XtNewString(v->progname);
4242
4243    for ( i = 1 ; (i < start_argc && start_argv != NULL) ; i++ )
4244    {
4245        restart_argv[i] = XtNewString(start_argv[i]);
4246    }
4247
4248    restart_argv[i] = XtNewString("-session"); i++;
4249    restart_argv[i] = XtNewString(sessionFileName); i++;
4250
4251    XSetCommand(X->dpy, XtWindow(X->kframe), restart_argv, i);
4252    XSync(X->dpy, False);
4253
4254    for ( i = 0 ; i < restart_argc -1 ; i++ )
4255        XtFree ((char *) restart_argv[i]);
4256
4257    XtFree ((char *) full_path);
4258    XtFree ((char *) file_name);
4259
4260    return;
4261 }
4262
4263 static void
4264 SaveSession( path, file_name )
4265         char *path ;
4266         char *file_name ;
4267 {
4268    char workspaceNumber[5];
4269    int fd;
4270    Atom * ws_presence = NULL;
4271    char * workspace_name;
4272    unsigned long num_workspaces = 0;
4273    Atom actual_type;
4274    int  actual_format;
4275    unsigned long nitems;
4276    unsigned long leftover;
4277    WM_STATE * wm_state;
4278
4279    char tempStr[50];
4280    Position x, y;
4281    Dimension width, height;
4282
4283    char * command;
4284    int command_len;
4285    int i;
4286    int j;
4287    char * msg;
4288    int view_index;
4289    char * tmpStr;
4290    XmVendorShellExtObject vendorExt;
4291    XmWidgetExtData        extData;
4292    Window                 junkWindow;
4293    int                    t_x, t_y;
4294    Arg                    args[5];
4295
4296      /*  Create the session file  */
4297
4298    if ((fd = creat (path, S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP)) == -1)
4299    {
4300       tmpStr = GETMESSAGE(2, 34, "Could not open the session file.");
4301       msg = XtNewString(tmpStr);
4302       _DtSimpleError (v->appname, DtError, NULL, msg);
4303       XtFree(msg);
4304       return;
4305    }
4306    close(fd);
4307
4308    /*  Getting the WM_STATE property to see if iconified or not */
4309    XGetWindowProperty (X->dpy, XtWindow (X->kframe),
4310                              wm_state_atom, 0L, (long) BUFSIZ, False,
4311                              wm_state_atom, &actual_type, &actual_format,
4312                              &nitems, &leftover, (unsigned char **) &wm_state);
4313
4314    /* Write out if iconified our not */
4315    if (wm_state->state == IconicState)
4316         put_resource(R_ICON,     set_bool(True)) ;
4317    else
4318         put_resource(R_ICON,     set_bool(False)) ;
4319
4320    /* does it have a menubar or not */
4321    if ( application_args.menuBar )
4322         put_resource(R_MENUBAR,     set_bool(True)) ;
4323    else
4324         put_resource(R_MENUBAR,     set_bool(False)) ;
4325
4326    /* is keys set to on/off */
4327    if (v->tstate)
4328         put_resource(R_KEYS,     set_bool(True)) ;
4329    else
4330         put_resource(R_KEYS,     set_bool(False)) ;
4331
4332    /*  Get the workspaces for this dt by accessing the property.  */
4333
4334    if (DtWsmGetWorkspacesOccupied (X->dpy, XtWindow (X->kframe),
4335                                   &ws_presence, &num_workspaces) == Success)
4336    {
4337       char *string;
4338
4339       string = (char *)XtMalloc(num_workspaces * 40);
4340       for (j = 0; j < num_workspaces; j++)
4341       {
4342          workspace_name = XGetAtomName (X->dpy, ws_presence[j]);
4343          if(j == 0)
4344             strcpy(string, workspace_name);
4345          else
4346             strcat(string, workspace_name);
4347          if(j + 1 != num_workspaces)
4348             strcat(string, " ");
4349          XtFree ((char *) workspace_name);
4350       }
4351       put_resource(R_WORKSPACE,     string) ;
4352
4353       XFree((char *)ws_presence);
4354       XtFree((char *)string);
4355    }
4356
4357
4358
4359    XtSetArg(args[0], XmNwidth, &width);
4360    XtSetArg(args[1], XmNheight, &height);
4361    XtGetValues(X->kframe, args, 2);
4362
4363    XTranslateCoordinates(XtDisplay(X->kframe),
4364                        XtWindow(X->kframe),
4365                        RootWindowOfScreen(XtScreen(X->kframe)),
4366                        0, 0, &t_x, &t_y,
4367                        &junkWindow);
4368    x = (Position) t_x;
4369    y = (Position) t_y;
4370
4371    /* Modify x & y to take into account window mgr frames */
4372    extData=_XmGetWidgetExtData(X->kframe, XmSHELL_EXTENSION);
4373    vendorExt = (XmVendorShellExtObject)extData->widget;
4374    x -= vendorExt->vendor.xOffset;
4375    y -= vendorExt->vendor.yOffset;
4376
4377    sprintf(tempStr, "%d", width);
4378    put_resource(R_WIDTH,     tempStr) ;
4379    sprintf(tempStr, "%d", height);
4380    put_resource(R_HEIGHT,     tempStr) ;
4381    sprintf(tempStr, "%d", x);
4382    put_resource(R_X,     tempStr) ;
4383    sprintf(tempStr, "%d", y);
4384    put_resource(R_Y,     tempStr) ;
4385
4386    write_resources(path);
4387 }
4388
4389 void
4390 RestoreSession()
4391 {
4392    Boolean status=False;
4393    char *path, *msg;
4394    char str[MAXLINE] ;
4395    char temp[MAXLINE] ;
4396    char * full_path = NULL;
4397    XrmDatabase db;
4398    int boolval, i, intval ;
4399    double result;
4400    int MPtemp[MP_SIZE];
4401
4402    status = DtSessionRestorePath(X->kframe, &full_path,
4403                                  application_args.session);
4404    if (!status)
4405       return;
4406
4407    path = XtNewString(full_path);
4408
4409    db = XrmGetFileDatabase(path) ;
4410    XrmMergeDatabases(db, &(X->rDB)) ;
4411
4412    if (get_int_resource(R_ACCURACY, &intval))
4413     {
4414       v->accuracy = intval ;
4415       if (v->accuracy < 0 || v->accuracy > 9)
4416         {
4417           msg = (char *) XtMalloc(strlen( opts[(int) O_ACCRANGE]) + 3);
4418           sprintf(msg, opts[(int) O_ACCRANGE]);
4419           _DtSimpleError (v->appname, DtWarning, NULL, msg);
4420           XtFree(msg);
4421           v->accuracy = 2 ;
4422         }
4423     }
4424
4425    if ((full_path = get_resource(R_BASE)) != NULL)
4426     {
4427       for (i = 0; i < MAXBASES; i++)
4428         if (EQUAL(full_path, base_str[i])) break ;
4429
4430       if (i == MAXBASES)
4431       {
4432           msg = (char *) XtMalloc(strlen( opts[(int) O_BASE]) + 3);
4433           sprintf(msg, opts[(int) O_BASE]);
4434           _DtSimpleError (v->appname, DtWarning, NULL, msg);
4435           XtFree(msg);
4436       }
4437       else
4438         {
4439           v->base = (enum base_type) i ;
4440         }
4441     }
4442
4443    if (get_str_resource(R_DISPLAY, str))
4444     {
4445       for (i = 0; i < MAXDISPMODES; i++)
4446         if (EQUAL(str, dtype_str[i])) break ;
4447
4448       if (i == MAXDISPMODES)
4449       {
4450           msg = (char *) XtMalloc(strlen( opts[(int) O_DISPLAY]) +
4451                                                           strlen(str) + 3);
4452           sprintf(msg, opts[(int) O_DISPLAY], str);
4453           _DtSimpleError (v->appname, DtWarning, NULL, msg);
4454           XtFree(msg);
4455       }
4456       else v->dtype = (enum num_type) i ;
4457     }
4458
4459    if (get_str_resource(R_MODE, str))
4460     {
4461       for (i = 0; i < MAXMODES; i++)
4462         if (EQUAL(str, mode_str[i])) break ;
4463
4464       if (i == MAXMODES)
4465       {
4466           msg = (char *)XtMalloc(strlen( opts[(int) O_MODE]) + strlen(str) + 3);
4467           sprintf(msg, opts[(int) O_MODE], str);
4468           _DtSimpleError (v->appname, DtWarning, NULL, msg);
4469           XtFree(msg);
4470       }
4471       else v->modetype = (enum mode_type) i ;
4472     }
4473
4474    if (get_str_resource(R_TRIG, str))
4475     {
4476       for (i = 0; i < MAXTRIGMODES; i++)
4477         if (EQUAL(str, ttype_str[i])) break ;
4478
4479       if (i == MAXTRIGMODES)
4480       {
4481           msg = (char *)XtMalloc(strlen( opts[(int) O_TRIG]) + strlen(str) + 3);
4482           sprintf(msg, opts[(int) O_TRIG], str);
4483           _DtSimpleError (v->appname, DtWarning, NULL, msg);
4484           XtFree(msg);
4485       }
4486       else v->ttype = (enum trig_type) i ;
4487     }
4488
4489    if (get_bool_resource(R_REGS,   &boolval)) v->rstate     = boolval ;
4490
4491    /* Get the iconify state */
4492    if (get_bool_resource(R_ICON,   &boolval)) v->iconic    = boolval;
4493
4494    /* Get the menubar state */
4495    if (get_bool_resource(R_MENUBAR,   &boolval))
4496       application_args.menuBar = boolval;
4497
4498    /* Get the keys state */
4499    if (get_bool_resource(R_KEYS,   &boolval)) v->tstate    = boolval;
4500
4501    /* Get the proper workspaces if needed */
4502    if ((full_path = get_resource(R_WORKSPACE)) != NULL)
4503       v->workspaces = XtNewString(full_path);
4504
4505    /* Get the x, y width, and height */
4506    if (get_int_resource(R_WIDTH, &intval))
4507       v->width = intval ;
4508    if (get_int_resource(R_HEIGHT, &intval))
4509       v->height = intval ;
4510    if (get_int_resource(R_X, &intval))
4511       v->x = intval ;
4512    if (get_int_resource(R_Y, &intval))
4513       v->y = intval ;
4514
4515    if (get_str_resource(R_DISPLAYED, str))
4516    {
4517       STRCPY(v->display, str);
4518       MPstr_to_num(str, v->base, v->MPdisp_val) ;
4519    }
4520
4521    if (get_str_resource(R_REG0, str))
4522       MPstr_to_num(str, v->base, v->MPmvals[0]) ;
4523    if (get_str_resource(R_REG1, str))
4524       MPstr_to_num(str, v->base, v->MPmvals[1]) ;
4525    if (get_str_resource(R_REG2, str))
4526       MPstr_to_num(str, v->base, v->MPmvals[2]) ;
4527    if (get_str_resource(R_REG3, str))
4528       MPstr_to_num(str, v->base, v->MPmvals[3]) ;
4529    if (get_str_resource(R_REG4, str))
4530       MPstr_to_num(str, v->base, v->MPmvals[4]) ;
4531    if (get_str_resource(R_REG5, str))
4532       MPstr_to_num(str, v->base, v->MPmvals[5]) ;
4533    if (get_str_resource(R_REG6, str))
4534       MPstr_to_num(str, v->base, v->MPmvals[6]) ;
4535    if (get_str_resource(R_REG7, str))
4536       MPstr_to_num(str, v->base, v->MPmvals[7]) ;
4537    if (get_str_resource(R_REG8, str))
4538       MPstr_to_num(str, v->base, v->MPmvals[8]) ;
4539    if (get_str_resource(R_REG9, str))
4540       MPstr_to_num(str, v->base, v->MPmvals[9]) ;
4541
4542    if (get_str_resource(R_FREG0, str))
4543    {
4544       MPstr_to_num(str, v->base, MPtemp) ;
4545       mpcmd(MPtemp, &(v->MPfvals[0]));
4546    }
4547    if (get_str_resource(R_FREG1, str))
4548    {
4549       MPstr_to_num(str, v->base, MPtemp) ;
4550       mpcmd(MPtemp, &(v->MPfvals[1]));
4551    }
4552    if (get_str_resource(R_FREG2, str))
4553    {
4554       MPstr_to_num(str, v->base, MPtemp) ;
4555       mpcmd(MPtemp, &(v->MPfvals[2]));
4556    }
4557    if (get_str_resource(R_FREG3, str))
4558    {
4559       MPstr_to_num(str, v->base, MPtemp) ;
4560       mpcmd(MPtemp, &(v->MPfvals[3]));
4561    }
4562    if (get_str_resource(R_FREG4, str))
4563    {
4564       MPstr_to_num(str, v->base, MPtemp) ;
4565       mpcmd(MPtemp, &(v->MPfvals[4]));
4566    }
4567    if (get_str_resource(R_FREG5, str))
4568    {
4569       MPstr_to_num(str, v->base, MPtemp) ;
4570       mpcmd(MPtemp, &(v->MPfvals[5]));
4571    }
4572
4573 }
4574
4575 static void
4576 setCalcHints()
4577 {
4578    char *ptr;
4579    Atom * workspace_atoms = NULL;
4580    int num_workspaces=0;
4581    Arg args[8];
4582    XWMHints   *wmhints;
4583
4584    if(v->width != 0 && v->height != 0)
4585    {
4586       WMShellWidget wm = (WMShellWidget)(X->kframe);
4587       wm->wm.size_hints.flags |= USPosition;
4588       XtSetArg (args[0], XmNx, (Position)v->x);
4589       XtSetArg (args[1], XmNy, (Position)v->y);
4590       XtSetArg (args[2], XmNwidth, (Dimension)v->width);
4591       XtSetArg (args[3], XmNheight, (Dimension)v->height);
4592       XtSetValues (X->kframe, args, 4);
4593    }
4594
4595    if (v->iconic)
4596    {
4597        /* add the iconify hint to the current shell */
4598        XtSetArg(args[0], XmNinitialState, IconicState);
4599        XtSetValues(X->kframe, args, 1);
4600    }
4601    else
4602    {
4603      /* Remove the iconify hint from the current shell */
4604      wmhints = XGetWMHints(X->dpy, XtWindow(X->kframe));
4605      wmhints->flags |= IconWindowHint;
4606      wmhints->initial_state = NormalState;
4607      XSetWMHints(X->dpy, XtWindow(X->kframe), wmhints);
4608      XFree(wmhints);
4609    }
4610
4611    if (v->workspaces)
4612    {
4613       do
4614       {
4615          ptr = DtStrchr (v->workspaces, ' ');
4616
4617          if (ptr != NULL) *ptr = NULL;
4618
4619          workspace_atoms = (Atom *) XtRealloc ((char *)workspace_atoms,
4620                               sizeof (Atom) * (num_workspaces + 1));
4621
4622          workspace_atoms[num_workspaces] =
4623                               XmInternAtom (X->dpy, v->workspaces, True);
4624
4625          num_workspaces++;
4626
4627          if (ptr != NULL)
4628          {
4629             *ptr = ' ';
4630             v->workspaces = ptr + 1;
4631          }
4632       } while (ptr != NULL);
4633
4634       DtWsmSetWorkspacesOccupied (X->dpy, XtWindow (X->kframe),
4635                               workspace_atoms, num_workspaces);
4636
4637       XtFree ((char *) workspace_atoms);
4638    }
4639 }
4640
4641 void
4642 TimerEvent( client_data, id )
4643         XtPointer client_data;
4644         XtIntervalId *id;
4645 {
4646   Arg args[1];
4647
4648   ignore_event = False;
4649
4650   if(client_data)
4651   {
4652     XtSetArg (args[0], XmNdefaultButton, X->CFpi_butOK);
4653     XtSetValues (X->CFframe, args, 1);
4654   }
4655 }
4656
4657 /* #ifdef hpux */
4658 #ifdef HP_EXTENSIONS
4659 static int
4660 GetKeyboardID()
4661 {
4662     XHPDeviceList *list, *slist;
4663     int ndevices = 0, i, kbd = 0;
4664
4665     slist = XHPListInputDevices(X->dpy, &ndevices);
4666     for (i = 0, list = slist; i < ndevices; i++, list++)
4667     {
4668        if (list->type != KEYBOARD && strcmp(list->name, PS2_DIN_NAME))
4669           continue;
4670        if (list->detailed_id & (HP_ITF_KBD | HP_HIL) == (HP_ITF_KBD | HP_HIL))
4671        {
4672           kbd = HIL_ITF_KBD;
4673           return(kbd);
4674        }
4675        else if (list->detailed_id & (PC101_KBD|HP_HIL) == (PC101_KBD|HP_HIL))
4676        {
4677           kbd = HIL_PC101_KBD;
4678           return(kbd);
4679        }
4680        else if (list->detailed_id & (PC101_KBD|SERIAL) == (PC101_KBD|SERIAL))
4681        {
4682           kbd = SERIAL_PC101_KBD;
4683           return(kbd);
4684        }
4685
4686        if (!kbd)
4687        {
4688           if (strcmp(list->name, PS2_DIN_NAME) == 0)
4689           {
4690              kbd = SERIAL_PC101_KBD;
4691              return(kbd);
4692           }
4693           else if (list->hil_id >= FIRST_HIL_KBD &&
4694                                              list->hil_id <= LAST_HIL_KBD)
4695           {
4696              if (list->io_byte & LED_BITS)
4697              {
4698                 kbd = HIL_PC101_KBD;
4699                 return(kbd);
4700              }
4701              else
4702              {
4703                 kbd = HIL_ITF_KBD;
4704                 return(kbd);
4705              }
4706           }
4707        }
4708     }
4709     XHPFreeDeviceList (slist);
4710     return(0);
4711 }
4712 #endif
4713
4714 static char *
4715 _DtcalcStripSpaces(file)
4716 char *file;
4717 {
4718    int i, j;
4719
4720    if (file == NULL)
4721       return (file);
4722
4723    for (i = 0; i < strlen(file); i++)
4724    {
4725       if (isspace(file[i]))
4726       {
4727          for(j = i; file[j] != NULL; j++)
4728             file[j] = file[j + 1];
4729       }
4730    }
4731
4732    return (file);
4733 }
4734