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