2 * CDE - Common Desktop Environment
4 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
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)
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
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with these librararies and programs; if not, write
20 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
21 * Floor, Boston, MA 02110-1301 USA
23 /* $TOG: motif.c /main/28 1998/07/21 16:17:00 samborn $ */
25 * (c) Copyright 1997, The Open Group
29 * Contains the user interface portion of the Desktop *
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. *
43 #include <sys/param.h>
47 #include <X11/keysym.h>
48 #include <X11/Xatom.h>
57 #include <X11/XHPlib.h>
58 #include <X11/HPkeysym.h>
59 #include <X11/Xutil.h>
64 #include <Xm/DrawingA.h>
65 #include <Xm/DrawingAP.h>
66 #include <Xm/MessageB.h>
67 #include <Xm/RowColumn.h>
68 #include <Xm/MwmUtil.h>
69 #include <Xm/ManagerP.h>
71 #include <Xm/ColorObjP.h>
73 #include <Xm/MenuShell.h>
76 #include <Xm/PushBP.h>
77 #include <Xm/PushBG.h>
78 #include <Xm/CascadeB.h>
79 #include <Xm/CascadeBG.h>
80 #include <Xm/MwmUtil.h>
81 #include <Xm/Protocols.h>
82 #include <Xm/VendorSEP.h>
83 /* Copied from BaseClassI.h */
84 extern XmWidgetExtData _XmGetWidgetExtData(
86 #if NeedWidePrototypes
87 unsigned int extType) ;
89 unsigned char extType) ;
90 #endif /* NeedWidePrototypes */
92 #include <X11/CoreP.h>
94 #include <X11/ShellP.h>
95 #include <X11/Shell.h>
96 #include <X11/IntrinsicP.h>
97 #include <X11/Intrinsic.h>
98 #include <X11/Shell.h>
99 #include <X11/Xatom.h>
100 #include <Xm/Protocols.h>
101 #include <X11/keysymdef.h>
103 #include <Dt/Session.h>
105 #include <Dt/Connect.h>
106 #include <Dt/FileM.h>
107 #include <Dt/Indicator.h>
109 #include <Dt/Message.h>
111 #include <Dt/CommandM.h>
112 #include <Dt/EnvControlP.h>
115 #include <X11/Xmu/Editres.h>
120 #include "ds_widget.h"
121 #include "ds_common.h"
122 #include "ds_popup.h"
127 static XtResource resources[] =
130 "postMenuBar", "PostMenuBar", XmRBoolean, sizeof (Boolean),
131 XtOffset (ApplicationArgsPtr, menuBar), XmRImmediate, (XtPointer) True,
135 "accuracy", "Accuracy", XmRInt, sizeof (int),
136 XtOffset (ApplicationArgsPtr, accuracy), XmRImmediate, (XtPointer) 2,
140 "base", "Base", XmRString, sizeof (char *),
141 XtOffset (ApplicationArgsPtr, base), XmRImmediate, (XtPointer) "decimal",
145 "displayNotation", "DisplayNotation", XmRString, sizeof (char *),
146 XtOffset (ApplicationArgsPtr, display), XmRImmediate, (XtPointer) "fixed",
150 "mode", "Mode", XmRString, sizeof (char *),
151 XtOffset (ApplicationArgsPtr, mode), XmRImmediate, (XtPointer)"scientific",
155 "trigType", "TrigType", XmRString, sizeof (char *),
156 XtOffset (ApplicationArgsPtr, trigType), XmRImmediate,
157 (XtPointer)"degrees",
161 char DTCALC_CLASS_NAME[] = "Dtcalc";
163 extern char *opts[] ; /* Command line option strings. */
166 XmPixelSet pixels[XmCO_MAX_NUM_COLORS];
169 Boolean BlackWhite = False;
171 char * dt_path = NULL;
173 static Widget funBtn = NULL;
174 static Widget constBtn = NULL;
175 static Widget accBtn = NULL;
176 static Widget stoBtn = NULL;
177 static Widget rclBtn = NULL;
178 static Widget exchBtn = NULL;
180 static Atom saveatom ;
181 static Atom command_atom ;
182 static Atom wm_state_atom;
184 Boolean ignore_event = False;
185 XtIntervalId timerId = NULL;
187 static int lastArmed[10];
188 static int countArmed = 0;
190 /* Structure used on a save session to see if a dt is iconic */
197 void menu_proc P((Widget, XtPointer, XtPointer)) ;
198 void show_ascii P((Widget, XtPointer, XtPointer)) ;
199 void write_cf_value P((Widget, XtPointer, XtPointer)) ;
200 void close_cf P((Widget, XtPointer, XtPointer)) ;
201 void close_ascii P((Widget, XtPointer, XtPointer)) ;
202 void move_cf P((Widget, XtPointer, XtPointer)) ;
203 void FocusInCB P((Widget, XtPointer, XtPointer)) ;
204 void map_popup P((Widget, XtPointer, XtPointer)) ;
208 static int GetKeyboardID P(()) ;
211 static int event_is_keypad P((XEvent *)) ;
212 static int get_next_event P((Widget, int, XEvent *)) ;
213 static int is_window_showing P((Widget)) ;
215 static KeySym keypad_keysym P((XEvent *)) ;
217 static void modelineValueChanged P((Widget, XtPointer, XtPointer)) ;
218 static void dtcalc_kkeyboard_create P((Widget)) ;
219 static void dtcalc_kpanel_create P((Widget)) ;
220 static void confirm_callback P((Widget, XtPointer, XtPointer)) ;
221 static void create_cfframe P(()) ;
222 static void create_menu P((enum menu_type, Widget, int)) ;
223 static void do_button P((Widget, XtPointer, XtPointer)) ;
224 static void do_confirm_notice P((Widget, char *)) ;
225 static void do_continue_notice P((Widget, char *)) ;
226 static void close_reg P((Widget, XtPointer, XtPointer)) ;
227 static void event_proc P((Widget, XtPointer, XEvent *, Boolean *)) ;
228 static void frame_interpose P((Widget, XtPointer, XEvent *, Boolean *)) ;
229 static void menu_handler P((Widget, XtPointer, XEvent *, Boolean *)) ;
230 static void popupHandler P((Widget, XtPointer, XEvent *, Boolean *)) ;
231 static void make_mode_frame P((enum mode_type)) ;
232 static void new_cf_value P((Widget, XtPointer, XtPointer)) ;
233 static void do_memory P((Widget, XtPointer, XtPointer)) ;
234 static void switch_mode P((enum mode_type)) ;
235 static void update_cf_value P(()) ;
236 static void xerror_interpose P((Display *, XErrorEvent *)) ;
238 static Widget button_create P((Widget, int, int, int, int)) ;
239 static void save_state P((Widget, XtPointer, XtPointer)) ;
240 static void SaveSession P(( char *, char * )) ;
241 static void setCalcHints P(()) ;
243 static char * _DtcalcStripSpaces P(( char * )) ;
245 static void ProcessMotifSelection(Widget);
247 extern char **environ ;
249 extern char *base_str[] ; /* Strings for each base value. */
250 extern char *calc_res[] ; /* Calctool X resources. */
251 extern char *dtype_str[] ; /* Strings for each display mode value. */
252 extern char *lstrs[] ; /* Labels for various Motif items. */
253 extern char *mess[] ; /* Message strings. */
254 extern char *mode_str[] ; /* Strings for each mode value. */
255 extern char *pstrs[] ; /* Property sheet strings. */
256 extern char *ttype_str[] ; /* Strings for each trig type value. */
257 extern char *vstrs[] ; /* Various strings. */
259 extern struct button buttons[] ; /* Calculator button values. */
260 extern struct button mode_buttons[] ; /* Calculator mode button values. */
261 extern struct menu cmenus[] ; /* Calculator menus. */
262 extern struct menu_entry menu_entries[] ; /* All the menu strings. */
264 extern Vars v ; /* Calctool variables and options. */
266 char translations_return[] = "<Key>Return:ManagerGadgetSelect()";
267 static Boolean NoDisplay=False;
274 char bind_home[MAXPATHLEN], **new_environ ;
278 XtSetLanguageProc(NULL, NULL, NULL);
279 _DtEnvControl(DT_ENV_SET);
280 signal (SIGHUP, SIG_IGN);
282 signal (SIGFPE, SIG_IGN);
285 X = (XVars) LINT_CAST(calloc(1, sizeof(XObject))) ;
286 X->home = getenv("HOME") ;
288 X->kframe = XtVaAppInitialize (&X->app,
289 DTCALC_CLASS_NAME, /* app class */
290 NULL, /* options list */
294 NULL, /* fallback resources */
295 XtNiconName, "dtcalc",
296 XtNiconPixmap, X->icon,
297 XtNiconMask, X->iconmask,
300 X->dpy = XtDisplay (X->kframe);
306 tmpStr = GETMESSAGE(2, 31, "Could not open display.\n");
307 msg = XtNewString(tmpStr);
308 FPRINTF(stderr, msg) ;
312 X->screen = DefaultScreen(X->dpy) ;
313 X->root = RootWindow(X->dpy, X->screen) ;
314 white_pixel = WhitePixel(X->dpy, X->screen);
315 black_pixel = BlackPixel(X->dpy, X->screen);
320 X->helpMapped = False;
322 if (DtInitialize (X->dpy, X->kframe, argv[0], DTCALC_CLASS_NAME) == False)
324 /* Fatal Error: could not connect to the messaging system. */
325 /* DtInitialize() has already logged an appropriate error msg */
329 /* Get the application defined resources */
330 XtGetApplicationResources(X->kframe, &application_args, resources, 6, NULL,0);
332 v = (Vars) LINT_CAST(calloc(1, sizeof(CalcVars))) ;
334 /* Get the dt path created and initialized */
335 dt_path = _DtCreateDtDirs (X->dpy);
339 v->keybdID = GetKeyboardID();
342 init_colors() ; /* get the pixels for the default colors in DT */
343 if(pixels[0].bg == white_pixel || pixels[0].bg == black_pixel)
346 if(colorSrv && !BlackWhite)
348 /* first get the Calculator's Icon */
349 pixmap = XmGetPixmap (DefaultScreenOfDisplay(X->dpy), CALC_ICON_NAME,
350 pixels[1].fg, pixels[1].bg);
351 if( pixmap != XmUNSPECIFIED_PIXMAP)
354 X->icon = XmUNSPECIFIED_PIXMAP;
356 /* now let's get the mask for the Calculator */
357 pixmap = _DtGetMask (DefaultScreenOfDisplay(X->dpy), CALC_ICON_NAME);
358 if( pixmap != XmUNSPECIFIED_PIXMAP)
359 X->iconmask = pixmap;
361 X->iconmask = XmUNSPECIFIED_PIXMAP;
365 /* first get the Calculator's Icon */
366 pixmap = XmGetPixmap (DefaultScreenOfDisplay(X->dpy), CALC_ICON_NAME_BM,
367 white_pixel, black_pixel);
368 if( pixmap != XmUNSPECIFIED_PIXMAP)
371 X->icon = XmUNSPECIFIED_PIXMAP;
373 /* now let's get the mask for the Calculator */
374 pixmap = _DtGetMask (DefaultScreenOfDisplay(X->dpy), CALC_ICON_NAME_BM);
375 if( pixmap != XmUNSPECIFIED_PIXMAP)
376 X->iconmask = pixmap;
378 X->iconmask = XmUNSPECIFIED_PIXMAP;
381 do_dtcalc(argc, argv) ;
394 button_create(owner, row, column, maxrows, maxcols)
396 int row, column, maxrows, maxcols ;
398 int n = row * maxcols + column ;
400 enum menu_type mtype = buttons[n].mtype ;
407 lstr = XmStringCreateLocalized(v->pstr) ;
413 else if(row >= 3 && row < 6)
415 else if(((row == 7 && column == 3) || (row == 13 && column == 3)) &&
418 else if((row >= 6 && row < 8) || (row >= 8 && row < 13 && column == 3) ||
419 (row == 13 && column == 2))
424 button = XtVaCreateManagedWidget(buttons[n].resname,
425 xmPushButtonWidgetClass,
427 XmNtopAttachment, XmATTACH_POSITION,
428 XmNtopPosition, row * maxcols,
429 XmNleftAttachment, XmATTACH_POSITION,
430 XmNleftPosition, column * maxrows,
431 XmNrightAttachment, XmATTACH_POSITION,
432 XmNrightPosition, (column+1) * maxrows,
433 XmNbottomAttachment, XmATTACH_POSITION,
434 XmNbottomPosition, (row+1) * maxcols,
435 XmNlabelString, lstr,
437 XmNtraversalOn, TRUE,
438 XmNalignment, XmALIGNMENT_CENTER,
439 XmNrecomputeSize, False,
440 XmNnavigationType, XmNONE,
444 button = XtVaCreateManagedWidget(buttons[n].resname,
445 xmPushButtonWidgetClass,
447 XmNtopAttachment, XmATTACH_POSITION,
448 XmNtopPosition, row * maxcols,
449 XmNleftAttachment, XmATTACH_POSITION,
450 XmNleftPosition, column * maxrows,
451 XmNrightAttachment, XmATTACH_POSITION,
452 XmNrightPosition, (column+1) * maxrows,
453 XmNbottomAttachment, XmATTACH_POSITION,
454 XmNbottomPosition, (row+1) * maxcols,
455 XmNlabelString, lstr,
456 XmNtraversalOn, TRUE,
457 XmNalignment, XmALIGNMENT_CENTER,
458 XmNrecomputeSize, False,
459 XmNnavigationType, XmNONE,
464 if (mtype != M_NONE) create_menu(mtype, button, n) ;
465 val = (v->curwin << 16) + n ;
466 XtAddCallback(button, XmNactivateCallback, do_button, (XtPointer) val) ;
467 XtAddCallback(button, XmNhelpCallback, HelpRequestCB, (XtPointer) val) ;
468 XtAddEventHandler(button, KeyPressMask | KeyReleaseMask,
469 FALSE, event_proc, NULL) ;
471 if( funBtn == NULL && strcmp(v->pstr, GETMESSAGE(3, 5, "Functions")) == 0)
473 else if( constBtn == NULL && strcmp(v->pstr,
474 GETMESSAGE(3, 6, "Constants")) == 0)
476 else if( accBtn == NULL && strcmp(v->pstr,
477 GETMESSAGE(3, 12, "Accuracy")) == 0)
479 else if( stoBtn == NULL && strcmp(v->pstr, GETMESSAGE(3, 13, "Store")) == 0)
481 else if( rclBtn == NULL && strcmp(v->pstr, GETMESSAGE(3, 14, "Recall")) == 0)
483 else if( exchBtn == NULL && strcmp(v->pstr,
484 GETMESSAGE(3, 15, "Exchange")) == 0)
492 dtcalc_initialize_rframe(owner, type)
499 XmString label_string;
500 Widget sep, button, frame, form;
504 if (X->rframe) return ;
506 X->rframe = XmCreateFormDialog(owner, "rframe", NULL, 0) ;
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);
513 set_title(FCP_REG, lstrs[(int) L_MEMT]) ;
515 frame = XmCreateFrame(X->rframe, "frame", NULL, 0);
516 XtManageChild(frame);
517 form = (Widget) XmCreateForm(frame, "form", NULL, 0) ;
523 XmNallowShellResize, TRUE,
524 XmNdefaultPosition, FALSE,
527 SPRINTF(str, "register%1d", 0) ;
528 X->registers[0] = XtVaCreateManagedWidget(str,
531 XmNtopAttachment, XmATTACH_FORM,
533 XmNleftAttachment, XmATTACH_FORM,
539 for (i = 1; i < MAXREGS; i++)
541 SPRINTF(str, "register%1d", i) ;
542 X->registers[i] = XtVaCreateManagedWidget(str,
545 XmNtopAttachment, XmATTACH_WIDGET,
546 XmNtopWidget, X->registers[i - 1],
548 XmNleftAttachment, XmATTACH_FORM,
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);
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);
578 XtAddCallback(button, XmNactivateCallback, close_reg, (XtPointer)type) ;
580 XtSetArg (args[0], XmNcancelButton, button);
581 XtSetArg (args[1], XmNdefaultButton, button);
582 XtSetValues (X->rframe, args, 2);
584 XtManageChild(button);
588 if (X->frframe) return ;
589 X->frframe = XmCreateFormDialog(owner, "frframe", NULL, 0) ;
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);
596 set_title(FCP_FIN_REG, GETMESSAGE(2, 18, lstrs[(int) L_FINMEMT] ));
598 frame = XmCreateFrame(X->frframe, "frame", NULL, 0);
599 XtManageChild(frame);
600 form = (Widget) XmCreateForm(frame, "form", NULL, 0) ;
606 XmNallowShellResize, TRUE,
607 XmNdefaultPosition, FALSE,
610 SPRINTF(str, "fregister%1d", 0) ;
611 X->fregisters[0] = XtVaCreateManagedWidget(str,
614 XmNtopAttachment, XmATTACH_FORM,
616 XmNleftAttachment, XmATTACH_FORM,
622 for (i = 1; i < FINREGS; i++)
624 SPRINTF(str, "fregister%1d", i) ;
625 X->fregisters[i] = XtVaCreateManagedWidget(str,
628 XmNtopAttachment, XmATTACH_WIDGET,
629 XmNtopWidget, X->fregisters[i - 1],
631 XmNleftAttachment, XmATTACH_FORM,
638 SPRINTF(str, "fregistervals%1d", 0) ;
639 X->fregistersvals[0] = XtVaCreateManagedWidget(str,
642 XmNtopAttachment, XmATTACH_FORM,
644 XmNleftAttachment, XmATTACH_WIDGET,
645 XmNleftWidget, X->fregisters[0],
647 XmNrightAttachment, XmATTACH_FORM,
653 for (i = 1; i < FINREGS; i++)
655 SPRINTF(str, "fregistervals%1d", i) ;
656 X->fregistersvals[i] = XtVaCreateManagedWidget(str,
659 XmNtopAttachment, XmATTACH_WIDGET,
660 XmNtopWidget, X->fregistersvals[i - 1],
662 XmNleftAttachment, XmATTACH_WIDGET,
663 XmNleftWidget, X->fregisters[i],
665 XmNrightAttachment, XmATTACH_FORM,
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);
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);
695 XtSetArg (args[0], XmNcancelButton, button);
696 XtSetArg (args[1], XmNdefaultButton, button);
697 XtSetValues (X->frframe, args, 2);
699 XtAddCallback(button, XmNactivateCallback, close_reg, NULL) ;
701 XtManageChild(button);
707 dtcalc_kkeyboard_create(owner)
713 buttonFrame = XtVaCreateManagedWidget("buttonFrame",
716 XmNshadowThickness, 0,
719 XmNtopAttachment, XmATTACH_WIDGET,
720 XmNtopWidget, X->modeFrame,
721 XmNrightAttachment, XmATTACH_FORM,
722 XmNleftAttachment, XmATTACH_FORM,
723 XmNbottomAttachment, XmATTACH_FORM,
726 X->kkeyboard = XtVaCreateManagedWidget("kkeyboard",
729 XmNfractionBase, BROWS * BCOLS,
730 XmNnavigationType, XmSTICKY_TAB_GROUP,
733 v->curwin = FCP_KEY ;
734 for (row = 0; row < BROWS; row++)
735 for (column = 0; column < BCOLS; column++)
737 X->kbuttons[row][column] = button_create(X->kkeyboard, row, column,
739 XtManageChild(X->kbuttons[row][column]) ;
741 grey_buttons(v->base) ;
746 dtcalc_kpanel_create(owner)
749 static char *mnames[] = { "base", "ttype", "num", "hyp",
750 "inv", "op", "mode" } ;
752 Widget basePulldown, numPulldown, modePulldown, trigPulldown, dummyText;
754 XmString label_string;
755 Pixel tmp_pixelbg, tmp_pixelfg;
756 XtTranslations trans_table;
758 trans_table = XtParseTranslationTable(translations_return);
764 if(pixels[2].bg == black_pixel)
766 tmp_pixelbg = black_pixel;
767 tmp_pixelfg = white_pixel;
771 tmp_pixelbg = white_pixel;
772 tmp_pixelfg = black_pixel;
777 tmp_pixelbg = pixels[6].bg;
778 tmp_pixelfg = white_pixel;
783 tmp_pixelbg = white_pixel;
784 tmp_pixelfg = black_pixel;
787 X->mainWin = XtVaCreateManagedWidget("mainWin",
788 xmMainWindowWidgetClass,
793 XtAddEventHandler(owner, 0, True,
794 (XtEventHandler) _XEditResCheckMessages,
798 if(application_args.menuBar)
799 create_menu_bar(X->mainWin);
801 X->kFrame = XtVaCreateManagedWidget("kFrame", xmFrameWidgetClass,
803 XmNshadowThickness, 1,
804 XmNshadowType, XmSHADOW_OUT,
809 X->kpanel = XtVaCreateManagedWidget("kpanel",
812 XmNshadowThickness, 0,
813 XmNbackground, tmp_pixelbg,
814 XmNforeground, tmp_pixelfg,
817 create_popup(X->kpanel);
819 X->textFrame = XtVaCreateManagedWidget("textFrame",
822 XmNshadowThickness, 2,
823 XmNshadowType, XmSHADOW_IN,
826 XmNtopAttachment, XmATTACH_FORM,
827 XmNrightAttachment, XmATTACH_FORM,
828 XmNleftAttachment, XmATTACH_FORM,
829 XmNnavigationType, XmTAB_GROUP,
831 XtAddCallback(X->textFrame, XmNhelpCallback, HelpRequestCB,
832 (XtPointer)HELP_DISPLAY) ;
834 X->textForm = XtVaCreateManagedWidget("textForm",
837 XmNshadowThickness, 0,
838 XmNbackground, tmp_pixelbg,
839 XmNforeground, tmp_pixelfg,
841 XtAddCallback(X->textForm, XmNhelpCallback, HelpRequestCB,
842 (XtPointer)HELP_DISPLAY) ;
844 X->modevals[(int) DISPLAYITEM] = XtVaCreateManagedWidget("display",
847 XmNtopAttachment, XmATTACH_FORM,
848 XmNrightAttachment, XmATTACH_FORM,
849 XmNbottomAttachment, XmATTACH_FORM,
850 XmNresizeWidth, TRUE,
851 XmNshadowThickness, 0,
852 XmNhighlightThickness, 0,
854 XmNverifyBell, FALSE,
855 XmNbackground, tmp_pixelbg,
856 XmNforeground, tmp_pixelfg,
858 XtAddCallback(X->modevals[(int) DISPLAYITEM], XmNhelpCallback, HelpRequestCB,
859 (XtPointer) HELP_DISPLAY) ;
860 XtAddEventHandler(X->modevals[(int) DISPLAYITEM],
861 KeyPressMask | KeyReleaseMask, FALSE, event_proc, NULL) ;
864 X->modeFrame = XtVaCreateManagedWidget("modeFrame",
867 XmNshadowThickness, 0,
870 XmNtopAttachment, XmATTACH_WIDGET,
871 XmNtopWidget, X->textFrame,
872 XmNrightAttachment, XmATTACH_FORM,
873 XmNleftAttachment, XmATTACH_FORM,
874 XmNnavigationType, XmTAB_GROUP,
876 XtAddCallback(X->modeFrame, XmNhelpCallback, HelpRequestCB,
877 (XtPointer) HELP_MODELINE) ;
879 X->modeline = XtVaCreateManagedWidget("modeline",
882 XmNshadowThickness, 0,
884 XtAddCallback(X->modeline, XmNhelpCallback, HelpRequestCB,
885 (XtPointer) HELP_MODELINE) ;
887 label_string = XmStringCreateLocalized (" ");
889 X->modevals[i] = XtVaCreateManagedWidget(mnames[i],
892 XmNtopAttachment, XmATTACH_FORM,
893 XmNrightAttachment, XmATTACH_FORM,
894 XmNrecomputeSize, False,
895 XmNalignment, XmALIGNMENT_CENTER,
896 XmNlabelString, label_string,
898 XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
899 (XtPointer) HELP_MODELINE) ;
902 X->modevals[i] = XtVaCreateManagedWidget(mnames[i],
905 XmNrightAttachment, XmATTACH_WIDGET,
906 XmNrightWidget, X->modevals[(int) OPITEM],
907 XmNtopAttachment, XmATTACH_FORM,
908 XmNrecomputeSize, False,
909 XmNalignment, XmALIGNMENT_CENTER,
910 XmNlabelString, label_string,
912 XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
913 (XtPointer) HELP_MODELINE) ;
916 X->modevals[i] = XtVaCreateManagedWidget(mnames[i],
919 XmNrightAttachment, XmATTACH_WIDGET,
920 XmNrightWidget, X->modevals[(int) HYPITEM],
921 XmNtopAttachment, XmATTACH_FORM,
922 XmNrecomputeSize, False,
923 XmNalignment, XmALIGNMENT_CENTER,
924 XmNlabelString, label_string,
926 XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
927 (XtPointer) HELP_MODELINE) ;
928 XmStringFree(label_string);
932 modePulldown = XmCreatePulldownMenu(X->modeline, "modePD", args, 0);
934 XtSetArg(args[0], XmNmarginHeight, 0);
935 XtSetArg(args[1], XmNmarginWidth, 0);
936 val = (v->curwin << 16) +
937 menu_entries[cmenus[(int) M_MODE].mindex + 1].val ;
938 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 9, "Financial") );
939 XtSetArg(args[2], XmNlabelString, label_string);
940 XtSetArg(args[3], XmNuserData, val);
941 modeArry[0] = XmCreatePushButtonGadget(modePulldown, "fin", args, 4);
942 XmStringFree(label_string);
943 XtAddCallback(modeArry[0], XmNactivateCallback, modelineValueChanged,
946 val = (v->curwin << 16) +
947 menu_entries[cmenus[(int) M_MODE].mindex + 2].val ;
948 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 10, "Logical") );
949 XtSetArg(args[2], XmNlabelString, label_string);
950 XtSetArg(args[3], XmNuserData, val);
951 modeArry[1] = XmCreatePushButtonGadget(modePulldown, "logic", args, 4);
952 XmStringFree(label_string);
953 XtAddCallback(modeArry[1], XmNactivateCallback, modelineValueChanged,
956 val = (v->curwin << 16) +
957 menu_entries[cmenus[(int) M_MODE].mindex + 3].val ;
958 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 11, "Scientific") );
959 XtSetArg(args[2], XmNlabelString, label_string);
960 XtSetArg(args[3], XmNuserData, val);
961 modeArry[2] = XmCreatePushButtonGadget(modePulldown, "Sci", args, 4);
962 XmStringFree(label_string);
963 XtAddCallback(modeArry[2], XmNactivateCallback, modelineValueChanged,
966 XtManageChildren(modeArry, 3);
968 /* create the Option Menu and attach it to the Pulldown MenuPane */
970 XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
971 XtSetArg (args[n], XmNtopWidget, X->modevals[(int)HYPITEM]); n++;
972 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
973 XtSetArg(args[n], XmNsubMenuId, modePulldown); n++;
974 XtSetArg(args[n], XmNmenuHistory, modeArry[(int)v->modetype]); n++;
975 X->modevals[i] = XmCreateOptionMenu(X->modeline, "mode", args, n);
976 XtManageChild (X->modevals[i]);
977 XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
978 (XtPointer) HELP_MODE) ;
980 XtOverrideTranslations(X->modevals[i], trans_table);
982 XtAddEventHandler(X->modevals[i], KeyPressMask | KeyReleaseMask,
983 FALSE, event_proc, NULL) ;
986 basePulldown = XmCreatePulldownMenu(X->modeline, "basePD", args, 0);
988 val = (v->curwin << 16) +
989 menu_entries[cmenus[(int) M_BASE].mindex].val ;
990 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 1, "Bin") );
991 XtSetArg(args[0], XmNmarginHeight, 0);
992 XtSetArg(args[1], XmNmarginWidth, 0);
993 XtSetArg(args[2], XmNlabelString, label_string);
994 XtSetArg(args[3], XmNuserData, val);
995 X->baseWidgArry[0] = XmCreatePushButtonGadget(basePulldown, "bin", args, 4);
996 XmStringFree(label_string);
997 XtAddCallback(X->baseWidgArry[0], XmNactivateCallback,
998 modelineValueChanged, (XtPointer) M_BASE);
1000 val = (v->curwin << 16) +
1001 menu_entries[cmenus[(int) M_BASE].mindex + 1].val ;
1002 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 2, "Oct") );
1003 XtSetArg(args[2], XmNlabelString, label_string);
1004 XtSetArg(args[3], XmNuserData, val);
1005 X->baseWidgArry[1] = XmCreatePushButtonGadget(basePulldown, "oct", args, 4);
1006 XmStringFree(label_string);
1007 XtAddCallback(X->baseWidgArry[1], XmNactivateCallback,
1008 modelineValueChanged, (XtPointer) M_BASE);
1010 val = (v->curwin << 16) +
1011 menu_entries[cmenus[(int) M_BASE].mindex + 2].val ;
1012 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 3, "Dec") );
1013 XtSetArg(args[2], XmNlabelString, label_string);
1014 XtSetArg(args[3], XmNuserData, val);
1015 X->baseWidgArry[2] = XmCreatePushButtonGadget(basePulldown, "dec", args, 4);
1016 XmStringFree(label_string);
1017 XtAddCallback(X->baseWidgArry[2], XmNactivateCallback,
1018 modelineValueChanged, (XtPointer) M_BASE);
1020 val = (v->curwin << 16) +
1021 menu_entries[cmenus[(int) M_BASE].mindex + 3].val ;
1022 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 4, "Hex") );
1023 XtSetArg(args[2], XmNlabelString, label_string);
1024 XtSetArg(args[3], XmNuserData, val);
1025 X->baseWidgArry[3] = XmCreatePushButtonGadget(basePulldown, "hex", args, 4);
1026 XmStringFree(label_string);
1027 XtAddCallback(X->baseWidgArry[3], XmNactivateCallback,
1028 modelineValueChanged, (XtPointer) M_BASE);
1030 XtManageChildren(X->baseWidgArry, 4);
1032 /* create the Option Menu and attach it to the Pulldown MenuPane */
1034 XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
1035 XtSetArg (args[n], XmNtopWidget, X->modevals[(int)HYPITEM]); n++;
1036 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
1037 XtSetArg(args[n], XmNsubMenuId, basePulldown); n++;
1038 XtSetArg(args[n], XmNmenuHistory, X->baseWidgArry[(int)v->base]); n++;
1039 X->modevals[i] = XmCreateOptionMenu(X->modeline, "base", args, n);
1040 XtManageChild (X->modevals[i]);
1041 XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
1042 (XtPointer) HELP_BASE) ;
1044 XtOverrideTranslations(X->modevals[i], trans_table);
1045 XtAddEventHandler(X->modevals[i], KeyPressMask | KeyReleaseMask,
1046 FALSE, event_proc, NULL) ;
1050 numPulldown = XmCreatePulldownMenu(X->modeline, "numPD", args, 0);
1052 val = (v->curwin << 16) +
1053 menu_entries[cmenus[(int) M_NUM].mindex].val ;
1054 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 5, "Eng") );
1055 XtSetArg(args[0], XmNmarginHeight, 0);
1056 XtSetArg(args[1], XmNmarginWidth, 0);
1057 XtSetArg(args[2], XmNlabelString, label_string);
1058 XtSetArg(args[3], XmNuserData, val);
1059 X->numWidgArry[0] = XmCreatePushButtonGadget(numPulldown, "eng", args, 4);
1060 XmStringFree(label_string);
1061 XtAddCallback(X->numWidgArry[0], XmNactivateCallback, modelineValueChanged,
1064 val = (v->curwin << 16) +
1065 menu_entries[cmenus[(int) M_NUM].mindex + 1].val ;
1066 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 6, "Fix") );
1067 XtSetArg(args[2], XmNlabelString, label_string);
1068 XtSetArg(args[3], XmNuserData, val);
1069 X->numWidgArry[1] = XmCreatePushButtonGadget(numPulldown, "fix", args, 4);
1070 XmStringFree(label_string);
1071 XtAddCallback(X->numWidgArry[1], XmNactivateCallback, modelineValueChanged,
1074 val = (v->curwin << 16) +
1075 menu_entries[cmenus[(int) M_NUM].mindex + 2].val ;
1076 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 7, "Sci") );
1077 XtSetArg(args[2], XmNlabelString, label_string);
1078 XtSetArg(args[3], XmNuserData, val);
1079 X->numWidgArry[2] = XmCreatePushButtonGadget(numPulldown, "sci", args, 4);
1080 XmStringFree(label_string);
1081 XtAddCallback(X->numWidgArry[2], XmNactivateCallback, modelineValueChanged,
1084 XtManageChildren(X->numWidgArry, 3);
1086 /* create the Option Menu and attach it to the Pulldown MenuPane */
1088 XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
1089 XtSetArg (args[n], XmNtopWidget, X->modevals[(int)HYPITEM]); n++;
1090 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
1091 XtSetArg(args[n], XmNsubMenuId, numPulldown); n++;
1092 XtSetArg(args[n], XmNmenuHistory, X->numWidgArry[(int)v->dtype]); n++;
1093 X->modevals[i] = XmCreateOptionMenu(X->modeline, "num", args, n);
1094 XtManageChild (X->modevals[i]);
1095 XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
1096 (XtPointer) HELP_NOTATION) ;
1098 XtOverrideTranslations(X->modevals[i], trans_table);
1099 XtAddEventHandler(X->modevals[i], KeyPressMask | KeyReleaseMask,
1100 FALSE, event_proc, NULL) ;
1103 i = (int) TTYPEITEM;
1104 trigPulldown = XmCreatePulldownMenu(X->modeline, "trigPD", args, 0);
1106 XtSetArg(args[0], XmNmarginHeight, 0);
1107 XtSetArg(args[1], XmNmarginWidth, 0);
1108 val = (v->curwin << 16) +
1109 menu_entries[cmenus[(int) M_TRIG].mindex].val ;
1110 label_string = XmStringCreateLocalized ( ttype_str[(int) DEG] );
1111 XtSetArg(args[2], XmNlabelString, label_string);
1112 XtSetArg(args[3], XmNuserData, val);
1113 X->ttypeWidgArry[0] =
1114 XmCreatePushButtonGadget(trigPulldown, "deg", args, 4);
1115 XmStringFree(label_string);
1116 XtAddCallback(X->ttypeWidgArry[0], XmNactivateCallback,
1117 modelineValueChanged, (XtPointer) M_TRIG);
1119 val = (v->curwin << 16) +
1120 menu_entries[cmenus[(int) M_TRIG].mindex + 1].val ;
1121 label_string = XmStringCreateLocalized ( ttype_str[(int) GRAD] );
1122 XtSetArg(args[2], XmNlabelString, label_string);
1123 XtSetArg(args[3], XmNuserData, val);
1124 X->ttypeWidgArry[1] =
1125 XmCreatePushButtonGadget(trigPulldown, "grd", args, 4);
1126 XmStringFree(label_string);
1127 XtAddCallback(X->ttypeWidgArry[1], XmNactivateCallback,
1128 modelineValueChanged, (XtPointer) M_TRIG);
1130 val = (v->curwin << 16) +
1131 menu_entries[cmenus[(int) M_TRIG].mindex + 2].val ;
1132 label_string = XmStringCreateLocalized ( ttype_str[(int) RAD] );
1133 XtSetArg(args[2], XmNlabelString, label_string);
1134 XtSetArg(args[3], XmNuserData, val);
1135 X->ttypeWidgArry[2] =
1136 XmCreatePushButtonGadget(trigPulldown, "rad", args, 4);
1137 XmStringFree(label_string);
1138 XtAddCallback(X->ttypeWidgArry[2], XmNactivateCallback,
1139 modelineValueChanged, (XtPointer) M_TRIG);
1141 XtManageChildren(X->ttypeWidgArry, 3);
1143 /* create the Option Menu and attach it to the Pulldown MenuPane */
1145 XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM); n++;
1146 XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
1147 XtSetArg (args[n], XmNtopWidget, X->modevals[(int) HYPITEM]); n++;
1148 XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
1149 XtSetArg(args[n], XmNsubMenuId, trigPulldown); n++;
1150 XtSetArg(args[n], XmNmenuHistory, X->ttypeWidgArry[(int)v->ttype]); n++;
1151 X->modevals[i] = XmCreateOptionMenu(X->modeline, "trig", args, n);
1152 XtManageChild (X->modevals[i]);
1153 XtAddCallback(X->modevals[i], XmNhelpCallback, HelpRequestCB,
1154 (XtPointer) HELP_TRIG) ;
1156 XtOverrideTranslations(X->modevals[i], trans_table);
1157 XtSetSensitive(X->modevals[i], True);
1159 XtSetArg (args[0], XmNrightAttachment, XmATTACH_WIDGET);
1160 XtSetArg (args[1], XmNrightWidget, X->modevals[(int)BASEITEM]);
1161 XtSetValues (X->modevals[(int)MODEITEM], args, 2);
1163 XtSetArg (args[0], XmNrightAttachment, XmATTACH_WIDGET);
1164 XtSetArg (args[1], XmNrightWidget, X->modevals[(int)NUMITEM]);
1165 XtSetValues (X->modevals[(int)BASEITEM], args, 2);
1167 XtSetArg (args[0], XmNrightAttachment, XmATTACH_WIDGET);
1168 XtSetArg (args[1], XmNrightWidget, X->modevals[(int)TTYPEITEM]);
1169 XtSetValues (X->modevals[(int)NUMITEM], args, 2);
1172 XtAddEventHandler(X->modevals[i], KeyPressMask | KeyReleaseMask,
1173 FALSE, event_proc, NULL) ;
1180 confirm_callback(widget, client_data, call_data)
1182 XtPointer client_data, call_data ;
1189 create_cfframe() /* Create auxiliary frame for CON/FUN key. */
1194 Widget sep, frame, form;
1195 XmString label_string;
1197 X->CFframe = (Widget) XmCreateFormDialog(X->kframe, "cfframe", NULL, 0) ;
1198 tstr = XmStringCreateLocalized(lstrs[(int) L_NEWCON]) ;
1199 XtVaSetValues(X->CFframe,
1200 XmNdialogTitle, tstr,
1201 XmNautoUnmanage, FALSE,
1202 XmNallowShellResize, FALSE,
1203 XmNdefaultPosition, FALSE,
1205 XmStringFree(tstr) ;
1207 /* Adjust the decorations for the dialog shell of the dialog */
1209 XtSetArg (args[j], XmNmwmFunctions, MWM_FUNC_MOVE); j++;
1210 XtSetArg (args[j], XmNmwmDecorations, MWM_DECOR_BORDER | MWM_DECOR_TITLE); j++;
1211 XtSetValues (XtParent(X->CFframe), args, j);
1213 frame = (Widget) XmCreateFrame(X->CFframe, "frame", NULL, 0) ;
1214 XtManageChild(frame);
1215 form = (Widget) XmCreateForm(frame, "form", NULL, 0) ;
1216 XtManageChild(form);
1219 X->CFpi_cftext = make_textW(form, lstrs[(int) L_CONNO]) ;
1220 X->CFpi_dtext = make_textW(form, lstrs[(int) L_DESC]) ;
1221 X->CFpi_vtext = make_textW(form, lstrs[(int) L_VALUE]) ;
1224 XtSetArg (args[j], XmNtopAttachment, XmATTACH_FORM); j++;
1225 XtSetArg (args[j], XmNtopOffset, 5); j++;
1226 XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1227 XtSetArg (args[j], XmNrightOffset, 5); j++;
1228 XtSetValues(X->CFpi_cftext->manager, args, j);
1231 XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1232 XtSetArg (args[j], XmNtopWidget, X->CFpi_cftext->manager); j++;
1233 XtSetArg (args[j], XmNtopOffset, 5); j++;
1234 XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1235 XtSetArg (args[j], XmNrightOffset, 5); j++;
1236 XtSetValues(X->CFpi_dtext->manager, args, j);
1239 XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1240 XtSetArg (args[j], XmNtopWidget, X->CFpi_dtext->manager); j++;
1241 XtSetArg (args[j], XmNtopOffset, 5); j++;
1242 XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1243 XtSetArg (args[j], XmNrightOffset, 5); j++;
1244 XtSetValues(X->CFpi_vtext->manager, args, j);
1247 XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1248 XtSetArg (args[j], XmNtopWidget, X->CFpi_vtext->manager); j++;
1249 XtSetArg (args[j], XmNtopOffset, 3); j++;
1250 XtSetArg (args[j], XmNleftAttachment, XmATTACH_FORM); j++;
1251 XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1252 sep = XmCreateSeparator(form, "sep", args, j);
1256 label_string = XmStringCreateLocalized ( GETMESSAGE(4, 4, "OK") );
1257 XtSetArg (args[j], XmNmarginHeight, 2); j++;
1258 XtSetArg (args[j], XmNmarginWidth, 15); j++;
1259 XtSetArg (args[j], XmNlabelString, label_string); j++;
1260 XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1261 XtSetArg (args[j], XmNtopWidget, sep); j++;
1262 XtSetArg (args[j], XmNtopOffset, 5); j++;
1263 XtSetArg (args[j], XmNleftAttachment, XmATTACH_FORM); j++;
1264 XtSetArg (args[j], XmNleftOffset, 15); j++;
1265 XtSetArg (args[j], XmNbottomAttachment, XmATTACH_FORM); j++;
1266 XtSetArg (args[j], XmNbottomOffset, 5); j++;
1267 XtSetArg (args[j], XmNshowAsDefault, True); j++;
1268 XtSetArg (args[j], XmNtraversalOn, True); j++;
1269 X->CFpi_butOK = XmCreatePushButton(form, "button", args, j);
1270 XmStringFree(label_string);
1271 XtManageChild(X->CFpi_butOK);
1274 label_string = XmStringCreateLocalized ( GETMESSAGE(3, 361, "Cancel") );
1275 XtSetArg (args[j], XmNmarginHeight, 2); j++;
1276 XtSetArg (args[j], XmNmarginWidth, 10); j++;
1277 XtSetArg (args[j], XmNlabelString, label_string); j++;
1278 XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1279 XtSetArg (args[j], XmNtopWidget, sep); j++;
1280 XtSetArg (args[j], XmNtopOffset, 10); j++;
1281 XtSetArg (args[j], XmNleftAttachment, XmATTACH_WIDGET); j++;
1282 XtSetArg (args[j], XmNleftWidget, X->CFpi_butOK); j++;
1283 XtSetArg (args[j], XmNleftOffset, 33); j++;
1284 XtSetArg (args[j], XmNbottomAttachment, XmATTACH_FORM); j++;
1285 XtSetArg (args[j], XmNbottomOffset, 10); j++;
1286 XtSetArg (args[j], XmNtraversalOn, True); j++;
1287 X->CFpi_butClose = XmCreatePushButton(form, "button", args, j);
1288 XmStringFree(label_string);
1289 XtManageChild(X->CFpi_butClose);
1292 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 18, "Help") );
1293 XtSetArg (args[j], XmNmarginHeight, 2); j++;
1294 XtSetArg (args[j], XmNmarginWidth, 10); j++;
1295 XtSetArg (args[j], XmNlabelString, label_string); j++;
1296 XtSetArg (args[j], XmNtopAttachment, XmATTACH_WIDGET); j++;
1297 XtSetArg (args[j], XmNtopWidget, sep); j++;
1298 XtSetArg (args[j], XmNtopOffset, 10); j++;
1299 XtSetArg (args[j], XmNrightAttachment, XmATTACH_FORM); j++;
1300 XtSetArg (args[j], XmNrightOffset, 15); j++;
1301 XtSetArg (args[j], XmNleftAttachment, XmATTACH_WIDGET); j++;
1302 XtSetArg (args[j], XmNleftWidget, X->CFpi_butClose); j++;
1303 XtSetArg (args[j], XmNleftOffset, 33); j++;
1304 XtSetArg (args[j], XmNbottomAttachment, XmATTACH_FORM); j++;
1305 XtSetArg (args[j], XmNbottomOffset, 10); j++;
1306 XtSetArg (args[j], XmNtraversalOn, True); j++;
1307 X->CFpi_butHelp = XmCreatePushButton(form, "button", args, j);
1308 XmStringFree(label_string);
1309 XtManageChild(X->CFpi_butHelp);
1311 XtAddCallback(X->CFpi_butOK, XmNactivateCallback, write_cf_value,
1312 (XtPointer) X->CFpi_butOK) ;
1313 XtAddCallback(X->CFpi_butClose, XmNactivateCallback, close_cf,
1316 XtAddCallback(X->CFpi_cftext->textfield, XmNactivateCallback, move_cf,
1317 (XtPointer) X->CFpi_butOK) ;
1318 XtAddCallback(X->CFpi_dtext->textfield, XmNactivateCallback, move_cf,
1319 (XtPointer) X->CFpi_butOK) ;
1320 XtAddCallback(X->CFpi_vtext->textfield, XmNactivateCallback, move_cf,
1321 (XtPointer) X->CFpi_butOK) ;
1323 XtAddCallback(X->CFpi_cftext->textfield, XmNfocusCallback, FocusInCB,
1325 XtAddCallback(X->CFpi_dtext->textfield, XmNactivateCallback, FocusInCB,
1328 XtSetArg (args[j], XmNcancelButton, X->CFpi_butClose); j++;
1329 XtSetValues (X->CFframe, args, j);
1332 XtSetArg (args[j], XmNdefaultButton, X->CFpi_butOK); j++;
1333 XtSetValues (form, args, j);
1335 /* Make the first prompt automatically get the focus. */
1336 XmProcessTraversal(X->CFpi_cftext->textfield, XmTRAVERSE_CURRENT);
1341 create_menu(mtype, button, n) /* Create popup menu for dtcalc button. */
1342 enum menu_type mtype ;
1346 char *mstr, *tmpStr, *ptr ;
1347 int i, invalid, val ;
1349 Boolean isAFunction = False;
1351 if ((mtype != M_CON && mtype != M_FUN) &&
1352 X->menus[(int) mtype] != NULL) return ; /* Already created? */
1354 X->menus[(int) mtype] = menu = XmCreatePopupMenu(button,
1357 X->mrec[(int) mtype] = n ;
1359 XtCreateManagedWidget(cmenus[(int) mtype].title, xmLabelWidgetClass,
1361 XtCreateManagedWidget("separator", xmSeparatorWidgetClass, menu, NULL, 0) ;
1362 XtCreateManagedWidget("separator", xmSeparatorWidgetClass, menu, NULL, 0) ;
1365 for (i = 0; i < cmenus[(int) mtype].total; i++)
1370 case M_CON : if (strlen(v->con_names[i])) /* Constants. */
1371 mstr = v->con_names[i] ;
1374 case M_FUN : if (strlen(v->fun_names[i])) /* Functions. */
1377 mstr = v->fun_names[i] ;
1381 default : mstr = menu_entries[cmenus[(int) mtype].mindex + i].str ;
1386 tmpStr = GETMESSAGE(3, 45, ".");
1387 if(strcmp(tmpStr, ".") != 0)
1389 /* if it's not a "." let's go change it to what it should be */
1390 ptr = DtStrchr(mstr, '.');
1394 mi = XtCreateManagedWidget(mstr, xmPushButtonWidgetClass,
1396 val = (v->curwin << 16) +
1397 menu_entries[cmenus[(int) mtype].mindex + i].val ;
1398 XtAddCallback(mi, XmNactivateCallback, menu_proc, (XtPointer) val) ;
1401 if( !isAFunction && mtype == M_FUN)
1403 mi = XtCreateManagedWidget(GETMESSAGE(2, 35, "No Functions Defined"),
1404 xmPushButtonWidgetClass, menu, NULL, 0) ;
1411 do_button(widget, client_data, call_data)
1413 XtPointer client_data, call_data ;
1418 int n = ((int) client_data) & 0xFFFF ;
1420 XtSetArg(args[0], XmNlabelString, &cstr);
1421 XtGetValues(X->modevals[OPITEM], args, 1);
1423 str = (char *) _XmStringUngenerate(cstr,
1424 XmFONTLIST_DEFAULT_TAG,
1425 XmCHARSET_TEXT, XmCHARSET_TEXT);
1427 if(strcmp(vstrs[(int) V_CLR], str) == 0 &&
1428 (buttons[n].value != KEY_CLR && buttons[n].value != KEY_QUIT))
1434 ProcessMotifSelection(X->modevals[(int) DISPLAYITEM]);
1435 v->curwin = ((int) client_data) >> 16 ;
1438 v->current = buttons[n].value ;
1441 else if (n >= 0 && n <= NOBUTTONS) process_item(n) ;
1448 do_continue_notice(parent, str)
1452 XmString contstr, message, cstr ;
1455 X->notice = (Widget) XmCreateInformationDialog(X->kframe, "continue",
1457 contstr = XmStringCreateLocalized(vstrs[(int) V_CONTINUE]) ;
1458 message = XmStringCreateLocalized( str );
1459 XtVaSetValues(X->notice,
1460 XmNautoUnmanage, FALSE,
1461 XmNcancelLabelString, contstr,
1462 XmNmessageString, message,
1463 XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL,
1465 XmStringFree(contstr) ;
1466 XmStringFree(message) ;
1467 XtUnmanageChild((Widget) XmMessageBoxGetChild(X->notice,
1468 XmDIALOG_OK_BUTTON)) ;
1469 XtUnmanageChild((Widget) XmMessageBoxGetChild(X->notice,
1470 XmDIALOG_HELP_BUTTON)) ;
1472 tmpStr = GETMESSAGE(2, 36, "Continue Notice");
1473 cstr = XmStringCreateLocalized(tmpStr) ;
1474 XtVaSetValues(X->notice, XmNdialogTitle, cstr, 0) ;
1475 XmStringFree(cstr) ;
1477 XtManageChild(X->notice) ;
1483 do_confirm_notice(parent, str)
1487 XmString confirm, cancel, message, cstr ;
1491 X->notice = (Widget) XmCreateInformationDialog(X->kframe, "continue",
1493 confirm = XmStringCreateLocalized(vstrs[(int) V_CONFIRM]) ;
1494 cancel = XmStringCreateLocalized(vstrs[(int) V_CANCEL]) ;
1495 message = XmStringCreateLocalized( str );
1496 XtVaSetValues(X->notice,
1497 XmNautoUnmanage, FALSE,
1498 XmNcancelLabelString, cancel,
1499 XmNokLabelString, confirm,
1500 XmNmessageString, message,
1501 XmNdialogStyle, XmDIALOG_APPLICATION_MODAL,
1503 XmStringFree(confirm) ;
1504 XmStringFree(cancel) ;
1505 XmStringFree(message) ;
1506 XtUnmanageChild((Widget) XmMessageBoxGetChild(X->notice,
1507 XmDIALOG_HELP_BUTTON)) ;
1508 XtAddCallback(X->notice, XmNokCallback, confirm_callback, NULL) ;
1510 tmpStr = GETMESSAGE(2, 37, "Confirmation Notice");
1511 cstr = XmStringCreateLocalized(tmpStr) ;
1512 XtVaSetValues(X->notice, XmNdialogTitle, cstr, 0) ;
1513 XmStringFree(cstr) ;
1515 XtManageChild(X->notice) ;
1522 close_reg(widget, client_data, call_data)
1524 XtPointer client_data, call_data ;
1526 int type = (int)client_data;
1530 XtUnmanageChild(X->rframe);
1531 XtUnmapWidget(XtParent(X->rframe));
1536 XtUnmanageChild(X->frframe);
1537 XtUnmapWidget(XtParent(X->frframe));
1545 * This routine causes the calculator buttons to looked depressed (armed)
1546 * and undepressed (disarmed) when the user uses the keyboard to select a
1547 * button on the keyboard. It's pretty straight forward:
1548 * The user pressess a key from the keyboard
1549 * The routine event_proc() gets called.
1550 * It determines whether the key from the keyboard is a valid key.
1551 * If it is, it sends that key to process_event()
1552 * This routines then determines whether the key is an active key.
1553 * If it is then it calls this routine to set the key to either armed
1554 * or disarmed. This state is determined by whether it is a keyboard
1555 * up event or a keyboard down event.
1556 * There is some special case code in here also. There was a bug where
1557 * if a user pressed a CNTL character key, the event order could cause
1558 * the key to stay depressed. The typical order is:
1563 * When this typical order was pressed things worked fine. But the problem
1564 * arose when the order was:
1569 * The problem was that when the last "KEY key up" was processed it is not
1570 * recognized as a control key, so the calculator thought is was a "normal"
1571 * key and disarmed that "normal" key button rather then the Control
1572 * key button. This is what the lastArmed and count static variables are
1573 * used for. They check to see if the last "KEY key up" corresponds to
1574 * the last "Control key down" button that was armed. If it doesn't then
1575 * we know we need to disarm the "Control key" button rather then the
1576 * "normal" button that was passed in.
1580 draw_button(n, fcptype, row, column, inverted)
1582 enum fcp_type fcptype ;
1583 int row, column, inverted ;
1587 XmPushButtonWidget pb;
1588 int i, j, row2, column2;
1589 static XtIntervalId timerId = 0;
1593 widget = X->kbuttons[row][column] ;
1594 lastArmed[countArmed] = n;
1601 for(i = 0; i < countArmed; i++)
1603 if(lastArmed[i] == n)
1606 if(countArmed == i && countArmed != 0)
1609 row2 = lastArmed[i] / MAXCOLS ;
1610 column2 = lastArmed[i] - (row2 * MAXCOLS) ;
1611 widget = X->kbuttons[row2][column2] ;
1612 for(j = i; j < countArmed; j++)
1613 lastArmed[j] = lastArmed[j + 1];
1620 strcpy(str, "Disarm");
1622 /* go call the correct arm/disarm function from Motif */
1623 XtCallActionProc(widget, str, X->event, NULL, 0) ;
1629 event_is_keypad(xevent)
1632 if (xevent->type != KeyPress && xevent->type != KeyRelease) return(0) ;
1633 return(X->kparray[xevent->xkey.keycode - X->kcmin] > 0) ;
1639 * This routine is called any time a key on the keyboard is pressed. It
1640 * then determines whether the key is a valid key or whether it is to
1641 * be ignore. If it is a valid key it passes it on to be processed.
1646 event_proc(widget, client_data, event, continue_to_dispatch)
1648 XtPointer client_data ;
1650 Boolean *continue_to_dispatch ;
1657 static char count = 0;
1659 /* If the ASCII convert dialog, or the Help dialog
1660 is up and managed, we don't want the keystrokes to go to the calculator
1661 main, just those dialogs
1662 if ((X->Aframe != NULL && XtIsManaged(X->Aframe)) ||
1663 (X->helpDialog != NULL && X->helpMapped))
1675 ignore_event = False;
1676 XtRemoveTimeOut(timerId);
1682 v->event_type = get_next_event(widget, 0, event) ;
1684 /* first check to see if there is an error condition, if there is we
1685 want to beep and return.
1688 XtSetArg(args[0], XmNlabelString, &label);
1689 XtGetValues(X->modevals[OPITEM], args, 1);
1691 str = (char *) _XmStringUngenerate(label,
1692 XmFONTLIST_DEFAULT_TAG,
1693 XmCHARSET_TEXT, XmCHARSET_TEXT);
1695 if(strcmp(vstrs[(int) V_CLR], str) == 0 &&
1696 (v->cur_ch != KEY_CLR && v->cur_ch != KEY_QUIT))
1698 if(v->event_type == KEYBOARD_DOWN)
1702 index = get_index(v->cur_ch);
1704 draw_button(index, v->curwin, v->row, v->column, FALSE);
1709 /* Now lets check to see if the input was for the Constants/Functions
1710 dialog. If it was process it.
1712 if(X->CFframe != NULL && XtIsManaged(X->CFframe))
1714 w = XmGetFocusWidget(X->CFframe);
1715 if(w == X->CFpi_butOK)
1717 if(v->cur_ch == KEY_EQ)
1719 XtCallCallbacks(X->CFpi_butOK, XmNarmCallback, (XtPointer) NULL);
1720 XtCallCallbacks(X->CFpi_butOK, XmNactivateCallback,
1723 if(v->event_type == ARROW || v->event_type == TAB)
1725 XtSetArg(args[0], XmNdefaultButton, X->CFpi_butOK);
1726 XtSetValues(X->CFframe, args, 1);
1731 else if(w == X->CFpi_butClose)
1733 if(v->cur_ch == KEY_EQ)
1735 XtCallCallbacks(X->CFpi_butClose, XmNarmCallback, (XtPointer) NULL);
1736 XtCallCallbacks(X->CFpi_butClose, XmNactivateCallback,
1739 if(v->event_type == ARROW || v->event_type == TAB)
1741 XtSetArg(args[0], XmNdefaultButton, NULL);
1742 XtSetValues(X->CFframe, args, 1);
1747 else if(w == X->CFpi_butHelp)
1749 if(v->cur_ch == KEY_EQ)
1751 XtCallCallbacks(X->CFpi_butHelp, XmNarmCallback, (XtPointer) NULL);
1752 XtCallCallbacks(X->CFpi_butHelp, XmNactivateCallback,
1753 (XtPointer) HELP_CONSTANT);
1755 if(v->event_type == ARROW || v->event_type == TAB)
1757 XtSetArg(args[0], XmNdefaultButton, NULL);
1758 XtSetValues(X->CFframe, args, 1);
1765 index = get_index(v->cur_ch);
1766 if (index != TITEMS)
1767 draw_button(index, v->curwin, v->row, v->column, FALSE);
1769 /* don't worry about this if there is something pending */
1770 if (v->pending == 0) {
1771 /* if the key is an "inactive" key (i.e. desensitized) then we want to
1776 if(v->cur_ch == KEY_2 ||
1777 v->cur_ch == KEY_3 ||
1778 v->cur_ch == KEY_4 ||
1779 v->cur_ch == KEY_5 ||
1780 v->cur_ch == KEY_6 ||
1784 if(v->cur_ch == KEY_8 ||
1788 if(v->cur_ch == KEY_A ||
1789 v->cur_ch == KEY_B ||
1790 v->cur_ch == KEY_C ||
1791 v->cur_ch == KEY_D ||
1792 v->cur_ch == KEY_E ||
1798 /* finally, check to see if it is a key we wish to ignore and motif
1801 if(v->event_type == F4_PRESS || v->event_type == ARROW ||
1802 v->event_type == TAB || v->event_type == CONTROL ||
1803 v->event_type == SHIFT || v->event_type == SPACE ||
1804 v->event_type == ESCAPE || v->event_type == META || v->event_type == ALT)
1806 else if(v->event_type == NUM_LOCK)
1808 v->num_lock = !v->num_lock;
1810 else if (v->cur_ch == CTL('/'))
1814 ProcessMotifSelection(X->modevals[(int) DISPLAYITEM]);
1815 process_event(v->event_type);
1819 if (v->num_lock == True)
1821 draw_button(0, v->curwin, 0, 0, TRUE);
1827 /* ------------------------------------------------------------- */
1828 /* Primarily handles the selection in the display text widget. */
1829 /* Update the display before the event is processed for dtcalc. */
1830 /* ------------------------------------------------------------- */
1833 ProcessMotifSelection(Widget W)
1838 char *display = NULL;
1839 XmTextPosition left, right;
1841 if (XmTextGetSelectionPosition (W, &left, &right) == True)
1844 display = XmTextGetString(W);
1846 bound = ( (long)strlen(display) - right + 1);
1848 for (i = 0; i < bound; i++)
1850 display[i+left] = display[i+right];
1853 index = get_index(v->cur_ch);
1854 key = buttons[index].value;
1856 /* ------------------------------------------------------------ */
1857 /* Append an extra character to be handled by do_delete func. */
1858 /* ------------------------------------------------------------ */
1863 display[i+1] = '\0';
1866 STRCPY(v->display, display);
1876 frame_interpose(widget, clientData, event, continue_to_dispatch)
1878 XtPointer clientData ;
1880 Boolean *continue_to_dispatch ;
1882 if (!v->started) return ;
1883 if (event->type == MapNotify)
1885 if (v->rstate) win_display(FCP_REG, TRUE) ;
1886 else if (v->frstate) win_display(FCP_FIN_REG, TRUE) ;
1889 else if (event->type == UnmapNotify) v->iconic = TRUE ;
1895 get_next_event(widget, ev_action, xevent)
1900 char *tmpStr, chs[2] ;
1901 int cval, down, nextc, up ;
1903 XKeyPressedEvent *key_event ;
1905 if (!v->started) return(LASTEVENTPLUSONE) ;
1906 nextc = xevent->type ;
1908 down = xevent->type == ButtonPress || xevent->type == KeyPress ;
1909 up = xevent->type == ButtonRelease || xevent->type == KeyRelease ;
1911 if (nextc == KeyPress || nextc == KeyRelease)
1913 key_event = (XKeyPressedEvent *) xevent ;
1914 chs[0] = chs[1] = (char)0;
1916 * If the user enters a multibyte character, XLookupString()
1917 * will return zero because it only handles Latin-1 characters.
1918 * We can just return then because we're only looking for
1919 * Latin-1 characters anyway (see CDExc15419).
1921 if (!XLookupString(key_event, chs, 1, &ksym,
1922 (XComposeStatus *) NULL))
1924 if (key_event->keycode == NUM_LOCK)
1927 return(LASTEVENTPLUSONE);
1931 Here's how the fix solves the problem:
1933 When you press ctrl-space, the input method converts your composed
1934 input to a Kanji character and sends a keyboard event to dtcalc with
1935 a keycode of 0. The keycode of 0 is the X convention that the
1936 application should call XmbLookupString() to get the Kanji character
1937 from the input method.
1939 dtcalc calls XLookupString() instead though, which being a much older
1940 interface, doesn't know about this convention. XLookupString() isn't
1941 able to map the keycode to anything and just returns 0.
1943 The fix catches this and returns immediately. Otherwise, the code
1944 would go on to call event_is_keypad() to see if the event was a keypad
1945 event like '+', '=', etc. That function would core dump at the
1946 following line because of the negative array index:
1948 return(X->kparray[xevent->xkey.keycode - X->kcmin] > 0) ;
1950 Returning immediately from get_next_event() avoids the core dump and
1951 doesn't hurt anything because dtcalc doesn't actually use any Kanji
1952 characters for its keypad characters, just ASCII ones.
1954 An alternative fix would be to use XmbLookupString() instead of
1955 XLookupString(). That fix would be more complex though, and as
1956 CDExc15419 points out, XLookupString() is fine here (as long as you
1957 check its return value).
1961 XLookupString(key_event, chs, 1, &ksym, (XComposeStatus *) NULL) ;
1963 if (ksym == XK_F4 && down) return(F4_PRESS) ;
1964 else if (ksym == XK_F4 && up) return(F4_PRESS) ;
1965 else if (ksym == XK_Right && down)
1967 if (!event_is_keypad(xevent))
1970 else if (ksym == XK_Left && down)
1972 if (!event_is_keypad(xevent))
1975 else if (ksym == XK_Up && down)
1977 if (!event_is_keypad(xevent))
1980 else if (ksym == XK_Down && down)
1982 if (!event_is_keypad(xevent))
1985 else if (ksym == XK_F10 && down) return(F4_PRESS);
1986 else if (ksym == XK_F10 && up) return(F4_PRESS);
1987 else if (ksym == XK_Tab && down) return(TAB);
1988 else if (ksym == XK_Tab && up) return(TAB);
1990 #ifdef HP_EXTENSIONS
1991 else if (ksym == XK_BackTab && down) return(SHIFT);
1992 else if (ksym == XK_BackTab && up) return(SHIFT);
1993 else if (ksym == hpXK_DeleteChar && down) cval = 127;
1994 else if (ksym == hpXK_DeleteChar && up) cval = 127;
1996 else if (ksym == XK_Return && down) cval = KEY_EQ;
1997 else if (ksym == XK_Return && up) cval = KEY_EQ;
1998 else if (ksym == XK_Escape && down) return(ESCAPE);
1999 else if (ksym == XK_Escape && up) return(ESCAPE);
2000 else if (ksym == XK_Control_L && down) return(CONTROL);
2001 else if (ksym == XK_Control_L && up) return(CONTROL);
2002 else if (ksym == XK_Control_R && down) return(CONTROL);
2003 else if (ksym == XK_Control_R && up) return(CONTROL);
2004 else if (ksym == XK_Meta_L && down) return(META);
2005 else if (ksym == XK_Meta_R && up) return(META);
2006 else if (ksym == XK_Meta_L && down) return(META);
2007 else if (ksym == XK_Meta_R && up) return(META);
2008 else if (ksym == XK_Alt_L && down) return(ALT);
2009 else if (ksym == XK_Alt_R && up) return(ALT);
2010 else if (ksym == XK_Alt_L && down) return(ALT);
2011 else if (ksym == XK_Alt_R && up) return(ALT);
2012 else if (ksym == XK_Select && down) return(SPACE);
2013 else if (ksym == XK_Select && up) return(SPACE);
2014 else if (ksym == XK_space && down) return(SPACE);
2015 else if (ksym == XK_space && up) return(SPACE);
2016 else if (ksym == XK_Shift_L || ksym == XK_Shift_R)
2017 return(LASTEVENTPLUSONE) ;
2018 else cval = chs[0] ;
2021 tmpStr = GETMESSAGE(3, 45, ".");
2022 if (event_is_keypad(xevent))
2026 * In keypad_keysym(), KeySym associated with xevent->xkey.keycode
2027 * is extracted by calling XKeycodeToKeysym(). But the current
2028 * implementation doesn't care of the modifires state. In this moment,
2029 * we can still use ksym which is got in the above XLookupString().
2030 * Sun's implementation seems to need an attention for this. But AIX
2032 * Still JP kbd NumLock state cannot be handled correctly.
2036 switch (keypad_keysym(xevent))
2039 case XK_KP_0 : v->cur_ch = '0' ;
2041 case XK_KP_1 : v->cur_ch = '1' ;
2043 case XK_KP_2 : v->cur_ch = '2' ;
2045 case XK_KP_3 : v->cur_ch = '3' ;
2047 case XK_KP_4 : v->cur_ch = '4' ;
2049 case XK_KP_5 : v->cur_ch = '5' ;
2051 case XK_KP_6 : v->cur_ch = '6' ;
2053 case XK_KP_7 : v->cur_ch = '7' ;
2055 case XK_KP_8 : v->cur_ch = '8' ;
2057 case XK_KP_9 : v->cur_ch = '9' ;
2059 case XK_KP_Add : v->cur_ch = '+' ;
2061 case XK_KP_Subtract : v->cur_ch = '-' ;
2063 case XK_KP_Multiply : v->cur_ch = 'x' ;
2065 case XK_KP_Divide : v->cur_ch = '/' ;
2068 case XK_KP_Enter : v->cur_ch = '=' ;
2070 case XK_KP_Decimal : v->cur_ch = tmpStr[0] ;
2072 if (down) return(KEYBOARD_DOWN) ;
2073 else if (up) return(KEYBOARD_UP) ;
2075 else if ((nextc == KeyPress || nextc == KeyRelease) &&
2076 (IS_KEY(cval, KEY_BSP) || IS_KEY(cval, KEY_CLR)))
2078 v->cur_ch = cval ; /* Delete and Back Space keys. */
2079 if (down) return(KEYBOARD_DOWN) ;
2080 else if (up) return(KEYBOARD_UP) ;
2083 if ((nextc == KeyPress || nextc == KeyRelease) && cval >= 0 && cval <= 127)
2086 /* If this is a '*' or Return key press, then map to their better known
2087 * equivalents, so that button highlighting works correctly.
2090 if (cval == '*') cval = KEY_MUL ;
2092 /* All the rest of the ASCII characters. */
2095 if (down) return(KEYBOARD_DOWN) ;
2096 else if (up) return(KEYBOARD_UP) ;
2099 return(LASTEVENTPLUSONE) ;
2104 get_resource(rtype) /* Get dtcalc resource from merged database. */
2105 enum res_type rtype ;
2109 STRCPY(str, calc_res[(int) rtype]) ;
2110 return(ds_get_resource(X->rDB, v->appname, str)) ;
2115 grey_button(row, column, state)
2116 int row, column, state ;
2118 XtSetSensitive(X->kbuttons[row][column], !state) ;
2125 char *tmpStr, *tmpStr1;
2127 tmpStr = GETMESSAGE(2, 12, "Calculator");
2128 tmpStr1 = XtNewString(tmpStr);
2129 XtVaSetValues(X->kframe,
2130 XmNiconName, tmpStr1,
2133 dtcalc_kpanel_create(X->kframe) ;
2134 dtcalc_kkeyboard_create(X->kpanel) ;
2136 XtSetMappedWhenManaged(X->kframe, False);
2137 XtRealizeWidget(X->kframe) ;
2138 XSync(X->dpy, False);
2140 XtSetMappedWhenManaged(X->kframe, True);
2141 XtMapWidget( X->kframe );
2142 XSync(X->dpy, False);
2152 is_window_showing(widget)
2155 return(XtIsManaged(widget)) ;
2166 XDisplayKeycodes(X->dpy, &X->kcmin, &X->kcmax) ;
2167 tmp = XGetKeyboardMapping(X->dpy, X->kcmin, 1, &X->keysyms_per_key) ;
2168 XFree((char *) tmp) ;
2170 X->kparray = (unsigned char *) malloc(X->kcmax - X->kcmin + 1) ;
2172 /* For each key, run through its list of keysyms. If this keysym is a
2173 * keypad keysym, we know this key is on the keypad. Mark it as such in
2177 for (i = X->kcmin; i <= X->kcmax; ++i)
2179 X->kparray[i - X->kcmin] = 0 ;
2180 for (j = 0; j < X->keysyms_per_key; ++j)
2182 ks = XKeycodeToKeysym(X->dpy, i, j) ;
2183 if (IsKeypadKey(ks))
2185 X->kparray[i - X->kcmin] = 1 ;
2194 keypad_keysym(xevent)
2198 int keycode = xevent->xkey.keycode ;
2201 for (i = 0; i < X->keysyms_per_key; ++i)
2203 ks = XKeycodeToKeysym(X->dpy, keycode, i) ;
2204 if (IsKeypadKey(ks))
2207 if(ks != XK_KP_Insert)
2218 X->rDB = ds_load_resources(X->dpy) ;
2225 char *tool_label = NULL ;
2228 if (v->titleline == NULL)
2230 tool_label = (char *) calloc(1, strlen(lstrs[(int) L_UCALC]) + 3);
2232 SPRINTF(tool_label, "%s", lstrs[(int) L_UCALC]);
2234 else read_str(&tool_label, v->titleline) ;
2236 X->clipboard = XInternAtom(X->dpy, "CLIPBOARD", FALSE) ;
2237 X->length_atom = XInternAtom(X->dpy, "LENGTH", FALSE) ;
2238 XtAddEventHandler(X->kframe, StructureNotifyMask, FALSE,
2239 frame_interpose, NULL) ;
2240 XtVaSetValues(X->kframe,
2241 XmNtitle, tool_label,
2244 XtVaGetValues(X->kframe,
2248 if(v->titleline == NULL)
2253 make_modewin() /* Draw special mode frame plus buttons. */
2255 switch_mode(v->modetype) ;
2259 make_registers(type) /* Calculate memory register frame values. */
2262 char line[MAXLINE] ; /* Current memory register line. */
2263 char *ptr, *tmp, *tmpStr;
2265 XmString str, numStr ;
2266 int MPtemp[MP_SIZE];
2270 if (!v->rstate) return ;
2272 else if(type == FIN)
2274 if (!v->frstate) return ;
2277 dtcalc_initialize_rframe(X->kframe, type) ;
2279 tmpStr = GETMESSAGE(3, 45, ".");
2282 for (i = 0; i < MAXREGS; i++)
2284 SPRINTF(line, "%s: %s", menu_entries[i + 10].str,
2285 make_number(v->MPmvals[i], FALSE)) ;
2288 /* if it's not a "." let's go change it to what it should be */
2289 ptr = DtStrrchr(line, '.');
2293 str = XmStringCreateLocalized(line) ;
2294 XtVaSetValues(X->registers[i], XmNlabelString, str, 0) ;
2300 for (i = 0; i < FINREGS; i++)
2304 mpcdm(&(v->MPfvals[i]), MPtemp);
2305 tmp = make_number(MPtemp, FALSE);
2306 ptr = DtStrchr(tmp, 'e');
2309 ptr = DtStrchr(tmp, '.');
2312 ptr = DtStrchr(tmp, ',');
2323 savAcc = v->accuracy;
2325 mpcdm(&(v->MPfvals[i]), MPtemp);
2326 tmp = make_number(MPtemp, FALSE);
2327 v->accuracy = savAcc;
2332 mpcdm(&(v->MPfvals[i]), MPtemp);
2333 tmp = make_number(MPtemp, FALSE);
2335 if(strcmp(tmpStr, ".") != 0)
2337 /* if it's not a "." let's go change it to what it should be */
2338 ptr = DtStrrchr(tmp, '.');
2342 str = XmStringCreateLocalized(menu_entries[i + 34].str) ;
2343 numStr = XmStringCreateLocalized(tmp);
2344 XtVaSetValues(X->fregisters[i], XmNlabelString, str, 0) ;
2345 XtVaSetValues(X->fregistersvals[i], XmNlabelString, numStr,
2346 XmNalignment, XmALIGNMENT_END, 0) ;
2348 XmStringFree(numStr) ;
2356 menu_handler(widget, client_data, event, continue_to_dispatch)
2358 XtPointer client_data ;
2360 Boolean *continue_to_dispatch ;
2365 X->mtype = (enum menu_type) client_data ;
2366 menu = X->menus[(int) X->mtype] ;
2367 XtVaGetValues(menu, XmNwhichButton, &button, 0) ;
2368 if (event->xbutton.button == button)
2370 XmMenuPosition(menu, (XButtonPressedEvent *) event) ;
2371 XtManageChild(menu) ;
2378 menu_proc(widget, client_data, call_data)
2380 XtPointer client_data, call_data ;
2382 int choice = ((int) client_data) & 0xFFFF ;
2384 v->curwin = ((int) client_data) >> 16 ;
2385 handle_menu_selection(X->mrec[(int) X->mtype], choice) ;
2391 new_cf_value(widget, client_data, call_data)
2393 XtPointer client_data, call_data ;
2396 for hard testing when there is no Input Method available
2397 wchar_t *wch = (wchar_t *) "wide";
2398 mbchar_t *mbch = (mbchar_t *) "MBYTE";
2401 enum menu_type mtype = (enum menu_type) client_data;
2404 if (X->CFframe == NULL) create_cfframe() ;
2408 set_text_str(X->CFpi_cftext, T_LABEL, lstrs[(int) L_CONNO]) ;
2410 cstr = XmStringCreateLocalized(lstrs[(int) L_NEWCON]) ;
2411 XtVaSetValues(X->CFframe, XmNdialogTitle, cstr, 0) ;
2412 XmStringFree(cstr) ;
2414 XtRemoveAllCallbacks(X->CFpi_butHelp, XmNactivateCallback);
2415 XtAddCallback(X->CFpi_butHelp, XmNactivateCallback, HelpRequestCB,
2416 (XtPointer) HELP_CONSTANT);
2421 set_text_str(X->CFpi_cftext, T_LABEL, lstrs[(int) L_FUNNO]) ;
2423 cstr = XmStringCreateLocalized(lstrs[(int) L_NEWFUN]) ;
2424 XtVaSetValues(X->CFframe, XmNdialogTitle, cstr, 0) ;
2425 XmStringFree(cstr) ;
2427 XtRemoveAllCallbacks(X->CFpi_butHelp, XmNactivateCallback);
2428 XtAddCallback(X->CFpi_butHelp, XmNactivateCallback, HelpRequestCB,
2429 (XtPointer) HELP_FUNCTION);
2432 /* Clear text fields. */
2434 set_text_str(X->CFpi_cftext, T_VALUE, "") ;
2435 set_text_str(X->CFpi_dtext, T_VALUE, "") ;
2436 set_text_str(X->CFpi_vtext, T_VALUE, "") ;
2439 for hard testing when there is no Input Method available
2440 XmTextFieldSetStringWcs(X->CFpi_vtext->textfield, wch);
2441 XmTextFieldSetStringWcs(X->CFpi_vtext->textfield, mbch);
2444 XmProcessTraversal(X->CFpi_cftext->textfield, XmTRAVERSE_CURRENT) ;
2446 if (!is_window_showing(X->CFframe))
2447 _DtGenericMapWindow (X->kframe, X->CFframe);
2449 XtManageChild(X->CFframe) ;
2451 /* lets set the focus in the first text widget */
2452 XmProcessTraversal(X->CFpi_cftext->textfield, XmTRAVERSE_CURRENT);
2453 ignore_event = True;
2454 timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
2455 TimerEvent, (XtPointer) NULL);
2460 put_resource(rtype, value) /* Put calc resource into database. */
2461 enum res_type rtype ;
2464 ds_put_resource(&(X->dtcalcDB), v->appname, calc_res[(int) rtype], value) ;
2471 enum fcp_type scurwin ;
2472 int column, n, row ;
2475 scurwin = v->curwin ;
2476 v->curwin = FCP_KEY ;
2477 for (row = 0; row < BROWS; row++)
2478 for (column = 0; column < BCOLS; column++)
2480 n = row * MAXCOLS + column ;
2482 lstr = XmStringCreateLocalized(v->pstr) ;
2483 XtVaSetValues(X->kbuttons[row][column], XmNlabelString, lstr, NULL);
2484 XmStringFree(lstr) ;
2486 v->curwin = scurwin ;
2491 save_cmdline(argc, argv)
2495 ds_save_cmdline(X->dpy, XtWindow(X->kframe), argc, argv) ;
2500 save_resources(filename)
2503 int reply = ds_save_resources(X->dtcalcDB, filename) ;
2505 if (reply) _DtSimpleError (v->appname, DtWarning, NULL, vstrs[(int) V_NORSAVE]);
2512 ErrDialog(string, X->mainWin);
2516 set_item(itemno, str)
2517 enum item_type itemno ;
2522 char *tmpStr, *ptr, displayStr[50];
2524 if (itemno == DISPLAYITEM)
2528 if(str != NULL && (strcmp(str, "") != 0))
2530 /* Let's get the decimal point, in some languages it's a , */
2531 strcpy(displayStr, str);
2532 tmpStr = GETMESSAGE(3, 45, ".");
2533 if(strcmp(tmpStr, ".") != 0)
2535 /* if it's not a "." let's go change it to what it should be */
2536 ptr = DtStrrchr(displayStr, '.');
2540 w = X->modevals[(int) DISPLAYITEM] ;
2541 XmTextSetString(w, displayStr) ;
2542 XmTextSetInsertionPosition(w, XmTextGetLastPosition(w)) ;
2543 XSync(X->dpy, False);
2552 cstr = XmStringCreateLocalized(str) ;
2553 XtVaSetValues(X->modevals[(int) itemno], XmNlabelString, cstr, 0) ;
2554 XmStringFree(cstr) ;
2560 set_title(fcptype, str) /* Set new title for a window. */
2561 enum fcp_type fcptype ;
2568 if (fcptype == FCP_KEY)
2570 else if (fcptype == FCP_REG)
2572 else if (fcptype == FCP_FIN_REG)
2574 else if (fcptype == FCP_MODE)
2575 w = X->mframe[(int) v->modetype] ;
2577 if (fcptype == FCP_KEY)
2578 XtVaSetValues(w, XmNtitle, str, 0) ;
2581 cstr = XmStringCreateLocalized(str) ;
2582 XtVaSetValues(w, XmNdialogTitle, cstr, 0) ;
2583 XmStringFree(cstr) ;
2590 show_ascii(widget, client_data, call_data)
2592 XtPointer client_data, call_data ;
2597 str = XmTextFieldGetString(X->Api_text->textfield);
2598 val = str[strlen(str) - 1] ;
2599 mpcim(&val, v->MPdisp_val) ;
2600 show_display(v->MPdisp_val) ;
2606 show_ascii_frame() /* Display ASCII popup. */
2610 Widget sep, frame, form;
2612 XmString label_string;
2614 if (X->Aframe == NULL)
2616 X->Aframe = (Widget) XmCreateFormDialog(X->kframe, "aframe", NULL, 0) ;
2617 tstr = XmStringCreateLocalized(pstrs[(int) P_ASCIIT]) ;
2618 XtVaSetValues(X->Aframe,
2619 XmNdialogTitle, tstr,
2620 XmNautoUnmanage, FALSE,
2621 XmNallowShellResize, TRUE,
2622 XmNdefaultPosition, FALSE,
2624 XmStringFree(tstr) ;
2626 /* Adjust the decorations for the dialog shell of the dialog */
2627 XtSetArg (args[0], XmNmwmFunctions, MWM_FUNC_MOVE);
2628 XtSetArg (args[1], XmNmwmDecorations, MWM_DECOR_BORDER | MWM_DECOR_TITLE);
2629 XtSetValues (XtParent(X->Aframe), args, 2);
2631 X->Api_text = make_textW(X->Aframe, pstrs[(int) P_CHAR]) ;
2633 XtSetArg (args[0], XmNtopAttachment, XmATTACH_FORM);
2634 XtSetArg (args[1], XmNtopOffset, 5);
2635 XtSetArg (args[2], XmNleftAttachment, XmATTACH_FORM);
2636 XtSetArg (args[3], XmNleftOffset, 5);
2637 XtSetValues(X->Api_text->manager, args, 4);
2639 XtSetArg (args[0], XmNmaxLength, 1);
2640 XtSetValues(X->Api_text->textfield, args, 1);
2642 XtSetArg (args[0], XmNtopAttachment, XmATTACH_WIDGET);
2643 XtSetArg (args[1], XmNtopWidget, X->Api_text->manager);
2644 XtSetArg (args[2], XmNtopOffset, 3);
2645 XtSetArg (args[3], XmNleftAttachment, XmATTACH_FORM);
2646 XtSetArg (args[4], XmNrightAttachment, XmATTACH_FORM);
2647 sep = XmCreateSeparator(X->Aframe, "sep", args, 5);
2650 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 33, "Apply") );
2651 XtSetArg (args[0], XmNmarginHeight, 2);
2652 XtSetArg (args[1], XmNmarginWidth, 15);
2653 XtSetArg (args[2], XmNlabelString, label_string);
2654 XtSetArg (args[3], XmNtopAttachment, XmATTACH_WIDGET);
2655 XtSetArg (args[4], XmNtopWidget, sep);
2656 XtSetArg (args[5], XmNtopOffset, 5);
2657 XtSetArg (args[6], XmNleftAttachment, XmATTACH_FORM);
2658 XtSetArg (args[7], XmNleftOffset, 10);
2659 XtSetArg (args[8], XmNbottomAttachment, XmATTACH_FORM);
2660 XtSetArg (args[9], XmNbottomOffset, 5);
2661 X->Api_butOK = XmCreatePushButton(X->Aframe, "button", args, 10);
2662 XmStringFree(label_string);
2663 XtManageChild(X->Api_butOK);
2665 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 32, "Close") );
2666 XtSetArg (args[0], XmNmarginHeight, 2);
2667 XtSetArg (args[1], XmNmarginWidth, 10);
2668 XtSetArg (args[2], XmNlabelString, label_string);
2669 XtSetArg (args[3], XmNtopAttachment, XmATTACH_WIDGET);
2670 XtSetArg (args[4], XmNtopWidget, sep);
2671 XtSetArg (args[5], XmNtopOffset, 5);
2672 XtSetArg (args[6], XmNleftAttachment, XmATTACH_WIDGET);
2673 XtSetArg (args[7], XmNleftWidget, X->Api_butOK);
2674 XtSetArg (args[8], XmNleftOffset, 10);
2675 XtSetArg (args[9], XmNbottomAttachment, XmATTACH_FORM);
2676 XtSetArg (args[10], XmNbottomOffset, 5);
2677 X->Api_butClose = XmCreatePushButton(X->Aframe, "button", args, 11);
2678 XmStringFree(label_string);
2679 XtManageChild(X->Api_butClose);
2681 label_string = XmStringCreateLocalized ( GETMESSAGE(2, 18, "Help") );
2682 XtSetArg (args[0], XmNmarginHeight, 2);
2683 XtSetArg (args[1], XmNmarginWidth, 10);
2684 XtSetArg (args[2], XmNlabelString, label_string);
2685 XtSetArg (args[3], XmNtopAttachment, XmATTACH_WIDGET);
2686 XtSetArg (args[4], XmNtopWidget, sep);
2687 XtSetArg (args[5], XmNtopOffset, 5);
2688 XtSetArg (args[6], XmNleftAttachment, XmATTACH_WIDGET);
2689 XtSetArg (args[7], XmNleftWidget, X->Api_butClose);
2690 XtSetArg (args[8], XmNleftOffset, 10);
2691 XtSetArg (args[9], XmNrightAttachment, XmATTACH_FORM);
2692 XtSetArg (args[10], XmNrightOffset, 10);
2693 XtSetArg (args[11], XmNbottomAttachment, XmATTACH_FORM);
2694 XtSetArg (args[12], XmNbottomOffset, 5);
2695 X->Api_butHelp = XmCreatePushButton(X->Aframe, "button", args, 13);
2696 XmStringFree(label_string);
2697 XtManageChild(X->Api_butHelp);
2699 XtAddCallback(X->Api_text->textfield, XmNactivateCallback,
2701 XtAddCallback(X->Api_butOK, XmNactivateCallback, show_ascii, NULL) ;
2702 XtAddCallback(X->Api_butClose, XmNactivateCallback, close_ascii,
2704 XtAddCallback(X->Api_butHelp, XmNactivateCallback, HelpRequestCB,
2705 (XtPointer) HELP_ASCII) ;
2708 XtSetArg (args[j], XmNcancelButton, X->Api_butClose); j++;
2709 XtSetArg (args[j], XmNdefaultButton, X->Api_butOK); j++;
2710 XtSetValues (X->Aframe, args, j);
2713 if (!is_window_showing(X->Aframe))
2714 _DtGenericMapWindow (X->kframe, X->Aframe);
2716 XtManageChild(X->Aframe) ;
2718 XmProcessTraversal(X->Api_text->textfield, XmTRAVERSE_CURRENT);
2719 ignore_event = True;
2720 timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
2721 TimerEvent, (XtPointer) NULL);
2728 saveatom = XmInternAtom(X->dpy, "WM_SAVE_YOURSELF", FALSE) ;
2729 command_atom = XA_WM_COMMAND;
2730 wm_state_atom = XmInternAtom (X->dpy, "WM_STATE", False);
2732 XmAddWMProtocols(X->kframe, &saveatom, 1) ;
2733 XmAddWMProtocolCallback(X->kframe, saveatom, save_state, (XtPointer)NULL) ;
2736 XSetErrorHandler((int (*)())xerror_interpose) ;
2737 XtAddEventHandler(X->kframe, KeyPressMask | KeyReleaseMask,
2738 FALSE, event_proc, NULL) ;
2739 XmProcessTraversal( X->kbuttons[0][0], XmTRAVERSE_CURRENT );
2743 XtAppMainLoop(X->app) ;
2747 clear_buttons( start )
2754 static Boolean first = True;
2759 if(buttons[i].str != NULL)
2761 XtFree(buttons[i].str);
2762 XtFree(buttons[i].str2);
2763 XtFree(buttons[i].resname);
2765 buttons[i].str = XtNewString("");
2766 buttons[i].str2 = XtNewString("");
2767 buttons[i].resname = XtNewString("blank");
2768 buttons[i].value = 0;
2769 buttons[i].opdisp = OP_SET;
2770 buttons[i].mtype = M_NONE;
2773 lstr = XmStringCreateLocalized(buttons[i].str);
2774 XtSetArg (args[n], XmNlabelString, lstr); n++;
2777 XtSetArg (args[n], XmNbackground, pixels[1].bg); n++;
2778 XtSetArg (args[n], XmNforeground, pixels[1].fg); n++;
2779 XtSetArg (args[n], XmNtopShadowColor, pixels[1].ts); n++;
2780 XtSetArg (args[n], XmNbottomShadowColor, pixels[1].bs); n++;
2781 XtSetArg (args[n], XmNarmColor, pixels[1].sc); n++;
2783 XtSetValues( X->kbuttons[0][0], args, n);
2784 XmStringFree(lstr) ;
2788 row = (start / BCOLS) + 3;
2789 column = start % BCOLS;
2790 for(i = start + 12; i < 24; i++)
2792 XtFree(buttons[i].str);
2793 XtFree(buttons[i].resname);
2794 buttons[i].str = XtNewString("");
2795 buttons[i].resname = XtNewString("blank");
2796 buttons[i].value = 0;
2797 buttons[i].opdisp = OP_SET;
2798 buttons[i].mtype = M_NONE;
2801 lstr = XmStringCreateLocalized(buttons[i].str);
2802 XtSetArg (args[n], XmNlabelString, lstr); n++;
2805 XtSetArg (args[n], XmNbackground, pixels[1].bg); n++;
2806 XtSetArg (args[n], XmNforeground, pixels[1].fg); n++;
2807 XtSetArg (args[n], XmNtopShadowColor, pixels[1].ts); n++;
2808 XtSetArg (args[n], XmNbottomShadowColor, pixels[1].bs); n++;
2809 XtSetArg (args[n], XmNarmColor, pixels[1].sc); n++;
2811 XtSetValues( X->kbuttons[row][column], args, n);
2812 XmStringFree(lstr) ;
2815 if(column % BCOLS == 0)
2833 for(i = 12; i < 24; i++)
2835 if(buttons[i].str != NULL)
2837 XtFree(buttons[i].str);
2838 XtFree(buttons[i].str2);
2839 XtFree(buttons[i].resname);
2841 buttons[i].str = XtNewString(mode_buttons[i - 12].str);
2842 buttons[i].str2 = XtNewString(mode_buttons[i - 12].str2);
2843 buttons[i].resname = XtNewString(mode_buttons[i - 12].resname);
2844 buttons[i].value = mode_buttons[i - 12].value;
2845 buttons[i].opdisp = mode_buttons[i - 12].opdisp;
2846 buttons[i].mtype = mode_buttons[i - 12].mtype;
2847 buttons[i].func = mode_buttons[i - 12].func;
2851 lstr = XmStringCreateLocalized(buttons[i].str2);
2853 lstr = XmStringCreateLocalized(buttons[i].str);
2854 XtSetArg (args[n], XmNlabelString, lstr); n++;
2857 XtSetArg (args[n], XmNbackground, pixels[7].bg); n++;
2858 XtSetArg (args[n], XmNforeground, pixels[7].fg); n++;
2859 XtSetArg (args[n], XmNtopShadowColor, pixels[7].ts); n++;
2860 XtSetArg (args[n], XmNbottomShadowColor, pixels[7].bs); n++;
2861 XtSetArg (args[n], XmNarmColor, pixels[7].sc); n++;
2863 XtSetValues( X->kbuttons[row][column], args, n);
2864 XmStringFree(lstr) ;
2867 if(column % BCOLS == 0)
2886 for(i = 12; i < 24; i++)
2888 if(buttons[i].str != NULL)
2890 XtFree(buttons[i].str);
2891 XtFree(buttons[i].str2);
2892 XtFree(buttons[i].resname);
2894 buttons[i].str = XtNewString(mode_buttons[i + 4].str);
2895 buttons[i].str2 = XtNewString(mode_buttons[i + 4].str2);
2896 buttons[i].resname = XtNewString(mode_buttons[i + 4].resname);
2897 buttons[i].value = mode_buttons[i + 4].value;
2898 buttons[i].opdisp = mode_buttons[i + 4].opdisp;
2899 buttons[i].mtype = mode_buttons[i + 4].mtype;
2900 buttons[i].func = mode_buttons[i + 4].func;
2904 lstr = XmStringCreateLocalized(buttons[i].str2);
2906 lstr = XmStringCreateLocalized(buttons[i].str);
2907 XtSetArg (args[n], XmNlabelString, lstr); n++;
2910 XtSetArg (args[n], XmNbackground, pixels[7].bg); n++;
2911 XtSetArg (args[n], XmNforeground, pixels[7].fg); n++;
2912 XtSetArg (args[n], XmNtopShadowColor, pixels[7].ts); n++;
2913 XtSetArg (args[n], XmNbottomShadowColor, pixels[7].bs); n++;
2914 XtSetArg (args[n], XmNarmColor, pixels[7].sc); n++;
2916 XtSetValues( X->kbuttons[row][column], args, n);
2917 XmStringFree(lstr) ;
2920 if(column % BCOLS == 0)
2939 for(i = 12; i < 24; i++)
2941 if(buttons[i].str != NULL)
2943 XtFree(buttons[i].str);
2944 XtFree(buttons[i].str2);
2945 XtFree(buttons[i].resname);
2947 buttons[i].str = XtNewString(mode_buttons[i + 20].str);
2948 buttons[i].str2 = XtNewString(mode_buttons[i + 20].str2);
2949 buttons[i].resname = XtNewString(mode_buttons[i + 20].resname);
2950 buttons[i].value = mode_buttons[i + 20].value;
2951 buttons[i].opdisp = mode_buttons[i + 20].opdisp;
2952 buttons[i].mtype = mode_buttons[i + 20].mtype;
2953 buttons[i].func = mode_buttons[i + 20].func;
2957 lstr = XmStringCreateLocalized(buttons[i].str2);
2959 lstr = XmStringCreateLocalized(buttons[i].str);
2960 XtSetArg (args[n], XmNlabelString, lstr); n++;
2963 XtSetArg (args[n], XmNbackground, pixels[7].bg); n++;
2964 XtSetArg (args[n], XmNforeground, pixels[7].fg); n++;
2965 XtSetArg (args[n], XmNtopShadowColor, pixels[7].ts); n++;
2966 XtSetArg (args[n], XmNbottomShadowColor, pixels[7].bs); n++;
2967 XtSetArg (args[n], XmNarmColor, pixels[7].sc); n++;
2969 XtSetValues( X->kbuttons[row][column], args, n);
2970 XmStringFree(lstr) ;
2973 if(column % BCOLS == 0)
2984 switch_mode(curmode)
2985 enum mode_type curmode ;
2991 v->modetype = curmode ;
2992 XtSetArg(args[0], XmNmenuHistory, modeArry[(int)curmode]);
2993 XtSetValues( X->modevals[(int)MODEITEM], args, 1);
2994 if((int)curmode == (int)FINANCIAL)
2997 XtSetSensitive(X->modevals[(int)TTYPEITEM], False);
2998 set_item(HYPITEM, " ") ;
2999 set_item(INVITEM, " ") ;
3002 else if((int)curmode == (int)LOGICAL)
3005 XtSetSensitive(X->modevals[(int)TTYPEITEM], False);
3006 set_item(HYPITEM, " ") ;
3007 set_item(INVITEM, " ") ;
3012 XtSetSensitive(X->modevals[(int)TTYPEITEM], True);
3013 set_item(HYPITEM, " ") ;
3014 set_item(INVITEM, " ") ;
3023 char message[MAXLINE] ;
3024 char str[MAXLINE] ; /* Temporary buffer for various strings. */
3025 char result[MAXLINE] ;
3027 double tmp ; /* For converting constant value. */
3029 int n ; /* Set to 1, if constant value is valid. */
3030 char cur_op, current, display[MAXLINE], old_cal_value, fnum[MAX_DIGITS+1];
3031 int cur_ch, toclear, tstate, pending, accuracy;
3032 int MPdisp_val[MP_SIZE], MPlast_input[MP_SIZE], MPresult[MP_SIZE] ;
3036 case M_CON : tmpStr = GETMESSAGE(3, 45, ".");
3037 if(strcmp(tmpStr, ".") != 0)
3039 /* if it's not a "." let's go change it to what it
3041 ptr = DtStrchr(X->vval, tmpStr[0]);
3045 ptr = DtStrchr(X->vval, tmpStr[0]);
3048 /* need to run a "compute" of what was typed in */
3049 len = strlen(X->vval) ;
3050 STRCPY(str, X->vval);
3051 if(X->vval[len - 1] != '=')
3053 /* need to add an '=' at the end of the string so it
3054 computes correctly */
3059 if(strncmp(str, "-", 1) == 0)
3062 for(i=0; i < len -1; i++)
3064 str[i] = str[i+inc];
3065 if(inc == 0 || isdigit((int)str[i]) || str[i] == '.')
3074 /* now let's compute it, first save off some state */
3076 current = v->current;
3077 old_cal_value = v->old_cal_value;
3079 toclear = v->toclear;
3081 pending = v->pending;
3082 STRCPY(display, v->display);
3083 STRCPY(fnum, v->fnum);
3084 mpstr(v->MPdisp_val, MPdisp_val);
3085 mpstr(v->MPlast_input, MPlast_input);
3086 mpstr(v->MPresult, MPresult);
3088 mpcim(&i, v->MPdisp_val) ;
3089 mpcim(&i, v->MPlast_input) ;
3090 mpcim(&i, v->MPresult) ;
3094 process_str(str, M_CON);
3097 /* get the computed value */
3098 accuracy = v->accuracy;
3100 STRCPY(result, make_number(v->MPresult, FALSE)) ;
3101 v->accuracy = accuracy ;
3103 /* return to previous state */
3105 v->current = current;
3106 v->old_cal_value = old_cal_value;
3108 v->toclear = toclear;
3110 v->pending = pending;
3111 STRCPY(v->display, display);
3112 STRCPY(v->fnum, fnum);
3113 mpstr(MPdisp_val, v->MPdisp_val);
3114 mpstr(MPlast_input, v->MPlast_input);
3115 mpstr(MPresult, v->MPresult);
3117 set_item(DISPLAYITEM, v->display);
3119 n = sscanf(result, "%lf", &tmp) ;
3120 ptr = DtStrchr(result, 'e');
3121 if (n != 1 || ptr != NULL || v->error == TRUE)
3123 SPRINTF(message, "%s\n%s", vstrs[(int) V_INVCON],
3124 vstrs[(int) V_NOCHANGE]) ;
3125 do_continue_notice(X->CFframe, message) ;
3126 set_item(OPITEM, "") ;
3127 if(v->cur_op != '?')
3128 set_item(OPITEM, buttons[get_index(v->cur_op)].str);
3133 if(v->cur_op != '?')
3134 set_item(OPITEM, buttons[get_index(v->cur_op)].str);
3136 /* now let's compute it, first save off some state */
3137 if(strncmp(result, "-", 1) == 0)
3139 len = strlen(result);
3141 STRCPY(str, result);
3142 for(i=0; i < len; i++)
3144 MPstr_to_num(str, DEC, v->MPcon_vals[X->cfno]) ;
3145 mpneg(v->MPcon_vals[X->cfno], v->MPcon_vals[X->cfno]) ;
3148 MPstr_to_num(result, DEC, v->MPcon_vals[X->cfno]) ;
3150 if(strncmp(result, "0.", 2) == 0 ||
3151 strncmp(result, "-0.", 3) == 0 )
3153 len = strlen(result);
3154 while(result[len - 1] == '0')
3156 result[len - 1] = '\0';
3160 SPRINTF(v->con_names[X->cfno], "%1d: %s [%s]",
3161 X->cfno, result, X->dval) ;
3163 case M_FUN : tmpStr = GETMESSAGE(3, 45, ".");
3164 if(strcmp(tmpStr, ".") != 0)
3166 /* if it's not a "." let's go change it to what it
3168 ptr = DtStrchr(X->vval, tmpStr[0]);
3172 ptr = DtStrchr(X->vval, tmpStr[0]);
3175 STRCPY(v->fun_vals[X->cfno], convert(X->vval)) ;
3176 if(strcmp(X->vval, "") != 0)
3178 SPRINTF(v->fun_names[X->cfno], "%1d: %s [%s]",
3179 X->cfno, X->vval, X->dval) ;
3182 STRCPY(v->fun_names[X->cfno], "");
3185 XtDestroyWidget(X->menus[(int) X->CFtype]) ;
3186 for (i = 0; i < NOBUTTONS; i++)
3187 if (buttons[i].mtype == X->CFtype)
3188 create_menu(X->CFtype, X->kbuttons[i / BCOLS][i % BCOLS], i) ;
3192 write_rcfile(X->CFtype, X->cfexists, X->cfno,
3196 write_rcfile(X->CFtype, X->cfexists, X->cfno,
3200 ignore_event = True;
3201 timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3202 TimerEvent, (XtPointer) NULL);
3208 win_display(fcptype, state)
3209 enum fcp_type fcptype ;
3213 Position newX, newY;
3216 if (fcptype == FCP_REG) widget = X->rframe ;
3217 else if (fcptype == FCP_MODE) widget = X->mframe[(int) v->modetype] ;
3218 else if (fcptype == FCP_FIN_REG) widget = X->frframe;
3223 if (state && !is_window_showing(widget))
3225 if (fcptype == FCP_REG || fcptype == FCP_FIN_REG)
3227 XtSetMappedWhenManaged(XtParent(widget), False);
3228 XSync(X->dpy, False);
3230 XtManageChild(widget) ;
3232 _DtChildPosition(widget, X->kframe, &newX, &newY);
3233 XtSetArg(args[0], XmNx, newX);
3234 XtSetArg(args[1], XmNy, newY);
3235 XtSetValues(widget, args, 2);
3237 XtSetMappedWhenManaged(XtParent(widget), True);
3238 XSync(X->dpy, False);
3240 XtMapWidget(XtParent(widget));
3242 else if (fcptype == FCP_MODE)
3243 _DtGenericMapWindow (X->kframe, widget);
3245 if (state) XtManageChild(widget) ;
3246 else XtUnmanageChild(widget) ;
3252 write_cf_value(widget, client_data, call_data)
3254 XtPointer client_data, call_data ;
3256 char message[MAXLINE] ;
3257 char str[MAXLINE] ; /* Temporary buffer for various strings. */
3258 Widget focus_widget;
3261 focus_widget = XmGetFocusWidget(widget);
3264 if(focus_widget != X->CFpi_vtext->textfield && focus_widget != X->CFpi_butOK)
3268 if(focus_widget == X->CFpi_vtext->textfield)
3270 X->vval = XmTextFieldGetString(X->CFpi_vtext->textfield);
3271 if(strcmp(X->vval, "") == 0)
3279 if(X->cfval != NULL)
3281 X->dval = XmTextFieldGetString(X->CFpi_dtext->textfield);
3282 if(strlen(X->dval) > 41)
3284 X->vval = XmTextFieldGetString(X->CFpi_vtext->textfield);
3285 X->cfval = XmTextFieldGetString(X->CFpi_cftext->textfield);
3286 SSCANF(X->cfval, "%d", &X->cfno) ;
3287 if ((strcmp(X->cfval, "") == 0) || X->cfval[0] < '0' || X->cfval[0] > '9' ||
3288 X->cfno < 0 || X->cfno > 9)
3290 SPRINTF(str, (X->CFtype == M_CON) ? vstrs[(int) V_LCON]
3291 : vstrs[(int) V_LFUN]) ;
3292 SPRINTF(message, "%s\n%s", str, vstrs[(int) V_RANGE]) ;
3293 do_continue_notice(X->CFframe, message) ;
3297 X->vval = (char *)_DtcalcStripSpaces((char *)X->vval);
3301 case M_CON : X->cfexists = 1 ; /* Always the default constants. */
3303 case M_FUN : if (strlen(v->fun_vals[X->cfno])) X->cfexists = 1 ;
3307 SPRINTF(str, mess[(int) MESS_CON],
3308 (X->CFtype == M_CON) ? vstrs[(int) V_UCON]
3309 : vstrs[(int) V_UFUN], X->cfno) ;
3310 SPRINTF(message, "%s\n%s", str, vstrs[(int) V_OWRITE]) ;
3311 XtUnmanageChild(X->CFframe) ;
3312 do_confirm_notice(X->CFframe, message) ;
3317 XtUnmanageChild(X->CFframe) ;
3320 XtSetArg (args[0], XmNdefaultButton, NULL);
3321 XtSetValues (X->CFframe, args, 1);
3326 xerror_interpose(display, error)
3328 XErrorEvent *error ;
3333 XGetErrorText(display, error->error_code, msg1, 80) ;
3334 sprintf(msg, "\nX Error (intercepted): %s\nMajor Request Code : %d\nMinor Request Code : %d\nResource ID (XID) : %lu\nError Serial Number : %lu\n", msg1, error->request_code, error->minor_code, error->resourceid, error->serial);
3335 _DtSimpleError (v->appname, DtError, NULL, msg);
3340 modelineValueChanged(widget, client_data, call_data)
3342 XtPointer client_data, call_data ;
3345 int position, val, choice;
3347 X->mtype = (enum menu_type) client_data ;
3348 XtSetArg (args[0], XmNuserData, &val);
3349 XtGetValues (widget, args, 1);
3351 choice = val & 0xFFFF ;
3352 v->curwin = ((int) val) >> 16 ;
3353 if(X->mtype == M_BASE)
3354 handle_menu_selection(56, choice) ;
3355 else if(X->mtype == M_NUM)
3356 handle_menu_selection(57, choice) ;
3357 else if(X->mtype == M_MODE)
3358 handle_menu_selection(58, choice) ;
3360 handle_menu_selection(59, choice) ;
3363 create_menu_bar(parent)
3367 int i, j, val, count;
3368 Widget WidgList[10];
3371 XmString labelString;
3372 Widget child, mem_reg;
3373 Widget lastCascadeButtonGadget;
3374 Widget lastCascadeButton;
3375 Widget lastMenuPane;
3376 Widget helpPulldown;
3377 Widget lastCascadeMenuPane;
3380 /* Create the pulldown menu */
3382 XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
3383 XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
3384 XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
3385 XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
3386 X->menubar = XmCreateMenuBar(parent, "mainMenu", args, n);
3387 XtManageChild(X->menubar);
3388 XtAddCallback(X->menubar, XmNhelpCallback, HelpRequestCB,
3389 (XtPointer)HELP_MENUBAR);
3391 mnemonic = GETMESSAGE(2, 13, "O");
3392 mnemonic = XtNewString(mnemonic);
3394 labelString = XmStringCreateLocalized ( GETMESSAGE(2, 14, "Options") );
3395 XtSetArg(args[n], XmNlabelString, labelString); n++;
3396 XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3397 XtSetArg(args[n], XmNmarginWidth, 6); n++;
3398 lastCascadeButtonGadget =
3399 XmCreateCascadeButtonGadget(X->menubar, "options", args, n);
3400 XtManageChild(lastCascadeButtonGadget);
3401 XmStringFree(labelString);
3404 lastMenuPane = XmCreatePulldownMenu(X->menubar, "optionMenu", NULL, 0);
3406 XtSetArg(args[0], XmNsubMenuId, lastMenuPane);
3407 XtSetValues(lastCascadeButtonGadget, args, 1);
3409 mnemonic = GETMESSAGE(2, 40, "R");
3410 mnemonic = XtNewString(mnemonic);
3412 XmStringCreateLocalized( GETMESSAGE(2, 15, "Memory Registers") );
3413 XtSetArg(args[0], XmNlabelString, labelString );
3414 XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3415 mem_reg = XmCreatePushButtonGadget (lastMenuPane, "memR", args, 2);
3416 XtManageChild(mem_reg);
3417 XmStringFree(labelString);
3418 XtAddCallback(mem_reg, XmNactivateCallback, (XtCallbackProc)do_memory,
3421 mnemonic = GETMESSAGE(2, 45, "g");
3422 mnemonic = XtNewString(mnemonic);
3424 XmStringCreateLocalized ( GETMESSAGE(3, 138, "Financial Registers") );
3425 XtSetArg(args[0], XmNlabelString, labelString );
3426 XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3427 mem_reg = XmCreatePushButtonGadget (lastMenuPane, "finR", args, 2);
3428 XtManageChild(mem_reg);
3429 XmStringFree(labelString);
3430 XtAddCallback(mem_reg, XmNactivateCallback, (XtCallbackProc)do_memory,
3433 mnemonic = GETMESSAGE(2, 41, "A");
3434 mnemonic = XtNewString(mnemonic);
3435 labelString=XmStringCreateLocalized ( GETMESSAGE(2, 16, "ASCII Convert") );
3436 XtSetArg(args[0], XmNlabelString, labelString );
3437 XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3438 child = XmCreatePushButtonGadget (lastMenuPane, "asc", args, 2);
3439 XtManageChild(child);
3440 XmStringFree(labelString);
3441 XtAddCallback(child, XmNactivateCallback, (XtCallbackProc)do_ascii,
3444 if(_DtNl_is_multibyte)
3445 XtSetSensitive(child, False);
3447 child = (Widget)XmCreateSeparatorGadget(lastMenuPane, "separator",args,0);
3448 XtManageChild(child);
3450 mnemonic = GETMESSAGE(2, 42, "F");
3451 mnemonic = XtNewString(mnemonic);
3452 labelString = XmStringCreateLocalized ( vstrs[(int) V_FUNWNAME] );
3453 XtSetArg(args[0], XmNlabelString, labelString );
3454 XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3455 child = XmCreatePushButtonGadget (lastMenuPane, "enterFunc", args, 2);
3456 XtManageChild(child);
3457 XmStringFree(labelString);
3458 XtAddCallback(child, XmNactivateCallback, (XtCallbackProc)new_cf_value,
3459 (XtPointer)(int)M_FUN);
3461 mnemonic = GETMESSAGE(2, 43, "C");
3462 mnemonic = XtNewString(mnemonic);
3463 labelString = XmStringCreateLocalized ( vstrs[(int) V_CONWNAME] );
3464 XtSetArg(args[0], XmNlabelString, labelString );
3465 XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3466 child = XmCreatePushButtonGadget (lastMenuPane, "enterCons", args, 2);
3467 XtManageChild(child);
3468 XmStringFree(labelString);
3469 XtAddCallback(child, XmNactivateCallback, (XtCallbackProc)new_cf_value,
3470 (XtPointer)(int)M_CON);
3472 child = (Widget)XmCreateSeparatorGadget(lastMenuPane, "separator",args,0);
3473 XtManageChild(child);
3475 mnemonic = GETMESSAGE(2, 44, "x");
3476 mnemonic = XtNewString(mnemonic);
3477 labelString = XmStringCreateLocalized ( GETMESSAGE(3, 403, "Exit") );
3478 XtSetArg(args[0], XmNlabelString, labelString );
3479 XtSetArg(args[1], XmNmnemonic, XStringToKeysym( mnemonic ) );
3480 child = XmCreatePushButtonGadget (lastMenuPane, "exit", args, 2);
3481 XtManageChild(child);
3482 XmStringFree(labelString);
3483 XtAddCallback(child, XmNactivateCallback, (XtCallbackProc)do_frame,
3487 mnemonic = GETMESSAGE(2, 17, "H");
3488 mnemonic = XtNewString(mnemonic);
3489 labelString = XmStringCreateLocalized ( GETMESSAGE(2, 18, "Help") );
3490 XtSetArg(args[n], XmNlabelString, labelString); n++;
3491 XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3492 XtSetArg(args[n], XmNmarginWidth, 6); n++;
3493 lastCascadeButtonGadget =
3494 XmCreateCascadeButtonGadget(X->menubar, "help", args, n);
3495 XmStringFree(labelString);
3498 helpPulldown = XmCreatePulldownMenu(X->menubar, "helpMenu", NULL, 0);
3500 XtSetArg(args[0], XmNsubMenuId, helpPulldown);
3501 XtSetValues(lastCascadeButtonGadget, args, 1);
3503 XtSetArg(args[0], XmNmenuHelpWidget, lastCascadeButtonGadget);
3504 XtSetValues (X->menubar, args, 1);
3506 XtManageChild(lastCascadeButtonGadget);
3511 mnemonic = GETMESSAGE(2, 19, "v");
3512 mnemonic = XtNewString(mnemonic);
3513 XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3514 labelString = XmStringCreateLocalized ( GETMESSAGE(2, 20, "Overview") );
3515 XtSetArg(args[n], XmNlabelString, labelString); n++;
3517 XmCreatePushButton(helpPulldown, "introduction", args, n );
3518 XtAddCallback(WidgList[count-1], XmNactivateCallback,
3519 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_INTRODUCTION);
3520 XmStringFree(labelString);
3523 WidgList[count++]= (Widget)XmCreateSeparatorGadget(helpPulldown,
3524 "separator",args,0);
3527 mnemonic = GETMESSAGE(2, 38, "C");
3528 mnemonic = XtNewString(mnemonic);
3529 XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3531 XmStringCreateLocalized ( GETMESSAGE(2,39,"Table of Contents") );
3532 XtSetArg(args[n], XmNlabelString, labelString); n++;
3533 WidgList[count++]= XmCreatePushButton(helpPulldown, "toc", args, n );
3534 XtAddCallback(WidgList[count-1], XmNactivateCallback,
3535 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TABLEOFCONTENTS);
3536 XmStringFree(labelString);
3540 mnemonic = GETMESSAGE(2, 21, "T");
3541 mnemonic = XtNewString(mnemonic);
3542 XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3543 labelString = XmStringCreateLocalized ( GETMESSAGE(2, 22, "Tasks") );
3544 XtSetArg(args[n], XmNlabelString, labelString); n++;
3545 WidgList[count++]= XmCreatePushButton(helpPulldown, "tasks", args, n );
3546 XtAddCallback(WidgList[count-1], XmNactivateCallback,
3547 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TASKS);
3548 XmStringFree(labelString);
3552 mnemonic = GETMESSAGE(2, 23, "R");
3553 mnemonic = XtNewString(mnemonic);
3554 XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3555 labelString = XmStringCreateLocalized ( GETMESSAGE(2, 24, "Reference") );
3556 XtSetArg(args[n], XmNlabelString, labelString); n++;
3557 WidgList[count++]= XmCreatePushButton(helpPulldown, "reference", args, n );
3558 XtAddCallback(WidgList[count-1], XmNactivateCallback,
3559 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_REFERENCE);
3560 XmStringFree(labelString);
3564 mnemonic = GETMESSAGE(2, 25, "O");
3565 mnemonic = XtNewString(mnemonic);
3566 XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3567 labelString = XmStringCreateLocalized ( GETMESSAGE(2, 26, "On Item") );
3568 XtSetArg(args[n], XmNlabelString, labelString); n++;
3569 WidgList[count++]= XmCreatePushButton(helpPulldown, "onItem", args, n );
3570 XtAddCallback(WidgList[count-1], XmNactivateCallback,
3571 (XtCallbackProc)HelpModeCB, (XtPointer)NULL);
3572 XmStringFree(labelString);
3575 WidgList[count++]= (Widget)XmCreateSeparatorGadget(helpPulldown,
3576 "separator",args,0);
3579 mnemonic = GETMESSAGE(2, 27, "U");
3580 mnemonic = XtNewString(mnemonic);
3581 XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3582 labelString = XmStringCreateLocalized ( GETMESSAGE(2, 28, "Using Help") );
3583 XtSetArg(args[n], XmNlabelString, labelString); n++;
3585 XmCreatePushButton(helpPulldown, "usingHelp", args, n );
3586 XtAddCallback(WidgList[count-1], XmNactivateCallback,
3587 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_USING);
3588 XmStringFree(labelString);
3591 WidgList[count++]= (Widget)XmCreateSeparatorGadget(helpPulldown,
3592 "separator",args,0);
3595 mnemonic = GETMESSAGE(2, 29, "A");
3596 mnemonic = XtNewString(mnemonic);
3597 XtSetArg(args[n], XmNmnemonic, XStringToKeysym( mnemonic ) ); n++;
3599 XmStringCreateLocalized ( GETMESSAGE(2, 30, "About Calculator") );
3600 XtSetArg(args[n], XmNlabelString, labelString); n++;
3601 WidgList[count++]= XmCreatePushButton(helpPulldown, "about", args, n );
3602 XtAddCallback(WidgList[count-1], XmNactivateCallback,
3603 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_VERSION);
3604 XmStringFree(labelString);
3607 XtManageChildren(WidgList, count);
3609 /* Fine tune the menubar */
3610 XtSetArg(args[0], XmNmarginWidth, 2);
3611 XtSetArg(args[1], XmNmarginHeight, 2);
3612 XtSetValues(X->menubar, args, 2);
3620 short act, inact, prim, second;
3622 XmeGetPixelData (X->screen, &colorUse, pixels, &act, &inact,
3625 if(pixels[0].bg == pixels[1].bg && pixels[1].bg == pixels[2].bg &&
3626 pixels[2].bg == pixels[3].bg && pixels[3].bg == pixels[4].bg &&
3627 pixels[4].bg == pixels[5].bg && pixels[5].bg == pixels[6].bg &&
3628 pixels[6].bg == pixels[7].bg && pixels[7].bg == 0)
3636 do_memory( w, client_data, call_data )
3638 XtPointer client_data ;
3639 XtPointer call_data ;
3641 int type = (int)client_data;
3648 make_registers(MEM) ;
3650 win_display(FCP_REG, TRUE) ;
3657 make_registers(FIN) ;
3659 win_display(FCP_FIN_REG, TRUE) ;
3661 ignore_event = True;
3662 timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3663 TimerEvent, (XtPointer) NULL);
3667 read_resources() /* Read all possible resources from the database. */
3669 int boolval, i, intval ;
3673 /* set the accuracy variable */
3674 if(application_args.accuracy > 9)
3676 else if(application_args.accuracy < 0)
3679 v->accuracy = application_args.accuracy;
3682 if(strcmp(application_args.base, "binary") == 0 ||
3683 strcmp(application_args.base, "bin") == 0)
3684 v->base = (enum base_type) 0 ;
3685 else if(strcmp(application_args.base, "octal") == 0 ||
3686 strcmp(application_args.base, "oct") == 0)
3687 v->base = (enum base_type) 1 ;
3688 else if(strcmp(application_args.base, "decimal") == 0 ||
3689 strcmp(application_args.base, "dec") == 0)
3690 v->base = (enum base_type) 2 ;
3691 else if(strcmp(application_args.base, "hexadecimal") == 0 ||
3692 strcmp(application_args.base, "hex") == 0)
3693 v->base = (enum base_type) 3 ;
3696 msg = (char *) XtMalloc(strlen( opts[(int) O_BASE]) + 3);
3697 sprintf(msg, opts[(int) O_BASE]);
3698 _DtSimpleError (v->appname, DtWarning, NULL, msg);
3700 v->base = (enum base_type) 2;
3703 /* set the display numeration */
3704 if(strcmp(application_args.display, "fixed") == 0)
3705 v->dtype = (enum base_type) 1 ;
3706 else if(strcmp(application_args.display, "eng") == 0 ||
3707 strcmp(application_args.display, "engineering") == 0)
3708 v->dtype = (enum base_type) 0 ;
3709 else if(strcmp(application_args.display, "scientific") == 0 ||
3710 strcmp(application_args.display, "sci") == 0)
3711 v->dtype = (enum base_type) 2 ;
3714 msg = (char *) XtMalloc(strlen( opts[(int) O_DISPLAY]) + strlen(str) + 3);
3715 sprintf(msg, opts[(int) O_DISPLAY], str);
3716 _DtSimpleError (v->appname, DtWarning, NULL, msg);
3718 v->dtype = (enum base_type) 1;
3722 if(strcmp(application_args.mode, "scientific") == 0)
3723 v->modetype = (enum base_type) 2 ;
3724 else if(strcmp(application_args.mode, "financial") == 0)
3725 v->modetype = (enum base_type) 0 ;
3726 else if(strcmp(application_args.mode, "logical") == 0)
3727 v->modetype = (enum base_type) 1 ;
3730 msg = (char *) XtMalloc(strlen( opts[(int) O_MODE]) + strlen(str) + 3);
3731 sprintf(msg, opts[(int) O_MODE], str);
3732 _DtSimpleError (v->appname, DtWarning, NULL, msg);
3734 v->modetype = (enum base_type) 2;
3737 /* set the display numeration */
3738 if(strcmp(application_args.trigType, "deg") == 0 ||
3739 strcmp(application_args.trigType, "degrees") == 0)
3740 v->ttype = (enum base_type) 0 ;
3741 else if(strcmp(application_args.trigType, "rad") == 0 ||
3742 strcmp(application_args.trigType, "radians") == 0)
3743 v->ttype = (enum base_type) 2 ;
3744 else if(strcmp(application_args.trigType, "grad") == 0 ||
3745 strcmp(application_args.trigType, "gradients") == 0)
3746 v->ttype = (enum base_type) 1 ;
3749 msg = (char *) XtMalloc(strlen( opts[(int) O_TRIG]) + strlen(str) + 3);
3750 sprintf(msg, opts[(int) O_TRIG], str);
3751 _DtSimpleError (v->appname, DtWarning, NULL, msg);
3753 v->ttype = (enum base_type) 0;
3759 close_cf(widget, client_data, call_data)
3761 XtPointer client_data, call_data ;
3765 XtSetArg (args[0], XmNdefaultButton, NULL);
3766 XtSetValues (X->CFframe, args, 1);
3768 XtUnmanageChild(X->CFframe) ;
3769 ignore_event = True;
3770 timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3771 TimerEvent, (XtPointer) NULL);
3775 close_ascii(widget, client_data, call_data)
3777 XtPointer client_data, call_data ;
3779 XtUnmanageChild(X->Aframe) ;
3780 ignore_event = True;
3781 timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3782 TimerEvent, (XtPointer) NULL);
3786 FocusInCB(widget, client_data, call_data)
3788 XtPointer client_data, call_data ;
3792 XtSetArg (args[0], XmNdefaultButton, NULL);
3793 XtSetValues (X->CFframe, args, 1);
3795 XtSetArg(args[0], XmNshowAsDefault, True);
3796 XtSetValues(X->CFpi_butOK, args, 1);
3800 move_cf(widget, client_data, call_data)
3802 XtPointer client_data, call_data ;
3809 if(widget == X->CFpi_cftext->textfield)
3811 XtSetArg (args[0], XmNdefaultButton, NULL);
3812 XtSetValues (X->CFframe, args, 1);
3814 XtSetArg(args[0], XmNshowAsDefault, True);
3815 XtSetValues(X->CFpi_butOK, args, 1);
3817 input = XmTextFieldGetString(X->CFpi_cftext->textfield);
3818 if(strcmp(input, "") != 0)
3819 XmProcessTraversal(X->CFpi_dtext->textfield, XmTRAVERSE_CURRENT);
3821 else if(widget == X->CFpi_dtext->textfield)
3823 XtSetArg (args[0], XmNdefaultButton, NULL);
3824 XtSetValues (X->CFframe, args, 1);
3826 XtSetArg(args[0], XmNshowAsDefault, True);
3827 XtSetValues(X->CFpi_butOK, args, 1);
3829 XmProcessTraversal(X->CFpi_vtext->textfield, XmTRAVERSE_CURRENT);
3832 else if(widget == X->CFpi_vtext->textfield)
3834 input = XmTextFieldGetString(X->CFpi_vtext->textfield);
3836 ignore_event = True;
3837 timerId = XtAppAddTimeOut (XtWidgetToApplicationContext (X->kframe), 300,
3838 TimerEvent, (XtPointer) value);
3841 create_popup(parent)
3848 Widget dummyHelp1, dummyHelp2, memRegs;
3849 Widget help, helpI, helpToc, helpT, helpR, helpO, helpU, helpV;
3851 X->popupMenu = XmCreatePopupMenu(parent, "popup", NULL, 0) ;
3852 XtCreateManagedWidget(GETMESSAGE(2, 46,"Calculator Popup"),
3853 xmLabelWidgetClass, X->popupMenu, NULL, 0) ;
3854 XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3855 X->popupMenu, NULL, 0) ;
3856 XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3857 X->popupMenu, NULL, 0) ;
3860 /* The popup menu contains the following entries ......................*/
3861 /* 1. Memory Registers ... */
3862 memRegs = XtVaCreateManagedWidget( "memRegs1",
3863 xmPushButtonWidgetClass,
3865 XmNlabelString, XmStringCreateLocalized(
3866 GETMESSAGE(2, 15, "Memory Registers") ),
3867 XmNmnemonic, XStringToKeysym(
3868 GETMESSAGE(2, 40, "R") ),
3870 XtAddCallback(memRegs, XmNactivateCallback, (XtCallbackProc)do_memory,
3873 /* 2. Finacial Registers ... */
3874 memRegs = XtVaCreateManagedWidget( "memRegs2",
3875 xmPushButtonWidgetClass,
3877 XmNlabelString, XmStringCreateLocalized(
3878 GETMESSAGE(3, 138, "Financial Registers") ),
3879 XmNmnemonic, XStringToKeysym(
3880 GETMESSAGE( 2, 45, "g" ) ),
3882 XtAddCallback(memRegs, XmNactivateCallback, (XtCallbackProc)do_memory,
3885 /* 3. Ascii Converter ... */
3886 X->asciiConv = XtVaCreateManagedWidget("asciiConv",
3887 xmPushButtonWidgetClass,
3890 XmStringCreateLocalized( GETMESSAGE(2, 16, "ASCII Convert") ),
3891 XmNmnemonic, XStringToKeysym(
3892 GETMESSAGE(2, 41, "A") ),
3894 XtAddCallback(X->asciiConv, XmNactivateCallback, (XtCallbackProc)do_ascii,
3897 if(_DtNl_is_multibyte)
3898 XtSetSensitive(X->asciiConv, False);
3900 XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3901 X->popupMenu, NULL, 0) ;
3903 /* 4. Enter Functions ... */
3904 X->enterFun = XtVaCreateManagedWidget("enterFun",
3905 xmPushButtonWidgetClass,
3908 XmStringCreateLocalized( vstrs[(int) V_FUNWNAME] ),
3909 XmNmnemonic, XStringToKeysym(
3910 GETMESSAGE(2, 42, "F") ),
3912 XtAddCallback(X->enterFun, XmNactivateCallback, (XtCallbackProc)new_cf_value,
3913 (XtPointer)(int)M_FUN);
3915 /* 5. Enter Constants ... */
3916 X->enterConst = XtVaCreateManagedWidget("enterConst",
3917 xmPushButtonWidgetClass,
3920 XmStringCreateLocalized( vstrs[(int) V_CONWNAME] ),
3921 XmNmnemonic, XStringToKeysym(
3922 GETMESSAGE(2, 43, "C") ),
3924 XtAddCallback(X->enterConst, XmNactivateCallback,(XtCallbackProc)new_cf_value,
3925 (XtPointer)(int)M_CON);
3927 XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3928 X->popupMenu, NULL, 0) ;
3933 dummyHelp1 = XtVaCreatePopupShell ("dummyHelp1",
3934 xmMenuShellWidgetClass,
3940 dummyHelp2 = XtVaCreateWidget("dummyHelp2",
3941 xmRowColumnWidgetClass, dummyHelp1,
3942 XmNrowColumnType, XmMENU_PULLDOWN,
3946 label = XmStringCreateLocalized ( GETMESSAGE(2, 20, "Overview") );
3947 helpI = XtVaCreateManagedWidget ("introduction",
3948 xmPushButtonGadgetClass, dummyHelp2,
3949 XmNlabelString, label,
3950 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 19, "v") ),
3954 XtAddCallback(helpI, XmNactivateCallback,
3955 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_INTRODUCTION);
3956 XmStringFree (label);
3958 XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
3959 dummyHelp2, NULL, 0);
3961 label = XmStringCreateLocalized ( GETMESSAGE(2, 39, "Table of Contents") );
3962 helpToc = XtVaCreateManagedWidget ("toc",
3963 xmPushButtonGadgetClass, dummyHelp2,
3964 XmNlabelString, label,
3965 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 38, "C") ),
3968 XtAddCallback(helpToc, XmNactivateCallback,
3969 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TABLEOFCONTENTS);
3971 XmStringFree(label);
3974 label = XmStringCreateLocalized ( GETMESSAGE(2, 22, "Tasks") );
3975 helpT = XtVaCreateManagedWidget ("tasks",
3976 xmPushButtonGadgetClass, dummyHelp2,
3977 XmNlabelString, label,
3978 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 21, "T") ),
3981 XtAddCallback(helpT, XmNactivateCallback,
3982 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TASKS);
3984 XmStringFree(label);
3987 label = XmStringCreateLocalized ( GETMESSAGE(2, 24, "Reference") );
3988 helpR = XtVaCreateManagedWidget ("reference",
3989 xmPushButtonGadgetClass, dummyHelp2,
3990 XmNlabelString, label,
3991 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 23, "R" ) ),
3995 XtAddCallback(helpR, XmNactivateCallback,
3996 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_REFERENCE);
3998 XmStringFree(label);
4000 label = XmStringCreateLocalized ( GETMESSAGE(2, 26, "On Item") );
4002 helpO = XtVaCreateManagedWidget ("onItem",
4003 xmPushButtonGadgetClass, dummyHelp2,
4004 XmNlabelString, label,
4005 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 25, "O") ),
4008 XtAddCallback(helpO, XmNactivateCallback,
4009 (XtCallbackProc)HelpModeCB, (XtPointer)NULL);
4011 XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
4012 dummyHelp2, NULL, 0);
4013 XmStringFree (label);
4015 label = XmStringCreateLocalized ( GETMESSAGE(2, 28, "Using Help") );
4016 helpU = XtVaCreateManagedWidget ("useHelp",
4017 xmPushButtonGadgetClass, dummyHelp2,
4018 XmNlabelString, label,
4019 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 27, "U") ),
4023 XtAddCallback(helpU, XmNactivateCallback,
4024 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_USING);
4026 XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
4027 dummyHelp2, NULL, 0);
4029 XmStringFree(label);
4031 label = XmStringCreateLocalized (GETMESSAGE(2, 30, "About Calculator") );
4032 helpV = XtVaCreateManagedWidget ("version",
4033 xmPushButtonGadgetClass, dummyHelp2,
4034 XmNlabelString, label,
4035 XmNmnemonic, XStringToKeysym( GETMESSAGE(2, 29, "A" ) ),
4038 XtAddCallback(helpV, XmNactivateCallback,
4039 (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_VERSION);
4041 XmStringFree(label);
4044 mnemonic = GETMESSAGE(2, 17, "H");
4045 label = XmStringCreateLocalized ( GETMESSAGE(2, 18, "Help") );
4046 help = XtVaCreateManagedWidget("help",
4047 xmCascadeButtonGadgetClass, X->popupMenu,
4048 XmNsubMenuId, dummyHelp2,
4049 XmNmnemonic, XStringToKeysym( mnemonic ),
4050 XmNlabelString, label,
4052 XmStringFree(label);
4054 XtCreateManagedWidget("separator", xmSeparatorWidgetClass,
4055 X->popupMenu, NULL, 0);
4058 label = XmStringCreateLocalized ( GETMESSAGE(3, 403, "Exit") );
4059 X->Close = XtVaCreateManagedWidget("close",
4060 xmPushButtonWidgetClass,
4062 XmNlabelString, label,
4064 XStringToKeysym(GETMESSAGE(2, 44, "X" )),
4066 XmStringFree(label);
4067 XtAddCallback(X->Close, XmNactivateCallback,(XtCallbackProc)do_frame,
4068 (XtPointer)(int)M_FUN);
4070 XtAddEventHandler(parent, ButtonPressMask, FALSE,
4071 popupHandler, (XtPointer) NULL) ;
4072 XtAddCallback(X->popupMenu, XmNmapCallback,(XtCallbackProc)map_popup,
4077 popupHandler(widget, client_data, event, continue_to_dispatch)
4079 XtPointer client_data ;
4081 Boolean *continue_to_dispatch ;
4083 XButtonPressedEvent *bevent;
4085 bevent = (XButtonPressedEvent *)event;
4087 if (event->type == ButtonPress && event->xbutton.button == Button3)
4089 if(bevent->x >= funBtn->core.x &&
4090 bevent->x <= funBtn->core.x + funBtn->core.width &&
4091 bevent->y >= funBtn->core.y +
4092 X->modeline->core.height + X->textForm->core.height &&
4093 bevent->y <= funBtn->core.y +funBtn->core.height +
4094 X->modeline->core.height + X->textForm->core.height)
4096 menu_handler(widget, (XtPointer)M_FUN, event, continue_to_dispatch);
4098 else if(bevent->x >= constBtn->core.x &&
4099 bevent->x <= constBtn->core.x + constBtn->core.width &&
4100 bevent->y >= constBtn->core.y +
4101 X->modeline->core.height + X->textForm->core.height &&
4102 bevent->y <= constBtn->core.y + constBtn->core.height +
4103 X->modeline->core.height + X->textForm->core.height)
4105 menu_handler(widget, (XtPointer)M_CON, event, continue_to_dispatch);
4107 else if(bevent->x >= accBtn->core.x &&
4108 bevent->x <= accBtn->core.x + accBtn->core.width &&
4109 bevent->y >= accBtn->core.y +
4110 X->modeline->core.height + X->textForm->core.height &&
4111 bevent->y <= accBtn->core.y + accBtn->core.height +
4112 X->modeline->core.height + X->textForm->core.height)
4114 menu_handler(widget, (XtPointer)M_ACC, event, continue_to_dispatch);
4116 else if(bevent->x >= rclBtn->core.x &&
4117 bevent->x <= rclBtn->core.x + rclBtn->core.width &&
4118 bevent->y >= rclBtn->core.y +
4119 X->modeline->core.height + X->textForm->core.height &&
4120 bevent->y <= rclBtn->core.y + rclBtn->core.height +
4121 X->modeline->core.height + X->textForm->core.height)
4123 menu_handler(widget, (XtPointer)M_RCL, event, continue_to_dispatch);
4125 else if(bevent->x >= stoBtn->core.x &&
4126 bevent->x <= stoBtn->core.x + stoBtn->core.width &&
4127 bevent->y >= stoBtn->core.y +
4128 X->modeline->core.height + X->textForm->core.height &&
4129 bevent->y <= stoBtn->core.y + stoBtn->core.height +
4130 X->modeline->core.height + X->textForm->core.height)
4132 menu_handler(widget, (XtPointer)M_STO, event, continue_to_dispatch);
4134 else if(bevent->x >= exchBtn->core.x &&
4135 bevent->x <= exchBtn->core.x + exchBtn->core.width &&
4136 bevent->y >= exchBtn->core.y +
4137 X->modeline->core.height + X->textForm->core.height &&
4138 bevent->y <= exchBtn->core.y + exchBtn->core.height +
4139 X->modeline->core.height + X->textForm->core.height)
4141 menu_handler(widget, (XtPointer)M_EXCH, event, continue_to_dispatch);
4145 XmMenuPosition(X->popupMenu, (XButtonPressedEvent *) event) ;
4146 XtManageChild(X->popupMenu) ;
4152 set_option_menu(type, base)
4158 if(type == BASEITEM)
4159 XtSetArg(args[0], XmNmenuHistory, X->baseWidgArry[base]);
4160 else if(type == NUMITEM)
4161 XtSetArg(args[0], XmNmenuHistory, X->numWidgArry[base]);
4163 XtSetArg(args[0], XmNmenuHistory, X->ttypeWidgArry[base]);
4164 XtSetValues( X->modevals[type], args, 1);
4168 map_popup(widget, client_data, call_data)
4170 XtPointer client_data, call_data ;
4172 XmAnyCallbackStruct * callback;
4174 XKeyPressedEvent *key_event ;
4176 callback = (XmAnyCallbackStruct *) call_data;
4177 event = (XEvent *) callback->event;
4178 key_event = (XKeyPressedEvent *) event ;
4180 if(event->type != KeyRelease)
4183 if (v->event_type == F4_PRESS)
4184 XmMenuPosition(widget, (XButtonPressedEvent *) event) ;
4189 save_state(widget, client_data, call_data)
4191 XtPointer client_data ;
4192 XtPointer call_data ;
4194 char *full_path = NULL;
4195 char *file_name = NULL;
4197 char *sessionFileName;
4199 char **restart_argv = NULL;
4200 static char **start_argv = NULL;
4202 int i, restart_argc;
4203 static int start_argc = 0;
4205 Boolean status = False;
4206 static Boolean first = True;
4208 status = DtSessionSavePath(widget, &full_path, &file_name);
4211 sessionFileName = file_name;
4214 XtFree( (char *)full_path);
4215 full_path = (char *) XtMalloc (sizeof (char) * MAX_PATH);
4216 sprintf( full_path, "%s/%s", dt_path, DTCALC_CLASS_NAME);
4217 sessionFileName = full_path;
4220 SaveSession(full_path, file_name);
4222 /* --------------------------------------------------------------- */
4223 /* Original commandline arguments were saved on the top window */
4224 /* They get reset here, take original and append them to restart */
4225 /* --------------------------------------------------------------- */
4230 XGetCommand(X->dpy, XtWindow(X->kframe), &start_argv, &start_argc);
4233 /* Generate the restart command and add it as the property value */
4235 restart_argc = start_argc + 3;
4236 restart_argv = (char **) XtMalloc(restart_argc * sizeof(char *));
4238 if (restart_argv == NULL)
4241 restart_argv[0] = XtNewString(v->progname);
4243 for ( i = 1 ; (i < start_argc && start_argv != NULL) ; i++ )
4245 restart_argv[i] = XtNewString(start_argv[i]);
4248 restart_argv[i] = XtNewString("-session"); i++;
4249 restart_argv[i] = XtNewString(sessionFileName); i++;
4251 XSetCommand(X->dpy, XtWindow(X->kframe), restart_argv, i);
4252 XSync(X->dpy, False);
4254 for ( i = 0 ; i < restart_argc -1 ; i++ )
4255 XtFree ((char *) restart_argv[i]);
4257 XtFree ((char *) full_path);
4258 XtFree ((char *) file_name);
4264 SaveSession( path, file_name )
4268 char workspaceNumber[5];
4270 Atom * ws_presence = NULL;
4271 char * workspace_name;
4272 unsigned long num_workspaces = 0;
4275 unsigned long nitems;
4276 unsigned long leftover;
4277 WM_STATE * wm_state;
4281 Dimension width, height;
4290 XmVendorShellExtObject vendorExt;
4291 XmWidgetExtData extData;
4296 /* Create the session file */
4298 if ((fd = creat (path, S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP)) == -1)
4300 tmpStr = GETMESSAGE(2, 34, "Could not open the session file.");
4301 msg = XtNewString(tmpStr);
4302 _DtSimpleError (v->appname, DtError, NULL, msg);
4308 /* Getting the WM_STATE property to see if iconified or not */
4309 XGetWindowProperty (X->dpy, XtWindow (X->kframe),
4310 wm_state_atom, 0L, (long) BUFSIZ, False,
4311 wm_state_atom, &actual_type, &actual_format,
4312 &nitems, &leftover, (unsigned char **) &wm_state);
4314 /* Write out if iconified our not */
4315 if (wm_state->state == IconicState)
4316 put_resource(R_ICON, set_bool(True)) ;
4318 put_resource(R_ICON, set_bool(False)) ;
4320 /* does it have a menubar or not */
4321 if ( application_args.menuBar )
4322 put_resource(R_MENUBAR, set_bool(True)) ;
4324 put_resource(R_MENUBAR, set_bool(False)) ;
4326 /* is keys set to on/off */
4328 put_resource(R_KEYS, set_bool(True)) ;
4330 put_resource(R_KEYS, set_bool(False)) ;
4332 /* Get the workspaces for this dt by accessing the property. */
4334 if (DtWsmGetWorkspacesOccupied (X->dpy, XtWindow (X->kframe),
4335 &ws_presence, &num_workspaces) == Success)
4339 string = (char *)XtMalloc(num_workspaces * 40);
4340 for (j = 0; j < num_workspaces; j++)
4342 workspace_name = XGetAtomName (X->dpy, ws_presence[j]);
4344 strcpy(string, workspace_name);
4346 strcat(string, workspace_name);
4347 if(j + 1 != num_workspaces)
4348 strcat(string, " ");
4349 XtFree ((char *) workspace_name);
4351 put_resource(R_WORKSPACE, string) ;
4353 XFree((char *)ws_presence);
4354 XtFree((char *)string);
4359 XtSetArg(args[0], XmNwidth, &width);
4360 XtSetArg(args[1], XmNheight, &height);
4361 XtGetValues(X->kframe, args, 2);
4363 XTranslateCoordinates(XtDisplay(X->kframe),
4364 XtWindow(X->kframe),
4365 RootWindowOfScreen(XtScreen(X->kframe)),
4371 /* Modify x & y to take into account window mgr frames */
4372 extData=_XmGetWidgetExtData(X->kframe, XmSHELL_EXTENSION);
4373 vendorExt = (XmVendorShellExtObject)extData->widget;
4374 x -= vendorExt->vendor.xOffset;
4375 y -= vendorExt->vendor.yOffset;
4377 sprintf(tempStr, "%d", width);
4378 put_resource(R_WIDTH, tempStr) ;
4379 sprintf(tempStr, "%d", height);
4380 put_resource(R_HEIGHT, tempStr) ;
4381 sprintf(tempStr, "%d", x);
4382 put_resource(R_X, tempStr) ;
4383 sprintf(tempStr, "%d", y);
4384 put_resource(R_Y, tempStr) ;
4386 write_resources(path);
4392 Boolean status=False;
4395 char temp[MAXLINE] ;
4396 char * full_path = NULL;
4398 int boolval, i, intval ;
4400 int MPtemp[MP_SIZE];
4402 status = DtSessionRestorePath(X->kframe, &full_path,
4403 application_args.session);
4407 path = XtNewString(full_path);
4409 db = XrmGetFileDatabase(path) ;
4410 XrmMergeDatabases(db, &(X->rDB)) ;
4412 if (get_int_resource(R_ACCURACY, &intval))
4414 v->accuracy = intval ;
4415 if (v->accuracy < 0 || v->accuracy > 9)
4417 msg = (char *) XtMalloc(strlen( opts[(int) O_ACCRANGE]) + 3);
4418 sprintf(msg, opts[(int) O_ACCRANGE]);
4419 _DtSimpleError (v->appname, DtWarning, NULL, msg);
4425 if ((full_path = get_resource(R_BASE)) != NULL)
4427 for (i = 0; i < MAXBASES; i++)
4428 if (EQUAL(full_path, base_str[i])) break ;
4432 msg = (char *) XtMalloc(strlen( opts[(int) O_BASE]) + 3);
4433 sprintf(msg, opts[(int) O_BASE]);
4434 _DtSimpleError (v->appname, DtWarning, NULL, msg);
4439 v->base = (enum base_type) i ;
4443 if (get_str_resource(R_DISPLAY, str))
4445 for (i = 0; i < MAXDISPMODES; i++)
4446 if (EQUAL(str, dtype_str[i])) break ;
4448 if (i == MAXDISPMODES)
4450 msg = (char *) XtMalloc(strlen( opts[(int) O_DISPLAY]) +
4452 sprintf(msg, opts[(int) O_DISPLAY], str);
4453 _DtSimpleError (v->appname, DtWarning, NULL, msg);
4456 else v->dtype = (enum num_type) i ;
4459 if (get_str_resource(R_MODE, str))
4461 for (i = 0; i < MAXMODES; i++)
4462 if (EQUAL(str, mode_str[i])) break ;
4466 msg = (char *)XtMalloc(strlen( opts[(int) O_MODE]) + strlen(str) + 3);
4467 sprintf(msg, opts[(int) O_MODE], str);
4468 _DtSimpleError (v->appname, DtWarning, NULL, msg);
4471 else v->modetype = (enum mode_type) i ;
4474 if (get_str_resource(R_TRIG, str))
4476 for (i = 0; i < MAXTRIGMODES; i++)
4477 if (EQUAL(str, ttype_str[i])) break ;
4479 if (i == MAXTRIGMODES)
4481 msg = (char *)XtMalloc(strlen( opts[(int) O_TRIG]) + strlen(str) + 3);
4482 sprintf(msg, opts[(int) O_TRIG], str);
4483 _DtSimpleError (v->appname, DtWarning, NULL, msg);
4486 else v->ttype = (enum trig_type) i ;
4489 if (get_bool_resource(R_REGS, &boolval)) v->rstate = boolval ;
4491 /* Get the iconify state */
4492 if (get_bool_resource(R_ICON, &boolval)) v->iconic = boolval;
4494 /* Get the menubar state */
4495 if (get_bool_resource(R_MENUBAR, &boolval))
4496 application_args.menuBar = boolval;
4498 /* Get the keys state */
4499 if (get_bool_resource(R_KEYS, &boolval)) v->tstate = boolval;
4501 /* Get the proper workspaces if needed */
4502 if ((full_path = get_resource(R_WORKSPACE)) != NULL)
4503 v->workspaces = XtNewString(full_path);
4505 /* Get the x, y width, and height */
4506 if (get_int_resource(R_WIDTH, &intval))
4508 if (get_int_resource(R_HEIGHT, &intval))
4509 v->height = intval ;
4510 if (get_int_resource(R_X, &intval))
4512 if (get_int_resource(R_Y, &intval))
4515 if (get_str_resource(R_DISPLAYED, str))
4517 STRCPY(v->display, str);
4518 MPstr_to_num(str, v->base, v->MPdisp_val) ;
4521 if (get_str_resource(R_REG0, str))
4522 MPstr_to_num(str, v->base, v->MPmvals[0]) ;
4523 if (get_str_resource(R_REG1, str))
4524 MPstr_to_num(str, v->base, v->MPmvals[1]) ;
4525 if (get_str_resource(R_REG2, str))
4526 MPstr_to_num(str, v->base, v->MPmvals[2]) ;
4527 if (get_str_resource(R_REG3, str))
4528 MPstr_to_num(str, v->base, v->MPmvals[3]) ;
4529 if (get_str_resource(R_REG4, str))
4530 MPstr_to_num(str, v->base, v->MPmvals[4]) ;
4531 if (get_str_resource(R_REG5, str))
4532 MPstr_to_num(str, v->base, v->MPmvals[5]) ;
4533 if (get_str_resource(R_REG6, str))
4534 MPstr_to_num(str, v->base, v->MPmvals[6]) ;
4535 if (get_str_resource(R_REG7, str))
4536 MPstr_to_num(str, v->base, v->MPmvals[7]) ;
4537 if (get_str_resource(R_REG8, str))
4538 MPstr_to_num(str, v->base, v->MPmvals[8]) ;
4539 if (get_str_resource(R_REG9, str))
4540 MPstr_to_num(str, v->base, v->MPmvals[9]) ;
4542 if (get_str_resource(R_FREG0, str))
4544 MPstr_to_num(str, v->base, MPtemp) ;
4545 mpcmd(MPtemp, &(v->MPfvals[0]));
4547 if (get_str_resource(R_FREG1, str))
4549 MPstr_to_num(str, v->base, MPtemp) ;
4550 mpcmd(MPtemp, &(v->MPfvals[1]));
4552 if (get_str_resource(R_FREG2, str))
4554 MPstr_to_num(str, v->base, MPtemp) ;
4555 mpcmd(MPtemp, &(v->MPfvals[2]));
4557 if (get_str_resource(R_FREG3, str))
4559 MPstr_to_num(str, v->base, MPtemp) ;
4560 mpcmd(MPtemp, &(v->MPfvals[3]));
4562 if (get_str_resource(R_FREG4, str))
4564 MPstr_to_num(str, v->base, MPtemp) ;
4565 mpcmd(MPtemp, &(v->MPfvals[4]));
4567 if (get_str_resource(R_FREG5, str))
4569 MPstr_to_num(str, v->base, MPtemp) ;
4570 mpcmd(MPtemp, &(v->MPfvals[5]));
4579 Atom * workspace_atoms = NULL;
4580 int num_workspaces=0;
4584 if(v->width != 0 && v->height != 0)
4586 WMShellWidget wm = (WMShellWidget)(X->kframe);
4587 wm->wm.size_hints.flags |= USPosition;
4588 XtSetArg (args[0], XmNx, (Position)v->x);
4589 XtSetArg (args[1], XmNy, (Position)v->y);
4590 XtSetArg (args[2], XmNwidth, (Dimension)v->width);
4591 XtSetArg (args[3], XmNheight, (Dimension)v->height);
4592 XtSetValues (X->kframe, args, 4);
4597 /* add the iconify hint to the current shell */
4598 XtSetArg(args[0], XmNinitialState, IconicState);
4599 XtSetValues(X->kframe, args, 1);
4603 /* Remove the iconify hint from the current shell */
4604 wmhints = XGetWMHints(X->dpy, XtWindow(X->kframe));
4605 wmhints->flags |= IconWindowHint;
4606 wmhints->initial_state = NormalState;
4607 XSetWMHints(X->dpy, XtWindow(X->kframe), wmhints);
4615 ptr = DtStrchr (v->workspaces, ' ');
4617 if (ptr != NULL) *ptr = NULL;
4619 workspace_atoms = (Atom *) XtRealloc ((char *)workspace_atoms,
4620 sizeof (Atom) * (num_workspaces + 1));
4622 workspace_atoms[num_workspaces] =
4623 XmInternAtom (X->dpy, v->workspaces, True);
4630 v->workspaces = ptr + 1;
4632 } while (ptr != NULL);
4634 DtWsmSetWorkspacesOccupied (X->dpy, XtWindow (X->kframe),
4635 workspace_atoms, num_workspaces);
4637 XtFree ((char *) workspace_atoms);
4642 TimerEvent( client_data, id )
4643 XtPointer client_data;
4648 ignore_event = False;
4652 XtSetArg (args[0], XmNdefaultButton, X->CFpi_butOK);
4653 XtSetValues (X->CFframe, args, 1);
4658 #ifdef HP_EXTENSIONS
4662 XHPDeviceList *list, *slist;
4663 int ndevices = 0, i, kbd = 0;
4665 slist = XHPListInputDevices(X->dpy, &ndevices);
4666 for (i = 0, list = slist; i < ndevices; i++, list++)
4668 if (list->type != KEYBOARD && strcmp(list->name, PS2_DIN_NAME))
4670 if (list->detailed_id & (HP_ITF_KBD | HP_HIL) == (HP_ITF_KBD | HP_HIL))
4675 else if (list->detailed_id & (PC101_KBD|HP_HIL) == (PC101_KBD|HP_HIL))
4677 kbd = HIL_PC101_KBD;
4680 else if (list->detailed_id & (PC101_KBD|SERIAL) == (PC101_KBD|SERIAL))
4682 kbd = SERIAL_PC101_KBD;
4688 if (strcmp(list->name, PS2_DIN_NAME) == 0)
4690 kbd = SERIAL_PC101_KBD;
4693 else if (list->hil_id >= FIRST_HIL_KBD &&
4694 list->hil_id <= LAST_HIL_KBD)
4696 if (list->io_byte & LED_BITS)
4698 kbd = HIL_PC101_KBD;
4709 XHPFreeDeviceList (slist);
4715 _DtcalcStripSpaces(file)
4723 for (i = 0; i < strlen(file); i++)
4725 if (isspace(file[i]))
4727 for(j = i; file[j] != NULL; j++)
4728 file[j] = file[j + 1];