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