home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / xfe / XfeWidgets / Xfe / DashBoard.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  34.2 KB  |  1,340 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18. /*-----------------------------------------*/
  19. /*                                                                        */
  20. /* Name:        <Xfe/DashBoard.c>                                        */
  21. /* Description:    XfeDashBoard widget source.                                */
  22. /* Author:        Ramiro Estrugo <ramiro@netscape.com>                    */
  23. /*                                                                        */
  24. /*----------------------------------------------------------------------*/
  25.  
  26.  
  27. #include <stdio.h>
  28.  
  29. #include <Xfe/DashBoardP.h>
  30. #include <Xfe/TaskBarP.h>
  31.  
  32. #include <Xm/DrawingA.h>
  33. #include <Xm/Form.h>
  34. #include <Xm/Label.h>
  35. #include <Xm/LabelG.h>
  36.  
  37. #include <Xm/MwmUtil.h>
  38. #include <Xm/DialogS.h>
  39.  
  40. #define MESSAGE1 "Widget is not an XfeDashBoard."
  41. #define MESSAGE2 "XfeDashBoard cannot have any additional children."
  42. #define MESSAGE3 "XmNprogressBar is a read-only resource."
  43. #define MESSAGE4 "XmNstatusBar is a read-only resource."
  44. #define MESSAGE5 "XmNtaskBar is a read-only resource."
  45. #define MESSAGE6 "XmNtoolBar is a read-only resource."
  46. #define MESSAGE7 "The XmNfloatingShell must have a vali XfeTaskBar descendant."
  47. #define MESSAGE8 "The class of XmNfloatingShell must be XmDialogShell."
  48. #define MESSAGE9 "The XmNfloatingShell must have a single valid child."
  49.  
  50. #define SHOW_TOOL_BAR(dp)            (_XfeChildIsShown((dp)->tool_bar))
  51. #define SHOW_STATUS_BAR(dp)            (_XfeChildIsShown((dp)->status_bar))
  52. #define SHOW_PROGRESS_BAR(dp)        (_XfeChildIsShown((dp)->progress_bar))
  53. #define SHOW_DOCKED_TASK_BAR(dp)    (_XfeChildIsShown((dp)->docked_task_bar))
  54.  
  55. /*----------------------------------------------------------------------*/
  56. /*                                                                        */
  57. /* Core class methods                                                    */
  58. /*                                                                        */
  59. /*----------------------------------------------------------------------*/
  60. static void     Initialize        (Widget,Widget,ArgList,Cardinal *);
  61. static void     Destroy            (Widget);
  62. static Boolean    SetValues        (Widget,Widget,Widget,ArgList,Cardinal *);
  63.  
  64. /*----------------------------------------------------------------------*/
  65. /*                                                                        */
  66. /* XfeManager class methods                                                */
  67. /*                                                                        */
  68. /*----------------------------------------------------------------------*/
  69. static void        PreferredGeometry    (Widget,Dimension *,Dimension *);
  70. static void        LayoutComponents    (Widget);
  71. static Boolean    AcceptChild            (Widget);
  72. static Boolean    DeleteChild            (Widget);
  73. static Boolean    InsertChild            (Widget);
  74.  
  75. /*----------------------------------------------------------------------*/
  76. /*                                                                        */
  77. /* Misc XfeDashBoard functions                                            */
  78. /*                                                                        */
  79. /*----------------------------------------------------------------------*/
  80. static Boolean        IsDocked                (Widget);
  81. static Dimension    MaxComponentHeight        (Widget);
  82. static void            ManageComponents        (Widget);
  83. static void            LayoutProgressBar        (Widget);
  84. static void            LayoutToolBar            (Widget);
  85. static void            LayoutStatusBar            (Widget);
  86. static void            LayoutDockedTaskBar        (Widget);
  87.  
  88. static void            UpdateUndockPixmap        (Widget);
  89. static void            AddFloatingShell        (Widget,Widget);
  90. static Boolean        CheckFloatingWidgets    (Widget,Widget);
  91. static void            RemoveFloatingShell        (Widget);
  92. static void            Undock                    (Widget);
  93. static void            Dock                    (Widget);
  94.  
  95. static Boolean        ShowDockedTaskBar        (Widget);
  96. static Boolean        DockedTaskBarEmpty        (Widget);
  97.  
  98. static Boolean        ChildIsProgressBar        (Widget);
  99. static Boolean        ChildIsStatusBar        (Widget);
  100.  
  101. /*----------------------------------------------------------------------*/
  102. /*                                                                        */
  103. /* TaskBar callbacks                                                    */
  104. /*                                                                        */
  105. /*----------------------------------------------------------------------*/
  106. static void    TaskBarActionCB            (Widget,XtPointer,XtPointer);
  107.  
  108. /*----------------------------------------------------------------------*/
  109. /*                                                                        */
  110. /* Floating shell event handlers and callbacks.                            */
  111. /*                                                                        */
  112. /*----------------------------------------------------------------------*/
  113. static void        FloatingShellEH            (Widget,XtPointer,XEvent *,Boolean *);
  114. static void        DestroyCB                (Widget,XtPointer,XtPointer);
  115. static void        FloatingCloseCB            (Widget,XtPointer,XtPointer);
  116.  
  117. /*----------------------------------------------------------------------*/
  118. /*                                                                        */
  119. /* XfeDashBoard Resources                                               */
  120. /*                                                                        */
  121. /*----------------------------------------------------------------------*/
  122. static XtResource resources[] =     
  123. {                    
  124.     /* Callback resources */         
  125.     { 
  126.         XmNdockCallback,
  127.         XmCCallback,
  128.         XmRCallback,
  129.         sizeof(XtCallbackList),
  130.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . dock_callback),
  131.         XmRImmediate, 
  132.         (XtPointer) NULL
  133.     },
  134.     { 
  135.         XmNundockCallback,
  136.         XmCCallback,
  137.         XmRCallback,
  138.         sizeof(XtCallbackList),
  139.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . undock_callback),
  140.         XmRImmediate, 
  141.         (XtPointer) NULL
  142.     },
  143.     { 
  144.         XmNfloatingMapCallback,
  145.         XmCCallback,
  146.         XmRCallback,
  147.         sizeof(XtCallbackList),
  148.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . floating_map_callback),
  149.         XmRImmediate, 
  150.         (XtPointer) NULL
  151.     },
  152.     { 
  153.         XmNfloatingUnmapCallback,
  154.         XmCCallback,
  155.         XmRCallback,
  156.         sizeof(XtCallbackList),
  157.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . floating_unmap_callback),
  158.         XmRImmediate, 
  159.         (XtPointer) NULL
  160.     },
  161.  
  162.  
  163.     /* Components */
  164.     { 
  165.         XmNprogressBar,
  166.         XmCReadOnly,
  167.         XmRWidget,
  168.         sizeof(Widget),
  169.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . progress_bar),
  170.         XmRImmediate, 
  171.         (XtPointer) NULL
  172.     },
  173.     { 
  174.         XmNstatusBar,
  175.         XmCReadOnly,
  176.         XmRWidget,
  177.         sizeof(Widget),
  178.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . status_bar),
  179.         XmRImmediate, 
  180.         (XtPointer) NULL
  181.     },
  182.     { 
  183.         XmNdockedTaskBar,
  184.         XmCReadOnly,
  185.         XmRWidget,
  186.         sizeof(Widget),
  187.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . docked_task_bar),
  188.         XmRImmediate, 
  189.         (XtPointer) NULL
  190.     },
  191.     { 
  192.         XmNtoolBar,
  193.         XmCReadOnly,
  194.         XmRWidget,
  195.         sizeof(Widget),
  196.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . tool_bar),
  197.         XmRImmediate, 
  198.         (XtPointer) NULL
  199.     },
  200.     { 
  201.         XmNfloatingShell,
  202.         XmCReadOnly,
  203.         XmRWidget,
  204.         sizeof(Widget),
  205.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . floating_shell),
  206.         XmRImmediate, 
  207.         (XtPointer) NULL
  208.     },
  209.     { 
  210.         XmNfloatingTaskBar,
  211.         XmCReadOnly,
  212.         XmRWidget,
  213.         sizeof(Widget),
  214.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . floating_task_bar),
  215.         XmRImmediate, 
  216.         (XtPointer) NULL
  217.     },
  218.  
  219.     /* Boolean resources */
  220.     { 
  221.         XmNshowDockedTaskBar,
  222.         XmCShowDockedTaskBar,
  223.         XmRBoolean,
  224.         sizeof(Boolean),
  225.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . show_docked_task_bar),
  226.         XmRImmediate, 
  227.         (XtPointer) True
  228.     },
  229.     { 
  230.         XmNdocked,
  231.         XmCDocked,
  232.         XmRBoolean,
  233.         sizeof(Boolean),
  234.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . docked),
  235.         XmRImmediate, 
  236.         (XtPointer) True
  237.     },
  238.  
  239.     /* Misc resources */
  240.     { 
  241.         XmNspacing,
  242.         XmCSpacing,
  243.         XmRHorizontalDimension,
  244.         sizeof(Dimension),
  245.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . spacing),
  246.         XmRImmediate, 
  247.         (XtPointer) 4
  248.     },
  249.  
  250.     /* Pixmap resource */
  251.     { 
  252.         XmNundockPixmap,
  253.         XmCUndockPixmap,
  254.         XmRPixmap,
  255.         sizeof(Pixmap),
  256.         XtOffsetOf(XfeDashBoardRec , xfe_dash_board . undock_pixmap),
  257.         XmRImmediate, 
  258.         (XtPointer) XmUNSPECIFIED_PIXMAP
  259.     },
  260. };   
  261.  
  262. /*----------------------------------------------------------------------*/
  263. /*                                                                        */
  264. /* XfeDashBoard Synthetic Resources                                        */
  265. /*                                                                        */
  266. /*----------------------------------------------------------------------*/
  267. static XmSyntheticResource syn_resources[] =
  268. {
  269.    { 
  270.        XmNspacing,
  271.        sizeof(Dimension),
  272.        XtOffsetOf(XfeDashBoardRec , xfe_dash_board . spacing),
  273.        _XmFromHorizontalPixels,
  274.        _XmToHorizontalPixels 
  275.    },
  276. };
  277.  
  278. /*----------------------------------------------------------------------*/
  279. /*                                                                        */
  280. /* Widget Class Record Initialization                                   */
  281. /*                                                                        */
  282. /*----------------------------------------------------------------------*/
  283. _XFE_WIDGET_CLASS_RECORD(dashboard,DashBoard) =
  284. {
  285.     {
  286.         (WidgetClass) &xfeManagerClassRec,        /* superclass           */
  287.         "XfeDashBoard",                            /* class_name           */
  288.         sizeof(XfeDashBoardRec),                /* widget_size          */
  289.         NULL,                                    /* class_initialize     */
  290.         NULL,                                    /* class_part_initialize*/
  291.         FALSE,                                  /* class_inited         */
  292.         Initialize,                             /* initialize           */
  293.         NULL,                                   /* initialize_hook      */
  294.         XtInheritRealize,                        /* realize              */
  295.         NULL,                                    /* actions              */
  296.         0,                                        /* num_actions            */
  297.         resources,                              /* resources            */
  298.         XtNumber(resources),                    /* num_resources        */
  299.         NULLQUARK,                              /* xrm_class            */
  300.         TRUE,                                   /* compress_motion      */
  301.         XtExposeCompressMaximal,                /* compress_exposure    */
  302.         TRUE,                                   /* compress_enterleave    */
  303.         FALSE,                                  /* visible_interest     */
  304.         Destroy,                                /* destroy              */
  305.         XtInheritResize,                        /* resize               */
  306.         XtInheritExpose,                        /* expose               */
  307.         SetValues,                              /* set_values           */
  308.         NULL,                                   /* set_values_hook      */
  309.         XtInheritSetValuesAlmost,                /* set_values_almost    */
  310.         NULL,                                    /* get_values_hook      */
  311.         NULL,                                   /* accexfe_focus         */
  312.         XtVersion,                              /* version              */
  313.         NULL,                                   /* callback_private     */
  314.         XtInheritTranslations,                    /* tm_table                */
  315.         XtInheritQueryGeometry,                    /* query_geometry       */
  316.         XtInheritDisplayAccelerator,            /* display accel        */
  317.         NULL,                                   /* extension            */
  318.     },
  319.  
  320.     /* Composite Part */
  321.     {
  322.         XtInheritGeometryManager,                /* geometry_manager        */
  323.         XtInheritChangeManaged,                    /* change_managed        */
  324.         XtInheritInsertChild,                    /* insert_child            */
  325.         XtInheritDeleteChild,                    /* delete_child            */
  326.         NULL                                    /* extension            */
  327.     },
  328.  
  329.     /* Constraint Part */
  330.     {
  331.         NULL,                                    /* resource list           */
  332.         0,                                        /* num resources           */
  333.         sizeof(XfeManagerConstraintRec),        /* constraint size         */
  334.         NULL,                                    /* init proc               */
  335.         NULL,                                   /* destroy proc            */
  336.         NULL,                                    /* set values proc         */
  337.         NULL,                                   /* extension               */
  338.     },
  339.  
  340.     /* XmManager Part */
  341.     {
  342.         XtInheritTranslations,                    /* tm_table                */
  343.         syn_resources,                            /* syn resources           */
  344.         XtNumber(syn_resources),                /* num syn_resources       */
  345.         NULL,                                   /* syn_cont_resources      */
  346.         0,                                      /* num_syn_cont_resource*/
  347.         XmInheritParentProcess,                 /* parent_process          */
  348.         NULL,                                   /* extension               */
  349.     },
  350.  
  351.     /* XfeManager Part     */
  352.     {
  353.         XfeInheritBitGravity,                    /* bit_gravity            */
  354.         PreferredGeometry,                        /* preferred_geometry    */
  355.         XfeInheritMinimumGeometry,                /* minimum_geometry        */
  356.         XfeInheritUpdateRect,                    /* update_rect            */
  357.         AcceptChild,                            /* accept_child            */
  358.         InsertChild,                            /* insert_child            */
  359.         DeleteChild,                            /* delete_child            */
  360.         NULL,                                    /* change_managed        */
  361.         NULL,                                    /* prepare_components    */
  362.         LayoutComponents,                        /* layout_components    */
  363.         NULL,                                    /* layout_children        */
  364.         NULL,                                    /* draw_background        */
  365.         XfeInheritDrawShadow,                    /* draw_shadow            */
  366.         NULL,                                    /* draw_components        */
  367.         NULL,                                    /* extension              */
  368.     },
  369.  
  370.     /* XfeDashBoard Part */
  371.     {
  372.         NULL,                                    /* extension              */
  373.     },
  374. };
  375.  
  376. /*----------------------------------------------------------------------*/
  377. /*                                                                        */
  378. /* xfeDashBoardWidgetClass declaration.                                    */
  379. /*                                                                        */
  380. /*----------------------------------------------------------------------*/
  381. _XFE_WIDGET_CLASS(dashboard,DashBoard);
  382.  
  383. /*----------------------------------------------------------------------*/
  384. /*                                                                        */
  385. /* Core class methods                                                    */
  386. /*                                                                        */
  387. /*----------------------------------------------------------------------*/
  388. static void
  389. Initialize(Widget rw,Widget nw,ArgList args,Cardinal *nargs)
  390. {
  391.     XfeDashBoardPart *    dp = _XfeDashBoardPart(nw);
  392.  
  393.     if (CheckFloatingWidgets(nw,dp->floating_shell))
  394.     {
  395.         AddFloatingShell(nw,dp->floating_shell);
  396.     }
  397.  
  398.     /* Update pixmaps */
  399.     UpdateUndockPixmap(nw);
  400.     
  401.     dp->floating_target = NULL;
  402.  
  403.     /* Finish of initialization */
  404.     _XfeManagerChainInitialize(rw,nw,xfeDashBoardWidgetClass);
  405. }
  406. /*----------------------------------------------------------------------*/
  407. static void
  408. Destroy(Widget w)
  409. {
  410.     XfeDashBoardPart * dp = _XfeDashBoardPart(w);
  411.  
  412.     /*RemoveFloatingShell(w);*/
  413.  
  414.     if (CheckFloatingWidgets(w,dp->floating_shell))
  415.     {
  416.         RemoveFloatingShell(w);
  417.     }
  418. }
  419. /*----------------------------------------------------------------------*/
  420. static Boolean
  421. SetValues(Widget ow,Widget rw,Widget nw,ArgList args,Cardinal *nargs)
  422. {
  423.     XfeDashBoardPart *        np = _XfeDashBoardPart(nw);
  424.     XfeDashBoardPart *        op = _XfeDashBoardPart(ow);
  425.     Boolean                    update_docked = False;
  426.  
  427.     /* floating_shell */
  428.     if (np->floating_shell != op->floating_shell)
  429.     {
  430.         if (CheckFloatingWidgets(ow,op->floating_shell))
  431.         {
  432.             RemoveFloatingShell(ow);
  433.         }
  434.  
  435.         if (CheckFloatingWidgets(nw,np->floating_shell))
  436.         {
  437.             AddFloatingShell(nw,np->floating_shell);
  438.         }
  439.         else
  440.         {
  441.             np->docked = True;
  442.  
  443.             update_docked = True;
  444.         }
  445.         
  446.         _XfemConfigFlags(nw) |= XfeConfigGLE;
  447.     }
  448.  
  449.     /* docked */
  450.     if (np->docked != op->docked)
  451.     {
  452.         update_docked = True;
  453.     }
  454.  
  455.     /* progress_bar */
  456.     if (np->progress_bar != op->progress_bar)
  457.     {
  458.         _XfeWarning(nw,MESSAGE3);
  459.         np->progress_bar = op->progress_bar;
  460.     }
  461.     
  462.     /* status_bar */
  463.     if (np->status_bar != op->status_bar)
  464.     {
  465.         _XfeWarning(nw,MESSAGE4);
  466.         np->status_bar = op->status_bar;
  467.     }
  468.     
  469.     /* docked_task_bar */
  470.     if (np->docked_task_bar != op->docked_task_bar)
  471.     {
  472.         _XfeWarning(nw,MESSAGE5);
  473.         np->docked_task_bar = op->docked_task_bar;
  474.     }
  475.     
  476.     /* tool_bar */
  477.     if (np->tool_bar != op->tool_bar)
  478.     {
  479.         _XfeWarning(nw,MESSAGE6);
  480.         np->tool_bar = op->tool_bar;
  481.     }
  482.  
  483.     /* show_docked_task_bar */
  484.     if (np->show_docked_task_bar != op->show_docked_task_bar)
  485.     {
  486.         _XfemConfigFlags(nw) |= XfeConfigGLE;
  487.     }
  488.  
  489.     /* undock_pixmap */
  490.     if (np->undock_pixmap != op->undock_pixmap)
  491.     {
  492.         /* Update undock pixmap */
  493.         UpdateUndockPixmap(nw);
  494.     }
  495.  
  496.     if (update_docked)
  497.     {
  498.         if (np->docked)
  499.         {
  500.             if (CheckFloatingWidgets(nw,np->floating_shell))
  501.             {
  502.                 XtUnmanageChild(np->floating_target);
  503.             }
  504.             
  505.             if (_XfeIsAlive(np->docked_task_bar))
  506.             {
  507.                 XtManageChild(np->docked_task_bar);
  508.             }
  509.         }
  510.         else
  511.         {
  512.             if (CheckFloatingWidgets(nw,np->floating_shell))
  513.             {
  514.                 np->docked = False;
  515.                 
  516.                 XtManageChild(np->floating_target);
  517.                 
  518.                 if (_XfeIsAlive(np->docked_task_bar))
  519.                 {
  520.                     XtUnmanageChild(np->docked_task_bar);
  521.                 }
  522.             }
  523.         }
  524.     }
  525.  
  526.     return _XfeManagerChainSetValues(ow,rw,nw,xfeDashBoardWidgetClass);
  527. }
  528. /*----------------------------------------------------------------------*/
  529.  
  530. /*----------------------------------------------------------------------*/
  531. /*                                                                        */
  532. /* XfeManager class methods                                                */
  533. /*                                                                        */
  534. /*----------------------------------------------------------------------*/
  535. static void
  536. PreferredGeometry(Widget w,Dimension * width,Dimension * height)
  537. {
  538.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  539.     Cardinal            num_shown = 0;
  540.  
  541.     *width  = 
  542.         _XfemOffsetLeft(w) + _XfemOffsetRight(w);
  543.  
  544.     if (SHOW_TOOL_BAR(dp))
  545.     {
  546.         *width += _XfeWidth(dp->tool_bar);
  547.  
  548.         num_shown++;
  549.     }
  550.  
  551.     if (SHOW_PROGRESS_BAR(dp))
  552.     {
  553.         *width += _XfeWidth(dp->progress_bar);
  554.  
  555.         num_shown++;
  556.     }
  557.  
  558.     if (SHOW_STATUS_BAR(dp))
  559.     {
  560.         *width += _XfeWidth(dp->status_bar);
  561.  
  562.         num_shown++;
  563.     }
  564.  
  565.     if (ShowDockedTaskBar(w))
  566.     {
  567.         *width += _XfeWidth(dp->docked_task_bar);
  568.  
  569.         num_shown++;
  570.     }
  571.  
  572.     if (num_shown)
  573.     {
  574.         *width += ((num_shown - 1) * dp->spacing);
  575.     }
  576.     
  577.     *height = _XfemOffsetTop(w) + _XfemOffsetBottom(w) + MaxComponentHeight(w);
  578. }
  579. /*----------------------------------------------------------------------*/
  580. static void
  581. LayoutComponents(Widget w)
  582. {
  583.     XfeDashBoardPart *        dp = _XfeDashBoardPart(w);
  584.  
  585.     /* Compute and store the max component height */
  586.     dp->max_component_height = MaxComponentHeight(w);
  587.  
  588.     /* Manage the components */
  589.     ManageComponents(w);
  590.  
  591.     if (SHOW_TOOL_BAR(dp))
  592.     {
  593.         LayoutToolBar(w);
  594.     }
  595.  
  596.     if (SHOW_PROGRESS_BAR(dp))
  597.     {
  598.         LayoutProgressBar(w);
  599.     }
  600.  
  601.     LayoutDockedTaskBar(w);
  602.  
  603.     if (SHOW_STATUS_BAR(dp))
  604.     {
  605.         LayoutStatusBar(w);
  606.     }
  607. }
  608. /*----------------------------------------------------------------------*/
  609. static Boolean
  610. AcceptChild(Widget child)
  611. {
  612.     Widget                    w = XtParent(child);
  613.     XfeDashBoardPart *        dp = _XfeDashBoardPart(w);
  614.     Boolean                    accept = False;
  615.     
  616.     /* Look for task bar */
  617.     if (XfeIsTaskBar(child))
  618.     {
  619.         accept = !dp->docked_task_bar;
  620.     }
  621.     /* Look for button tool bar */
  622.     else if (XfeIsToolBar(child))
  623.     {
  624.         accept = !dp->tool_bar;
  625.     }
  626.     /* Look for progress bar */
  627.     else if (ChildIsProgressBar(child))
  628.     {
  629.         accept = !dp->progress_bar;
  630.     }
  631.     /* Look for status bar */
  632.     else if (ChildIsStatusBar(child))
  633.     {
  634.         accept = !dp->status_bar;
  635.     }
  636.  
  637.     return accept;
  638. }
  639. /*----------------------------------------------------------------------*/
  640. static Boolean
  641. InsertChild(Widget child)
  642. {
  643.     Widget                    w = XtParent(child);
  644.     XfeDashBoardPart *        dp = _XfeDashBoardPart(w);
  645.     Boolean                    layout = False;
  646.  
  647.     /* Task bar */
  648.     if (XfeIsTaskBar(child))
  649.     {
  650.         dp->docked_task_bar = child;
  651.  
  652.         /* Add undock callback to docked task bar */
  653.         XtAddCallback(dp->docked_task_bar,XmNactionCallback,
  654.                       TaskBarActionCB,(XtPointer) w);
  655.         
  656.         /* Make sure the action button does show */
  657.         XtVaSetValues(dp->docked_task_bar,XmNshowActionButton,True,NULL);
  658.         
  659.         layout = True;
  660.     }
  661.     /* Button tool bar */
  662.     else if (XfeIsToolBar(child))
  663.     {
  664.         dp->tool_bar = child;
  665.         
  666.         layout = True;
  667.     }
  668.     /* Progress bar */
  669.     else if (ChildIsProgressBar(child))
  670.     {
  671.         dp->progress_bar = child;
  672.  
  673.         layout = True;    
  674.     }
  675.     /* Status bar */
  676.     else if (ChildIsStatusBar(child))
  677.     {
  678.         dp->status_bar = child;
  679.  
  680.         layout = True;
  681.     }
  682.  
  683.     return layout;
  684. }
  685. /*----------------------------------------------------------------------*/
  686. static Boolean
  687. DeleteChild(Widget child)
  688. {
  689.     Widget                    w = XtParent(child);
  690.     XfeDashBoardPart *        dp = _XfeDashBoardPart(w);
  691.  
  692.     /* Keep track of deleted widgets */
  693.     if (child == dp->tool_bar)
  694.     {
  695.         dp->tool_bar = NULL;
  696.     }
  697.     else if (child == dp->progress_bar)
  698.     {
  699.         dp->progress_bar = NULL;
  700.     }
  701.     else if (child == dp->status_bar)
  702.     {
  703.         dp->status_bar = NULL;
  704.     }
  705.     else if (child == dp->docked_task_bar)
  706.     {
  707.         dp->docked_task_bar = NULL;
  708.     }
  709.  
  710.     return True;
  711. }
  712. /*----------------------------------------------------------------------*/
  713.  
  714.  
  715. /*----------------------------------------------------------------------*/
  716. /*                                                                        */
  717. /* Misc XfeDashBoard functions                                            */
  718. /*                                                                        */
  719. /*----------------------------------------------------------------------*/
  720. static Boolean
  721. ChildIsProgressBar(Widget child)
  722. {
  723.     return (XmIsDrawingArea(child) || 
  724.             XmIsForm(child) || 
  725.             XmIsFrame(child) || 
  726.             XfeIsProgressBar(child));
  727. }
  728. /*----------------------------------------------------------------------*/
  729. static Boolean
  730. ChildIsStatusBar(Widget child)
  731. {
  732.     return (XmIsLabel(child) || 
  733.             XmIsLabelGadget(child) || 
  734.             (XfeIsLabel(child) && !XfeIsButton(child)));
  735. }
  736. /*----------------------------------------------------------------------*/
  737. static Boolean
  738. ShowDockedTaskBar(Widget w)
  739. {
  740.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  741.  
  742.     return (dp->show_docked_task_bar && dp->docked_task_bar && IsDocked(w));
  743. }
  744. /*----------------------------------------------------------------------*/
  745. static Boolean
  746. DockedTaskBarEmpty(Widget w)
  747. {
  748.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  749.  
  750.     return (_XfeIsAlive(dp->docked_task_bar) &&
  751.             (XfeChildrenGetNumManaged(dp->docked_task_bar) <= 1));
  752. }
  753. /*----------------------------------------------------------------------*/
  754. static Boolean
  755. CheckFloatingWidgets(Widget w,Widget shell)
  756. {
  757.     Boolean result = False;
  758.  
  759.     if (_XfeIsAlive(shell))
  760.     {
  761.         /* Make sure the class of the shell is XmDialogShell */
  762.         if (XmIsDialogShell(shell))
  763.         {
  764.             Widget     task_bar;
  765.             Widget    target;
  766.             
  767.             /* The target widget is the first child of the floating shell */
  768.             target = _XfemChildren(shell)[0];
  769.             
  770.             /* The docked taskbar is the first descendant of task bar class */
  771.             task_bar = XfeDescendantFindByClass(shell,xfeTaskBarWidgetClass,
  772.                                                 XfeFIND_ALIVE,False);
  773.             
  774.             /* Make sure the target is valid */
  775.             if (_XfeIsAlive(target))
  776.             {
  777.                 result = True;
  778.             }
  779.             else
  780.             {
  781.                 _XfeWarning(w,MESSAGE9);
  782.             }
  783.             
  784.             /* Make sure the docked task bar is valid */
  785.             if (_XfeIsAlive(task_bar) && XfeIsTaskBar(task_bar))
  786.             {
  787.                 result = True;
  788.             }
  789.             else
  790.             {
  791.                 _XfeWarning(w,MESSAGE7);
  792.             }
  793.         }
  794.         else
  795.         {
  796.             _XfeWarning(w,MESSAGE8);
  797.         }
  798.         
  799.     }
  800.  
  801.     return result;
  802. }
  803. /*----------------------------------------------------------------------*/
  804. static void
  805. AddFloatingShell(Widget w,Widget shell)
  806. {
  807.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  808.  
  809.     /* Make sure the floating widgets are valid before adding them */
  810.     if (!CheckFloatingWidgets(w,shell))
  811.     {
  812.         return;
  813.     }
  814.  
  815.     /* Assign the global floating widget for our convenience */
  816.     /* The target widget is the first child of the floating shell */
  817.     /* The docked taskbar is the first descendant of task bar class */
  818.     dp->floating_shell        = shell;
  819.     dp->floating_target        = _XfemChildren(shell)[0];
  820.     dp->floating_task_bar    = XfeDescendantFindByClass(shell,
  821.                                                        xfeTaskBarWidgetClass,
  822.                                                        XfeFIND_ALIVE,
  823.                                                        False);
  824.  
  825.     /* Make sure the action button does not show */
  826.     XtVaSetValues(dp->floating_task_bar,XmNshowActionButton,False,NULL);
  827.  
  828.     /* Handle changes in view window structure */
  829.     XtAddEventHandler(dp->floating_shell,
  830.                       StructureNotifyMask,
  831.                       False,
  832.                       FloatingShellEH,
  833.                       (XtPointer) w);
  834.  
  835.     /* Handle floating window closing */
  836.     XfeShellAddCloseCallback(dp->floating_shell,
  837.                              FloatingCloseCB,
  838.                              (XtPointer) w);
  839.  
  840.     XtAddCallback(dp->floating_shell,XmNdestroyCallback,
  841.                   DestroyCB,(XtPointer) w);
  842.  
  843.     XtAddCallback(dp->floating_task_bar,XmNdestroyCallback,
  844.                   DestroyCB,(XtPointer) w);
  845.  
  846.     XtAddCallback(dp->floating_target,XmNdestroyCallback,
  847.                   DestroyCB,(XtPointer) w);
  848.  
  849.     if (IsDocked(w))
  850.     {
  851.         dp->docked = True;
  852.  
  853.         if (CheckFloatingWidgets(w,dp->floating_shell))
  854.         {
  855.             XtUnmanageChild(dp->floating_target);
  856.         }
  857.         
  858.         if (_XfeIsAlive(dp->docked_task_bar))
  859.         {
  860.             XtManageChild(dp->docked_task_bar);
  861.         }
  862.     }
  863.     else
  864.     {
  865.         dp->docked = False;
  866.  
  867.         if (CheckFloatingWidgets(w,dp->floating_shell))
  868.         {
  869.             dp->docked = False;
  870.             
  871.             XtManageChild(dp->floating_target);
  872.             
  873.             if (_XfeIsAlive(dp->docked_task_bar))
  874.             {
  875.                 XtUnmanageChild(dp->docked_task_bar);
  876.             }
  877.         }
  878.     }
  879. }
  880. /*----------------------------------------------------------------------*/
  881. static void
  882. RemoveFloatingShell(Widget w)
  883. {
  884.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  885.  
  886.     if (dp->floating_task_bar && dp->floating_shell)
  887.     {
  888.         /* Handle changes in view window structure */
  889.         XtRemoveEventHandler(dp->floating_shell,
  890.                              StructureNotifyMask,
  891.                              False,
  892.                              FloatingShellEH,
  893.                              (XtPointer) w);
  894.  
  895.         /* Dont need to handle floating window closing any more */
  896.         XfeShellRemoveCloseCallback(dp->floating_shell,
  897.                                     FloatingCloseCB,
  898.                                     (XtPointer) w);
  899.     }
  900.  
  901.     dp->floating_task_bar = NULL;
  902.     dp->floating_target = NULL;
  903.     dp->floating_shell = NULL;
  904. }
  905. /*----------------------------------------------------------------------*/
  906. static void
  907. ManageComponents(Widget w)
  908. {
  909.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  910.  
  911.     _XfemIgnoreConfigure(w) = True;
  912.  
  913.     if (IsDocked(w))
  914.     {
  915.         if (dp->docked_task_bar)
  916.         {
  917.             if (dp->show_docked_task_bar)
  918.             {
  919.                 XtManageChild(dp->docked_task_bar);
  920.             }
  921.             else
  922.             {
  923.                 XtUnmanageChild(dp->docked_task_bar);
  924.             }
  925.         }
  926.     }
  927.     else
  928.     {
  929.         if (_XfeIsAlive(dp->floating_target))
  930.         {
  931.             XtManageChild(dp->floating_target);
  932.         }
  933.  
  934.         if (dp->docked_task_bar)
  935.         {
  936.             XtUnmanageChild(dp->docked_task_bar);
  937.         }
  938.     }
  939.     
  940.     _XfemIgnoreConfigure(w) = False;
  941. }
  942. /*----------------------------------------------------------------------*/
  943. static Dimension
  944. MaxComponentHeight(Widget w)
  945. {
  946.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  947.     Dimension            max_height = 0;
  948.  
  949.     if (SHOW_TOOL_BAR(dp))
  950.     {
  951.         max_height = _XfeHeight(dp->tool_bar);
  952.     }
  953.  
  954.     if (SHOW_PROGRESS_BAR(dp))
  955.     {
  956.         max_height = XfeMax(max_height,_XfeHeight(dp->progress_bar));
  957.     }
  958.  
  959.     if (SHOW_STATUS_BAR(dp))
  960.     {
  961.         max_height = XfeMax(max_height,_XfeHeight(dp->status_bar));
  962.     }
  963.  
  964.     if (ShowDockedTaskBar(w))
  965.     {
  966.         max_height = XfeMax(max_height,_XfeHeight(dp->docked_task_bar));
  967.     }
  968.     
  969.     return max_height;
  970. }
  971. /*----------------------------------------------------------------------*/
  972. static void
  973. LayoutToolBar(Widget w)
  974. {
  975.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  976.  
  977.     assert( SHOW_TOOL_BAR(dp) );
  978.  
  979.     /* Layout the tool bar all the way to the left */
  980.     _XfeConfigureWidget(dp->tool_bar,
  981.                         
  982.                         _XfemOffsetLeft(w),
  983.                         
  984.                         _XfemOffsetTop(w),
  985.                         
  986.                         _XfeWidth(dp->tool_bar),
  987.                         
  988.                         dp->max_component_height);
  989. }
  990. /*----------------------------------------------------------------------*/
  991. static void
  992. LayoutProgressBar(Widget w)
  993. {
  994.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  995.     Position            x;
  996.  
  997.     assert( SHOW_PROGRESS_BAR(dp) );
  998.  
  999.     if (SHOW_TOOL_BAR(dp))
  1000.     {
  1001.         x = _XfeX(dp->tool_bar) + 
  1002.             _XfeWidth(dp->tool_bar) +
  1003.             dp->spacing;
  1004.     }
  1005.     else
  1006.     {
  1007.         x = _XfemOffsetLeft(w);
  1008.     }
  1009.     
  1010.     if (_XfeWidth(dp->progress_bar) > 0)
  1011.     {
  1012.         _XfeConfigureWidget(dp->progress_bar,
  1013.                             
  1014.                             x,
  1015.                             
  1016.                             _XfemOffsetTop(w),
  1017.                             
  1018.                             _XfeWidth(dp->progress_bar),
  1019.                             
  1020.                             dp->max_component_height);
  1021.     }
  1022. }
  1023. /*----------------------------------------------------------------------*/
  1024. static void
  1025. LayoutDockedTaskBar(Widget w)
  1026. {
  1027.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  1028.  
  1029.     if (!_XfeIsAlive(dp->docked_task_bar))
  1030.     {
  1031.         return;
  1032.     }
  1033.  
  1034.     /* If the taskbar is empty, hide it */
  1035.     if (DockedTaskBarEmpty(w))
  1036.     {
  1037.         XtVaSetValues(dp->docked_task_bar,XmNmappedWhenManaged,False,NULL);
  1038.     }    
  1039.     else
  1040.     {
  1041.         XtVaSetValues(dp->docked_task_bar,XmNmappedWhenManaged,True,NULL);
  1042.     }
  1043.  
  1044.     /* If the taskbar is not mapped when managed, dont do layout for it */
  1045.     if (!_XfeMappedWhenManaged(dp->docked_task_bar))
  1046.     {
  1047.         return;
  1048.     }
  1049.     
  1050.     /* Layout the task bar and status bar according to docking state */
  1051.     if (ShowDockedTaskBar(w))
  1052.     {
  1053.         /* Layout the docked task bar to the far right */
  1054.         _XfeConfigureWidget(dp->docked_task_bar,
  1055.                             
  1056.                             _XfeWidth(w) - 
  1057.                             _XfemOffsetRight(w) - 
  1058.                             _XfeWidth(dp->docked_task_bar),
  1059.  
  1060.                             _XfemOffsetTop(w),
  1061.  
  1062.                             _XfeWidth(dp->docked_task_bar),
  1063.                             
  1064.                             dp->max_component_height);
  1065.  
  1066.         /*
  1067.          * Raise the taskbar so that it will always show even when the
  1068.          * dashboard display is tiny 
  1069.          */
  1070.         if (XtIsRealized(dp->docked_task_bar))
  1071.         {
  1072.             XRaiseWindow(XtDisplay(dp->docked_task_bar),
  1073.                          _XfeWindow(dp->docked_task_bar));
  1074.         }
  1075.     }
  1076. }
  1077. /*----------------------------------------------------------------------*/
  1078. static void
  1079. LayoutStatusBar(Widget w)
  1080. {
  1081.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  1082.     Position            x1;
  1083.     Position            x2;
  1084.  
  1085.     assert( SHOW_STATUS_BAR(dp) );
  1086.  
  1087.     /* Compute the right-most coordinate */
  1088.     if (ShowDockedTaskBar(w) && !DockedTaskBarEmpty(w))
  1089.         
  1090.     {
  1091.         x2 = _XfeX(dp->docked_task_bar) - dp->spacing;
  1092.     }
  1093.     else
  1094.     {
  1095.         x2 = _XfeWidth(w) - _XfemOffsetRight(w);
  1096.     }
  1097.     
  1098.     if (SHOW_PROGRESS_BAR(dp))
  1099.     {
  1100.         x1 = 
  1101.             _XfeX(dp->progress_bar) + 
  1102.             _XfeWidth(dp->progress_bar) + 
  1103.             dp->spacing;
  1104.     }
  1105.     else if (SHOW_TOOL_BAR(dp))
  1106.     {
  1107.         x1 = 
  1108.             _XfeX(dp->tool_bar) + 
  1109.             _XfeWidth(dp->tool_bar) + 
  1110.             dp->spacing;
  1111.     }
  1112.     else
  1113.     {
  1114.         x1 = _XfemOffsetLeft(w);
  1115.     }
  1116.     
  1117.     
  1118.     if (x2 > x1)
  1119.     {
  1120.         /* Use the full extent of the widget */
  1121.         _XfeConfigureWidget(dp->status_bar,
  1122.                             
  1123.                             x1,
  1124.                             
  1125.                             _XfemOffsetLeft(w),
  1126.                             
  1127.                             x2 - x1,
  1128.                             
  1129.                             dp->max_component_height);
  1130.     }
  1131. }
  1132. /*----------------------------------------------------------------------*/
  1133. static Boolean
  1134. IsDocked(Widget w)
  1135. {
  1136.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  1137.  
  1138.     return !(_XfeIsAlive(dp->floating_target) && 
  1139.              XtIsManaged(dp->floating_target));
  1140.  
  1141.     /* return !(dp->floating_task_bar && XtIsManaged(dp->floating_task_bar)); */
  1142. }
  1143. /*----------------------------------------------------------------------*/
  1144. static void
  1145. UpdateUndockPixmap(Widget w)
  1146. {
  1147.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  1148.  
  1149.     if (dp->docked_task_bar)
  1150.     {
  1151.         if (_XfePixmapGood(dp->undock_pixmap))
  1152.         {
  1153.             XtVaSetValues(dp->docked_task_bar,
  1154.                           XmNactionPixmap,            dp->undock_pixmap,
  1155.                           NULL);
  1156.         }
  1157.     }
  1158. }
  1159. /*----------------------------------------------------------------------*/
  1160. static void
  1161. Undock(Widget w)
  1162. {
  1163.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  1164.     Boolean                invoke_callback = dp->docked;
  1165.  
  1166.     /* Undock only if a floating shell has been installed */
  1167.     if (CheckFloatingWidgets(w,dp->floating_shell))
  1168.     {
  1169.         dp->docked = False;
  1170.         
  1171.         /* XtManageChild(dp->floating_task_bar); */
  1172.         if (CheckFloatingWidgets(w,dp->floating_shell))
  1173.         {
  1174.             XtManageChild(dp->floating_target);
  1175.         }
  1176.  
  1177.         if (_XfeIsAlive(dp->docked_task_bar))
  1178.         {
  1179.             XtUnmanageChild(dp->docked_task_bar);
  1180.         }
  1181.     }
  1182.  
  1183.     if (invoke_callback)
  1184.     {
  1185. /*         printf("Undock(%s,%p)\n",XtName(XtParent(XtParent(w))),XtParent(XtParent(w))); */
  1186.  
  1187.         _XfeInvokeCallbacks(w,dp->undock_callback,XmCR_UNDOCK,NULL,False);
  1188.  
  1189.     }
  1190. }
  1191. /*----------------------------------------------------------------------*/
  1192. static void
  1193. Dock(Widget w)
  1194. {
  1195.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  1196.     Boolean                invoke_callback = !dp->docked;
  1197.  
  1198.     dp->docked = True;
  1199.  
  1200.     if (CheckFloatingWidgets(w,dp->floating_shell))
  1201.     {
  1202.         /* XtUnmanageChild(dp->floating_task_bar); */
  1203.         XtUnmanageChild(dp->floating_target);
  1204.     }
  1205.  
  1206.     if (_XfeIsAlive(dp->docked_task_bar))
  1207.     {
  1208.         XtManageChild(dp->docked_task_bar);
  1209.     }
  1210.  
  1211.     if (invoke_callback)
  1212.     {
  1213. /*          printf("Dock(%s,%p)\n",XtName(XtParent(XtParent(w))),XtParent(XtParent(w))); */
  1214.  
  1215.         _XfeInvokeCallbacks(w,dp->dock_callback,XmCR_DOCK,NULL,False);
  1216.     }
  1217. }
  1218. /*----------------------------------------------------------------------*/
  1219.  
  1220.  
  1221. /*----------------------------------------------------------------------*/
  1222. /*                                                                        */
  1223. /* Floating shell / task bar event handlers and callbacks.                */
  1224. /*                                                                        */
  1225. /*----------------------------------------------------------------------*/
  1226. static void
  1227. FloatingShellEH(Widget        shell,
  1228.                 XtPointer    client_data,
  1229.                 XEvent *    event,
  1230.                 Boolean *    cont)
  1231. {
  1232.     Widget                w = (Widget) client_data;
  1233.     XfeDashBoardPart *    dp = _XfeDashBoardPart(w);
  1234.  
  1235.     if (event)
  1236.     {
  1237.         switch(event->type)
  1238.         {
  1239.         case MapNotify:
  1240.             
  1241.             Undock(w);
  1242.  
  1243.             _XfeInvokeCallbacks(w,dp->floating_map_callback,
  1244.                                 XmCR_FLOATING_MAP,event,False);
  1245.             
  1246.             break;
  1247.  
  1248.         case UnmapNotify:
  1249.             
  1250.             Dock(w);
  1251.  
  1252.             _XfeInvokeCallbacks(w,dp->floating_unmap_callback,
  1253.                                 XmCR_FLOATING_UNMAP,event,False);
  1254.  
  1255.             break;
  1256.         }
  1257.     }
  1258.  
  1259.     *cont = True;
  1260. }
  1261. /*----------------------------------------------------------------------*/
  1262. static void
  1263. DestroyCB(Widget child,XtPointer client_data,XtPointer call_data)
  1264. {
  1265.     Widget w = (Widget) client_data;
  1266.     
  1267.     RemoveFloatingShell(w);
  1268. }
  1269. /*----------------------------------------------------------------------*/
  1270. static void
  1271. FloatingCloseCB(Widget child,XtPointer client_data,XtPointer call_data)
  1272. {
  1273.     Widget w = (Widget) client_data;
  1274.  
  1275.     Dock(w);
  1276. }
  1277. /*----------------------------------------------------------------------*/
  1278.  
  1279. /*----------------------------------------------------------------------*/
  1280. /*                                                                        */
  1281. /* TaskBar callbacks                                                    */
  1282. /*                                                                        */
  1283. /*----------------------------------------------------------------------*/
  1284. static void
  1285. TaskBarActionCB(Widget button,XtPointer client_data,XtPointer call_data)
  1286. {
  1287.     Widget w = (Widget) client_data;
  1288.  
  1289.     Undock(w);
  1290. }
  1291. /*----------------------------------------------------------------------*/
  1292.  
  1293. /*----------------------------------------------------------------------*/
  1294. /*                                                                        */
  1295. /* XfeDashBoard Public Methods                                            */
  1296. /*                                                                        */
  1297. /*----------------------------------------------------------------------*/
  1298. Widget
  1299. XfeCreateDashBoard(Widget parent,char *name,Arg *args,Cardinal count)
  1300. {
  1301.    return (XtCreateWidget(name,xfeDashBoardWidgetClass,parent,args,count));
  1302. }
  1303. /*----------------------------------------------------------------------*/
  1304. /* extern */ Widget
  1305. XfeDashBoardGetComponent(Widget dashboard,XfeDashBoardComponent component)
  1306. {
  1307.     XfeDashBoardPart *    dp = _XfeDashBoardPart(dashboard);
  1308.     Widget                cw = NULL;
  1309.  
  1310.     switch(component)
  1311.     {
  1312.     case XfeDASH_BOARD_TOOL_BAR:
  1313.         cw = dp->tool_bar;
  1314.         break;
  1315.  
  1316.     case XfeDASH_BOARD_DOCKED_TASK_BAR:
  1317.         cw = dp->docked_task_bar;
  1318.         break;
  1319.  
  1320.     case XfeDASH_BOARD_FLOATING_TASK_BAR:
  1321.         cw = dp->floating_task_bar;
  1322.         break;
  1323.  
  1324.     case XfeDASH_BOARD_FLOATING_SHELL:
  1325.         cw = dp->floating_shell;
  1326.         break;
  1327.  
  1328.     case XfeDASH_BOARD_PROGRESS_BAR:
  1329.         cw = dp->progress_bar;
  1330.         break;
  1331.  
  1332.     case XfeDASH_BOARD_STATUS_BAR:
  1333.         cw = dp->status_bar;
  1334.         break;
  1335.     }
  1336.  
  1337.     return cw;
  1338. }
  1339. /*----------------------------------------------------------------------*/
  1340.