cde/programs/dtstyle/Mouse.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /************************************<+>*************************************
  24  ****************************************************************************
  25  **
  26  **   File:        Mouse.c
  27  **
  28  **   Project:     DT 3.0
  29  **
  30  **   Description: Controls the Dtstyle Mouse dialog
  31  **
  32  **
  33  **  (c) Copyright Hewlett-Packard Company, 1990.
  34  **
  35  **
  36  **
  37  ****************************************************************************
  38  ************************************<+>*************************************/
  39 /*$XConsortium: Mouse.c /main/5 1996/07/19 13:45:42 pascale $*/
  40
  41 #include <X11/Xlib.h>
  42
  43 #include <Xm/Xm.h>
  44 #include <Xm/Form.h>
  45 #include <Xm/Frame.h>
  46 #include <Xm/LabelG.h>
  47 #include <Xm/MwmUtil.h>
  48 #include <Xm/MessageB.h>
  49 #include <Xm/PushB.h>
  50 #include <Xm/PushBG.h>
  51 #include <Xm/RowColumn.h>
  52 #include <Xm/Scale.h>
  53 #include <Xm/ToggleBG.h>
  54 #include <Xm/VendorSEP.h>
  55
  56 #include <Dt/DialogBox.h>
  57 #include <Dt/Message.h>
  58 #include <Dt/SessionM.h>
  59 #include <Dt/HourGlass.h>
  60 #include <Dt/UserMsg.h>
  61
  62 #include "Help.h"
  63 #include "Main.h"
  64 #include "SaveRestore.h"
  65
  66 /*+++++++++++++++++++++++++++++++++++++++*/
  67 /* include extern functions              */
  68 /*+++++++++++++++++++++++++++++++++++++++*/
  69 #include "Mouse.h"
  70
  71 /*+++++++++++++++++++++++++++++++++++++++*/
  72 /* Local #defines                        */
  73 /*+++++++++++++++++++++++++++++++++++++++*/
  74 #define ACCEL_MIN        0
  75 #define ACCEL_MAX        10
  76 #define THRESH_MIN       0
  77 #define THRESH_MAX       15
  78 #define THRESHDEFAULT    10
  79 #define DCLICK_MIN       0
  80 #define DCLICK_MAX       10
  81 #define POINTER2B        0
  82 #define POINTER3B        1
  83 #define DCLICKDEFAULT    500
  84 #define RIGHT_HANDED     0
  85 #define LEFT_HANDED      1
  86 #define TRANSFER         0
  87 #define ADJUST           1
  88
  89
  90 #define LEFTMSG ((char *)GETMESSAGE(9, 1, "Left"))
  91 #define RIGHTMSG ((char *)GETMESSAGE(9, 2, "Right"))
  92 #define HANDMSG ((char *)GETMESSAGE(9, 3, "Handedness:"))
  93 #define MIDDLEMSG ((char *)GETMESSAGE(9, 4, "Button 2:"))
  94 #define MSG3  ((char *)GETMESSAGE(9, 10, "ERROR: setting pointer mapping\n"))
  95 #define TRANSMSG ((char *)GETMESSAGE(9, 11, "Transfer"))
  96 #define ADJMSG ((char *)GETMESSAGE(9, 12, "Adjust"))
  97 #define WARN_MSG  ((char *)GETMESSAGE(9, 13, "The right and left mouse buttons will swap\n\
  98 functions immediately after you click on OK.\n\
  99 The `Test Double-Click' graphic in the Mouse\n\
 100 window shows the current handedness by the \n\
 101 positions of Button 1 and Button 3."))
 102 #define MID_WARN_MSG_T  ((char *)GETMESSAGE(9, 14, "If you click on OK, mouse button 2 will be set\n\
 103 to `transfer' (drag) at your next session."))
 104 #define IMMEDIATE_MSG  ((char *)GETMESSAGE(9, 15, "The new double-click time will take effect\n\
 105 as applications are restarted."))
 106 #define  LATER_MSG  ((char *)GETMESSAGE(9, 16, "The new double-click time will take effect\n\
 107 at your next session."))
 108 #define MID_WARN_MSG_A  ((char *)GETMESSAGE(9, 19, "If you click on OK, mouse button 2 will be set\n\
 109 to `adjust' at your next session. Button 2 may\n\
 110 be used to adjust text and list selections.\n\
 111 Transfer actions (drag) on text and lists will\n\
 112 require the use of Button 1."))
 113 #define MENUMSG ((char *)GETMESSAGE(9, 20, "Menu"))
 114
 115 #define B2              "Dtms2B.bm"
 116 #define B2_REV          "Dtms2BR.bm"
 117 #define B3              "Dtms3B.bm"
 118 #define B3_REV          "Dtms3BR.bm"
 119
 120 static char *multiClickTimeString = "*multiClickTime:%d\n";
 121 static char *enableBtn1TransferString = "*enableBtn1Transfer:%s\n";
 122 static char *mouseString = "Mouse";
 123
 124 /*+++++++++++++++++++++++++++++++++++++++*/
 125 /* Internal Functions                    */
 126 /*+++++++++++++++++++++++++++++++++++++++*/
 127
 128 static Widget build_mouseDialog(
 129                         Widget shell) ;
 130 static void formLayoutCB(
 131                         Widget w,
 132                         XtPointer client_data,
 133                         XtPointer call_data) ;
 134 static void _DtmapCB_mouseDialog(
 135                         Widget w,
 136                         XtPointer client_data,
 137                         XtPointer call_data) ;
 138 static int getValue(
 139                         Widget w) ;
 140 static void valueChangedCB(
 141                         Widget w,
 142                         XtPointer client_data,
 143                         XtPointer call_data) ;
 144 static void dclickVCCB(
 145                         Widget w,
 146                         XtPointer client_data,
 147                         XtPointer call_data) ;
 148 static void dclickTestCB(
 149                         Widget w,
 150                         XtPointer client_data,
 151                         XtPointer call_data) ;
 152 static void reverseToggleCB(
 153                         Widget w,
 154                         XtPointer client_data,
 155                         XtPointer call_data) ;
 156 static void midreverseToggleCB(
 157                         Widget w,
 158                         XtPointer client_data,
 159                         XtPointer call_data) ;
 160 static void warnToggleCB(
 161                         Widget w,
 162                         XtPointer client_data,
 163                         XtPointer call_data) ;
 164 static void midwarnToggleCB(
 165                         Widget w,
 166                         XtPointer client_data,
 167                         XtPointer call_data) ;
 168 static void cancelWarnCB(
 169                         Widget w,
 170                         XtPointer client_data,
 171                         XtPointer call_data) ;
 172 static void midcancelWarnCB(
 173                         Widget w,
 174                         XtPointer client_data,
 175                         XtPointer call_data) ;
 176 static void systemDefaultCB(
 177                         Widget w,
 178                         XtPointer client_data,
 179                         XtPointer call_data) ;
 180 static void ButtonCB(
 181                         Widget w,
 182                         XtPointer client_data,
 183                         XtPointer call_data) ;
 184
 185
 186 /*+++++++++++++++++++++++++++++++++++++++*/
 187 /* Internal Variables                    */
 188 /*+++++++++++++++++++++++++++++++++++++++*/
 189
 190 typedef struct {
 191     Widget      pictFrame;
 192     Widget      pictRC;
 193     Widget      pictButton;
 194     Widget      pictLabel;
 195     Widget      handLabGad;
 196     Widget      rightToggle;
 197     Widget      leftToggle;
 198     Widget      middleLabGad;
 199     Widget      transferToggle;
 200     Widget      adjustToggle;
 201     Widget      systemDefault;
 202     Widget      accelLabGad;
 203     Widget      threshLabGad;
 204     Widget      dclickLabGad;
 205     Widget      accelScale;
 206     Widget      threshScale;
 207     Widget      dclickScale;
 208     Pixmap      pixmap;
 209     Pixmap      b3;
 210     Pixmap      b3_rev;
 211     Pixmap      b2;
 212     Pixmap      b2_rev;
 213     Pixmap      pixmapSel;
 214     Pixmap      b3Sel;
 215     Pixmap      b3_revSel;
 216     Pixmap      b2Sel;
 217     Pixmap      b2_revSel;
 218     int         type;
 219     int         numButtons;
 220     int         accel_numerator;
 221     int         accel_denominator;
 222     int         threshold;
 223     Boolean     dclickChanged;
 224     Boolean     btn2Changed;
 225     XtIntervalId     timeID;
 226     int         mydclick;
 227     Boolean     systemDefaultFlag;
 228     unsigned char map_return[256];
 229     unsigned char new_map_return[256];
 230     Boolean     origHanded;
 231     Boolean     handed;
 232     Boolean     function;
 233     Boolean     origFunction;
 234 } Mouse;
 235
 236 static Widget warnDialog;
 237 static Widget midwarnDialog;
 238
 239 static Mouse mouse;
 240 static saveRestore save = {FALSE, 0, };
 241
 242
 243 /*+++++++++++++++++++++++++++++++++++++++*/
 244 /* popup_mouseBB                         */
 245 /*+++++++++++++++++++++++++++++++++++++++*/
 246
 247 void
 248 popup_mouseBB( Widget shell )
 249 {
 250     if (style.mouseDialog == NULL) {
 251         _DtTurnOnHourGlass(shell);
 252         build_mouseDialog(shell);
 253         mouse.systemDefaultFlag = True;
 254         mouse.dclickChanged = False;
 255         mouse.btn2Changed = False;
 256         XtManageChild(style.mouseDialog);
 257         _DtTurnOffHourGlass(shell);
 258     }
 259     else
 260     {
 261         XtManageChild(style.mouseDialog);
 262         raiseWindow(XtWindow(XtParent(style.mouseDialog)));
 263     }
 264 }
 265
 266 /*+++++++++++++++++++++++++++++++++++++++*/
 267 /* build__mouseDialog                    */
 268 /*+++++++++++++++++++++++++++++++++++++++*/
 269 static Widget
 270 build_mouseDialog( Widget shell )
 271 {
 272     register int     i, n;
 273     Arg              args[MAX_ARGS];
 274     int              nmap;
 275     XmString         button_string[NUM_LABELS];
 276     Widget           form;
 277     int              count = 0;
 278     Widget           widget_list[15];
 279     XmString         string;
 280
 281     Dimension        MaxLabelWidth1;
 282     Dimension        HandLabelWidth;
 283     Dimension        MiddleLabelWidth;
 284     Dimension        MaxToggleWidth;
 285     Dimension        RightToggleWidth;
 286     Dimension        TransferToggleWidth;
 287
 288     XrmDatabase database;
 289     char *str_name;
 290     char *str_class;
 291     char **str_type_return;
 292     XrmValue value_return;
 293
 294     /* check hil device# for 2 or 3 button mouse      */
 295     /* IMPORTANT NOTE:                                */
 296     /* X servers will return different values for     */
 297     /* mouse.numButtons in the call below.            */
 298     /* The HP X server will return 5 if a quarted     */
 299     /* threebutton mouse is present and a 3 if a      */
 300     /* quarted two-button mouse is present. The IBM   */
 301     /* does not support a two-button mouse.           */
 302     /* The cod ebelow always loads a three-button     */
 303     /* for IBM/Sun/HP unless a non-quarted two-button */
 304     /* mouse is present on the HP server.             */
 305     /* When porting this code to a non IBM/Sun/HP     */
 306     /* platform that has or supports a two-button     */
 307     /* mouse the code below may have to be changed to */
 308     /* take into account the behavior of the new      */
 309     /* server.                                        */
 310
 311     nmap = 256;
 312     mouse.numButtons = XGetPointerMapping(style.display, mouse.map_return,
 313                                            nmap);
 314     if ( mouse.numButtons == 2 )
 315           mouse.type = POINTER2B;
 316     else if  ( mouse.numButtons == 3 || mouse.numButtons == 5 )
 317         mouse.type = POINTER3B;
 318     else
 319         mouse.type = 99;
 320     /* choose a bitmap based on button mapping   *
 321      * and number of buttons                     */
 322
 323     if(mouse.type == POINTER3B)
 324     {
 325         mouse.b3     = XmGetPixmap(style.screen, B3,
 326                                  style.secBSCol, style.secTSCol);
 327         mouse.b3_rev = XmGetPixmap(style.screen, B3_REV,
 328                                  style.secBSCol, style.secTSCol);
 329         mouse.b3Sel  = XmGetPixmap(style.screen, B3,
 330                                  style.secTSCol, style.secBSCol );
 331         mouse.b3_revSel = XmGetPixmap(style.screen, B3_REV,
 332                                  style.secTSCol, style.secBSCol);
 333
 334         if(mouse.map_return[0] == 1)
 335         {
 336             mouse.pixmap = mouse.b3;
 337             mouse.pixmapSel = mouse.b3Sel;
 338         }
 339         else
 340         {
 341             mouse.pixmap = mouse.b3_rev;
 342             mouse.pixmapSel = mouse.b3_revSel;
 343         }
 344     }
 345     else /* 2 button mouse */
 346     {
 347         mouse.b2        = XmGetPixmap(style.screen, B2,
 348                              style.secBSCol, style.secTSCol);
 349         mouse.b2_rev    = XmGetPixmap(style.screen, B2_REV,
 350                             style.secBSCol, style.secTSCol);
 351         mouse.b2Sel     = XmGetPixmap(style.screen, B2,
 352                              style.secTSCol, style.secBSCol);
 353         mouse.b2_revSel = XmGetPixmap(style.screen, B2_REV,
 354                              style.secTSCol, style.secBSCol);
 355
 356         if(mouse.map_return[0] == 1)
 357         {
 358             mouse.pixmap = mouse.b2;
 359             mouse.pixmapSel = mouse.b2Sel;
 360         }
 361         else
 362         {
 363             mouse.pixmap = mouse.b2_rev;
 364             mouse.pixmapSel = mouse.b2_revSel;
 365         }
 366     }
 367
 368     /*Get the value of doubleclick*/
 369     mouse.mydclick = XtGetMultiClickTime(style.display);
 370     if (mouse.mydclick > 0)
 371       mouse.mydclick = mouse.mydclick/100;
 372     if (mouse.mydclick < 1)
 373       mouse.mydclick = 1;
 374
 375     /*Get the value of the enableBtn1Transfer resource */
 376     /*from the data base. */
 377
 378     str_name = "*enableBtn1Transfer";
 379     str_class = "*EnableBtn1Transfer";
 380
 381     database = XrmGetDatabase(style.display);
 382     if (!XrmGetResource(database, str_name, str_class, (char **)&str_type_return, &value_return))
 383       {
 384         mouse.function = TRANSFER;
 385         mouse.origFunction = TRANSFER;
 386       }
 387     else
 388       if (strcmp(value_return.addr, "True") == 0)
 389         {
 390           mouse.function = ADJUST;
 391           mouse.origFunction = ADJUST;
 392         }
 393       else
 394         {
 395           mouse.function = TRANSFER;
 396           mouse.origFunction = TRANSFER;
 397         }
 398
 399     /* Set up DialogBoxDialog button labels */
 400     button_string[0] = CMPSTR(_DtOkString);
 401     button_string[1] = CMPSTR(_DtCancelString);
 402     button_string[2] = CMPSTR(_DtHelpString);
 403
 404     /* Create toplevel DialogBox */
 405     /* saveRestore
 406      * Note that save.poscnt has been initialized elsewhere.
 407      * save.posArgs may contain information from restoreMouse().*/
 408
 409     XtSetArg(save.posArgs[save.poscnt], XmNbuttonCount, NUM_LABELS);
 410     save.poscnt++;
 411     XtSetArg(save.posArgs[save.poscnt], XmNbuttonLabelStrings, button_string);
 412     save.poscnt++;
 413     XtSetArg (save.posArgs[save.poscnt], XmNdefaultPosition, False);
 414     save.poscnt++;
 415     style.mouseDialog = __DtCreateDialogBoxDialog(shell, mouseString,
 416                    save.posArgs, save.poscnt);
 417     XtAddCallback(style.mouseDialog, XmNcallback, ButtonCB, NULL);
 418     XtAddCallback(style.mouseDialog, XmNhelpCallback,
 419             (XtCallbackProc)HelpRequestCB, (XtPointer)HELP_MOUSE_DIALOG);
 420
 421
 422     XmStringFree(button_string[0]);
 423     XmStringFree(button_string[1]);
 424     XmStringFree(button_string[2]);
 425
 426     widget_list[0] = _DtDialogBoxGetButton(style.mouseDialog,2);
 427     n=0;
 428     XtSetArg(args[n], XmNautoUnmanage, False); n++;
 429     XtSetArg(args[n], XmNcancelButton, widget_list[0]); n++;
 430     XtSetValues (style.mouseDialog, args, n);
 431
 432     n=0;
 433     XtSetArg(args[n], XmNtitle, ((char *)GETMESSAGE(9, 18, "Style Manager - Mouse"))); n++;
 434     XtSetArg (args[n], XmNuseAsyncGeometry, True); n++;
 435     XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC); n++;
 436     XtSetValues (XtParent(style.mouseDialog), args, n);
 437
 438     n = 0;
 439     XtSetArg(args[n], XmNhorizontalSpacing, style.horizontalSpacing); n++;
 440     XtSetArg(args[n], XmNverticalSpacing, style.verticalSpacing); n++;
 441     XtSetArg(args[n], XmNallowOverlap, False); n++;
 442     XtSetArg(args[n], XmNchildType, XmWORK_AREA);  n++;
 443     form = XmCreateForm(style.mouseDialog, "mouseForm", args, n);
 444
 445     n = 0;
 446     XtSetArg(args[n], XmNmarginHeight, LB_MARGIN_HEIGHT);  n++;
 447     XtSetArg(args[n], XmNmarginWidth, LB_MARGIN_WIDTH);  n++;
 448     string = CMPSTR(((char *)GETMESSAGE(9, 5, "Default")));
 449     XtSetArg(args[n], XmNlabelString, string); n++;
 450     widget_list[count++] =
 451     mouse.systemDefault= XmCreatePushButtonGadget(form, "systemDefault", args, n);
 452     XmStringFree(string);
 453
 454     n = 0;
 455     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
 456     widget_list[count++] =
 457     mouse.pictFrame= XmCreateFrame(form, "pictFrame", args, n);
 458
 459     n = 0;
 460     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
 461     XtSetArg(args[n], XmNadjustMargin, False); n++;
 462     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_BEGINNING); n++;
 463     mouse.pictRC = XmCreateRowColumn(mouse.pictFrame, "pictRC", args, n);
 464
 465     n = 0;
 466     XtSetArg(args[n], XmNlabelType, XmPIXMAP); n++;
 467     XtSetArg(args[n], XmNlabelPixmap, mouse.pixmap); n++;
 468     XtSetArg(args[n], XmNrecomputeSize, False); n++;
 469     XtSetArg(args[n], XmNmarginWidth, 0); n++;
 470     XtSetArg(args[n], XmNmarginHeight, 0); n++;
 471     XtSetArg(args[n], XmNshadowThickness, 0); n++;
 472     XtSetArg(args[n], XmNmultiClick, XmMULTICLICK_KEEP); n++;
 473     mouse.pictButton= XmCreatePushButton(mouse.pictRC, "mousePict", args, n);
 474
 475     n = 0;
 476     string = CMPSTR ((char *)GETMESSAGE(9, 17, "Test\nDouble-Click"));
 477     XtSetArg(args[n], XmNlabelString, string); n++;
 478     mouse.pictLabel= XmCreateLabelGadget(mouse.pictRC, "mouseLabel", args, n);
 479     XmStringFree(string);
 480
 481     n = 0;
 482     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 483     XtSetArg(args[n], XmNmarginHeight, 0); n++;
 484     string = CMPSTR(HANDMSG);
 485     XtSetArg(args[n], XmNlabelString, string); n++;
 486     widget_list[count++] =
 487     mouse.handLabGad= XmCreateLabelGadget(form,"handLabGad", args, n);
 488     XmStringFree(string);
 489
 490     n=0;
 491     string = CMPSTR(RIGHTMSG);
 492     XtSetArg(args[n], XmNlabelString, string); n++;
 493     XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
 494     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
 495     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 496     mouse.rightToggle= XmCreateToggleButtonGadget(form,
 497                    "rightToggle", args, n);
 498     XmStringFree(string);
 499
 500     n=0;
 501     string = CMPSTR(LEFTMSG);
 502     XtSetArg(args[n], XmNlabelString, string); n++;
 503     XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
 504     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
 505     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 506     mouse.leftToggle= XmCreateToggleButtonGadget(form,
 507                   "leftToggle", args, n);
 508     XmStringFree(string);
 509
 510
 511     n = 0;
 512     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 513     XtSetArg(args[n], XmNmarginHeight, 0); n++;
 514     string = CMPSTR(MIDDLEMSG);
 515     XtSetArg(args[n], XmNlabelString, string); n++;
 516     widget_list[count++] =
 517     mouse.middleLabGad= XmCreateLabelGadget(form,"middleLabGad", args, n);
 518     XmStringFree(string);
 519
 520     n=0;
 521     string = CMPSTR(TRANSMSG);
 522     XtSetArg(args[n], XmNlabelString, string); n++;
 523     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
 524     XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
 525     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 526     mouse.transferToggle= XmCreateToggleButtonGadget(form,
 527                    "transToggle", args, n);
 528     XmStringFree(string);
 529
 530     n=0;
 531     string = CMPSTR(ADJMSG);
 532     XtSetArg(args[n], XmNlabelString, string); n++;
 533     XtSetArg(args[n], XmNnavigationType, XmTAB_GROUP); n++;
 534     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
 535     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 536     mouse.adjustToggle= XmCreateToggleButtonGadget(form,
 537                   "adjToggle", args, n);
 538     XmStringFree(string);
 539
 540     n = 0;
 541     XtSetArg(args[n], XmNalignment, XmALIGNMENT_END); n++;
 542     XtSetArg(args[n], XmNmarginHeight, 0); n++;
 543     string = CMPSTR(((char *)GETMESSAGE(9, 6, "Double-Click")));
 544     XtSetArg(args[n], XmNlabelString, string); n++;
 545     widget_list[count++] =
 546     mouse.dclickLabGad= XmCreateLabelGadget(form,"dclickLabGad", args, n);
 547     XmStringFree(string);
 548
 549     n = 0;
 550     XtSetArg(args[n], XmNmaximum, DCLICK_MAX); n++;
 551     XtSetArg(args[n], XmNminimum, DCLICK_MIN); n++;
 552     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
 553     XtSetArg(args[n], XmNprocessingDirection, XmMAX_ON_RIGHT); n++;
 554     XtSetArg(args[n], XmNhighlightThickness, SCALE_HIGHLIGHT_THICKNESS);  n++;
 555     XtSetArg(args[n], XmNshowValue, True); n++;
 556     XtSetArg(args[n], XmNvalue, mouse.mydclick); n++;
 557     XtSetArg(args[n], XmNdecimalPoints, (short)1); n++;
 558     widget_list[count++] =
 559     mouse.dclickScale= XmCreateScale(form,"dclickScale", args, n);
 560
 561     n = 0;
 562     XtSetArg(args[n], XmNalignment, XmALIGNMENT_END); n++;
 563     XtSetArg(args[n], XmNmarginHeight, 0); n++;
 564     string = CMPSTR(((char *)GETMESSAGE(9, 8, "Acceleration")));
 565     XtSetArg(args[n], XmNlabelString, string); n++;
 566     widget_list[count++] =
 567     mouse.accelLabGad= XmCreateLabelGadget(form,"accelLabGad", args, n);
 568     XmStringFree(string);
 569
 570     n = 0;
 571     XtSetArg(args[n], XmNminimum, ACCEL_MIN); n++;
 572     XtSetArg(args[n], XmNmaximum, ACCEL_MAX); n++;
 573     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
 574     XtSetArg(args[n], XmNprocessingDirection, XmMAX_ON_RIGHT); n++;
 575     XtSetArg(args[n], XmNhighlightThickness, SCALE_HIGHLIGHT_THICKNESS);  n++;
 576     XtSetArg(args[n], XmNshowValue, True); n++;
 577     widget_list[count++] =
 578     mouse.accelScale= XmCreateScale(form,"accelScale", args, n);
 579
 580     n = 0;
 581     XtSetArg(args[n], XmNalignment, XmALIGNMENT_END); n++;
 582     XtSetArg(args[n], XmNmarginHeight, 0); n++;
 583     string = CMPSTR(((char *)GETMESSAGE(9, 9, "Threshold")));
 584     XtSetArg(args[n], XmNlabelString, string); n++;
 585     widget_list[count++] =
 586     mouse.threshLabGad= XmCreateLabelGadget(form,"threshLabGad", args, n);
 587     XmStringFree(string);
 588
 589     n = 0;
 590     XtSetArg(args[n], XmNminimum, THRESH_MIN); n++;
 591     XtSetArg(args[n], XmNmaximum, THRESH_MAX); n++;
 592     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
 593     XtSetArg(args[n], XmNprocessingDirection, XmMAX_ON_RIGHT); n++;
 594     XtSetArg(args[n], XmNhighlightThickness, SCALE_HIGHLIGHT_THICKNESS);  n++;
 595     XtSetArg(args[n], XmNshowValue, True); n++;
 596     widget_list[count++] =
 597     mouse.threshScale= XmCreateScale(form,"threshScale", args, n);
 598
 599     XtAddCallback(style.mouseDialog, XmNmapCallback, formLayoutCB, NULL);
 600     XtAddCallback(style.mouseDialog, XmNmapCallback, _DtmapCB_mouseDialog, shell);
 601     XtAddCallback(mouse.systemDefault, XmNactivateCallback,
 602                   systemDefaultCB, NULL);
 603
 604     /* calculate the max width for toggles for the overall alignment */
 605     /* Set labels to max label width */
 606
 607     MaxLabelWidth1 = HandLabelWidth = XtWidth(mouse.handLabGad);
 608     MiddleLabelWidth = XtWidth(mouse.middleLabGad);
 609     if (MiddleLabelWidth > MaxLabelWidth1)
 610     {
 611         MaxLabelWidth1 = MiddleLabelWidth;
 612     }
 613
 614     MaxToggleWidth = RightToggleWidth = XtWidth(mouse.rightToggle);
 615     TransferToggleWidth = XtWidth(mouse.transferToggle);
 616     if (TransferToggleWidth > MaxToggleWidth)
 617     {
 618         MaxToggleWidth = TransferToggleWidth;
 619     }
 620
 621
 622     if (mouse.function == TRANSFER)
 623       {
 624         XmToggleButtonGadgetSetState(mouse.transferToggle, True, True);
 625         XmToggleButtonGadgetSetState(mouse.adjustToggle, False, False);
 626       }
 627     else
 628       {
 629         XmToggleButtonGadgetSetState(mouse.adjustToggle, True, True);
 630         XmToggleButtonGadgetSetState(mouse.transferToggle, False, False);
 631       }
 632
 633     XtVaSetValues(mouse.handLabGad, XmNwidth, MaxLabelWidth1, NULL);
 634     XtVaSetValues(mouse.middleLabGad, XmNwidth, MaxLabelWidth1, NULL);
 635
 636     XtVaSetValues(mouse.rightToggle, XmNwidth, MaxToggleWidth, NULL);
 637     XtVaSetValues(mouse.transferToggle, XmNwidth, MaxToggleWidth, NULL);
 638
 639     XtAddCallback(mouse.rightToggle, XmNvalueChangedCallback,
 640                   warnToggleCB, (XtPointer)RIGHT_HANDED);
 641
 642     XtAddCallback(mouse.leftToggle, XmNvalueChangedCallback,
 643                   warnToggleCB, (XtPointer)LEFT_HANDED);
 644
 645     XtAddCallback(mouse.transferToggle, XmNvalueChangedCallback,
 646                   midwarnToggleCB, (XtPointer)TRANSFER);
 647
 648     XtAddCallback(mouse.adjustToggle, XmNvalueChangedCallback,
 649                   midwarnToggleCB, (XtPointer)ADJUST);
 650
 651     XtAddCallback(mouse.accelScale, XmNvalueChangedCallback,
 652                   valueChangedCB, NULL);
 653
 654     XtAddCallback(mouse.threshScale, XmNvalueChangedCallback,
 655                   valueChangedCB, NULL);
 656     XtAddCallback(mouse.dclickScale, XmNvalueChangedCallback,
 657                   dclickVCCB, (caddr_t)mouse.pictButton);
 658     XtAddCallback(mouse.pictButton, XmNactivateCallback,
 659                   dclickTestCB, NULL);
 660
 661     XtManageChild(form);
 662     XtManageChildren(widget_list,count);
 663     XtManageChild(mouse.pictRC);
 664     XtManageChild(mouse.pictButton);
 665     XtManageChild(mouse.pictLabel);
 666     XtManageChild(mouse.rightToggle);
 667     XtManageChild(mouse.leftToggle);
 668
 669     /*
 670      * If there are only two mouse buttons then switch the
 671      * label for the transferToggle to "Menu" and mark it
 672      * insensitive but checked.
 673      * Otherwise manage both the transfer and adjust toggles.
 674      */
 675     if (mouse.numButtons == 2) {
 676         n=0;
 677         string = CMPSTR(MENUMSG);
 678         XtSetArg(args[n], XmNlabelString, string); n++;
 679         XtSetValues(mouse.transferToggle, args, n);
 680         XmStringFree(string);
 681         XmToggleButtonGadgetSetState(mouse.transferToggle, True, False);
 682         XtManageChild(mouse.transferToggle);
 683     } else {
 684         XtManageChild(mouse.transferToggle);
 685         XtManageChild(mouse.adjustToggle);
 686     }
 687
 688     return(style.mouseDialog);
 689 }
 690
 691
 692 /*+++++++++++++++++++++++++++++++++++++++*/
 693 /* formLayoutCB                          */
 694 /*+++++++++++++++++++++++++++++++++++++++*/
 695 static void
 696 formLayoutCB(
 697         Widget w,
 698         XtPointer client_data,
 699         XtPointer call_data )
 700 {
 701     int              n;
 702     Arg              args[MAX_ARGS];
 703     Dimension        MaxLabelWidth;
 704     Dimension        AccelLabelWidth;
 705     Dimension        ThreshLabelWidth;
 706     Dimension        DclickLabelWidth;
 707     Dimension        ScaleHeight;
 708     Dimension        LabelHeight;
 709     int              TopOffset;
 710     int              LeftOffset;
 711
 712     /* Do the scale and label attachments */
 713
 714     ScaleHeight = XtHeight(mouse.accelScale);
 715
 716     MaxLabelWidth = AccelLabelWidth = XtWidth(mouse.accelLabGad);
 717     LabelHeight = XtHeight(mouse.accelLabGad);
 718
 719     ThreshLabelWidth = XtWidth(mouse.threshLabGad);
 720     if (ThreshLabelWidth > MaxLabelWidth)
 721     {
 722         MaxLabelWidth = ThreshLabelWidth;
 723     }
 724
 725     DclickLabelWidth = XtWidth(mouse.dclickLabGad);
 726     if (DclickLabelWidth > MaxLabelWidth)
 727     {
 728         MaxLabelWidth = DclickLabelWidth;
 729     }
 730
 731     /* Mouse Picture PushButton */
 732     n=0;
 733     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);      n++;
 734     XtSetArg(args[n], XmNtopOffset,        style.verticalSpacing);   n++;
 735     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 736     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_FORM);      n++;
 737     XtSetArg(args[n], XmNleftOffset,       style.horizontalSpacing); n++;
 738     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_NONE);      n++;
 739     XtSetValues (mouse.pictFrame, args, n);
 740
 741
 742     /* System Default Button */
 743     n=0;
 744     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_FORM);      n++;
 745     XtSetArg(args[n], XmNtopOffset,        style.verticalSpacing);   n++;
 746     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 747     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_NONE);      n++;
 748     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_FORM);      n++;
 749     XtSetArg(args[n], XmNrightOffset,      style.horizontalSpacing); n++;
 750     XtSetValues (mouse.systemDefault, args, n);
 751
 752
 753     /*  Handedness Label */
 754     n=0;
 755     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_WIDGET);    n++;
 756     XtSetArg(args[n], XmNtopWidget,        mouse.systemDefault); n++;
 757     XtSetArg(args[n], XmNtopOffset,        4*style.verticalSpacing);   n++;
 758     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 759     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_WIDGET);    n++;
 760     XtSetArg(args[n], XmNleftWidget,       mouse.pictFrame);    n++;
 761     XtSetArg(args[n], XmNleftOffset,       2*style.horizontalSpacing); n++;
 762     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_NONE);    n++;
 763     XtSetValues (mouse.handLabGad, args, n);
 764
 765     /* right toggle */
 766     n=0;
 767     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_OPPOSITE_WIDGET);    n++;
 768     XtSetArg(args[n], XmNtopWidget,        mouse.handLabGad); n++;
 769     XtSetArg(args[n], XmNtopOffset,        -5);   n++;
 770     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 771     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_WIDGET);    n++;
 772     XtSetArg(args[n], XmNleftWidget,       mouse.handLabGad);    n++;
 773     XtSetArg(args[n], XmNleftOffset,       style.horizontalSpacing); n++;
 774     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_NONE);    n++;
 775     XtSetValues (mouse.rightToggle, args, n);
 776
 777     /* left toggle */
 778     n=0;
 779     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_OPPOSITE_WIDGET);    n++;
 780     XtSetArg(args[n], XmNtopWidget,        mouse.handLabGad); n++;
 781     XtSetArg(args[n], XmNtopOffset,        -5);   n++;
 782     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 783     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_WIDGET);    n++;
 784     XtSetArg(args[n], XmNleftWidget,       mouse.rightToggle);    n++;
 785     XtSetArg(args[n], XmNleftOffset,       style.horizontalSpacing); n++;
 786     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_FORM);    n++;
 787     XtSetValues (mouse.leftToggle, args, n);
 788
 789
 790     /*  Middle button Label */
 791     n=0;
 792     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_WIDGET);    n++;
 793     XtSetArg(args[n], XmNtopWidget,        mouse.handLabGad); n++;
 794     XtSetArg(args[n], XmNtopOffset,        3*style.verticalSpacing);   n++;
 795     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 796     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_WIDGET);    n++;
 797     XtSetArg(args[n], XmNleftWidget,       mouse.pictFrame);    n++;
 798     XtSetArg(args[n], XmNleftOffset,       2*style.horizontalSpacing); n++;
 799     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_NONE);    n++;
 800     XtSetValues (mouse.middleLabGad, args, n);
 801
 802
 803     /* transfer toggle */
 804     n=0;
 805     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_OPPOSITE_WIDGET);    n++;
 806     XtSetArg(args[n], XmNtopWidget,        mouse.middleLabGad); n++;
 807     XtSetArg(args[n], XmNtopOffset,        -5);   n++;
 808     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 809     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_OPPOSITE_WIDGET);    n++;
 810     XtSetArg(args[n], XmNleftWidget,       mouse.rightToggle);    n++;
 811     XtSetArg(args[n], XmNleftOffset,       0); n++;
 812     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_NONE);    n++;
 813     XtSetValues (mouse.transferToggle, args, n);
 814
 815     /* adjust toggle */
 816     n=0;
 817     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_OPPOSITE_WIDGET);    n++;
 818     XtSetArg(args[n], XmNtopWidget,        mouse.middleLabGad); n++;
 819     XtSetArg(args[n], XmNtopOffset,        -5);   n++;
 820     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 821     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_WIDGET);    n++;
 822     XtSetArg(args[n], XmNleftWidget,       mouse.transferToggle);    n++;
 823     XtSetArg(args[n], XmNleftOffset,       style.horizontalSpacing); n++;
 824     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_FORM);    n++;
 825     XtSetValues (mouse.adjustToggle, args, n);
 826
 827
 828
 829     TopOffset = ScaleHeight + style.verticalSpacing - LabelHeight;
 830
 831     /* DoubleClick Label */
 832     n=0;
 833     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_WIDGET);    n++;
 834     XtSetArg(args[n], XmNtopWidget,        mouse.pictFrame) ;   n++;
 835     XtSetArg(args[n], XmNtopOffset,        TopOffset);          n++;
 836     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 837     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_FORM);      n++;
 838     LeftOffset =  MaxLabelWidth + style.horizontalSpacing - DclickLabelWidth;
 839     XtSetArg(args[n], XmNleftOffset,       LeftOffset);         n++;
 840     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_NONE);      n++;
 841     XtSetValues (mouse.dclickLabGad, args, n);
 842
 843     /* DoubleClick Scale */
 844     n=0;
 845     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_NONE);      n++;
 846     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 847     XtSetArg(args[n], XmNbottomWidget,     mouse.dclickLabGad); n++;
 848     XtSetArg(args[n], XmNbottomOffset,     0);                  n++;
 849     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_WIDGET);    n++;
 850     XtSetArg(args[n], XmNleftWidget,       mouse.dclickLabGad); n++;
 851     XtSetArg(args[n], XmNleftOffset,       2*style.horizontalSpacing); n++;
 852     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_FORM);      n++;
 853     XtSetValues (mouse.dclickScale, args, n);
 854
 855     /* Acceleration Label */
 856     n=0;
 857     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_WIDGET);    n++;
 858     XtSetArg(args[n], XmNtopWidget,        mouse.dclickLabGad); n++;
 859     XtSetArg(args[n], XmNtopOffset,        TopOffset);          n++;
 860     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE);      n++;
 861     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_FORM);      n++;
 862     LeftOffset =  MaxLabelWidth + style.horizontalSpacing - AccelLabelWidth;
 863     XtSetArg(args[n], XmNleftOffset,       LeftOffset);         n++;
 864     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_NONE);      n++;
 865     XtSetValues (mouse.accelLabGad, args, n);
 866
 867     /* Acceleration Scale */
 868     n=0;
 869     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_NONE);      n++;
 870     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 871     XtSetArg(args[n], XmNbottomWidget,     mouse.accelLabGad);  n++;
 872     XtSetArg(args[n], XmNbottomOffset,     0);                  n++;
 873     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_WIDGET);    n++;
 874     XtSetArg(args[n], XmNleftWidget,       mouse.accelLabGad);  n++;
 875     XtSetArg(args[n], XmNleftOffset,       2*style.horizontalSpacing); n++;
 876     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_FORM);      n++;
 877     XtSetValues (mouse.accelScale, args, n);
 878
 879     /* Threshold Label */
 880     n=0;
 881     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_WIDGET);    n++;
 882     XtSetArg(args[n], XmNtopWidget,        mouse.accelScale);   n++;
 883     XtSetArg(args[n], XmNtopOffset,        TopOffset);          n++;
 884     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 885     XtSetArg(args[n], XmNbottomOffset,     style.verticalSpacing);   n++;
 886     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_FORM);      n++;
 887     LeftOffset =  MaxLabelWidth + style.horizontalSpacing - ThreshLabelWidth;
 888     XtSetArg(args[n], XmNleftOffset,       LeftOffset);         n++;
 889     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_NONE);      n++;
 890     XtSetValues (mouse.threshLabGad, args, n);
 891
 892     /* Threshold Scale */
 893     n=0;
 894     XtSetArg(args[n], XmNtopAttachment,    XmATTACH_NONE);      n++;
 895     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 896     XtSetArg(args[n], XmNbottomWidget,     mouse.threshLabGad); n++;
 897     XtSetArg(args[n], XmNbottomOffset,     0);                  n++;
 898     XtSetArg(args[n], XmNleftAttachment,   XmATTACH_WIDGET);    n++;
 899     XtSetArg(args[n], XmNleftWidget,       mouse.threshLabGad); n++;
 900     XtSetArg(args[n], XmNleftOffset,       2*style.horizontalSpacing); n++;
 901     XtSetArg(args[n], XmNrightAttachment,  XmATTACH_FORM);      n++;
 902     XtSetValues (mouse.threshScale, args, n);
 903
 904     XtRemoveCallback(style.mouseDialog, XmNmapCallback, formLayoutCB, NULL);
 905
 906 }
 907
 908 /*+++++++++++++++++++++++++++++++++++++++*/
 909 /* _DtmapCB_mouseDialog                     */
 910 /*+++++++++++++++++++++++++++++++++++++++*/
 911 static void
 912 _DtmapCB_mouseDialog(
 913         Widget w,
 914         XtPointer client_data,
 915         XtPointer call_data )
 916 {
 917     int         n;
 918     int         i;
 919     int         nmap;
 920     Arg         args[MAX_ARGS];
 921     static int  first_time = 1;
 922
 923     if (first_time)
 924     {
 925         DtWsmRemoveWorkspaceFunctions(style.display, XtWindow(XtParent(w)));
 926
 927         if (!save.restoreFlag)
 928             putDialog((Widget)client_data, w);
 929
 930         first_time = 0;
 931     }
 932     else
 933     {
 934         /* Don't need to do XGetPointerMapping first time dialog
 935          * is mapped because it is done when dialog is created
 936          * The type of device will not change between remapping
 937          */
 938         nmap = 256;
 939         mouse.numButtons = XGetPointerMapping(style.display,
 940                                 mouse.map_return, nmap);
 941     }
 942
 943     /* save mouse mapping values */
 944     for (i=0; i<mouse.numButtons; i++)
 945         mouse.new_map_return[i] = mouse.map_return[i];
 946
 947     /* change Pointer Mapping */
 948     /* the ReverseToggleCB will set the correct Pixmap */
 949     if (mouse.map_return[0] == 1)  /* right-handed */
 950     {
 951         mouse.handed = RIGHT_HANDED;
 952         mouse.origHanded = RIGHT_HANDED;
 953         XmToggleButtonGadgetSetState(mouse.rightToggle, True, True);
 954         XmToggleButtonGadgetSetState(mouse.leftToggle, False, False);
 955     }
 956     else  /* left-handed */
 957     {
 958         mouse.handed = LEFT_HANDED;
 959         mouse.origHanded = LEFT_HANDED;
 960         XmToggleButtonGadgetSetState(mouse.leftToggle, True, True);
 961         XmToggleButtonGadgetSetState(mouse.rightToggle, False, False);
 962     }
 963
 964     /* MultiClickTime will not change between remapping */
 965
 966     XGetPointerControl(style.display, &mouse.accel_numerator,
 967                 &mouse.accel_denominator, &mouse.threshold);
 968     n=0;
 969     XtSetArg(args[n], XmNvalue,mouse.accel_numerator); n++;
 970     XtSetValues(mouse.accelScale, args, n);
 971
 972     n=0;
 973     XtSetArg(args[n], XmNvalue,mouse.threshold); n++;
 974     XtSetValues(mouse.threshScale, args, n);
 975
 976
 977 }
 978
 979 static int
 980 getValue(
 981         Widget w )
 982 {
 983     int n, value;
 984     Arg args[1];
 985
 986     n=0;
 987     XtSetArg(args[n], XmNvalue, &value); n++;
 988     XtGetValues(w, args, n);
 989     return(value);
 990 }
 991
 992
 993 /*+++++++++++++++++++++++++++++++++++++++*/
 994 /* valueChangedCB                        */
 995 /*+++++++++++++++++++++++++++++++++++++++*/
 996 static void
 997 valueChangedCB(
 998         Widget w,
 999         XtPointer client_data,
1000         XtPointer call_data )
1001 {
1002
1003     int     new_acceln, new_acceld, new_thresh;
1004
1005      /* set mouse parameters to new scale values */
1006      new_acceld = 1;
1007      new_acceln = getValue(mouse.accelScale);
1008      new_thresh = getValue(mouse.threshScale);
1009
1010      XChangePointerControl(style.display, True, True, new_acceln,
1011                          new_acceld, new_thresh);
1012
1013      mouse.systemDefaultFlag = False;
1014
1015 }
1016
1017 /*+++++++++++++++++++++++++++++++++++++++*/
1018 /* dclickVCCB                            */
1019 /*+++++++++++++++++++++++++++++++++++++++*/
1020 static void
1021 dclickVCCB(
1022         Widget w,
1023         XtPointer client_data,
1024         XtPointer call_data )
1025 {
1026   XmScaleCallbackStruct *cb = (XmScaleCallbackStruct *) call_data;
1027
1028   mouse.dclickChanged = True;
1029   XtSetMultiClickTime (style.display, (cb->value)*100);
1030 }
1031
1032 /*+++++++++++++++++++++++++++++++++++++++*/
1033 /* dclickTestCB                          */
1034 /*+++++++++++++++++++++++++++++++++++++++*/
1035 static void
1036 dclickTestCB(
1037         Widget w,
1038         XtPointer client_data,
1039         XtPointer call_data )
1040 {
1041     Arg  color[3], args[10];       /*  arg list            */
1042     register int    n;             /*  arg count           */
1043     XmPushButtonCallbackStruct *cb = (XmPushButtonCallbackStruct *)call_data;
1044     static int selectstate = False;
1045
1046     if (cb->event->xbutton.button == 1)
1047     {
1048         if(cb->click_count == 2)
1049         {
1050             if (selectstate)
1051             {
1052                 n=0;
1053                 XtSetArg(color[n], XmNlabelPixmap, mouse.pixmap); n++;
1054                 XtSetValues (w, color, n);
1055
1056                 if (style.useMultiColorIcons)
1057                 {
1058                     n=0;
1059                     XtSetArg(color[n], XmNbackground, style.secBgCol); n++;
1060                     XtSetValues (w, color, n);
1061                     XtSetValues (mouse.pictRC, color, n);
1062                     XtSetValues (mouse.pictLabel, color, n);
1063                 }
1064
1065                 selectstate = False;
1066             }
1067             else
1068             {
1069                 /* This will change the  background color to select color,
1070                    but it causes the pixmap to redraw if IT was changed.*/
1071
1072                 n=0;
1073                 XtSetArg(color[n], XmNlabelPixmap, mouse.pixmapSel); n++;
1074                 XtSetValues (w, color, n);
1075
1076                 if (style.useMultiColorIcons)
1077                 {
1078                     n=0;
1079                     XtSetArg(color[n], XmNbackground, style.secSelectColor); n++;
1080                     XtSetValues (w, color, n);
1081                     XtSetValues (mouse.pictRC, color, n);
1082                     XtSetValues (mouse.pictLabel, color, n);
1083                 }
1084
1085                 selectstate = True;
1086             }
1087         }
1088     }
1089 }
1090
1091
1092
1093
1094
1095 /*+++++++++++++++++++++++++++++++++++++++**/
1096 /* warnToggleCB - put up a warning dialog */
1097 /* about changing the handedness.         */
1098 /*+++++++++++++++++++++++++++++++++++++++**/
1099
1100 static void
1101 warnToggleCB(
1102         Widget w,
1103         XtPointer client_data,
1104         XtPointer call_data )
1105 {
1106
1107   register int     n;
1108   Arg              args[10];
1109   XmString         string;
1110   Boolean          set;
1111
1112
1113   if (w == mouse.leftToggle && mouse.handed == LEFT_HANDED)
1114     {
1115       XmToggleButtonGadgetSetState(mouse.leftToggle, True, False);
1116       return;
1117     }
1118   if (w == mouse.rightToggle && mouse.handed == RIGHT_HANDED)
1119     {
1120       XmToggleButtonGadgetSetState(mouse.rightToggle, True, False);
1121       return;
1122     }
1123   if (w == mouse.rightToggle)
1124     {
1125       XmToggleButtonGadgetSetState(mouse.leftToggle, False, False);
1126     }
1127   else
1128     {
1129       XmToggleButtonGadgetSetState(mouse.rightToggle, False, False);
1130     }
1131
1132   n = 0;
1133   XtSetArg(args[n], XmNokLabelString, CMPSTR(_DtOkString)); n++;
1134   XtSetArg(args[n], XmNcancelLabelString, CMPSTR(_DtCancelString)); n++;
1135   string = CMPSTR(WARN_MSG);
1136   XtSetArg(args[n], XmNmessageString, string); n++;
1137   XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC ); n++;
1138   XtSetArg(args[n], XmNborderWidth, 3); n++;
1139   XtSetArg(args[n], XmNdialogStyle, XmDIALOG_SYSTEM_MODAL); n++;
1140   XtSetArg(args[n], XmNdialogTitle, CMPSTR((char *)GETMESSAGE(2,2, "Notice"))); n++;
1141   warnDialog = XmCreateInformationDialog(style.shell, "WarnDialog", args, n);
1142   XmStringFree(string);
1143   XtUnmanageChild (XmMessageBoxGetChild(warnDialog, XmDIALOG_HELP_BUTTON));
1144   XtAddCallback(warnDialog, XmNokCallback, reverseToggleCB, client_data);
1145   XtAddCallback(warnDialog, XmNcancelCallback, cancelWarnCB, client_data);
1146   XtManageChild(warnDialog);
1147 }
1148
1149
1150 /*++++++++++++++++++++++++++++++++++++++++++**/
1151 /* midwarnToggleCB - put up a warning dialog */
1152 /* about changing the function of the middle */
1153 /* button.                                   */
1154 /*++++++++++++++++++++++++++++++++++++++++++**/
1155
1156 static void
1157 midwarnToggleCB(
1158         Widget w,
1159         XtPointer client_data,
1160         XtPointer call_data )
1161 {
1162
1163   register int     n;
1164   Arg              args[10];
1165   XmString         warnstring;
1166   Boolean          set;
1167
1168   if (w == mouse.adjustToggle && mouse.function == ADJUST)
1169     {
1170       XmToggleButtonGadgetSetState(mouse.adjustToggle, True, False);
1171       return;
1172     }
1173   if (w == mouse.transferToggle && mouse.function == TRANSFER)
1174     {
1175       XmToggleButtonGadgetSetState(mouse.transferToggle, True, False);
1176       return;
1177     }
1178
1179   n = 0;
1180   XtSetArg(args[n], XmNokLabelString, CMPSTR(_DtOkString)); n++;
1181   XtSetArg(args[n], XmNcancelLabelString, CMPSTR(_DtCancelString)); n++;
1182   XtSetArg(args[n], XmNborderWidth, 3); n++;
1183   XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC ); n++;
1184   XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
1185   XtSetArg(args[n], XmNdialogTitle, CMPSTR((char *)GETMESSAGE(2,2, "Notice"))); n++;
1186   midwarnDialog = XmCreateInformationDialog(style.shell, "MidWarnDialog", args, n);
1187
1188   XtUnmanageChild (XmMessageBoxGetChild(midwarnDialog, XmDIALOG_HELP_BUTTON));
1189
1190
1191   if ((Boolean)client_data == TRANSFER)
1192     {
1193       warnstring = CMPSTR(MID_WARN_MSG_T);
1194       XtVaSetValues(midwarnDialog, XmNmessageString, warnstring, NULL); n++;
1195
1196       XmToggleButtonGadgetSetState(mouse.adjustToggle, False, False);
1197     }
1198   else
1199     {
1200       warnstring = CMPSTR(MID_WARN_MSG_A);
1201       XtVaSetValues(midwarnDialog, XmNmessageString, warnstring, NULL); n++;
1202
1203       XmToggleButtonGadgetSetState(mouse.transferToggle, False, False);
1204     }
1205   XmStringFree(warnstring);
1206
1207
1208   XtAddCallback(midwarnDialog, XmNokCallback, midreverseToggleCB,
1209                 client_data);
1210   XtAddCallback(midwarnDialog, XmNcancelCallback, midcancelWarnCB,
1211                 client_data);
1212   XtManageChild(midwarnDialog);
1213 }
1214
1215 /*+++++++++++++++++++++++++++++++++++++++*/
1216 /* cancelWarnCB - callback for the      */
1217 /* cancel button of the warnDialog      */
1218 /*+++++++++++++++++++++++++++++++++++++++*/
1219
1220 static void
1221 cancelWarnCB(
1222         Widget w,
1223         XtPointer client_data,
1224         XtPointer call_data )
1225 {
1226
1227   register int     n;
1228   Arg              args[10];
1229   XmString         string;
1230
1231   if (mouse.handed == RIGHT_HANDED)
1232     {
1233       XmToggleButtonGadgetSetState(mouse.rightToggle, True, False);
1234       XmToggleButtonGadgetSetState(mouse.leftToggle, False, False);
1235     }
1236   else
1237     {
1238       XmToggleButtonGadgetSetState(mouse.leftToggle, True, False);
1239       XmToggleButtonGadgetSetState(mouse.rightToggle, False, False);
1240     }
1241   XtDestroyWidget(warnDialog);
1242 }
1243
1244 /*+++++++++++++++++++++++++++++++++++++++*/
1245 /* midcancelWarnCB - callback for the    */
1246 /* cancel button of the midwarnDialog    */
1247 /*+++++++++++++++++++++++++++++++++++++++*/
1248
1249 static void
1250 midcancelWarnCB(
1251         Widget w,
1252         XtPointer client_data,
1253         XtPointer call_data )
1254 {
1255
1256   register int     n;
1257   Arg              args[10];
1258   XmString         string;
1259
1260   if (mouse.function == TRANSFER)
1261     {
1262       XmToggleButtonGadgetSetState(mouse.transferToggle, True, True);
1263       XmToggleButtonGadgetSetState(mouse.adjustToggle, False, False);
1264     }
1265   else
1266     {
1267       XmToggleButtonGadgetSetState(mouse.adjustToggle, True, True);
1268       XmToggleButtonGadgetSetState(mouse.transferToggle, False, False);
1269     }
1270   XtDestroyWidget(midwarnDialog);
1271 }
1272
1273 /*+++++++++++++++++++++++++++++++++++++++*/
1274 /* reverseToggleCB                       */
1275 /*+++++++++++++++++++++++++++++++++++++++*/
1276
1277 static void
1278 reverseToggleCB(
1279         Widget w,
1280         XtPointer client_data,
1281         XtPointer call_data )
1282 {
1283   register int     n;
1284   int              i, j;
1285   Arg              args[MAX_ARGS];
1286   Boolean          set;
1287   Boolean          toggle;
1288
1289   toggle = (Boolean) client_data;
1290
1291   if(mouse.type == POINTER3B)
1292     {
1293         if (toggle == LEFT_HANDED)
1294           {
1295             if (mouse.handed == LEFT_HANDED)
1296               return;
1297             mouse.handed = LEFT_HANDED;
1298             mouse.pixmap = mouse.b3_rev;
1299             mouse.pixmapSel = mouse.b3_revSel;
1300             for(i = 0, j = 3; i < 3; i++, j--)
1301               mouse.new_map_return[i] = j;
1302             mouse.new_map_return[3] = 5;
1303             mouse.new_map_return[4] = 4;
1304           }
1305         else
1306           {
1307             if (mouse.handed == RIGHT_HANDED)
1308               return;
1309             mouse.handed = RIGHT_HANDED;
1310             mouse.pixmap = mouse.b3;
1311             mouse.pixmapSel = mouse.b3Sel;
1312             for(i = 0, j = 1; i < 3; i++, j++)
1313               mouse.new_map_return[i] = j;
1314             mouse.new_map_return[3] = 4;
1315             mouse.new_map_return[4] = 5;
1316           }
1317       }
1318   else     /* 2B mouse */
1319     {
1320            if (toggle == LEFT_HANDED)
1321              {
1322                if (mouse.handed == LEFT_HANDED)
1323                  return;
1324                mouse.handed = LEFT_HANDED;
1325                mouse.pixmap = mouse.b2_rev;
1326                mouse.pixmapSel = mouse.b2_revSel;
1327                for(i = 0, j = 2; i < 2; i++, j--)
1328                  mouse.new_map_return[i] = j;
1329              }
1330            else
1331            {
1332              if (mouse.handed == RIGHT_HANDED)
1333                return;
1334              mouse.handed = RIGHT_HANDED;
1335              mouse.pixmap = mouse.b2;
1336                mouse.pixmapSel = mouse.b2Sel;
1337                for(i = 0, j = 1; i < 2; i++, j++)
1338                  mouse.new_map_return[i] = j;
1339            }
1340          }
1341
1342   n=0;
1343   XtSetArg(args[n], XmNlabelPixmap, mouse.pixmap); n++;
1344         XtSetValues(mouse.pictButton, args, n);
1345
1346   /* change Pointer Mapping */
1347   if (XSetPointerMapping(style.display, mouse.new_map_return, mouse.numButtons)
1348                    != MappingSuccess)
1349     _DtSimpleError (progName, DtWarning, NULL, MSG3, NULL);
1350
1351   mouse.systemDefaultFlag = False;
1352   XtDestroyWidget(warnDialog);
1353
1354 }
1355
1356
1357 /*+++++++++++++++++++++++++++++++++++++++*/
1358 /* midreverseToggleCB                    */
1359 /*+++++++++++++++++++++++++++++++++++++++*/
1360
1361 static void
1362 midreverseToggleCB(
1363         Widget w,
1364         XtPointer client_data,
1365         XtPointer call_data )
1366 {
1367     register int     n;
1368     int              i, j;
1369     Arg              args[MAX_ARGS];
1370     Boolean          set;
1371     Boolean          toggle;
1372
1373      toggle = (Boolean) client_data;
1374
1375     if (toggle == ADJUST)
1376       {
1377         if (mouse.function == ADJUST)
1378           return;
1379         mouse.function = ADJUST;
1380       }
1381     else
1382       {
1383         if (mouse.function == TRANSFER)
1384           return;
1385         mouse.function = TRANSFER;
1386       }
1387     mouse.btn2Changed = True;
1388     mouse.systemDefaultFlag = False;
1389
1390     XtDestroyWidget(midwarnDialog);
1391 }
1392
1393
1394 /*+++++++++++++++++++++++++++++++++++++++*/
1395 /* systemDefaultCB                       */
1396 /*+++++++++++++++++++++++++++++++++++++++*/
1397 static void
1398 systemDefaultCB(
1399         Widget w,
1400         XtPointer client_data,
1401         XtPointer call_data )
1402 {
1403   int           n, i, j;
1404   Arg           args[MAX_ARGS];
1405   Bool          do_accel, do_thresh;
1406   int           new_acceln, new_acceld, new_thresh;
1407   char          dclickRes[40];
1408
1409   /* set default mouse values */
1410   new_acceld = -1;
1411   new_acceln = -1;
1412   new_thresh = THRESHDEFAULT;
1413   do_accel = 1;
1414   do_thresh = 1;
1415   XChangePointerControl(style.display, do_accel, do_thresh, new_acceln,
1416                         new_acceld, new_thresh);
1417
1418   /*get default mouse values for sliders*/
1419   XGetPointerControl(style.display, &new_acceln, &new_acceld, &new_thresh);
1420
1421   n=0;
1422   XtSetArg(args[n], XmNvalue,new_acceln); n++;
1423   XtSetValues(mouse.accelScale, args, n);
1424
1425   n=0;
1426   XtSetArg(args[n], XmNvalue,new_thresh); n++;
1427   XtSetValues(mouse.threshScale, args, n);
1428
1429   n=0;
1430   XtSetArg(args[n], XmNvalue,DCLICKDEFAULT/100); n++;
1431   XtSetValues(mouse.dclickScale, args, n);
1432
1433   sprintf(dclickRes, multiClickTimeString, DCLICKDEFAULT);
1434   _DtAddToResource(style.display,dclickRes);
1435
1436   /* change mouse mapping to default */
1437   if(mouse.type == POINTER3B)
1438     {
1439       mouse.pixmap = mouse.b3;
1440       mouse.pixmapSel = mouse.b3Sel;
1441       for(i = 0, j = 1; i < 3; i++, j++)
1442         mouse.new_map_return[i] = j;
1443       mouse.new_map_return[3] = 4;
1444       mouse.new_map_return[4] = 5;
1445     }
1446   else
1447     {
1448       mouse.pixmap = mouse.b2;
1449       mouse.pixmapSel = mouse.b2Sel;
1450       for(i = 0, j = 1; i < 2; i++, j++)
1451         mouse.new_map_return[i] = j;
1452     }
1453
1454   if (mouse.handed != RIGHT_HANDED)
1455     {
1456       /* change Pointer Mapping */
1457       if(XSetPointerMapping(style.display, mouse.new_map_return,
1458                             mouse.numButtons) != MappingSuccess)
1459         _DtSimpleError (progName, DtWarning, NULL, MSG3, NULL);
1460
1461       n=0;
1462       XtSetArg(args[n], XmNlabelPixmap, mouse.pixmap); n++;
1463       XtSetValues(mouse.pictButton, args, n);
1464
1465
1466       mouse.handed = RIGHT_HANDED;
1467       XmToggleButtonGadgetSetState(mouse.rightToggle, True, True);
1468       XmToggleButtonGadgetSetState(mouse.leftToggle, False, False);
1469
1470     }
1471
1472   if (mouse.function != TRANSFER)
1473     {
1474       mouse.function = TRANSFER;
1475       mouse.btn2Changed = True;
1476       XmToggleButtonGadgetSetState(mouse.transferToggle, True, True);
1477       XmToggleButtonGadgetSetState(mouse.adjustToggle, False, False);
1478     }
1479
1480   mouse.systemDefaultFlag = True;
1481 }
1482
1483
1484 /*+++++++++++++++++++++++++++++++++++++++*/
1485 /* ButtonCB                              */
1486 /* callback for PushButtons in DialogBox */
1487 /*+++++++++++++++++++++++++++++++++++++++*/
1488 static void
1489 ButtonCB(
1490         Widget w,
1491         XtPointer client_data,
1492         XtPointer call_data )
1493 {
1494     int           n, i, j;
1495     Arg           args[MAX_ARGS];
1496     DtDialogBoxCallbackStruct *cb = (DtDialogBoxCallbackStruct *) call_data;
1497     Bool          do_accel, do_thresh;
1498     Bool          set;
1499     char          message1[6], message2[50], message3[6], message4[6];
1500     char          pointerStr[70];
1501     static char   dclickRes[40];
1502     static char   enableBtn1Res[40];
1503     int           dclick;
1504     int     new_acceln, new_acceld, new_thresh;
1505
1506     switch (cb->button_position)
1507     {
1508       case OK_BUTTON:
1509
1510          XtUnmanageChild(w);
1511
1512          /* if sendSettings is true send data to Session Manager */
1513
1514          if(style.smState.smSendSettings)
1515          {
1516              if (mouse.systemDefaultFlag && !mouse.dclickChanged)
1517              {
1518                 SmDefaultPointerSettings();
1519              }
1520              else /* dclick or one of the sliders changed */
1521              {
1522                 sprintf(message1,"%d", mouse.numButtons );
1523                 if(mouse.numButtons == 3 || mouse.numButtons == 5)
1524                    sprintf(message2,"%d_%d_%d", mouse.new_map_return[0],
1525                                                 mouse.new_map_return[1],
1526                                                 mouse.new_map_return[2]);
1527                 else
1528                    sprintf(message2,"%d_%d_%d_%d_%d", mouse.new_map_return[0],
1529                                                       mouse.new_map_return[1],
1530                                                       mouse.new_map_return[2],
1531                                                       mouse.new_map_return[3],
1532                                                       mouse.new_map_return[4]);
1533                 sprintf(message3,"%d", getValue(mouse.accelScale));
1534                 sprintf(message4,"%d", getValue(mouse.threshScale));
1535
1536                 sprintf(dclickRes, multiClickTimeString,
1537                                    getValue(mouse.dclickScale)*100);
1538
1539                 if (mouse.dclickChanged)
1540                 {
1541                   if (style.xrdb.writeXrdbImmediate) {
1542                     InfoDialog(IMMEDIATE_MSG, style.shell, False);
1543                    _DtAddToResource(style.display,dclickRes);
1544                   }
1545                   else
1546                     InfoDialog(LATER_MSG, style.shell, False);
1547                 }
1548
1549                 sprintf (pointerStr,"%s %s %s %s %s",
1550                          message1, message2, message3, message4,
1551                          dclickRes );
1552
1553                 SmNewPointerSettings (pointerStr);
1554
1555               }
1556            }
1557          else
1558            {  /* sendSettings is False. If double click has changed update Xrdb */
1559
1560              if (mouse.dclickChanged)
1561                {
1562                  InfoDialog(IMMEDIATE_MSG, style.shell, False);
1563                  sprintf(dclickRes, multiClickTimeString,
1564                          getValue(mouse.dclickScale)*100);
1565                  _DtAddToResource(style.display,dclickRes);
1566                }
1567            }
1568          mouse.dclickChanged = False;
1569
1570          if (mouse.btn2Changed)
1571            if(mouse.function == TRANSFER)
1572              sprintf(enableBtn1Res, enableBtn1TransferString, "button2_transfer");
1573            else
1574              sprintf(enableBtn1Res, enableBtn1TransferString, "True");
1575            _DtAddToResource(style.display,enableBtn1Res);
1576
1577          break;
1578
1579        case CANCEL_BUTTON:
1580
1581          XtUnmanageChild(w);
1582
1583          /* check if values and changePonterControl only if needed */
1584
1585           new_acceln = getValue(mouse.accelScale);
1586           if (new_acceln != mouse.accel_numerator)
1587           {
1588               /* reset to incoming mouse values */
1589               n=0;
1590               XtSetArg(args[n], XmNvalue,mouse.accel_numerator); n++;
1591               XtSetValues(mouse.accelScale, args, n);
1592           }
1593
1594           new_thresh = getValue(mouse.threshScale);
1595           if (new_thresh != mouse.threshold)
1596           {
1597               /* reset to incoming mouse values */
1598               n=0;
1599               XtSetArg(args[n], XmNvalue,mouse.threshold); n++;
1600               XtSetValues(mouse.threshScale, args, n);
1601           }
1602
1603           n=0;
1604           XtSetArg(args[n], XmNvalue,mouse.mydclick); n++;
1605           XtSetValues(mouse.dclickScale, args, n);
1606           mouse.dclickChanged = False;
1607           XtSetMultiClickTime(style.display, mouse.mydclick*100);
1608
1609           if ((new_thresh != mouse.threshold) ||
1610               (new_acceln != mouse.accel_numerator))
1611           {
1612               do_accel = mouse.accel_numerator ? 1:0;
1613               do_thresh = mouse.threshold ? 1:0;
1614               XChangePointerControl(style.display, do_accel, do_thresh,
1615                    mouse.accel_numerator, mouse.accel_denominator,
1616                    mouse.threshold);
1617           }
1618
1619
1620          if (mouse.handed != mouse.origHanded)
1621            {
1622              if (XSetPointerMapping(style.display, mouse.map_return,
1623                                     mouse.numButtons) != MappingSuccess)
1624                _DtSimpleError (progName, DtWarning, NULL, MSG3, NULL);
1625
1626              /* load the correct mouse pixmaps */
1627
1628              if(mouse.type == POINTER3B)
1629                {
1630                  if (mouse.origHanded == LEFT_HANDED)
1631                    {
1632                      mouse.pixmap = mouse.b3_rev;
1633                      mouse.pixmapSel = mouse.b3_revSel;
1634                    }
1635                  else
1636                    {
1637                      if (mouse.origHanded == RIGHT_HANDED)
1638                        {
1639                          mouse.pixmap = mouse.b3;
1640                          mouse.pixmapSel = mouse.b3Sel;
1641                        }
1642                    }
1643                }
1644              else     /* 2B mouse */
1645                {
1646                  if (mouse.origHanded == LEFT_HANDED)
1647                    {
1648                      mouse.pixmap = mouse.b2_rev;
1649                      mouse.pixmapSel = mouse.b2_revSel;
1650                    }
1651                  else
1652                    {
1653                      if (mouse.origHanded == RIGHT_HANDED)
1654                        {
1655                          mouse.pixmap = mouse.b2;
1656                          mouse.pixmapSel = mouse.b2Sel;
1657                        }
1658                    }
1659                }
1660
1661              n=0;
1662              XtSetArg(args[n], XmNlabelPixmap, mouse.pixmap); n++;
1663              XtSetValues(mouse.pictButton, args, n);
1664            }
1665
1666          if (mouse.function != mouse.origFunction)
1667            {
1668              mouse.function = mouse.origFunction;
1669              if (mouse.origFunction == TRANSFER)
1670                {
1671                  XmToggleButtonGadgetSetState(mouse.transferToggle, True, True);
1672                  XmToggleButtonGadgetSetState(mouse.adjustToggle, False, False);
1673                }
1674              else
1675                {
1676                  XmToggleButtonGadgetSetState(mouse.transferToggle, False, False);
1677                  XmToggleButtonGadgetSetState(mouse.adjustToggle, True, True);
1678                }
1679            }
1680          break;
1681
1682        case HELP_BUTTON:
1683          XtCallCallbacks(style.mouseDialog, XmNhelpCallback, (XtPointer)NULL);
1684          break;
1685
1686        default:
1687          break;
1688        }
1689   }
1690
1691
1692 /************************************************************************
1693  * restoreMouse()
1694  *
1695  * restore any state information saved with saveMouse.
1696  * This is called from restoreSession with the application
1697  * shell and the special xrm database retrieved for restore.
1698 ************************************************************************/
1699 void
1700 restoreMouse(
1701         Widget shell,
1702         XrmDatabase db )
1703 {
1704     XrmName xrm_name[5];
1705     XrmRepresentation rep_type;
1706     XrmValue value;
1707
1708     xrm_name [0] = XrmStringToQuark ("Mouse");
1709     xrm_name [2] = NULL;
1710
1711     /* get x position */
1712     xrm_name [1] = XrmStringToQuark ("x");
1713     if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value)){
1714         XtSetArg (save.posArgs[save.poscnt], XmNx, atoi((char *)value.addr)); save.poscnt++;
1715         save.restoreFlag = True;
1716     }
1717
1718     /* get y position */
1719     xrm_name [1] = XrmStringToQuark ("y");
1720     if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value)){
1721       XtSetArg (save.posArgs[save.poscnt], XmNy, atoi((char *)value.addr)); save.poscnt++;
1722     }
1723
1724     xrm_name [1] = XrmStringToQuark ("ismapped");
1725     XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value);
1726     /* Are we supposed to be mapped? */
1727     if (strcmp(value.addr, "True") == 0)
1728       popup_mouseBB(shell);
1729 }
1730
1731 /************************************************************************
1732  * saveMouse()
1733  *
1734  * This routine will write out to the passed file descriptor any state
1735  * information this dialog needs.  It is called from saveSessionCB with the
1736  * file already opened.
1737  * All information is saved in xrm format.  There is no restriction
1738  * on what can be saved.  It doesn't have to be defined or be part of any
1739  * widget or Xt definition.  Just name and save it here and recover it in
1740  * restoreBackdrop.  The suggested minimum is whether you are mapped, and your
1741  * location.
1742  ************************************************************************/
1743 void
1744 saveMouse(
1745         int fd )
1746 {
1747     Position x,y;
1748     char *bufr = style.tmpBigStr;     /* size=[1024], make bigger if needed */
1749     XmVendorShellExtObject  vendorExt;
1750     XmWidgetExtData         extData;
1751
1752     if (style.mouseDialog != NULL)
1753     {
1754         if (XtIsManaged(style.mouseDialog))
1755             sprintf(bufr, "*Mouse.ismapped: True\n");
1756         else
1757             sprintf(bufr, "*Mouse.ismapped: False\n");
1758
1759         /* Get and write out the geometry info for our Window */
1760         x = XtX(XtParent(style.mouseDialog));
1761         y = XtY(XtParent(style.mouseDialog));
1762
1763         /* Modify x & y to take into account window mgr frames
1764          * This is pretty bogus, but I don't know a better way to do it.
1765          */
1766         extData = _XmGetWidgetExtData(style.shell, XmSHELL_EXTENSION);
1767         vendorExt = (XmVendorShellExtObject)extData->widget;
1768         x -= vendorExt->vendor.xOffset;
1769         y -= vendorExt->vendor.yOffset;
1770
1771         sprintf(bufr, "%s*Mouse.x: %d\n", bufr, x);
1772         sprintf(bufr, "%s*Mouse.y: %d\n", bufr, y);
1773
1774         write (fd, bufr, strlen(bufr));
1775     }
1776 }
1777