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