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