cde/programs/dtcalc/motif.c

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