cde/programs/dtwm/WmHelp.c

   1 /* $TOG: WmHelp.c /main/8 1997/06/18 17:30:51 samborn $ */
   2 #ifdef WSM
   3 /*
   4  * (c) Copyright 1987, 1988, 1989, 1990, 1992, 1993 HEWLETT-PACKARD COMPANY
   5  * (c) Copyright 1989, 1990, 1991, 1992 OPEN SOFTWARE FOUNDATION, INC.
   6  * ALL RIGHTS RESERVED
   7 */
   8 #ifdef REV_INFO
   9 #ifndef lint
  10 static char rcsid[] = ""
  11 #endif
  12 #endif
  13
  14 /*
  15  * Included Files:
  16  */
  17 #if defined(sun)
  18 #ifndef XK_MISCELLANY
  19 #define XK_MISCELLANY
  20 #endif
  21 #endif
  22
  23 #include "WmGlobal.h"
  24 #include "WmError.h"
  25 #include "WmHelp.h"
  26 #ifdef PANELIST
  27 #include "WmPanelP.h"
  28 #endif /* PANELIST */
  29 #include "WmResNames.h"
  30 #include "WmWrkspace.h"
  31 #include "DataBaseLoad.h"
  32 #include <stdio.h>
  33 #include <Xm/Xm.h>
  34 #include <Xm/XmP.h>
  35 #include <Xm/MessageB.h>
  36 #include <X11/keysymdef.h>
  37 #include <X11/keysym.h>
  38 #include <X11/Shell.h>
  39 #include <Xm/MwmUtil.h>
  40
  41 #include <Dt/HelpDialog.h>
  42 #include <Dt/HelpQuickD.h>
  43
  44 #include <Dt/DtNlUtils.h>
  45
  46 #include <X11/cursorfont.h>
  47
  48
  49 /****************************************************************
  50  *
  51  *  Cache List Info Structure Definition.
  52  *
  53  ****************************************************************/
  54 typedef struct _CacheListStruct {
  55     Widget                    helpDialog;
  56     Boolean                   inUseFlag;
  57     Boolean                   hLink;
  58     Boolean                   restored;
  59     char                      *workspaces;
  60     Position                  xPos;
  61     Position                  yPos;
  62     struct _CacheListStruct   *pNext;
  63     struct _CacheListStruct   *pPrevious;
  64 } CacheListStruct;
  65
  66 typedef struct _DisplayTopicInfo {
  67     char                      *workspaces;
  68     Position                  xPos;
  69     Position                  yPos;
  70 } DisplayTopicInfo;
  71
  72 /*
  73  * Function Declarations:
  74  */
  75
  76 /********    Static Function Declarations    ********/
  77 static int LocateTheControl(
  78                         Display *dpy,
  79                         int screen,
  80                         Widget *pWidget);
  81 static WmScreenData *WmScreenDataFromWidget (
  82                                              Widget theWidget) ;
  83
  84 static int WmDtReturnSelectedWidget (
  85                          Widget theWidget,
  86                          Cursor cursor,
  87                          Widget *pWidget);
  88 static void WmDtDisplayTopic (
  89                                Widget  parent,
  90                                char    *accessPath,
  91                                char    *idString,
  92                                int     helpType,
  93                                Widget  wmClient,
  94                                Boolean wmHelp,
  95                                ArgList argList,
  96                                int     argCount,
  97                                ClientData *pCData,
  98                                Boolean hyperLink,
  99                                DisplayTopicInfo *displayTopicInfo);
 100 static void WmDtCloseHelpCB (
 101                               Widget w,
 102                               XtPointer clientData,
 103                               XtPointer callData);
 104 static void WmDtWmCloseHelpCB (
 105                               Widget w,
 106                               XtPointer clientData,
 107                               XtPointer callData);
 108 static void WmDtVersionCloseCB (
 109                                  Widget w,
 110                                  XtPointer clientData,
 111                                  XtPointer callData);
 112 static void WmDtVersionPopupCB (
 113                                  Widget w,
 114                                  XtPointer clientData,
 115                                  XtPointer callData);
 116
 117 static void WmDtProcessLinkCB (
 118                                 Widget w,
 119                                 XtPointer clientData,
 120                                 XtPointer callData);
 121 static Boolean WmDtGetFromCache(
 122                                  CacheListStruct **pCurrentNode,
 123                                  WmScreenData *pSD);
 124 static void ShowHelpDialog(
 125                       ClientData *pClient);
 126
 127 static void HideHelpDialog(
 128                       WmScreenData *pSD,
 129                       Boolean userDismissed );
 130 static void wmDtHelpSetPosition(
 131                                  PtrWsDtHelpData pHelp,
 132                                  WmScreenData *pSD,
 133                                  Boolean restorePos);
 134 static void wmDtHelpMapEventHandler (
 135                                  Widget,
 136                                  XtPointer,
 137                                  XEvent *,
 138                                  Boolean *);
 139 static void wmDtErrorDialog(
 140                 WmScreenData *pSD,
 141                 String sMessage,
 142                 String sTitle);
 143 static void wmDtErrorDialogOkCB(
 144                 Widget w,
 145                 XtPointer client_data,
 146                 XtPointer call_data );
 147 static void wmDtErrorDialogPopupCB(
 148                 Widget w,
 149                 XtPointer client_data,
 150                 XtPointer call_data );
 151 static void wmDtErrorDialogHide(
 152                 WmScreenData *pSD );
 153
 154 /********    End Static Function Declarations    ********/
 155
 156
 157 /*
 158  * Global Variables:
 159  */
 160
 161
 162 static  DisplayTopicInfo displayTopicInfo;
 163 static  Widget      versionWidget = (Widget)NULL;
 164
 165 #define  PT_IN_CHILD(X, Y, CHILD) \
 166          (((X) >=  (CHILD)->core.x) && \
 167           ((X) <= ((CHILD)->core.x + (Position) (CHILD)->core.width)) && \
 168           ((Y) >=  (CHILD)->core.y) && \
 169           ((Y) <= ((CHILD)->core.y + (Position) (CHILD)->core.height)))
 170
 171 #define MAX_WIDGET_PATH 100
 172
 173
 174 /**********************************************************************
 175  * Function: LocateTheControl()
 176  *
 177  *
 178  *
 179  **********************************************************************/
 180 static int
 181 LocateTheControl(
 182         Display *dpy,
 183         int screen,
 184         Widget *pWidget )
 185 {
 186
 187     Widget           child;
 188     CompositeWidget  comp_widget;
 189     int              status;
 190     Cursor           cursor;
 191     XEvent           event;
 192     Window           target_win = None;
 193     int              buttons = 0;
 194     int              x,y;
 195     int              i;
 196     Window           parent;
 197     Window           sub;
 198     int              new_x, new_y;
 199     int              offset;
 200     KeySym           keySym;
 201     Widget           widget = NULL;
 202
 203     Boolean          foundOne = False;
 204     int  clientNum, scr;
 205     WmFpEmbeddedClientData *pECD;
 206     WmScreenData     *pSD = NULL;
 207
 208
 209
 210     /* Make the target cursor */
 211     cursor = XCreateFontCursor (wmGD.display, XC_question_arrow);
 212
 213     /* Grab the pointer using target cursor, letting it roam all over */
 214     status = XGrabPointer (wmGD.display, RootWindow(wmGD.display, screen),
 215                            False,
 216                            ButtonPressMask|ButtonReleaseMask, GrabModeAsync,
 217                            GrabModeAsync, None, cursor, CurrentTime);
 218     if (status != GrabSuccess)
 219     {
 220         Warning (((char *)GETMESSAGE(29, 1,
 221         "Help on Item failed. Another program may have grabbed the mouse.")));
 222         return(DtHELP_SELECT_ERROR);
 223     }
 224
 225
 226     /* Grab the Keyboard so we can catch the ESC button press */
 227     status = XGrabKeyboard(wmGD.display, RootWindow(wmGD.display, screen),
 228                            False,
 229                            GrabModeAsync, GrabModeAsync, CurrentTime);
 230     if (status != GrabSuccess)
 231     {
 232         XUngrabPointer (wmGD.display, CurrentTime);
 233         Warning (((char *)GETMESSAGE(29, 2,
 234         "Help on Item failed. Another program may have grabbed the mouse.")));
 235         return(DtHELP_SELECT_ERROR);
 236     }
 237
 238     /* Let the user select a window... */
 239     while ((target_win == None) || (buttons != 0))
 240     {
 241         XtAppNextEvent(wmGD.mwmAppContext, &event);
 242
 243         switch (event.type)
 244         {
 245           case ButtonPress:
 246             if (target_win == None)
 247             {
 248                 target_win = event.xbutton.subwindow; /* window selected */
 249                 if (target_win == None)
 250                     target_win = RootWindow (wmGD.display, screen);
 251             }
 252             buttons++;
 253             break;
 254           case ButtonRelease:
 255             /* there may have been some down before we started */
 256             if (buttons > 0)
 257                 buttons--;
 258             break;
 259           case KeyPress:
 260             /* Look for ESC key press and stop if we get one */
 261             if (event.xkey.state & ShiftMask)
 262                 offset = 1;
 263             else
 264                 offset = 0;
 265
 266             keySym = XLookupKeysym((XKeyEvent *)&event, offset);
 267             if (keySym == XK_Escape)
 268             {
 269                 XUngrabKeyboard (wmGD.display, CurrentTime);
 270                 XUngrabPointer (wmGD.display, CurrentTime);
 271                 return(DtHELP_SELECT_ABORT);
 272             }
 273         }
 274
 275         XtDispatchEvent(&event);
 276     }
 277
 278     XUngrabKeyboard (wmGD.display, CurrentTime);      /* Done with keyboard */
 279     XUngrabPointer (wmGD.display, CurrentTime);      /* Done with pointer */
 280
 281 #ifdef  DEBUGGER
 282     printf("RootWindow (wmGD.display, screen) = %ld\n", RootWindow (wmGD.display, screen));
 283     printf("event.xbutton.root       = %ld\n", event.xbutton.root);
 284     printf("event.xbutton.window     = %ld\n", event.xbutton.window);
 285     printf("event.xbutton.subwindow  = %ld\n", event.xbutton.subwindow);
 286     printf("event.xbutton.x          = %d\n",  event.xbutton.x);
 287     printf("event.xbutton.y          = %d\n",  event.xbutton.y);
 288     printf("event.xbutton.x_root     = %d\n",  event.xbutton.x_root);
 289     printf("event.xbutton.y_root     = %d\n",  event.xbutton.y_root);
 290 #endif  /*  DEBUGGER  */
 291
 292     if (target_win == RootWindow (wmGD.display, screen))
 293         return (DtHELP_SELECT_INVALID);
 294
 295     for (scr = 0; scr < wmGD.numScreens; scr++)
 296     {
 297         if (wmGD.Screens[scr].managed &&
 298             wmGD.Screens[scr].screen == screen)
 299         {
 300             pSD = (&(wmGD.Screens[scr]));
 301             break;
 302         }
 303     }
 304     if (!pSD)
 305     {
 306         pSD=wmGD.pActiveSD;
 307     }
 308
 309     /* check for subwindows */
 310     parent = RootWindow (wmGD.display, screen);
 311     x      = event.xbutton.x_root;
 312     y      = event.xbutton.y_root;
 313
 314     while (!foundOne)
 315     {
 316         XTranslateCoordinates(wmGD.display, parent, target_win, x, y,
 317                               &new_x, &new_y, &sub);
 318         if (!sub)
 319         {
 320             x = new_x;
 321             y = new_y;
 322             break;
 323         }
 324         else
 325         {
 326             pECD = (WmFpEmbeddedClientData *) pSD->pECD;
 327             for (clientNum = 0; clientNum < pSD->numEmbeddedClients;
 328                  clientNum++, pECD++)
 329             {
 330                 if ((pECD->pCD) &&
 331                     (target_win == pECD->pCD->client))
 332                 {
 333                     widget = pECD->wControl;
 334                     foundOne = True;
 335                     break;
 336                 }
 337             }
 338             parent = target_win;
 339             target_win = sub;
 340             x = new_x;
 341             y = new_y;
 342         }
 343     }
 344
 345
 346     if (widget == NULL)
 347     {
 348         widget = XtWindowToWidget (wmGD.display, target_win);
 349     }
 350
 351     if (widget == NULL)
 352     {
 353         widget = XtWindowToWidget (wmGD.display1, target_win);
 354
 355         if (widget == NULL)
 356         {
 357             return (DtHELP_SELECT_INVALID);
 358         }
 359     }
 360
 361     if (!XtIsComposite (widget))
 362     {
 363         *pWidget = widget;
 364         return (DtHELP_SELECT_VALID);
 365     }
 366     comp_widget = (CompositeWidget)widget;
 367
 368     /*  look for gadgets at this point  */
 369     for (i = 0; i < comp_widget->composite.num_children; i++)
 370     {
 371         child = comp_widget->composite.children[i];
 372
 373         if (PT_IN_CHILD (x, y, child) && XtIsManaged(child))
 374         {
 375             *pWidget = child;
 376             return (DtHELP_SELECT_VALID);
 377         }
 378     }
 379
 380     if (widget != NULL)
 381     {
 382        *pWidget = widget;
 383         return (DtHELP_SELECT_VALID);
 384     }
 385
 386     return (DtHELP_SELECT_INVALID);
 387
 388 } /* END OF FUNCTION LocateTheControl */
 389
 390
 391 /**********************************************************************
 392  *
 393  * Cache Creek related help functions
 394  *
 395  **********************************************************************/
 396
 397 /*************************************<->*************************************
 398  *
 399  *  WmDtStringHelpCB
 400  *
 401  *
 402  *  Description:
 403  *  -----------
 404  *
 405  *
 406  *************************************<->***********************************/
 407
 408 void WmDtStringHelpCB (Widget theWidget,
 409                         XtPointer client_data,
 410                         XtPointer call_data)
 411 {
 412     WmScreenData *pSD;
 413     char * theHelpString = (char *)client_data;
 414     Widget theRealWidget = theWidget;
 415     if( XmIsGadget(theWidget))
 416     {
 417         theRealWidget = XtParent(theWidget);
 418     }
 419     pSD = WmScreenDataFromWidget(theWidget);
 420
 421 /*    WmDtDisplayTopic(theRealWidget, NULL, theHelpString, */
 422     WmDtDisplayTopic(pSD->screenTopLevelW1, NULL, theHelpString,
 423                       DtHELP_TYPE_DYNAMIC_STRING, (Widget) NULL, True,
 424                       NULL, 0, NULL, False, NULL);
 425
 426
 427
 428 } /* END OF FUNCTION WmDtStringHelpCB */
 429
 430
 431 /*************************************<->*************************************
 432  *
 433  *  WmDtWmStringHelpCB
 434  *
 435  *
 436  *  Description:
 437  *  -----------
 438  *
 439  *
 440  *************************************<->***********************************/
 441
 442 void WmDtWmStringHelpCB (Widget theWidget,
 443                         XtPointer client_data,
 444                         XtPointer call_data)
 445 {
 446     WmScreenData *pSD;
 447     char * theHelpString = (char *)client_data;
 448     pSD = WmScreenDataFromWidget(theWidget);
 449
 450 #ifdef OLD
 451     if (XtDisplay(theWidget) == DISPLAY)
 452     {
 453         WmDtDisplayTopic(pSD->screenTopLevelW1,
 454                           NULL, theHelpString,
 455                           DtHELP_TYPE_STRING, theWidget, True,
 456                           NULL, 0, NULL, False, NULL);
 457     }
 458     else
 459     {
 460         WmDtDisplayTopic(theWidget, NULL, theHelpString,
 461                           DtHELP_TYPE_STRING, theWidget, True,
 462                           NULL, 0, NULL, False, NULL);
 463
 464     }
 465 #endif /* OLD */
 466         WmDtDisplayTopic(pSD->screenTopLevelW1,
 467                           NULL, theHelpString,
 468                           DtHELP_TYPE_DYNAMIC_STRING, theWidget, True,
 469                           NULL, 0, NULL, False, NULL);
 470
 471
 472 } /* END OF FUNCTION WmDtWmStringHelpCB */
 473
 474
 475
 476 /*************************************<->*************************************
 477  *
 478  *  WmDtDisplayTopicHelp
 479  *
 480  *  Description:
 481  *  -----------
 482  *  External entry procedure used to display help topics.
 483  *
 484  *************************************<->***********************************/
 485
 486 void WmDtDisplayTopicHelp (Widget widget,
 487                         char * helpVolume,
 488                         char * locationID)
 489 {
 490     WmScreenData *pSD = WmScreenDataFromWidget(widget);
 491
 492     WmDtDisplayTopic(pSD->screenTopLevelW1,
 493                       helpVolume, locationID,
 494                       DtHELP_TYPE_TOPIC, (Widget) NULL, True,
 495                       NULL, 0, NULL, False, NULL);
 496 }
 497
 498 /*************************************<->*************************************
 499  *
 500  *  WmDtDisplayStringHelp
 501  *
 502  *  Description:
 503  *  -----------
 504  *  External entry procedure used to display help topics.
 505  *
 506  *************************************<->***********************************/
 507
 508 void WmDtDisplayStringHelp (Widget widget,
 509                         char * helpString)
 510 {
 511     WmScreenData *pSD = WmScreenDataFromWidget(widget);
 512
 513     WmDtDisplayTopic(pSD->screenTopLevelW1,
 514                           NULL, helpString,
 515                           DtHELP_TYPE_DYNAMIC_STRING, widget, True,
 516                           NULL, 0, NULL, False, NULL);
 517 }
 518
 519 /*************************************<->*************************************
 520  *
 521  *  WmDtWmTopicHelpCB
 522  *
 523  *
 524  *  Description:
 525  *  -----------
 526  *  for each icon in the icon box
 527  *
 528  *************************************<->***********************************/
 529
 530 void WmDtWmTopicHelpCB (Widget theWidget,
 531                         XtPointer client_data,
 532                         XtPointer call_data)
 533 {
 534     Widget shellWidget;
 535     WmScreenData *pSD;
 536     char *helpVolume =  WM_DT_HELP_VOLUME;
 537     char *locationID = (char *)client_data;
 538     pSD = WmScreenDataFromWidget(theWidget);
 539
 540     shellWidget = theWidget;
 541     while (!(XtIsSubclass(XtParent(shellWidget), shellWidgetClass)))
 542     {
 543         shellWidget = XtParent(shellWidget);
 544     }
 545
 546     WmDtDisplayTopic(pSD->screenTopLevelW1, helpVolume,
 547                       locationID,
 548                       DtHELP_TYPE_TOPIC, shellWidget, True,
 549                       NULL, 0, NULL, False, NULL);
 550
 551 } /* END OF FUNCTION WmDtWmTopicHelpCB */
 552
 553 /****************************************************************************
 554  * Function:         WmScreenDataFromWidget(
 555  *                              Widget theWidget)
 556  *
 557  * Parameters:
 558  *
 559  * Return Value:    pSD
 560  *
 561  * Purpose:
 562  *
 563  ***************************************************************************/
 564 static WmScreenData *
 565 WmScreenDataFromWidget (Widget theWidget)
 566 {
 567
 568     WmScreenData *pSD = NULL;
 569     int scr;
 570
 571     CacheListStruct *pTemp;
 572
 573     if (theWidget)
 574     {
 575         for (scr = 0; scr < wmGD.numScreens; scr++)
 576         {
 577             if (wmGD.Screens[scr].managed &&
 578                 wmGD.Screens[scr].screen ==
 579                 XScreenNumberOfScreen(XtScreen(theWidget)))
 580             {
 581                 pSD = (&(wmGD.Screens[scr]));
 582                 break;
 583             }
 584         }
 585         if (!pSD)
 586         {
 587             pSD=wmGD.pActiveSD;
 588         }
 589     }
 590     else
 591     {
 592         pSD=wmGD.pActiveSD;
 593     }
 594     return(pSD);
 595
 596 } /* END OF FUNCTION WmScreenDataFromWidget */
 597
 598 /****************************************************************************
 599  * Function:         WmDtCloseHelpCB(
 600  *                              Widget w,
 601  *                              caddr_t clientData,
 602  *                              caddr_t callData
 603  *
 604  * Parameters:
 605  *
 606  * Return Value:    Void.
 607  *
 608  * Purpose:         Process close requests on all Help Dialog widgets
 609  *                  created and managed by this application.
 610  *
 611  ***************************************************************************/
 612 static void WmDtCloseHelpCB (
 613     Widget w,
 614     XtPointer clientData,
 615     XtPointer callData)
 616 {
 617     WmScreenData *pSD = NULL;
 618     int scr;
 619     Widget helpDialog = (Widget) clientData;
 620
 621     CacheListStruct *pTemp;
 622
 623     pSD = WmScreenDataFromWidget(w);
 624     pTemp = pSD->cachedHelp;
 625
 626     /* Search our Cache List for the closed help dialog */
 627     while ((pTemp->helpDialog != helpDialog) && (pTemp != NULL))
 628     {
 629         pTemp = pTemp->pNext;
 630     }
 631
 632     if (pTemp == NULL)
 633     {
 634         /* ERROR */
 635      /* printf("Didn't find our help dialog widget in the cache list??? /n");*/
 636     }
 637
 638     XtPopdown (XtParent(helpDialog));
 639
 640     pTemp->inUseFlag  = FALSE;
 641     pSD->cachedHelp->hLink  = False;
 642
 643     /* Re-Assign our pTemp to point to our head so we can see
 644      * if we have any in-use help dialog in our list.
 645      */
 646     pTemp = pSD->cachedHelp;
 647
 648 } /* END OF FUNCTION WmDtCloseHelpCB */
 649
 650
 651 /****************************************************************************
 652  * Function:         WmDtWmCloseHelpCB(
 653  *                              Widget w,
 654  *                              caddr_t clientData,
 655  *                              caddr_t callData
 656  *
 657  * Parameters:
 658  *
 659  * Return Value:    Void.
 660  *
 661  * Purpose:         Process close requests on all Help Dialog widgets
 662  *                  created and managed by this application.
 663  *
 664  ***************************************************************************/
 665 static void WmDtWmCloseHelpCB (
 666     Widget w,
 667     XtPointer clientData,
 668     XtPointer callData)
 669 {
 670     WmScreenData *pSD;
 671     Widget helpDialog = (Widget) clientData;
 672     pSD = WmScreenDataFromWidget(w);
 673     HideHelpDialog (pSD, True);
 674
 675 } /* END OF FUNCTION WmDtWmCloseHelpCB */
 676
 677
 678
 679 /****************************************************************************
 680  * Function:         WmDtWmPopupHelpCB(
 681  *                              Widget w,
 682  *                              caddr_t clientData,
 683  *                              caddr_t callData
 684  *
 685  * Parameters:
 686  *
 687  * Return Value:    Void.
 688  *
 689  * Purpose:         Process
 690  *
 691  *
 692  ***************************************************************************/
 693 static void WmDtWmPopupHelpCB (
 694     Widget w,
 695     XtPointer clientData,
 696     XtPointer callData)
 697 {
 698     PtrWsDtHelpData  pHelp;
 699     WmScreenData *pSD;
 700
 701     pSD = WmScreenDataFromWidget(w);
 702
 703     pHelp = &pSD->dtHelp;
 704
 705     if (pSD->dtHelp.restored)
 706     {
 707         /*  set position of dialog to restored position  */
 708         wmDtHelpSetPosition (pHelp, pSD, True);
 709         pSD->dtHelp.restored = False;
 710     }
 711     else
 712     {
 713         /*  set position of dialog relative to client window  */
 714         wmDtHelpSetPosition (pHelp, pSD, False);
 715     }
 716
 717 } /* END OF FUNCTION WmDtWmPopupHelpCB */
 718
 719
 720 /****************************************************************************
 721  * Function:         WmDtVersionPopupCB(
 722  *                              Widget w,
 723  *                              caddr_t clientData,
 724  *                              caddr_t callData
 725  *
 726  * Parameters:
 727  *
 728  * Return Value:    Void.
 729  *
 730  * Purpose:         Process
 731  *
 732  *
 733  ***************************************************************************/
 734 static void WmDtVersionPopupCB (
 735     Widget w,
 736     XtPointer clientData,
 737     XtPointer callData)
 738 {
 739     Arg         setArgs[10];
 740     Arg         getArgs[10];
 741     Dimension   width, height;
 742     int         x, y;
 743     int         n;
 744
 745     if (w)
 746     {
 747 #ifdef OLD
 748         n = 0;
 749         XtSetArg (setArgs[n], XmNx, 0);  n++;
 750         XtSetArg (setArgs[n], XmNy, 0);  n++;
 751 #endif /* OLD */
 752
 753         /*
 754          * Center the Version Dialog on the screen
 755          */
 756
 757         n = 0;
 758         XtSetArg(getArgs[n], XmNheight, &height); n++;
 759         XtSetArg(getArgs[n], XmNwidth, &width); n++;
 760         XtGetValues (w, (ArgList) getArgs, n);
 761
 762         x = (DisplayWidth
 763              (DISPLAY, XScreenNumberOfScreen(XtScreen(w))) - ((int) width))/2;
 764         y = (DisplayHeight
 765              (DISPLAY, XScreenNumberOfScreen(XtScreen(w))) - ((int) height))/2;
 766         n = 0;
 767         XtSetArg(setArgs[n], XmNx, (XtArgVal) x); n++;
 768         XtSetArg(setArgs[n], XmNy, (XtArgVal) y); n++;
 769         XtSetValues (w, setArgs, n);
 770     }
 771
 772 } /* END OF FUNCTION WmDtVersionPopupCB */
 773
 774
 775
 776 /****************************************************************************
 777  * Function:         WmDtPopupHelpCB(
 778  *                              Widget helpShellW,
 779  *                              caddr_t clientData,
 780  *                              caddr_t callData
 781  *
 782  * Parameters:
 783  *
 784  * Return Value:    Void.
 785  *
 786  * Purpose:         Process
 787  *
 788  *
 789  ***************************************************************************/
 790 static void WmDtPopupHelpCB (
 791     Widget helpShellW,
 792     XtPointer clientData,
 793     XtPointer callData)
 794 {
 795     char * ptr;
 796     Atom * workspace_atoms = NULL;
 797     int num_workspaces=0;
 798
 799     CacheListStruct *pTemp = (CacheListStruct *)clientData;
 800     Arg args[10];
 801     int n;
 802
 803     n = 0;
 804     XtSetArg (args[n], XmNgeometry, NULL);   n++;
 805     XtSetArg (args[n], XmNwaitForWm, False); n++;
 806
 807     if (pTemp)
 808     {
 809         if (pTemp->workspaces)
 810         {
 811             char **atom_names = NULL;
 812             do
 813             {
 814                 ptr = DtStrchr (pTemp->workspaces, '*');
 815                 if (ptr != NULL) *ptr = NULL;
 816
 817                 atom_names =
 818                     (char **) XtRealloc ((char *)atom_names,
 819                                          sizeof(char*) * (num_workspaces + 1));
 820                 atom_names[num_workspaces] = XtNewString(pTemp->workspaces);
 821                 num_workspaces++;
 822
 823                 if (ptr != NULL)
 824                 {
 825                     *ptr = '*';
 826                     pTemp->workspaces = ptr + 1;
 827                 }
 828             } while (ptr != NULL);
 829
 830             workspace_atoms = (Atom *) XtMalloc(sizeof(Atom) * num_workspaces);
 831             XInternAtoms(wmGD.display, atom_names, num_workspaces,
 832                          True, workspace_atoms);
 833
 834             DtWsmSetWorkspacesOccupied (XtDisplay(helpShellW),
 835                                         XtWindow (helpShellW),
 836                                         workspace_atoms,
 837                                         num_workspaces);
 838
 839             while (num_workspaces-- > 0)
 840               XtFree(atom_names[num_workspaces]);
 841             XtFree ((char *) atom_names);
 842             XtFree ((char *) workspace_atoms);
 843         }
 844
 845         XtSetArg (args[n], XmNx, pTemp->xPos);       n++;
 846         XtSetArg (args[n], XmNy, pTemp->yPos);       n++;
 847         pTemp->restored = False;
 848         XtRemoveCallback(helpShellW, XmNpopupCallback,
 849                          WmDtPopupHelpCB, clientData);
 850         XtAddCallback(helpShellW, XmNpopupCallback, WmDtPopupHelpCB, NULL);
 851     }
 852     else
 853     {
 854         XtSetArg (args[n], XmNx, 0);         n++;
 855         XtSetArg (args[n], XmNy, 0);         n++;
 856     }
 857
 858     XtSetValues (helpShellW, args, n);
 859
 860
 861 } /* END OF FUNCTION WmDtPopupHelpCB */
 862
 863
 864
 865 /****************************************************************************
 866  * Function:         WmDtVersionCloseCB(
 867  *                              Widget w,
 868  *                              caddr_t clientData,
 869  *                              caddr_t callData
 870  *
 871  * Parameters:
 872  *
 873  * Return Value:    Void.
 874  *
 875  * Purpose:         Process close requests on all Help Dialog widgets
 876  *                  created and managed by this application.
 877  *
 878  ***************************************************************************/
 879 static void WmDtVersionCloseCB (
 880     Widget w,
 881     XtPointer clientData,
 882     XtPointer callData)
 883 {
 884     XtUnmanageChild (w);
 885
 886 } /* END OF FUNCTION WmDtWmVersionCloseHelpCB */
 887
 888
 889
 890
 891 /****************************************************************************
 892  * Function:        void WmDtProcessLinkCB(
 893  *                              Widget w,
 894  *                              caddr_t  clientData,
 895  *                              caddr_t callData
 896  *
 897  * Parameters:
 898  *
 899  * Return Value:    Void.
 900  *
 901  * Purpose:         Process JUMP-NEW and APP-LINK hypertext requests in a
 902  *                  given Help Dialog Window.
 903  *
 904  *                  This is the callback used for the DtNhyperLinkCallback
 905  *                  on each of the help dialog widges created.
 906  *
 907  ****************************************************************************/
 908 static void WmDtProcessLinkCB (
 909     Widget w,
 910     XtPointer clientData,
 911     XtPointer callData)
 912
 913 {
 914     DtHelpDialogCallbackStruct * hyperData =
 915         (DtHelpDialogCallbackStruct *) callData;
 916
 917     switch (hyperData->hyperType)
 918     {
 919       case DtHELP_LINK_JUMP_NEW:
 920         WmDtDisplayTopic (XtParent(w), hyperData->helpVolume,
 921                            hyperData->locationId,
 922                            /* DtHELP_LINK_JUMP_NEW */ DtHELP_TYPE_TOPIC,
 923                            (Widget)NULL, False,
 924                            NULL, 0, NULL, True, NULL);
 925         break;
 926
 927       default:  /* This catches the application definded link types */
 928         if (hyperData->hyperType >= 100)
 929         {
 930             /* The application would put any code here to handle their
 931              * Applicaiton-defined-links.
 932              */
 933         }
 934         else
 935         {
 936             /* ERROR */
 937             /* printf("We some how got a bogus hyptertext link type/n");*/
 938         }
 939     }  /* End Switch Statement */
 940
 941 } /* END OF FUNCTION WmDtProcessLinkCB */
 942
 943
 944 /****************************************************************************
 945  * Function:        void WmDtHelpOnVersion(
 946  *                              Widget parent)
 947  *
 948  * Parameters:
 949  *
 950  * Return Value:    Void.
 951  *
 952  * Purpose:         Displays a new Cache Creek help topic in a new/cached
 953  *                  help dialog widget.
 954  *
 955  ****************************************************************************/
 956 void WmDtHelpOnVersion (
 957                          Widget  parent)
 958
 959 {
 960 #ifndef NO_DT
 961
 962     Arg         setArgs[10];
 963     Arg         setArgs2[5];
 964     int         n, n2;
 965     Widget printButton = NULL;
 966     Widget helpButton = NULL;
 967     Widget backButton = NULL;
 968     Widget closeButton = NULL;
 969     XmString    label = NULL;
 970
 971    if((versionWidget != NULL) &&
 972        (XtIsManaged(versionWidget)))
 973     {
 974         return ;
 975     }
 976
 977     n = 0;
 978     if (!(versionWidget))
 979     {
 980 #ifndef NO_MESSAGE_CATALOG
 981         XtSetArg (setArgs[n], XmNtitle, wmNLS.defaultVersionTitle);     n++;
 982 #else
 983         XtSetArg (setArgs[n], XmNtitle, "About Workspace Manager");     n++;
 984 #endif
 985
 986
 987         XtSetArg (setArgs[n], DtNhelpType, DtHELP_TYPE_TOPIC);    n++;
 988         XtSetArg (setArgs[n], DtNlocationId, "_COPYRIGHT");  n++;
 989         XtSetArg (setArgs[n], DtNhelpVolume, WM_DT_HELP_VOLUME);     n++;
 990
 991         versionWidget = DtCreateHelpQuickDialog (parent, "VersionDialog",
 992                                                   setArgs, n);
 993
 994         XtAddCallback(versionWidget, DtNcloseCallback,
 995                       WmDtVersionCloseCB,
 996                       (XtPointer) versionWidget);
 997
 998         XtAddCallback(XtParent(versionWidget), XmNpopupCallback,
 999                       WmDtVersionPopupCB, NULL);
1000
1001         closeButton = DtHelpQuickDialogGetChild( versionWidget,
1002                                              DtHELP_QUICK_CLOSE_BUTTON );
1003         n2=0;
1004
1005 #ifndef NO_MESSAGE_CATALOG
1006         XtSetArg (setArgs2[n2], DtNcloseLabelString, wmGD.okLabel);    n2++;
1007 #else
1008         XtSetArg (setArgs2[n2], DtNcloseLabelString,
1009               label=XmStringCreateLocalized ("OK")); n2++;
1010 #endif
1011
1012         XtSetValues(closeButton, setArgs2, n2);
1013         if(label)XmStringFree(label);
1014
1015         printButton = DtHelpQuickDialogGetChild( versionWidget,
1016                                              DtHELP_QUICK_PRINT_BUTTON );
1017         helpButton = DtHelpQuickDialogGetChild( versionWidget,
1018                                              DtHELP_QUICK_HELP_BUTTON );
1019         backButton = DtHelpQuickDialogGetChild( versionWidget,
1020                                              DtHELP_QUICK_BACK_BUTTON );
1021
1022         XtUnmanageChild(printButton);
1023         XtUnmanageChild(helpButton);
1024         XtUnmanageChild(backButton);
1025     }
1026     else
1027     {
1028         XtSetArg (setArgs[n], DtNlocationId, "_COPYRIGHT");  n++;
1029         XtSetArg (setArgs[n], DtNhelpVolume, WM_DT_HELP_VOLUME);     n++;
1030         XtSetValues(versionWidget, setArgs, n);
1031     }
1032     XtManageChild(versionWidget);
1033
1034 #endif /* NO_DT */
1035
1036 } /* END OF FUNCTION WmDtHelpOnVersion  */
1037
1038
1039
1040 /******************************<->*************************************
1041  *
1042  *  Boolean WmDtHelp (String args)
1043  *
1044  *  Description:
1045  *  -----------
1046  *  Invoke item help
1047  *
1048  *  Inputs:
1049  *  ------
1050  *  args -
1051  *
1052  *  Outputs:
1053  *  -------
1054  *  Return - True if the find a help callback; false otherwise.
1055  *
1056  *  Comments:
1057  *  --------
1058  *
1059  ******************************<->***********************************/
1060
1061 Boolean
1062 WmDtHelp (String args)
1063 {
1064     WmScreenData *pSD;
1065     Widget theWidget;
1066     WmPanelistObject  pPanelist;
1067     char *theHelpVolume = WM_DT_HELP_VOLUME;
1068     char *theHelpTopic  = WM_DT_HELP_TOPIC;
1069     char volume[MAXWMPATH + 1];
1070     char topic[MAXWMPATH + 1];
1071     int  argCount = 0;
1072
1073
1074     /* get right screen data */
1075 /*    pSD = WmScreenDataFromWidget(w);*/
1076     pSD = wmGD.pActiveSD;
1077
1078
1079     pPanelist = (WmPanelistObject) pSD->wPanelist;
1080
1081     if (theWidget = O_Panel(pPanelist))
1082     {
1083         if (args )
1084         {
1085             /*
1086              * parse args for volume and topic
1087              */
1088             WmDtGetHelpArgs((unsigned char*)args, &volume, &topic, &argCount);
1089             if (argCount == 1)
1090             {
1091                 WmDtDisplayTopic(pSD->screenTopLevelW1,
1092                                   theHelpVolume,
1093                                   topic,
1094                                   DtHELP_TYPE_TOPIC, theWidget, True,
1095                                   NULL, 0, NULL, False, NULL);
1096             }
1097             else
1098             {
1099                 WmDtDisplayTopic(pSD->screenTopLevelW1,
1100                                   volume,
1101                                   topic,
1102                                   DtHELP_TYPE_TOPIC, theWidget, False,
1103                                   NULL, 0, NULL, False, NULL);
1104             }
1105
1106         }
1107         else
1108         {
1109             WmDtDisplayTopic(pSD->screenTopLevelW1,
1110                               theHelpVolume,
1111                               theHelpTopic,
1112                               DtHELP_TYPE_TOPIC, theWidget, True,
1113                               NULL, 0, NULL, False, NULL);
1114         }
1115         return(True);
1116     }
1117     else
1118     {
1119         return (False);
1120     }
1121 }  /* END OF FUNCTION WmDtHelp */
1122
1123
1124 /******************************<->*************************************
1125  *
1126  *  Boolean WmDtHelpMode (void)
1127  *
1128  *  Description:
1129  *  -----------
1130  *  Invoke item help mode
1131  *
1132  *  Inputs:
1133  *  ------
1134  *  args -
1135  *
1136  *  Outputs:
1137  *  -------
1138  *  Return - True if the find a help callback; false otherwise.
1139  *
1140  *  Comments:
1141  *  --------
1142  *
1143  ******************************<->***********************************/
1144
1145 Boolean
1146 WmDtHelpMode (void)
1147 {
1148     Widget selectedWidget = NULL;
1149     int iStatus;
1150     String sTmp, sMessage, sTitle;
1151
1152     iStatus = WmDtReturnSelectedWidget(wmGD.topLevelW, NULL,
1153                         &selectedWidget);
1154
1155     switch (iStatus)
1156     {
1157         case DtHELP_SELECT_VALID:
1158             if (selectedWidget != (Widget) NULL)
1159             {
1160                 do
1161                 {
1162                     if ((XtHasCallbacks(selectedWidget,
1163                             XmNhelpCallback) == XtCallbackHasSome))
1164                     {
1165                         XtCallCallbacks(selectedWidget, XmNhelpCallback,
1166                             (XtPointer)NULL);
1167                         return(True);
1168                     }
1169                     else
1170                     {
1171                         selectedWidget = XtParent(selectedWidget);
1172                     }
1173                 }
1174                 while (selectedWidget != NULL);
1175             }
1176             break;
1177
1178         case DtHELP_SELECT_INVALID:
1179             /* invalid selection error (window not of this process) */
1180 #ifndef NO_MESSAGE_CATALOG
1181             sTmp = (char *)GETMESSAGE(29, 3,
1182                  "You must select a Workspace Manager\n\
1183 dialog, an item in the Front Panel,\n\
1184 or an item in a subpanel.");
1185             sMessage = XtNewString (sTmp);
1186             sTmp = (char *)GETMESSAGE(29, 4,
1187                 "Workspace Manager - Help On Item Error");
1188             sTitle = XtNewString (sTmp);
1189 #else
1190             sMessage = "You must select a Workspace Manager\n\
1191 dialog, an item in the Front Panel,\n\
1192 or an item in a subpanel.";
1193             sTitle = "Workspace Manager - Help On Item Error";
1194 #endif
1195             wmDtErrorDialog (ACTIVE_PSD, sMessage, sTitle);
1196 #ifndef NO_MESSAGE_CATALOG
1197             if (sMessage) XtFree (sMessage);
1198             if (sTitle) XtFree (sTitle);
1199 #endif
1200             break;
1201
1202         case DtHELP_SELECT_ERROR:
1203             /* error (like grab failed) */
1204             break;
1205
1206         case DtHELP_SELECT_ABORT:
1207             /* user aborted this selection */
1208             break;
1209     } /* end switch */
1210
1211     return (False);
1212 }  /* END OF FUNCTION WmDtHelpMode */
1213
1214
1215
1216 /*****************************************************************************
1217  * Function:     WmDtReturnSelectedWidget (Widget, Cursor, Widget *)
1218  *
1219  * Parameters:   Widget      Specifies a valid widget within the app's
1220  *                           widget hierarchy.
1221  *               Cursor      Cursor to grab pointer with (use NULL!!)
1222  *               Widget *    ptr to loc to receive returned widget
1223  *
1224  * Return Value:  DtHELP_SELECT_ERROR  - error in getting the widget
1225  *                DtHELP_SELECT_ABORT  - user aborted
1226  *                DtHELP_SELECT_INVALID - user selected invalid window
1227  *                DtHELP_SELECT_VALID  - valid widget returned
1228  *
1229  * Purpose: Allows developers to get the widget ID for any widget in their UI
1230  *          that the user has selected vai the pointer.  This function will
1231  *          cause the cursor to change and allow a user to select an item in
1232  *          the UI.
1233  *
1234  *****************************************************************************/
1235 static int
1236 WmDtReturnSelectedWidget(
1237         Widget theWidget,
1238         Cursor cursor,
1239         Widget *pWidget )
1240
1241 {
1242     Display   *dpy;
1243     int       screen;
1244     int       iStatus;
1245
1246     /* Setup some needed variables */
1247     dpy = XtDisplay(theWidget);
1248     screen = ACTIVE_SCREEN;
1249
1250     /* refresh the display */
1251     XmUpdateDisplay(theWidget);
1252
1253     /* Change the curser to let the user select the desired widget */
1254     iStatus = LocateTheControl(dpy, screen, pWidget);
1255
1256     return (iStatus);
1257
1258 } /* END OF FUNCTION WmDtReturnSelectedWidget */
1259
1260
1261 /****************************************************************************
1262  * Function:        void WmDtDisplayTopic(
1263  *                              Widget parent,
1264  *                              char *helpVolume,
1265  *                              char *locationId,
1266  *                              Widget wmClient,
1267  *                              Boolean wmHelp,
1268  *                              ArgList argList,
1269  *                              int argCount,
1270  *                              ClientData *pCData,
1271  *                              Boolean  hyperlink,
1272  *                              DisplayTopicInfo   *displayTopicInfo)
1273  *
1274  * Parameters:
1275  *
1276  * Return Value:    Void.
1277  *
1278  * Purpose:         Displays a new Cache Creek help topic in a new/cached
1279  *                  help dialog widget.
1280  *
1281  ****************************************************************************/
1282 static void
1283 WmDtDisplayTopic (
1284     Widget  parent,
1285     char    *helpVolume,
1286     char    *locationId,
1287     int      helpType,
1288     Widget  wmClient,
1289     Boolean wmHelp ,
1290     ArgList argList,
1291     int argCount,
1292     ClientData *pCData,
1293     Boolean hyperLink,
1294     DisplayTopicInfo *displayTopicInfo)
1295
1296 {
1297 #ifndef NO_DT
1298     Arg         setArgs[10];
1299     Arg         smallArgs[2];
1300     ArgList  argsNew;
1301     int         n;
1302     int         ac;
1303     Widget      helpWidget;
1304     Widget      shellWidget;
1305     char *      helpTitle;
1306     WmPanelistObject  pPanelist;
1307     char *      defaultTitle="Help";
1308     ClientData *pCD = NULL;
1309     WmScreenData *pSD = NULL;
1310     CacheListStruct *pCurrentNode = NULL;
1311     Boolean       cachedNode = FALSE;
1312
1313
1314     pSD = WmScreenDataFromWidget (parent);
1315
1316
1317     pPanelist = (WmPanelistObject) pSD->wPanelist;
1318
1319     if (argCount)
1320     {
1321         /*argsNew = (ArgList) XtMalloc( sizeof( Arg) * (argCount + 1)) ;*/
1322         argsNew = (ArgList) XtMalloc( sizeof( Arg) * (argCount)) ;
1323         memcpy( argsNew, argList, (sizeof( Arg) * argCount)) ;
1324     }
1325
1326     shellWidget = parent;
1327     while (!(XtIsSubclass(shellWidget, shellWidgetClass)))
1328     {
1329         shellWidget = XtParent(shellWidget);
1330     }
1331
1332     n = 0;
1333     switch (helpType)
1334     {
1335       case  DtHELP_TYPE_TOPIC:
1336         if (helpVolume != NULL)
1337         {
1338             XtSetArg (setArgs[n],DtNhelpVolume,helpVolume);     n++;
1339         }
1340         XtSetArg (setArgs[n], DtNlocationId,locationId);        n++;
1341         helpTitle=locationId;
1342         break;
1343
1344       case DtHELP_TYPE_DYNAMIC_STRING:
1345         XtSetArg (setArgs[n], DtNstringData, locationId);        n++;
1346 /*      helpTitle=locationId;*/
1347         helpTitle=defaultTitle;
1348         break;
1349
1350       case DtHELP_TYPE_MAN_PAGE:
1351         break;
1352
1353       case DtHELP_TYPE_FILE:
1354
1355         break;
1356
1357       default:
1358         /* error condition, don't try to display help */
1359         break;
1360     }
1361
1362     if (n)
1363     {
1364         XtSetArg (setArgs[n], DtNhelpType, helpType);        n++;
1365
1366         if (wmHelp)
1367         {
1368             if (pSD->dtHelp.shell)
1369             {
1370                 helpWidget = pSD->dtHelp.dialog;
1371                 XtSetValues(helpWidget, setArgs, n);
1372             }
1373             else
1374             {
1375 #ifndef NO_MESSAGE_CATALOG
1376                 XtSetArg (setArgs[n], XmNtitle,
1377                           wmNLS.defaultDtwmHelpTitle);     n++;
1378 #else
1379                 XtSetArg (setArgs[n], XmNtitle,
1380                                 "Workspace Manager - Help");     n++;
1381 #endif
1382
1383                 pSD->dtHelp.dialog =
1384                     DtCreateHelpDialog(shellWidget, "helpWidget", setArgs, n);
1385                 helpWidget = pSD->dtHelp.dialog;
1386                 pSD->dtHelp.shell = XtParent(helpWidget);
1387                 pSD->dtHelp.bMapped = False;
1388
1389                 n = 0;
1390                 XtSetArg (setArgs[n], XmNname, "wmHelp");     n++;
1391                 if (argCount)
1392                 {
1393                     XtSetValues(pSD->dtHelp.shell,
1394                                 argList, argCount);
1395                 }
1396
1397                 XtAddCallback(helpWidget,
1398                               DtNhyperLinkCallback,
1399                               WmDtProcessLinkCB, NULL);
1400
1401                 XtAddCallback(helpWidget, DtNcloseCallback,
1402                               WmDtWmCloseHelpCB,
1403                               (XtPointer) helpWidget);
1404
1405                 XtAddCallback(pSD->dtHelp.shell, XmNpopupCallback,
1406                               WmDtWmPopupHelpCB, NULL);
1407
1408                 XtAddEventHandler(pSD->dtHelp.shell,
1409                         StructureNotifyMask,
1410                         False,
1411                         wmDtHelpMapEventHandler,
1412                         (XtPointer) pSD);
1413
1414             }
1415             if(pCData)
1416             {
1417                 ShowHelpDialog(pCData);
1418             }
1419             else
1420             {
1421                 if (wmClient)
1422                 {
1423                     XFindContext (DISPLAY, XtWindow(XtParent(wmClient)),
1424                                   wmGD.windowContextType, (caddr_t *)&pCD);
1425                 }
1426                 else
1427                 {
1428                     XFindContext (DISPLAY, XtWindow(O_Shell(pPanelist)),
1429                                   wmGD.windowContextType, (caddr_t *)&pCD);
1430                 }
1431                 ShowHelpDialog(pCD);
1432             }
1433         }     /* if (wmHelp) */
1434         else
1435         {
1436             /* Get a used or new node form our cache if we have one */
1437             cachedNode = WmDtGetFromCache(&pCurrentNode, pSD);
1438
1439             /* If we got a free one from the Cache, use it */
1440             /* Set Values on current free one, then map it */
1441             if (cachedNode)
1442             {
1443                 XtSetValues(pCurrentNode->helpDialog, setArgs, n);
1444             }
1445             else
1446             {
1447 #ifndef NO_MESSAGE_CATALOG
1448                 XtSetArg (setArgs[n], XmNtitle,
1449                           wmNLS.defaultHelpTitle);     n++;
1450 #else
1451                 XtSetArg (setArgs[n], XmNtitle,
1452                                 "Workspace Manager - Help");     n++;
1453 #endif
1454
1455                 XtSetArg (setArgs[n], XmNgeometry, NULL); n++;
1456                 XtSetArg (setArgs[n], XmNx, 0); n++;
1457                 XtSetArg (setArgs[n], XmNy, 0); n++;
1458
1459                 pCurrentNode->helpDialog =
1460                     DtCreateHelpDialog(shellWidget, "helpWidget", setArgs, n);
1461                 n = 0;
1462                 XtSetArg (setArgs[n], XmNname, "cachedHelp");     n++;
1463                 if (argCount)
1464                 {
1465                     XtSetValues(shellWidget, argList, argCount);
1466                 }
1467
1468                 XtAddCallback(pCurrentNode->helpDialog,
1469                               DtNhyperLinkCallback,
1470                               WmDtProcessLinkCB, NULL);
1471
1472                 XtAddCallback(pCurrentNode->helpDialog, DtNcloseCallback,
1473                               WmDtCloseHelpCB,
1474                               (XtPointer) pCurrentNode->helpDialog);
1475
1476                 if (hyperLink)
1477                 {
1478                     pCurrentNode->hLink = True;
1479                 }
1480                 else
1481                 {
1482                     if (displayTopicInfo)
1483                     {
1484                         pCurrentNode->workspaces =
1485                             displayTopicInfo->workspaces;
1486                         pCurrentNode->xPos = displayTopicInfo->xPos;
1487                         pCurrentNode->yPos = displayTopicInfo->yPos;
1488                         pCurrentNode->restored = True;
1489                         XtAddCallback(XtParent(pCurrentNode->helpDialog),
1490                                       XmNpopupCallback,
1491                                       WmDtPopupHelpCB,
1492                                       (XtPointer)pCurrentNode);
1493                     }
1494                     else
1495                     {
1496                         XtAddCallback(XtParent(pCurrentNode->helpDialog),
1497                                       XmNpopupCallback,
1498                                       WmDtPopupHelpCB, NULL);
1499                     }
1500                 }
1501
1502             }
1503             helpWidget = pCurrentNode->helpDialog;
1504             XtManageChild(helpWidget);
1505             XtPopup(XtParent(helpWidget), XtGrabNone);
1506         }
1507
1508     } /* if n is still 0, we did not find a useful help type */
1509 #endif /* NO_DT */
1510 } /* END OF FUNCTION WmDtDisplayTopic  */
1511
1512
1513 /****************************************************************************
1514  * Function:        static Boolean WmDtGetFromCache(
1515  *                                       CacheListStruct **pCurrentNode)
1516  *
1517  *
1518  * Parameters:
1519  *
1520  * Return Value:    Void.
1521  *
1522  * Purpose:         Gets a free help node form our cache list.  If none are
1523  *                  free, it will return fallse and the calling routine will
1524  *                  create a new help dialog widget.
1525  *
1526  ****************************************************************************/
1527 static Boolean WmDtGetFromCache(
1528                                  CacheListStruct **pCurrentNode,
1529                                  WmScreenData       *pSD)
1530 {
1531     CacheListStruct *pTemp;
1532
1533     if (pSD->cachedHelp == NULL)
1534     {
1535         /* We have a new list so lets create one and pass it back */
1536         pSD->cachedHelp =
1537             (CacheListStruct *) XtMalloc((sizeof(CacheListStruct)));
1538
1539         /* Assign the default values to our node */
1540         pSD->cachedHelp->helpDialog = NULL;
1541         pSD->cachedHelp->inUseFlag  = TRUE;
1542         pSD->cachedHelp->restored  = False;
1543         pSD->cachedHelp->hLink  = False;
1544         pSD->cachedHelp->pNext      = NULL;
1545         pSD->cachedHelp->pPrevious = NULL;
1546
1547         /* Return our head pointer because it's our first and only node */
1548         *pCurrentNode = pSD->cachedHelp;
1549         return (FALSE);
1550     }
1551     else
1552     {
1553         /* We have some nodes so search for a free one first */
1554         pTemp = pSD->cachedHelp;
1555
1556         while (pTemp != NULL)
1557         {
1558             if (pTemp->inUseFlag == FALSE)
1559             {
1560                 pTemp->inUseFlag = TRUE;
1561                 pTemp->hLink  = False;
1562                 pTemp->restored  = False;
1563                 *pCurrentNode = pTemp;
1564                 return (TRUE);
1565             }
1566             else
1567                 pTemp = pTemp->pNext;
1568         }
1569
1570
1571         /*
1572          * If we did not find a free node then we must add a new one to the
1573          * top of the list, and return it.
1574          */
1575
1576         pTemp =  (CacheListStruct *) XtMalloc((sizeof(CacheListStruct)));
1577
1578         /* Assign the default values to our node */
1579         pTemp->helpDialog = NULL;
1580         pTemp->inUseFlag  = TRUE;
1581         pTemp->restored  = False;
1582         pTemp->hLink  = False;
1583         pTemp->pNext      = pSD->cachedHelp;
1584         pTemp->pPrevious  = NULL;
1585
1586         pSD->cachedHelp->pPrevious = pTemp;
1587
1588         /* Re-Assign our head pointer to point to the new head of the list */
1589         pSD->cachedHelp = pTemp;
1590
1591         /* Return our head pointer because it's our new node */
1592         *pCurrentNode = pSD->cachedHelp;
1593         return (FALSE);
1594     }
1595
1596 } /* END OF FUNCTION WmDtGetFromCache */
1597
1598 /* End of Dt utils */
1599
1600
1601 /*************************************<->*************************************
1602  *
1603  *  void
1604  *  RestoreHelpDialogs (pSD)
1605  *
1606  *
1607  *  Description:
1608  *  -----------
1609  *  Saves the state of the help system
1610  *
1611  *  Inputs:
1612  *  ------
1613  *
1614  *
1615  *  Outputs:
1616  *  -------
1617  *  Return = none
1618  *
1619  *
1620  *  Comments:
1621  *  --------
1622  *
1623  ******************************<->***********************************/
1624
1625 Boolean
1626 RestoreHelpDialogs(
1627         WmScreenData *pSD)
1628 {
1629 #ifndef NO_DT
1630     XrmDatabase db;
1631     XrmName xrm_name[5];
1632     XrmRepresentation rep_type;
1633     XrmValue value;
1634
1635     Position xLoc, yLoc;
1636     short columns, rows;
1637     int helpType;
1638     char geometry[40];
1639     int wsCnt;
1640     int cCount;
1641     int cachedCount=0;
1642     char dialogName[10];
1643
1644     ClientData *pCD = NULL;
1645     char *tTitle = NULL;
1646     char *wsName = NULL;
1647     char *wmClientName = NULL;
1648     char *helpVolume = NULL;
1649     char *locationId = NULL;
1650     char *stringData = NULL;
1651     char *workspaces = NULL;
1652
1653     Arg setArgs[20];
1654     int ac;
1655
1656     WmPanelistObject  pPanelist = (WmPanelistObject) pSD->wPanelist;
1657
1658     xLoc = 0;
1659     yLoc = 0;
1660     columns = 40;
1661     rows = 15;
1662
1663     if (pSD->helpResources)
1664     {
1665         if ((db = XrmGetStringDatabase (pSD->helpResources)) == NULL)
1666         {
1667             return(False);
1668         }
1669         xrm_name [0] = XrmStringToQuark ("wsHelp");
1670         xrm_name [1] = XrmStringToQuark ("onScreen");
1671         xrm_name [2] = NULL;
1672
1673
1674         if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value))
1675         {
1676             /* Are we supposed to be mapped? */
1677             if (strcmp(value.addr, "True") == 0)
1678             {
1679                 ac = 0;
1680                 /* get x position */
1681                 xrm_name [1] = XrmStringToQuark ("x");
1682                 if (XrmQGetResource (db, xrm_name, xrm_name,
1683                                      &rep_type, &value))
1684                 {
1685                     pSD->dtHelp.xPos = (Position)atoi((char *)value.addr);
1686                     pSD->dtHelp.restored = True;
1687                 }
1688
1689                 /* get y position */
1690                 xrm_name [1] = XrmStringToQuark ("y");
1691                 if (XrmQGetResource (db, xrm_name, xrm_name,
1692                                      &rep_type, &value))
1693                 {
1694                     pSD->dtHelp.yPos = (Position)atoi((char *)value.addr);
1695                     pSD->dtHelp.restored = True;
1696                 }
1697
1698                 /* get columns */
1699                 xrm_name [1] = XrmStringToQuark ("columns");
1700                 if (XrmQGetResource (db, xrm_name, xrm_name,
1701                                      &rep_type, &value))
1702                 {
1703                     XtSetArg (setArgs[ac], XmNcolumns,
1704                               (short)atoi((char *)value.addr)); ac++;
1705                     columns = (short)atoi((char *)value.addr);
1706                 }
1707
1708                 /* get rows */
1709                 xrm_name [1] = XrmStringToQuark ("rows");
1710                 if (XrmQGetResource (db, xrm_name, xrm_name,
1711                                      &rep_type, &value))
1712                 {
1713                     XtSetArg (setArgs[ac], XmNrows,
1714                               (short)atoi((char *)value.addr)); ac++;
1715                     rows = (short)atoi((char *)value.addr);
1716                 }
1717                 sprintf (geometry, "=+%d+%d", xLoc, yLoc);
1718
1719                 XtSetArg (setArgs[ac], XmNgeometry,
1720                           XtNewString(geometry)); ac++;
1721
1722                 /* get visiblePathCount */
1723                 xrm_name [1] = XrmStringToQuark ("vPCount");
1724                 if (XrmQGetResource (db, xrm_name, xrm_name,
1725                                      &rep_type, &value))
1726                 {
1727                     XtSetArg (setArgs[ac], DtNvisiblePathCount,
1728                               (int)atoi((char *)value.addr)); ac++;
1729                 }
1730
1731                 /* get topicTitle */
1732                 xrm_name [1] = XrmStringToQuark ("tTitle");
1733                 if (XrmQGetResource (db, xrm_name, xrm_name,
1734                                      &rep_type, &value))
1735                 {
1736                     tTitle = XtNewString ((char *)value.addr);
1737                     XtSetArg (setArgs[ac], DtNtopicTitle, tTitle); ac++;
1738                 }
1739
1740                 /* get help type */
1741                 xrm_name [1] = XrmStringToQuark ("helpType");
1742                 if (XrmQGetResource (db, xrm_name, xrm_name,
1743                                      &rep_type, &value))
1744                 {
1745                     XtSetArg (setArgs[ac], DtNhelpType,
1746                               (int)atoi((char *)value.addr)); ac++;
1747                     helpType = (int)atoi((char *)value.addr);
1748                 }
1749
1750
1751                 switch (helpType)
1752                 {
1753                   case  DtHELP_TYPE_TOPIC:
1754                     /* get helpVolume */
1755                     xrm_name [1] = XrmStringToQuark ("helpVolume");
1756                     if (XrmQGetResource (db, xrm_name, xrm_name,
1757                                          &rep_type, &value))
1758                     {
1759                         helpVolume = XtNewString ((char *)value.addr);
1760 /*                      XtSetArg (setArgs[ac], DtNhelpVolume,
1761                                   helpVolume); ac++;*/
1762                     }
1763                     /* get locationId */
1764                     xrm_name [1] = XrmStringToQuark ("locationId");
1765                     if (XrmQGetResource (db, xrm_name, xrm_name,
1766                                          &rep_type, &value))
1767                     {
1768                         locationId = XtNewString ((char *)value.addr);
1769 /*                      XtSetArg (setArgs[ac], DtNlocationId,
1770                                   locationId); ac++;*/
1771                     }
1772
1773                     break;
1774
1775                   case DtHELP_TYPE_DYNAMIC_STRING:
1776
1777                     /* get stringData */
1778                     xrm_name [1] = XrmStringToQuark ("stringData");
1779                     if (XrmQGetResource (db, xrm_name, xrm_name,
1780                                          &rep_type, &value))
1781                     {
1782                         stringData = XtNewString ((char *)value.addr);
1783 /*                      XtSetArg (setArgs[ac], DtNstringData,
1784                                   stringData); ac++;*/
1785                         locationId = stringData;
1786                     }
1787
1788                     break;
1789
1790                   case DtHELP_TYPE_MAN_PAGE:
1791
1792                     break;
1793
1794                   case DtHELP_TYPE_FILE:
1795
1796                     break;
1797
1798                   default:
1799                     /* error condition, don't try to display help */
1800                     break;
1801                 }
1802
1803                 /* get name of wm client for which wmHelp is transient */
1804
1805                 xrm_name [1] = XrmStringToQuark ("windowGroup");
1806                 if (XrmQGetResource (db, xrm_name, xrm_name,
1807                                      &rep_type, &value))
1808                 {
1809                     wmClientName =  ((char *)value.addr);
1810                     if ((!strcmp(wmClientName, pSD->iconBoxName)) &&
1811                         (pSD->useIconBox))
1812                     {
1813                         xrm_name [1] = XrmStringToQuark ("wsName");
1814                         if (XrmQGetResource (db, xrm_name, xrm_name,
1815                                              &rep_type, &value))
1816                         {
1817                             wsName = (char *)value.addr;
1818                             for (wsCnt = 0; wsCnt < pSD->numWorkspaces;
1819                                  wsCnt++)
1820                             {
1821                                 if (!strcmp(pSD->pWS[wsCnt].name, wsName))
1822                                 {
1823                                     pCD=pSD->pWS[wsCnt].pIconBox->pCD_iconBox;
1824                                     break;
1825                                 }
1826                             }
1827                         }
1828
1829                     }
1830 /*
1831                     else if(!strcmp(wmClientName, O_PanelName(pPanelist)))
1832                     {
1833                         pCD=O_ClientData(pPanelist);
1834                     }
1835 */
1836                 }
1837
1838                 /*
1839                  *  Map the help dialog
1840                  */
1841
1842                 WmDtDisplayTopic(pSD->screenTopLevelW1, helpVolume,
1843                                   locationId,
1844                                   helpType, NULL, True,
1845                                   setArgs, ac, pCD, False, NULL);
1846             }
1847         }/* if (XrmQGetResource for wsHelp) */
1848
1849         xrm_name [0] = XrmStringToQuark ("cachedHelp");
1850         xrm_name [1] = XrmStringToQuark ("cachedCount");
1851         xrm_name [2] = NULL;
1852
1853
1854         if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value))
1855         {
1856             /* restore cachedCount number of help dialogs */
1857             cachedCount = (int)atoi((char *)value.addr);
1858             for (cCount=1; cCount < (cachedCount + 1); cCount++)
1859             {
1860                 sprintf (dialogName,  "oWsHelp%d", cCount);
1861                 xrm_name [0] = XrmStringToQuark (dialogName);
1862                 xrm_name [1] = NULL;
1863                 xrm_name [2] = NULL;
1864
1865                 displayTopicInfo.xPos = 0;
1866                 displayTopicInfo.xPos = 0;
1867                 displayTopicInfo.workspaces = NULL;
1868
1869                 ac = 0;
1870                 /* get x position */
1871                 xrm_name [1] = XrmStringToQuark ("x");
1872                 if (XrmQGetResource (db, xrm_name, xrm_name,
1873                                      &rep_type, &value))
1874                 {
1875                     /*              XtSetArg (setArgs[ac], XmNx,
1876                                     atoi((char *)value.addr)); ac++;*/
1877                     xLoc = (Position)atoi((char *)value.addr);
1878                     displayTopicInfo.xPos = xLoc;
1879                 }
1880
1881                 /* get y position */
1882                 xrm_name [1] = XrmStringToQuark ("y");
1883                 if (XrmQGetResource (db, xrm_name, xrm_name,
1884                                      &rep_type, &value))
1885                 {
1886                     /*              XtSetArg (setArgs[ac], XmNy,
1887                                     atoi((char *)value.addr)); ac++;*/
1888                     yLoc = (Position)atoi((char *)value.addr);
1889                     displayTopicInfo.yPos = yLoc;
1890                 }
1891
1892                 /* get columns */
1893                 xrm_name [1] = XrmStringToQuark ("columns");
1894                 if (XrmQGetResource (db, xrm_name, xrm_name,
1895                                      &rep_type, &value))
1896                 {
1897                     XtSetArg (setArgs[ac], XmNcolumns,
1898                               (short)atoi((char *)value.addr)); ac++;
1899                     columns = (short)atoi((char *)value.addr);
1900                 }
1901
1902                 /* get rows */
1903                 xrm_name [1] = XrmStringToQuark ("rows");
1904                 if (XrmQGetResource (db, xrm_name, xrm_name,
1905                                      &rep_type, &value))
1906                 {
1907                     XtSetArg (setArgs[ac], XmNrows,
1908                               (short)atoi((char *)value.addr)); ac++;
1909                     rows = (short)atoi((char *)value.addr);
1910                 }
1911                 sprintf (geometry, "=+%d+%d", xLoc, yLoc);
1912
1913                 XtSetArg (setArgs[ac], XmNgeometry,
1914                           XtNewString(geometry)); ac++;
1915
1916                 /* get visiblePathCount */
1917                 xrm_name [1] = XrmStringToQuark ("vPCount");
1918                 if (XrmQGetResource (db, xrm_name, xrm_name,
1919                                      &rep_type, &value))
1920                 {
1921                     XtSetArg (setArgs[ac], DtNvisiblePathCount,
1922                               (int)atoi((char *)value.addr)); ac++;
1923                 }
1924
1925                 /* get topicTitle */
1926                 xrm_name [1] = XrmStringToQuark ("tTitle");
1927                 if (XrmQGetResource (db, xrm_name, xrm_name,
1928                                      &rep_type, &value))
1929                 {
1930                     tTitle = XtNewString ((char *)value.addr);
1931                     XtSetArg (setArgs[ac], DtNtopicTitle, tTitle); ac++;
1932                 }
1933
1934                 /* get workspaces list */
1935                 xrm_name [1] = XrmStringToQuark ("workspaces");
1936                 if (XrmQGetResource (db, xrm_name, xrm_name,
1937                                      &rep_type, &value))
1938                 {
1939                     workspaces = XtNewString ((char *)value.addr);
1940                     displayTopicInfo.workspaces = workspaces;
1941                 }
1942
1943
1944                 /* get help type */
1945                 xrm_name [1] = XrmStringToQuark ("helpType");
1946                 if (XrmQGetResource (db, xrm_name, xrm_name,
1947                                      &rep_type, &value))
1948                 {
1949                     XtSetArg (setArgs[ac], DtNhelpType,
1950                               (int)atoi((char *)value.addr)); ac++;
1951                     helpType = (int)atoi((char *)value.addr);
1952                 }
1953
1954
1955                 switch (helpType)
1956                 {
1957                   case  DtHELP_TYPE_TOPIC:
1958                     /* get helpVolume */
1959                     xrm_name [1] = XrmStringToQuark ("helpVolume");
1960                     if (XrmQGetResource (db, xrm_name, xrm_name,
1961                                          &rep_type, &value))
1962                     {
1963                         helpVolume = XtNewString ((char *)value.addr);
1964                     }
1965                     /* get locationId */
1966                     xrm_name [1] = XrmStringToQuark ("locationId");
1967                     if (XrmQGetResource (db, xrm_name, xrm_name,
1968                                          &rep_type, &value))
1969                     {
1970                         locationId = XtNewString ((char *)value.addr);
1971                     }
1972
1973                     break;
1974
1975                   case DtHELP_TYPE_DYNAMIC_STRING:
1976
1977                     /* get stringData */
1978                     xrm_name [1] = XrmStringToQuark ("stringData");
1979                     if (XrmQGetResource (db, xrm_name, xrm_name,
1980                                          &rep_type, &value))
1981                     {
1982                         stringData = XtNewString ((char *)value.addr);
1983                         /* XtSetArg (setArgs[ac], DtNstringData,
1984                                                 stringData); ac++;*/
1985                         locationId = stringData;
1986                     }
1987
1988                     break;
1989
1990                   case DtHELP_TYPE_MAN_PAGE:
1991
1992                     break;
1993
1994                   case DtHELP_TYPE_FILE:
1995
1996                     break;
1997
1998                   default:
1999                     /* error condition, don't try to display help */
2000                     break;
2001
2002                 } /* switch */
2003
2004                 WmDtDisplayTopic(pSD->screenTopLevelW1, helpVolume,
2005                                   locationId,
2006                                   helpType, NULL, False,
2007                                   setArgs, ac, NULL, False,
2008                                   &displayTopicInfo);
2009
2010             } /* for all cached help dialogs */
2011
2012
2013         } /* if (XrmQGetResource ) cachedHelp/cachedCount */
2014
2015         XrmDestroyDatabase(db);
2016     }
2017 #endif /* NO_DT */
2018 } /* END OF FUNCTION  RestoreHelpDialogs */
2019
2020 /*************************************<->*************************************
2021  *
2022  *  void
2023  *  SaveHelpResources (pSD)
2024  *
2025  *
2026  *  Description:
2027  *  -----------
2028  *  Saves the state of the help system
2029  *
2030  *  Inputs:
2031  *  ------
2032  *
2033  *
2034  *  Outputs:
2035  *  -------
2036  *  Return = none
2037  *
2038  *
2039  *  Comments:
2040  *  --------
2041  *
2042  ******************************<->***********************************/
2043
2044 void
2045 SaveHelpResources(
2046         WmScreenData *pSD)
2047 {
2048 #ifndef NO_DT
2049     PtrWsDtHelpData  pHelp;
2050     CacheListStruct *pTemp;
2051     Arg getArgs[20];
2052     int ac;
2053
2054     Window wmGroupWindow;
2055     ClientData *pCD;
2056     ClientData *pCDforHelp;
2057     int wsCnt;
2058     int thisCnt;
2059     WorkspaceID wsID;
2060     WmWorkspaceData *pWS;
2061
2062     Position xLoc, yLoc;
2063     short columns, rows;
2064     unsigned char helpType;
2065     int vPCount;
2066     char *helpVolume;
2067     char *locationId;
2068     char *stringData;
2069     char *topicTitle;
2070     char *wsName;
2071     char workspaces[MAXWMPATH+1];
2072
2073     char buffer[MAXWMPATH+1];
2074     char *res_class;
2075     char *data;
2076     int cum_len;
2077
2078     char screenName[10];
2079     char dialogName[128];
2080     char resString[MAXWMPATH+1];
2081
2082     int  cachedCount=0;
2083
2084
2085     pHelp = &pSD->dtHelp;
2086
2087     /* allocate initial data space */
2088     if ((data = (char *) XtMalloc (MAXWMPATH+1)) == NULL)
2089     {
2090         Warning (((char *)
2091                   GETMESSAGE(76,12,"Insufficient memory to save resources")));
2092         Do_Quit_Mwm (False);
2093     }
2094     cum_len = 1;
2095     *data = '\0';
2096
2097     /* Get our current resource class */
2098
2099     if (MwmBehavior)
2100     {
2101         res_class = WM_RESOURCE_CLASS;
2102     }
2103     else
2104     {
2105         res_class = DT_WM_RESOURCE_CLASS;
2106     }
2107
2108     sprintf (screenName, "%d\0", pSD->screen);
2109
2110     sprintf (buffer, "%s*%s*%s:  \\n ", res_class,  screenName,
2111              WmNhelpResources);
2112     AddStringToResourceData (buffer, &data, &cum_len);
2113
2114     if (pHelp->onScreen)
2115     {
2116         sprintf (dialogName, "wsHelp");
2117         sprintf (buffer, "%s*onScreen: True\\n ", dialogName);
2118         AddStringToResourceData (buffer, &data, &cum_len);
2119
2120         ac = 0;
2121         XtSetArg(getArgs[ac], XmNx, &xLoc);   ac++;
2122         XtSetArg(getArgs[ac], XmNy, &yLoc);   ac++;
2123         XtGetValues(pSD->dtHelp.shell, getArgs, ac);
2124         if (!XFindContext (DISPLAY, XtWindow(pSD->dtHelp.shell),
2125                            wmGD.windowContextType, (caddr_t *)&pCDforHelp))
2126         {
2127             if (wmGD.positionIsFrame)
2128             {
2129                 xLoc = xLoc - pCDforHelp->clientOffset.x;
2130                 yLoc = yLoc - pCDforHelp->clientOffset.y;
2131             }
2132         }
2133
2134         ac = 0;
2135         XtSetArg(getArgs[ac], XmNcolumns, &columns); ac++;
2136         XtSetArg(getArgs[ac], XmNrows, &rows);   ac++;
2137         XtSetArg(getArgs[ac], DtNhelpType, &helpType);   ac++;
2138         XtSetArg(getArgs[ac], DtNvisiblePathCount, &vPCount);   ac++;
2139         XtSetArg(getArgs[ac], DtNtopicTitle, &topicTitle);   ac++;
2140         XtGetValues(pSD->dtHelp.dialog, getArgs, ac);
2141
2142         sprintf (buffer, "%s*x: %d \\n ", dialogName, xLoc);
2143         AddStringToResourceData (buffer, &data, &cum_len);
2144         sprintf (buffer, "%s*y: %d \\n ", dialogName, yLoc);
2145         AddStringToResourceData (buffer, &data, &cum_len);
2146         sprintf (buffer, "%s*columns: %d \\n ", dialogName, columns);
2147         AddStringToResourceData (buffer, &data, &cum_len);
2148         sprintf (buffer, "%s*rows: %d \\n ", dialogName, rows);
2149         AddStringToResourceData (buffer, &data, &cum_len);
2150         sprintf (buffer, "%s*helpType: %d \\n ", dialogName, helpType);
2151         AddStringToResourceData (buffer, &data, &cum_len);
2152         sprintf (buffer, "%s*vPCount: %d \\n ", dialogName, vPCount);
2153         AddStringToResourceData (buffer, &data, &cum_len);
2154         sprintf (buffer, "%s*tTitle: %s\\n ", dialogName, topicTitle);
2155         AddStringToResourceData (buffer, &data, &cum_len);
2156
2157         ac = 0;
2158         switch (helpType)
2159         {
2160           case  DtHELP_TYPE_TOPIC:
2161             XtSetArg (getArgs[ac],DtNhelpVolume, &helpVolume); ac++;
2162             XtSetArg (getArgs[ac], DtNlocationId, &locationId); ac++;
2163             XtGetValues(pSD->dtHelp.dialog, getArgs, ac);
2164             sprintf (buffer, "%s*helpVolume: %s\\n ", dialogName, helpVolume);
2165             AddStringToResourceData (buffer, &data, &cum_len);
2166             sprintf (buffer, "%s*locationId: %s\\n ", dialogName, locationId);
2167             AddStringToResourceData (buffer, &data, &cum_len);
2168
2169             break;
2170
2171           case DtHELP_TYPE_DYNAMIC_STRING:
2172             XtSetArg (getArgs[ac], DtNstringData, &stringData); ac++;
2173             XtGetValues(pSD->dtHelp.dialog, getArgs, ac);
2174             sprintf (buffer, "%s*stringData: %s\\n ", dialogName, stringData);
2175             AddStringToResourceData (buffer, &data, &cum_len);
2176
2177             break;
2178
2179           case DtHELP_TYPE_MAN_PAGE:
2180
2181             break;
2182
2183           case DtHELP_TYPE_FILE:
2184
2185             break;
2186
2187           default:
2188             /* error condition, don't try to display help */
2189             break;
2190         }
2191
2192         ac = 0;
2193         XtSetArg(getArgs[ac], XmNwindowGroup, &wmGroupWindow);   ac++;
2194         XtGetValues(pSD->dtHelp.shell, getArgs, ac);
2195
2196         if (!XFindContext (DISPLAY, wmGroupWindow,
2197                            wmGD.windowContextType, (caddr_t *)&pCD))
2198         {
2199             sprintf (buffer, "%s*windowGroup: %s\\n ", dialogName,
2200                      pCD->clientName);
2201             AddStringToResourceData (buffer, &data, &cum_len);
2202
2203             if ((!strcmp(pCD->clientName, pSD->iconBoxName)) &&
2204                 (pSD->useIconBox))
2205             {
2206                 wsName = XGetAtomName(DISPLAY,
2207                                       pCD->pWsList[pCD->currentWsc].wsID);
2208                 sprintf (buffer, "%s*wsName: %s\\n ", dialogName,
2209                          wsName);
2210                 AddStringToResourceData (buffer, &data, &cum_len);
2211                 XFree(wsName);
2212             }
2213         }
2214
2215     }
2216
2217     if (pSD->cachedHelp != NULL)
2218     {
2219         /*
2220          * We have some nodes so search for
2221          * managed dialogs and save their state
2222          */
2223
2224         pTemp = pSD->cachedHelp;
2225
2226         while (pTemp != NULL)
2227         {
2228             if (pTemp->inUseFlag == FALSE)
2229             {
2230                 pTemp = pTemp->pNext;
2231             }
2232             else
2233             {
2234                 cachedCount++;
2235                 sprintf (dialogName,  "oWsHelp%d",cachedCount);
2236
2237                 ac = 0;
2238                 XtSetArg(getArgs[ac], XmNx, &xLoc);   ac++;
2239                 XtSetArg(getArgs[ac], XmNy, &yLoc);   ac++;
2240                 XtGetValues(XtParent(pTemp->helpDialog), getArgs, ac);
2241                 if (!XFindContext (DISPLAY,
2242                                    XtWindow(XtParent(pTemp->helpDialog)),
2243                                    wmGD.windowContextType,
2244                                    (caddr_t *)&pCDforHelp))
2245                 {
2246                     if (wmGD.positionIsFrame)
2247                     {
2248                         xLoc = xLoc - pCDforHelp->clientOffset.x;
2249                         yLoc = yLoc - pCDforHelp->clientOffset.y;
2250                     }
2251                 }
2252                 else
2253                 {
2254                     pCDforHelp = NULL;
2255                 }
2256
2257
2258                 ac = 0;
2259                 XtSetArg(getArgs[ac], XmNcolumns, &columns); ac++;
2260                 XtSetArg(getArgs[ac], XmNrows, &rows);   ac++;
2261                 XtSetArg(getArgs[ac], DtNhelpType, &helpType);   ac++;
2262                 XtSetArg(getArgs[ac], DtNvisiblePathCount, &vPCount);   ac++;
2263                 XtSetArg(getArgs[ac], DtNtopicTitle, &topicTitle);   ac++;
2264                 XtGetValues(pTemp->helpDialog, getArgs, ac);
2265
2266                 sprintf (buffer, "%s*x: %d \\n ", dialogName, xLoc);
2267                 AddStringToResourceData (buffer, &data, &cum_len);
2268                 sprintf (buffer, "%s*y: %d \\n ", dialogName, yLoc);
2269                 AddStringToResourceData (buffer, &data, &cum_len);
2270                 sprintf (buffer, "%s*columns: %d \\n ", dialogName, columns);
2271                 AddStringToResourceData (buffer, &data, &cum_len);
2272                 sprintf (buffer, "%s*rows: %d \\n ", dialogName, rows);
2273                 AddStringToResourceData (buffer, &data, &cum_len);
2274                 sprintf (buffer, "%s*helpType: %d \\n ", dialogName, helpType);
2275                 AddStringToResourceData (buffer, &data, &cum_len);
2276                 sprintf (buffer, "%s*vPCount: %d \\n ", dialogName, vPCount);
2277                 AddStringToResourceData (buffer, &data, &cum_len);
2278                 sprintf (buffer, "%s*tTitle: %s\\n ", dialogName, topicTitle);
2279                 AddStringToResourceData (buffer, &data, &cum_len);
2280
2281                 ac = 0;
2282                 switch (helpType)
2283                 {
2284                   case  DtHELP_TYPE_TOPIC:
2285                     XtSetArg (getArgs[ac],DtNhelpVolume, &helpVolume); ac++;
2286                     XtSetArg (getArgs[ac], DtNlocationId, &locationId); ac++;
2287                     XtGetValues(pTemp->helpDialog, getArgs, ac);
2288                     sprintf (buffer, "%s*helpVolume: %s\\n ",
2289                              dialogName, helpVolume);
2290                     AddStringToResourceData (buffer, &data, &cum_len);
2291                     sprintf (buffer, "%s*locationId: %s\\n ",
2292                              dialogName, locationId);
2293                     AddStringToResourceData (buffer, &data, &cum_len);
2294
2295                     break;
2296
2297                   case DtHELP_TYPE_DYNAMIC_STRING:
2298                     XtSetArg (getArgs[ac], DtNstringData, &stringData); ac++;
2299                     XtGetValues(pTemp->helpDialog, getArgs, ac);
2300                     sprintf (buffer, "%s*stringData: %s\\n ",
2301                              dialogName, stringData);
2302                     AddStringToResourceData (buffer, &data, &cum_len);
2303
2304                     break;
2305
2306                   case DtHELP_TYPE_MAN_PAGE:
2307
2308                     break;
2309
2310                   case DtHELP_TYPE_FILE:
2311
2312                     break;
2313
2314                   default:
2315                     /* error condition, don't try to display help */
2316                     break;
2317                 }
2318
2319                 if (pCDforHelp)
2320                 {
2321                     thisCnt = 0;
2322                     sprintf(workspaces,"");
2323                     for (wsCnt = 0; wsCnt < pSD->numWorkspaces;
2324                          wsCnt++)
2325                     {
2326                         wsID = XInternAtom (DISPLAY, pSD->pWS[wsCnt].name,
2327                                             False);
2328                         pWS = GetWorkspaceData (pSD, wsID);
2329
2330                         if (ClientInWorkspace (pWS, pCDforHelp))
2331                         {
2332                             if (thisCnt == 0)
2333                             {
2334                                 strcpy(workspaces, pSD->pWS[wsCnt].name);
2335
2336                             }
2337                             else
2338                             {
2339                                 strcat(workspaces, "*");
2340                                 strcat(workspaces, pSD->pWS[wsCnt].name);
2341                             }
2342                             thisCnt++;
2343                         }
2344                     }
2345                     sprintf (buffer, "%s*workspaces: %s\\n ", dialogName,
2346                              workspaces);
2347                     AddStringToResourceData (buffer, &data, &cum_len);
2348                 }
2349                 pTemp = pTemp->pNext;
2350             }
2351         } /* While */
2352         if (cachedCount)
2353         {
2354             sprintf (buffer, "cachedHelp*cachedCount: %d\\n ",  cachedCount);
2355             AddStringToResourceData (buffer, &data, &cum_len);
2356         }
2357     }
2358
2359     if (data)
2360     {
2361         /*
2362          * Save help resources as a string
2363          */
2364         sprintf (buffer, " \n");
2365         AddStringToResourceData (buffer, &data, &cum_len);
2366
2367         _DtAddToResource (DISPLAY, data);
2368         XtFree(data);
2369     }
2370 #endif /*  NO_DT */
2371 } /* END OF FUNCTION  SaveHelpResources */
2372
2373
2374
2375 /* Code stolen from WmPresence.c */
2376
2377 /*************************************<->*************************************
2378  *
2379  *  void
2380  *  ShowHelpDialog (pClient)
2381  *
2382  *
2383  *  Description:
2384  *  -----------
2385  *  Pops up (shows) the help dialog
2386  *
2387  *  Inputs:
2388  *  ------
2389  *
2390  *
2391  *  Outputs:
2392  *  -------
2393  *  Return = none
2394  *
2395  *
2396  *  Comments:
2397  *  --------
2398  *
2399  ******************************<->***********************************/
2400
2401 static void
2402 ShowHelpDialog(
2403         ClientData *pClient)
2404 {
2405     PtrWsDtHelpData  pHelp;
2406     WmScreenData *pSD;
2407     ClientData *pOldCD;
2408
2409     if (!(pClient))
2410     {
2411         pSD=wmGD.pActiveSD;
2412     }
2413     else
2414     {
2415         pSD = pClient->pSD;
2416     }
2417     pHelp = &pSD->dtHelp;
2418
2419     pOldCD = pHelp->pCDforClient;
2420     pHelp->pCDforClient = pClient;
2421 /*    pHelp->contextForClient = wsContext;*/
2422
2423     if (pSD->dtHelp.onScreen)
2424     {
2425         ClientData *pCD = NULL;
2426
2427         XFindContext (DISPLAY, XtWindow (pSD->dtHelp.shell),
2428                         wmGD.windowContextType, (XtPointer) &pCD);
2429
2430         if ((!pSD->dtHelp.bMapped) ||
2431             (pCD &&
2432              (!ClientInWorkspace (ACTIVE_WS, pCD) ||
2433              (pCD->clientState == MINIMIZED_STATE) ||
2434              (pOldCD && pOldCD != pHelp->pCDforClient))))
2435         {
2436             HideHelpDialog (pSD, True);
2437         }
2438     }
2439
2440     /*
2441      * pop it up
2442      */
2443
2444     XtManageChild(pSD->dtHelp.dialog);
2445     XtPopup (pSD->dtHelp.shell, XtGrabNone);
2446
2447     pSD->dtHelp.onScreen = True;
2448
2449 } /* END OF FUNCTION  ShowHelpDialog */
2450
2451
2452 /*************************************<->*************************************
2453  *
2454  *  void
2455  *  HideHelpDialog (pSD, userDismissed)
2456  *
2457  *
2458  *  Description:
2459  *  -----------
2460  *  Pops down (hides) the workspace presence dialog
2461  *
2462  *  Inputs:
2463  *  ------
2464  *  pSD = pointer to screen data
2465  *  userDismissed = did the user dismiss or did workspace switching
2466  *                  unpost the workspace presence box ?
2467  *
2468  *  Outputs:
2469  *  -------
2470  *  Return = none
2471  *
2472  *
2473  *  Comments:
2474  *  --------
2475  *
2476  ******************************<->***********************************/
2477
2478 static void
2479 HideHelpDialog(
2480         WmScreenData *pSD,
2481         Boolean userDismissed )
2482
2483 {
2484     if (pSD->dtHelp.onScreen)
2485     {
2486         /* Pop down the shell */
2487         XtPopdown (pSD->dtHelp.shell);
2488
2489         /*
2490          * Do a withdraw to make sure window gets unmanaged
2491          * (popdown does nothing if its unmapped)
2492          */
2493         XWithdrawWindow (DISPLAY, XtWindow (pSD->dtHelp.shell),
2494                          pSD->screen);
2495         /* must sync to insure event order */
2496         XSync (DISPLAY, False);
2497
2498
2499         pSD->dtHelp.onScreen = False;
2500         pSD->dtHelp.userDismissed = userDismissed;
2501     }
2502
2503 } /* END OF FUNCTION HideHelpDialog  */
2504
2505
2506 /*************************************<->*************************************
2507  *
2508  *  wmDtHelpSetPosition (pHelp, pSD, restorePos)
2509  *
2510  *
2511  *  Description:
2512  *  -----------
2513  *  Sets the position of the workspace presence dialog
2514  *
2515  *  Inputs:
2516  *  ------
2517  *  pPres = pointer to workspace presence data
2518  *
2519  *  Outputs:
2520  *  --------
2521  *
2522  ******************************<->***********************************/
2523 static void
2524 wmDtHelpSetPosition(
2525                      PtrWsDtHelpData pHelp,
2526                      WmScreenData *pSD,
2527                      Boolean restorePos)
2528 {
2529     Arg args[10];
2530     int n;
2531     XFontStruct *font;
2532     Dimension height;
2533     Window wGroup;
2534     int x, y;
2535     ClientData *pCDforHelp;
2536
2537     if (!restorePos)
2538     {
2539         /*
2540          * Get size of this dialog
2541          */
2542         n = 0;
2543         XtSetArg (args[n], XmNheight, &height); n++;
2544         XtGetValues (pHelp->shell, args, n);
2545
2546         if (wmGD.positionIsFrame)
2547         {
2548             if (pSD->decoupleTitleAppearance)
2549             {
2550                 font = pSD->clientTitleAppearance.font;
2551             }
2552             else
2553             {
2554                 font = pSD->clientAppearance.font;
2555             }
2556
2557 /*          height += TEXT_HEIGHT(font) + (2 * pSD->frameBorderWidth);*/
2558             height += TEXT_HEIGHT(font) + (2 * pSD->resizeBorderWidth);
2559         }
2560
2561
2562         /*
2563          * set position of dialog relative to client window
2564          * (use system menu position)
2565          * set this dialog to be transient for the client
2566          * for which it is posted.
2567      */
2568         if (pHelp->pCDforClient)
2569         {
2570             GetSystemMenuPosition (pHelp->pCDforClient,
2571                                    &x, &y, height,
2572                                    (Context)0);
2573 #ifdef NO
2574             if(y < pHelp->pCDforClient->frameInfo.y)
2575             {
2576                 if (!XFindContext (DISPLAY, XtWindow(pHelp->shell),
2577                                    wmGD.windowContextType,
2578                                    (caddr_t *)&pCDforHelp))
2579                 {
2580                     if (wmGD.positionIsFrame)
2581                     {
2582 /*                      x = x - pCDforHelp->clientOffset.x;*/
2583                         y = y - pCDforHelp->clientOffset.x;
2584                     }
2585                 }
2586                 else
2587                 {
2588                     y = y - (2 * pSD->frameBorderWidth);
2589                 }
2590             }
2591 #endif
2592         }
2593         else
2594         {
2595             /*
2596              * Don't have a client so map at 0,0
2597          */
2598             x = 0;
2599             y = 0;
2600         }
2601     }
2602     else
2603     {
2604         x = pHelp->xPos;
2605         y = pHelp->yPos;
2606     }
2607
2608     n = 0;
2609     XtSetArg (args[n], XmNgeometry, NULL); n++;
2610     XtSetArg (args[n], XmNx, x);                                n++;
2611     XtSetArg (args[n], XmNy, y);                                n++;
2612     XtSetArg (args[n], XmNtransientFor, NULL);                  n++;
2613
2614     if (pHelp->pCDforClient)
2615     {
2616         int ac;
2617         Arg al[5];
2618
2619         ac = 0;
2620         XtSetArg (al[ac], XmNwindowGroup, &wGroup); ac++;
2621         XtGetValues (pHelp->shell, al, ac);
2622
2623 #ifdef FUTURE
2624         if (pHelp->contextForClient != F_CONTEXT_ICON)
2625         {
2626             XtSetArg (args[n], XmNwindowGroup,
2627                       pHelp->pCDforClient->client);
2628             n++;
2629         }
2630         else if (pSD->useIconBox && P_ICON_BOX(pHelp->pCDforClient))
2631         {
2632             XtSetArg (args[n], XmNwindowGroup,
2633                       P_ICON_BOX(pHelp->pCDforClient)->pCD_iconBox->client);
2634             n++;
2635         }
2636         else
2637         {
2638             XtSetArg (args[n], XmNwindowGroup, 0); n++;
2639         }
2640 #else /* FUTURE */
2641         if (wGroup != pHelp->pCDforClient->client)
2642         {
2643             /*
2644              * Changing who this is transient for, need to
2645              * make sure the window is unmapped so that the
2646              * window manager moves it to the right place.
2647              */
2648             HideHelpDialog (pSD, True);
2649         }
2650
2651         XtSetArg (args[n], XmNwindowGroup, pHelp->pCDforClient->client); n++;
2652 #endif /* FUTURE */
2653     }
2654     else
2655     {
2656         if (wGroup != 0)
2657         {
2658             HideHelpDialog (pSD, True);
2659         }
2660         XtSetArg (args[n], XmNwindowGroup, 0); n++;
2661     }
2662
2663     XtSetArg (args[n], XmNwaitForWm, False);                    n++;
2664
2665     XtSetValues (pHelp->shell, args, n);
2666
2667
2668 } /* END OF FUNCTION wmDtHelpSetPosition */
2669
2670 /* End of Code stolen from WmPresence.c */
2671
2672 /*************************************<->*************************************
2673  *
2674  *  wmDtHelpMapEventHandler (wHelp, pSD, pEvent)
2675  *
2676  *
2677  *  Description:
2678  *  -----------
2679  *  An XtEventHandler called on structure notify events on the screen's
2680  *  help window.  (Only handles map and unmap events)
2681  *
2682  *  Inputs:
2683  *  ------
2684  *  wHelp = help widget
2685  *  pSD = ptr to screen data
2686  *  pEvent = event triggering this call
2687  *
2688  *  Outputs:
2689  *  --------
2690  *
2691  ******************************<->***********************************/
2692 static void
2693 wmDtHelpMapEventHandler(
2694         Widget wHelp,
2695         XtPointer ptr,
2696         XEvent  *pEvent,
2697         Boolean *pBoolean)      /* unused */
2698 {
2699     WmScreenData *pSD = (WmScreenData *) ptr;
2700
2701     switch (pEvent->type)
2702     {
2703         case MapNotify:
2704             pSD->dtHelp.bMapped = True;
2705             break;
2706
2707         case UnmapNotify:
2708             pSD->dtHelp.bMapped = False;
2709             break;
2710     }
2711 }
2712 /* END OF FUNCTION wmDtHelpMapHandler */
2713
2714
2715
2716 /*************************************<->*************************************
2717  *
2718  *  wmDtErrorDialog (pSD, message, title)
2719  *
2720  *
2721  *  Description:
2722  *  -----------
2723  *  Called to show an error message
2724  *
2725  *  Inputs:
2726  *  ------
2727  *  pSD = ptr to screen data
2728  *  message = error message to display
2729  *  title = title for the error dialog
2730  *
2731  *  Outputs:
2732  *  --------
2733  *
2734  ******************************<->***********************************/
2735 static void
2736 wmDtErrorDialog(
2737         WmScreenData *pSD,
2738         String sMessage,
2739         String sTitle
2740                 )
2741 {
2742     int ac;
2743     Arg al[20];
2744     XmString xmsMessage;
2745     XmString xmsTitle;
2746     Widget wTemp;
2747     Widget wParent;
2748     Widget wShell;
2749     Window wRoot, wChild;
2750     int rootX, rootY, winX, winY;
2751     unsigned int mask;
2752     Dimension dWidth, dHeight;
2753     Position x, y;
2754 #ifdef PANELIST
2755     WmPanelistObject  pPanelist;
2756 #endif /* PANELIST */
2757
2758     xmsMessage =
2759             XmStringCreateLocalized (sMessage);
2760     xmsTitle =
2761             XmStringCreateLocalized (sTitle);
2762
2763     if (pSD->dtHelp.errorDialog == NULL)
2764     {
2765         XmString tmpXmString = (XmString)NULL;
2766
2767         ac = 0;
2768         XtSetArg (al[ac], XmNmessageString, xmsMessage);        ac++;
2769         XtSetArg (al[ac], XmNdialogTitle, xmsTitle);            ac++;
2770 #ifndef NO_MESSAGE_CATALOG
2771         XtSetArg (al[ac], XmNokLabelString, wmGD.okLabel);      ac++;
2772 #else
2773         tmpXmString = XmStringCreateLocalized ("OK");
2774         XtSetArg (al[ac], XmNokLabelString, tmpXmString); ac++;
2775 #endif
2776
2777 #if 0
2778         if ((wmGD.dtSD == pSD) && pSD->wPanelist)
2779         {
2780             pPanelist = (WmPanelistObject) pSD->wPanelist;
2781             wParent = O_Shell (pPanelist);
2782         }
2783         else
2784         {
2785             wParent = pSD->screenTopLevelW1;
2786         }
2787 #else
2788         wParent = pSD->screenTopLevelW1;
2789 #endif
2790         pSD->dtHelp.errorDialog =
2791             XmCreateErrorDialog (wParent, "Error Dialog", al, ac);
2792
2793         if (tmpXmString)
2794             XmStringFree(tmpXmString);
2795
2796         wTemp = XmMessageBoxGetChild (pSD->dtHelp.errorDialog,
2797                         XmDIALOG_HELP_BUTTON);
2798         XtUnmanageChild (wTemp);
2799
2800         wTemp = XmMessageBoxGetChild (pSD->dtHelp.errorDialog,
2801                         XmDIALOG_CANCEL_BUTTON);
2802         XtUnmanageChild (wTemp);
2803
2804         XtAddCallback (pSD->dtHelp.errorDialog, XmNokCallback,
2805                         wmDtErrorDialogOkCB, (XtPointer)pSD);
2806
2807         wShell = pSD->dtHelp.errorDialog;
2808         while (!(XtIsSubclass(wShell, shellWidgetClass)))
2809         {
2810             wShell = XtParent(wShell);
2811         }
2812         XtAddCallback(wShell, XmNpopupCallback, wmDtErrorDialogPopupCB,
2813                         (XtPointer)pSD);
2814
2815         XtRealizeWidget (pSD->dtHelp.errorDialog);
2816
2817         /* remove some WM functions */
2818         ac = 0;
2819         XtSetArg (al[ac], XmNmwmFunctions, (MWM_FUNC_ALL|
2820             MWM_FUNC_RESIZE|MWM_FUNC_MINIMIZE|MWM_FUNC_MAXIMIZE));
2821             ac++;
2822         XtSetValues (wShell, al, ac);
2823
2824         DtWsmRemoveWorkspaceFunctions (DISPLAY, XtWindow(wShell));
2825     }
2826     else
2827     {
2828         /* make sure it's unmanaged */
2829         wmDtErrorDialogHide (pSD);
2830
2831         /* set new message and title */
2832         ac = 0;
2833         XtSetArg (al[ac], XmNmessageString, xmsMessage);        ac++;
2834         XtSetArg (al[ac], XmNdialogTitle, xmsTitle);            ac++;
2835         XtSetValues (pSD->dtHelp.errorDialog, al, ac);
2836     }
2837
2838     if (pSD->dtHelp.errorDialog)
2839     {
2840         XtManageChild (pSD->dtHelp.errorDialog);
2841         XtPopup (XtParent(pSD->dtHelp.errorDialog), XtGrabNone);
2842     }
2843
2844     XmStringFree (xmsMessage);
2845     XmStringFree (xmsTitle);
2846 }
2847 /* END OF FUNCTION wmDtErrorDialog */
2848
2849 \f
2850 /*************************************<->*************************************
2851  *
2852  *  void
2853  *  wmDtErrorDialogHide (pSD)
2854  *
2855  *
2856  *  Description:
2857  *  -----------
2858  *
2859  *
2860  *  Inputs:
2861  *  ------
2862  *  pSD = ptr to screen data
2863  *
2864  *
2865  *  Outputs:
2866  *  -------
2867  *  Return = ...
2868  *
2869  *
2870  *  Comments:
2871  *  --------
2872  *
2873  *************************************<->***********************************/
2874
2875 static void
2876 wmDtErrorDialogHide( WmScreenData *pSD )
2877 {
2878     Widget wShell;
2879
2880     XtPopdown (XtParent(pSD->dtHelp.errorDialog));
2881     XtUnmanageChild (pSD->dtHelp.errorDialog);
2882     /*
2883      * Do a withdraw to make sure window gets unmanaged
2884      * (popdown does nothing if its unmapped)
2885      */
2886     wShell = pSD->dtHelp.errorDialog;
2887     while (!(XtIsSubclass(wShell, shellWidgetClass)))
2888     {
2889         wShell = XtParent(wShell);
2890     }
2891     if (wShell)
2892         XWithdrawWindow (DISPLAY, XtWindow (wShell), pSD->screen);
2893
2894     /* must sync to insure event order */
2895     XSync (DISPLAY, False);
2896
2897 } /* END OF FUNCTION wmDtErrorDialogHide */
2898
2899 \f
2900 /*************************************<->*************************************
2901  *
2902  *  void
2903  *  wmDtErrorDialogOkCB (w, client_data, call_data)
2904  *
2905  *
2906  *  Description:
2907  *  -----------
2908  *
2909  *
2910  *  Inputs:
2911  *  ------
2912  *  w = ...
2913  *  client_data = ...
2914  *  call_data = ...
2915  *
2916  *
2917  *  Outputs:
2918  *  -------
2919  *  Return = ...
2920  *
2921  *
2922  *  Comments:
2923  *  --------
2924  *
2925  *************************************<->***********************************/
2926
2927 static void
2928 wmDtErrorDialogOkCB(
2929         Widget w,
2930         XtPointer client_data,
2931         XtPointer call_data )
2932 {
2933     WmScreenData *pSD = (WmScreenData *) client_data;
2934
2935     wmDtErrorDialogHide (pSD);
2936
2937 } /* END OF FUNCTION wmDtErrorDialogOkCB */
2938
2939 \f
2940 /*************************************<->*************************************
2941  *
2942  *  void
2943  *  wmDtErrorDialogPopupCB (w, client_data, call_data)
2944  *
2945  *
2946  *  Description:
2947  *  -----------
2948  *
2949  *
2950  *  Inputs:
2951  *  ------
2952  *  w = ...
2953  *  client_data = ...
2954  *  call_data = ...
2955  *
2956  *
2957  *  Outputs:
2958  *  -------
2959  *  Return = ...
2960  *
2961  *
2962  *  Comments:
2963  *  --------
2964  *
2965  *************************************<->***********************************/
2966
2967 static void
2968 wmDtErrorDialogPopupCB(
2969         Widget w,
2970         XtPointer client_data,
2971         XtPointer call_data )
2972 {
2973     WmScreenData *pSD = (WmScreenData *) client_data;
2974     Window wRoot, wChild;
2975     int rootX, rootY, winX, winY;
2976     unsigned int mask;
2977     Dimension dWidth, dHeight;
2978     Position x, y;
2979     Arg al[10];
2980     int ac;
2981
2982     /* set new position near cursor position */
2983     XQueryPointer (DISPLAY, XtWindow(pSD->screenTopLevelW1),
2984         &wRoot, &wChild, &rootX, &rootY, &winX, &winY, &mask);
2985
2986     ac = 0;
2987     XtSetArg (al[ac], XmNwidth, &dWidth);                       ac++;
2988     XtSetArg (al[ac], XmNheight, &dHeight);                     ac++;
2989     XtGetValues (w, al, ac);
2990
2991     x = (Position) rootX - (dWidth / 2);
2992     y = (Position) rootY - (dHeight / 2);
2993
2994     if ((x + ((Position) dWidth / 2)) > DisplayWidth (DISPLAY, pSD->screen))
2995         x = DisplayWidth (DISPLAY,pSD->screen) - (dWidth/2) - 1;
2996     if (x < 0)
2997         x = 0;
2998
2999     if ((y + ((Position) dHeight / 2)) > DisplayHeight (DISPLAY, pSD->screen))
3000         y = DisplayHeight (DISPLAY,pSD->screen) - (dHeight/2) - 1;
3001     if (y < 0)
3002         y = 0;
3003
3004     ac = 0;
3005     XtSetArg (al[ac], XmNx, x);                 ac++;
3006     XtSetArg (al[ac], XmNy, y);                 ac++;
3007     XtSetArg (al[ac], XmNwindowGroup,
3008                         XtUnspecifiedWindowGroup);      ac++;
3009     XtSetArg (al[ac], XmNwaitForWm, False);             ac++;
3010     XtSetValues (w, al, ac);
3011
3012
3013 } /* END OF FUNCTION wmDtErrorDialogPopupCB */
3014
3015 /****************************   eof    ***************************/
3016 #endif /* WSM */
3017
3018
3019
3020