cde/programs/dtcalc/motif.c

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