cde/programs/dtwm/WmHelp.c

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