cde/programs/dtcalc/motif.c

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