1321 lines
32 KiB
C
1321 lines
32 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Name: <Xfe/DashBoard.c> */
|
|
/* Description: XfeDashBoard widget source. */
|
|
/* Author: Ramiro Estrugo <ramiro@netscape.com> */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <Xfe/DashBoardP.h>
|
|
/* #include <Xfe/TaskBarP.h> */
|
|
|
|
#include <Xm/DrawingA.h>
|
|
#include <Xm/Form.h>
|
|
#include <Xm/Label.h>
|
|
#include <Xm/LabelG.h>
|
|
|
|
#include <Xm/MwmUtil.h>
|
|
#include <Xm/DialogS.h>
|
|
|
|
#define MESSAGE1 "Widget is not an XfeDashBoard."
|
|
#define MESSAGE2 "XfeDashBoard cannot have any additional children."
|
|
#define MESSAGE3 "XmNprogressBar is a read-only resource."
|
|
#define MESSAGE4 "XmNstatusBar is a read-only resource."
|
|
#define MESSAGE5 "XmNtaskBar is a read-only resource."
|
|
#define MESSAGE6 "XmNtoolBar is a read-only resource."
|
|
#define MESSAGE7 "The XmNfloatingShell must have a valid XfeToolBar descendant."
|
|
#define MESSAGE8 "The class of XmNfloatingShell must be XmDialogShell."
|
|
#define MESSAGE9 "The XmNfloatingShell must have a single valid child."
|
|
|
|
#define SHOW_TOOL_BAR(dp) (_XfeChildIsShown((dp)->tool_bar))
|
|
#define SHOW_STATUS_BAR(dp) (_XfeChildIsShown((dp)->status_bar))
|
|
#define SHOW_PROGRESS_BAR(dp) (_XfeChildIsShown((dp)->progress_bar))
|
|
#define SHOW_DOCKED_TASK_BAR(dp) (_XfeChildIsShown((dp)->docked_task_bar))
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Core class methods */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static void Initialize (Widget,Widget,ArgList,Cardinal *);
|
|
static void Destroy (Widget);
|
|
static Boolean SetValues (Widget,Widget,Widget,ArgList,Cardinal *);
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* XfeManager class methods */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static void PreferredGeometry (Widget,Dimension *,Dimension *);
|
|
static Boolean AcceptStaticChild (Widget);
|
|
static Boolean DeleteStaticChild (Widget);
|
|
static Boolean InsertStaticChild (Widget);
|
|
static void LayoutStaticChildren (Widget);
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Misc XfeDashBoard functions */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean IsDocked (Widget);
|
|
static Dimension MaxComponentHeight (Widget);
|
|
static void ManagerStaticChildren (Widget);
|
|
static void LayoutProgressBar (Widget);
|
|
static void LayoutToolBar (Widget);
|
|
static void LayoutStatusBar (Widget);
|
|
static void LayoutDockedTaskBar (Widget);
|
|
|
|
static void UpdateUndockPixmap (Widget);
|
|
static void AddFloatingShell (Widget,Widget);
|
|
static Boolean CheckFloatingWidgets (Widget,Widget);
|
|
static void RemoveFloatingShell (Widget);
|
|
static void Undock (Widget);
|
|
static void Dock (Widget);
|
|
|
|
static Boolean ShowDockedTaskBar (Widget);
|
|
static Boolean DockedTaskBarEmpty (Widget);
|
|
|
|
static Boolean ChildIsProgressBar (Widget);
|
|
static Boolean ChildIsStatusBar (Widget);
|
|
static Boolean ChildIsTaskBar (Widget);
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Floating shell event handlers and callbacks. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static void FloatingShellEH (Widget,XtPointer,XEvent *,Boolean *);
|
|
static void DestroyCB (Widget,XtPointer,XtPointer);
|
|
static void FloatingCloseCB (Widget,XtPointer,XtPointer);
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* XfeDashBoard Resources */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static XtResource resources[] =
|
|
{
|
|
/* Callback resources */
|
|
{
|
|
XmNdockCallback,
|
|
XmCCallback,
|
|
XmRCallback,
|
|
sizeof(XtCallbackList),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . dock_callback),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
{
|
|
XmNundockCallback,
|
|
XmCCallback,
|
|
XmRCallback,
|
|
sizeof(XtCallbackList),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . undock_callback),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
{
|
|
XmNfloatingMapCallback,
|
|
XmCCallback,
|
|
XmRCallback,
|
|
sizeof(XtCallbackList),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . floating_map_callback),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
{
|
|
XmNfloatingUnmapCallback,
|
|
XmCCallback,
|
|
XmRCallback,
|
|
sizeof(XtCallbackList),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . floating_unmap_callback),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
|
|
|
|
/* Components */
|
|
{
|
|
XmNprogressBar,
|
|
XmCReadOnly,
|
|
XmRWidget,
|
|
sizeof(Widget),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . progress_bar),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
{
|
|
XmNstatusBar,
|
|
XmCReadOnly,
|
|
XmRWidget,
|
|
sizeof(Widget),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . status_bar),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
{
|
|
XmNdockedTaskBar,
|
|
XmCReadOnly,
|
|
XmRWidget,
|
|
sizeof(Widget),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . docked_task_bar),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
{
|
|
XmNtoolBar,
|
|
XmCReadOnly,
|
|
XmRWidget,
|
|
sizeof(Widget),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . tool_bar),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
{
|
|
XmNfloatingShell,
|
|
XmCReadOnly,
|
|
XmRWidget,
|
|
sizeof(Widget),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . floating_shell),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
{
|
|
XmNfloatingTaskBar,
|
|
XmCReadOnly,
|
|
XmRWidget,
|
|
sizeof(Widget),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . floating_task_bar),
|
|
XmRImmediate,
|
|
(XtPointer) NULL
|
|
},
|
|
|
|
/* Boolean resources */
|
|
{
|
|
XmNshowDockedTaskBar,
|
|
XmCShowDockedTaskBar,
|
|
XmRBoolean,
|
|
sizeof(Boolean),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . show_docked_task_bar),
|
|
XmRImmediate,
|
|
(XtPointer) True
|
|
},
|
|
{
|
|
XmNdocked,
|
|
XmCDocked,
|
|
XmRBoolean,
|
|
sizeof(Boolean),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . docked),
|
|
XmRImmediate,
|
|
(XtPointer) True
|
|
},
|
|
|
|
/* Misc resources */
|
|
{
|
|
XmNspacing,
|
|
XmCSpacing,
|
|
XmRHorizontalDimension,
|
|
sizeof(Dimension),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . spacing),
|
|
XmRImmediate,
|
|
(XtPointer) 4
|
|
},
|
|
|
|
/* Pixmap resource */
|
|
{
|
|
XmNundockPixmap,
|
|
XmCUndockPixmap,
|
|
XmRPixmap,
|
|
sizeof(Pixmap),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . undock_pixmap),
|
|
XmRImmediate,
|
|
(XtPointer) XmUNSPECIFIED_PIXMAP
|
|
},
|
|
};
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* XfeDashBoard Synthetic Resources */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static XmSyntheticResource syn_resources[] =
|
|
{
|
|
{
|
|
XmNspacing,
|
|
sizeof(Dimension),
|
|
XtOffsetOf(XfeDashBoardRec , xfe_dash_board . spacing),
|
|
_XmFromHorizontalPixels,
|
|
_XmToHorizontalPixels
|
|
},
|
|
};
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Widget Class Record Initialization */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
_XFE_WIDGET_CLASS_RECORD(dashboard,DashBoard) =
|
|
{
|
|
{
|
|
(WidgetClass) &xfeManagerClassRec, /* superclass */
|
|
"XfeDashBoard", /* class_name */
|
|
sizeof(XfeDashBoardRec), /* widget_size */
|
|
NULL, /* class_initialize */
|
|
NULL, /* class_part_initialize*/
|
|
FALSE, /* class_inited */
|
|
Initialize, /* initialize */
|
|
NULL, /* initialize_hook */
|
|
XtInheritRealize, /* realize */
|
|
NULL, /* actions */
|
|
0, /* num_actions */
|
|
(XtResource *)resources, /* resources */
|
|
XtNumber(resources), /* num_resources */
|
|
NULLQUARK, /* xrm_class */
|
|
TRUE, /* compress_motion */
|
|
XtExposeCompressMaximal, /* compress_exposure */
|
|
TRUE, /* compress_enterleave */
|
|
FALSE, /* visible_interest */
|
|
Destroy, /* destroy */
|
|
XtInheritResize, /* resize */
|
|
XtInheritExpose, /* expose */
|
|
SetValues, /* set_values */
|
|
NULL, /* set_values_hook */
|
|
XtInheritSetValuesAlmost, /* set_values_almost */
|
|
NULL, /* get_values_hook */
|
|
NULL, /* accexfe_focus */
|
|
XtVersion, /* version */
|
|
NULL, /* callback_private */
|
|
XtInheritTranslations, /* tm_table */
|
|
XtInheritQueryGeometry, /* query_geometry */
|
|
XtInheritDisplayAccelerator, /* display accel */
|
|
NULL, /* extension */
|
|
},
|
|
|
|
/* Composite Part */
|
|
{
|
|
XtInheritGeometryManager, /* geometry_manager */
|
|
XtInheritChangeManaged, /* change_managed */
|
|
XtInheritInsertChild, /* insert_child */
|
|
XtInheritDeleteChild, /* delete_child */
|
|
NULL /* extension */
|
|
},
|
|
|
|
/* Constraint Part */
|
|
{
|
|
NULL, /* resource list */
|
|
0, /* num resources */
|
|
sizeof(XfeManagerConstraintRec), /* constraint size */
|
|
NULL, /* init proc */
|
|
NULL, /* destroy proc */
|
|
NULL, /* set values proc */
|
|
NULL, /* extension */
|
|
},
|
|
|
|
/* XmManager Part */
|
|
{
|
|
XtInheritTranslations, /* tm_table */
|
|
(XmSyntheticResource *)syn_resources, /* syn resources */
|
|
XtNumber(syn_resources), /* num syn_resources */
|
|
NULL, /* syn_cont_resources */
|
|
0, /* num_syn_cont_resource*/
|
|
XmInheritParentProcess, /* parent_process */
|
|
NULL, /* extension */
|
|
},
|
|
|
|
/* XfeManager Part */
|
|
{
|
|
XfeInheritBitGravity, /* bit_gravity */
|
|
PreferredGeometry, /* preferred_geometry */
|
|
XfeInheritUpdateBoundary, /* update_boundary */
|
|
XfeInheritUpdateChildrenInfo, /* update_children_info */
|
|
XfeInheritLayoutWidget, /* layout_widget */
|
|
AcceptStaticChild, /* accept_static_child */
|
|
InsertStaticChild, /* insert_static_child */
|
|
DeleteStaticChild, /* delete_static_child */
|
|
LayoutStaticChildren, /* layout_static_children */
|
|
NULL, /* change_managed */
|
|
NULL, /* prepare_components */
|
|
NULL, /* layout_components */
|
|
NULL, /* draw_background */
|
|
XfeInheritDrawShadow, /* draw_shadow */
|
|
NULL, /* draw_components */
|
|
XfeInheritDrawAccentBorder, /* draw_accent_border */
|
|
NULL, /* extension */
|
|
|
|
},
|
|
|
|
/* XfeDashBoard Part */
|
|
{
|
|
NULL, /* extension */
|
|
},
|
|
};
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* xfeDashBoardWidgetClass declaration. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
_XFE_WIDGET_CLASS(dashboard,DashBoard);
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Core class methods */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
Initialize(Widget rw,Widget nw,ArgList args,Cardinal *nargs)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(nw);
|
|
|
|
if (CheckFloatingWidgets(nw,dp->floating_shell))
|
|
{
|
|
AddFloatingShell(nw,dp->floating_shell);
|
|
}
|
|
|
|
/* Update pixmaps */
|
|
UpdateUndockPixmap(nw);
|
|
|
|
dp->floating_target = NULL;
|
|
|
|
/* Finish of initialization */
|
|
_XfeManagerChainInitialize(rw,nw,xfeDashBoardWidgetClass);
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
Destroy(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
/*RemoveFloatingShell(w);*/
|
|
|
|
if (CheckFloatingWidgets(w,dp->floating_shell))
|
|
{
|
|
RemoveFloatingShell(w);
|
|
}
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
SetValues(Widget ow,Widget rw,Widget nw,ArgList args,Cardinal *nargs)
|
|
{
|
|
XfeDashBoardPart * np = _XfeDashBoardPart(nw);
|
|
XfeDashBoardPart * op = _XfeDashBoardPart(ow);
|
|
Boolean update_docked = False;
|
|
|
|
/* floating_shell */
|
|
if (np->floating_shell != op->floating_shell)
|
|
{
|
|
if (CheckFloatingWidgets(ow,op->floating_shell))
|
|
{
|
|
RemoveFloatingShell(ow);
|
|
}
|
|
|
|
if (CheckFloatingWidgets(nw,np->floating_shell))
|
|
{
|
|
AddFloatingShell(nw,np->floating_shell);
|
|
}
|
|
else
|
|
{
|
|
np->docked = True;
|
|
|
|
update_docked = True;
|
|
}
|
|
|
|
_XfemConfigFlags(nw) |= XfeConfigGLE;
|
|
}
|
|
|
|
/* docked */
|
|
if (np->docked != op->docked)
|
|
{
|
|
update_docked = True;
|
|
}
|
|
|
|
/* progress_bar */
|
|
if (np->progress_bar != op->progress_bar)
|
|
{
|
|
_XfeWarning(nw,MESSAGE3);
|
|
np->progress_bar = op->progress_bar;
|
|
}
|
|
|
|
/* status_bar */
|
|
if (np->status_bar != op->status_bar)
|
|
{
|
|
_XfeWarning(nw,MESSAGE4);
|
|
np->status_bar = op->status_bar;
|
|
}
|
|
|
|
/* docked_task_bar */
|
|
if (np->docked_task_bar != op->docked_task_bar)
|
|
{
|
|
_XfeWarning(nw,MESSAGE5);
|
|
np->docked_task_bar = op->docked_task_bar;
|
|
}
|
|
|
|
/* tool_bar */
|
|
if (np->tool_bar != op->tool_bar)
|
|
{
|
|
_XfeWarning(nw,MESSAGE6);
|
|
np->tool_bar = op->tool_bar;
|
|
}
|
|
|
|
/* show_docked_task_bar */
|
|
if (np->show_docked_task_bar != op->show_docked_task_bar)
|
|
{
|
|
_XfemConfigFlags(nw) |= XfeConfigGLE;
|
|
}
|
|
|
|
/* undock_pixmap */
|
|
if (np->undock_pixmap != op->undock_pixmap)
|
|
{
|
|
/* Update undock pixmap */
|
|
UpdateUndockPixmap(nw);
|
|
}
|
|
|
|
if (update_docked)
|
|
{
|
|
if (np->docked)
|
|
{
|
|
if (CheckFloatingWidgets(nw,np->floating_shell))
|
|
{
|
|
XtUnmanageChild(np->floating_target);
|
|
}
|
|
|
|
if (_XfeIsAlive(np->docked_task_bar))
|
|
{
|
|
XtManageChild(np->docked_task_bar);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (CheckFloatingWidgets(nw,np->floating_shell))
|
|
{
|
|
np->docked = False;
|
|
|
|
XtManageChild(np->floating_target);
|
|
|
|
if (_XfeIsAlive(np->docked_task_bar))
|
|
{
|
|
XtUnmanageChild(np->docked_task_bar);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return _XfeManagerChainSetValues(ow,rw,nw,xfeDashBoardWidgetClass);
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* XfeManager class methods */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
PreferredGeometry(Widget w,Dimension * width,Dimension * height)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
Cardinal num_shown = 0;
|
|
|
|
*width =
|
|
_XfemOffsetLeft(w) + _XfemOffsetRight(w);
|
|
|
|
if (SHOW_TOOL_BAR(dp))
|
|
{
|
|
*width += _XfeWidth(dp->tool_bar);
|
|
|
|
num_shown++;
|
|
}
|
|
|
|
if (SHOW_PROGRESS_BAR(dp))
|
|
{
|
|
*width += _XfeWidth(dp->progress_bar);
|
|
|
|
num_shown++;
|
|
}
|
|
|
|
if (SHOW_STATUS_BAR(dp))
|
|
{
|
|
*width += _XfeWidth(dp->status_bar);
|
|
|
|
num_shown++;
|
|
}
|
|
|
|
if (ShowDockedTaskBar(w))
|
|
{
|
|
*width += _XfeWidth(dp->docked_task_bar);
|
|
|
|
num_shown++;
|
|
}
|
|
|
|
if (num_shown)
|
|
{
|
|
*width += ((num_shown - 1) * dp->spacing);
|
|
}
|
|
|
|
*height = _XfemOffsetTop(w) + _XfemOffsetBottom(w) + MaxComponentHeight(w);
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
LayoutStaticChildren(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
/* Compute and store the max component height */
|
|
dp->max_component_height = MaxComponentHeight(w);
|
|
|
|
/* Manage the components */
|
|
ManagerStaticChildren(w);
|
|
|
|
if (SHOW_TOOL_BAR(dp))
|
|
{
|
|
LayoutToolBar(w);
|
|
}
|
|
|
|
if (SHOW_PROGRESS_BAR(dp))
|
|
{
|
|
LayoutProgressBar(w);
|
|
}
|
|
|
|
LayoutDockedTaskBar(w);
|
|
|
|
if (SHOW_STATUS_BAR(dp))
|
|
{
|
|
LayoutStatusBar(w);
|
|
}
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
AcceptStaticChild(Widget child)
|
|
{
|
|
Widget w = XtParent(child);
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
Boolean accept = False;
|
|
|
|
/* Look for tool bar and task bar */
|
|
if (XfeIsToolBar(child))
|
|
{
|
|
accept = (!dp->docked_task_bar || !dp->tool_bar);
|
|
}
|
|
else if (XmIsForm(child))
|
|
{
|
|
accept = !dp->docked_task_bar;
|
|
}
|
|
/* Look for progress bar */
|
|
else if (ChildIsProgressBar(child))
|
|
{
|
|
accept = !dp->progress_bar;
|
|
}
|
|
/* Look for status bar */
|
|
else if (ChildIsStatusBar(child))
|
|
{
|
|
accept = !dp->status_bar;
|
|
}
|
|
|
|
return accept;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
InsertStaticChild(Widget child)
|
|
{
|
|
Widget w = XtParent(child);
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
Boolean layout = False;
|
|
|
|
/* Tool Bars bar */
|
|
if (XfeIsToolBar(child) || XmIsForm(child))
|
|
{
|
|
/* Task bar */
|
|
if (!dp->tool_bar)
|
|
{
|
|
dp->docked_task_bar = child;
|
|
}
|
|
/* Tool bar */
|
|
else
|
|
{
|
|
dp->tool_bar = child;
|
|
}
|
|
|
|
layout = True;
|
|
}
|
|
/* Progress bar */
|
|
else if (ChildIsProgressBar(child))
|
|
{
|
|
dp->progress_bar = child;
|
|
|
|
layout = True;
|
|
}
|
|
/* Status bar */
|
|
else if (ChildIsStatusBar(child))
|
|
{
|
|
dp->status_bar = child;
|
|
|
|
layout = True;
|
|
}
|
|
|
|
return layout;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
DeleteStaticChild(Widget child)
|
|
{
|
|
Widget w = XtParent(child);
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
/* Keep track of deleted widgets */
|
|
if (child == dp->tool_bar)
|
|
{
|
|
dp->tool_bar = NULL;
|
|
}
|
|
else if (child == dp->progress_bar)
|
|
{
|
|
dp->progress_bar = NULL;
|
|
}
|
|
else if (child == dp->status_bar)
|
|
{
|
|
dp->status_bar = NULL;
|
|
}
|
|
else if (child == dp->docked_task_bar)
|
|
{
|
|
dp->docked_task_bar = NULL;
|
|
}
|
|
|
|
return True;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Misc XfeDashBoard functions */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
ChildIsProgressBar(Widget child)
|
|
{
|
|
return XfeIsProgressBar(child);
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
ChildIsStatusBar(Widget child)
|
|
{
|
|
return (XmIsLabel(child) ||
|
|
XmIsLabelGadget(child) ||
|
|
(XfeIsLabel(child) && !XfeIsButton(child)));
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
ShowDockedTaskBar(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
return (dp->show_docked_task_bar && dp->docked_task_bar && IsDocked(w));
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
DockedTaskBarEmpty(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
return (_XfeIsAlive(dp->docked_task_bar) &&
|
|
(XfeChildrenGetNumManaged(dp->docked_task_bar) <= 1));
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
CheckFloatingWidgets(Widget w,Widget shell)
|
|
{
|
|
Boolean result = False;
|
|
|
|
if (_XfeIsAlive(shell))
|
|
{
|
|
/* Make sure the class of the shell is XmDialogShell */
|
|
if (XmIsDialogShell(shell))
|
|
{
|
|
Widget task_bar;
|
|
Widget target;
|
|
|
|
/* The target widget is the first child of the floating shell */
|
|
target = _XfemChildren(shell)[0];
|
|
|
|
/* The docked taskbar is the first descendant of task bar class */
|
|
/* task_bar = XfeDescendantFindByClass(shell,xfeTaskBarWidgetClass, */
|
|
/* XfeFIND_ALIVE,False); */
|
|
|
|
task_bar = XfeDescendantFindByClass(shell,xfeToolBarWidgetClass,
|
|
XfeFIND_ALIVE,False);
|
|
|
|
/* Make sure the target is valid */
|
|
if (_XfeIsAlive(target))
|
|
{
|
|
result = True;
|
|
}
|
|
else
|
|
{
|
|
_XfeWarning(w,MESSAGE9);
|
|
}
|
|
|
|
/* Make sure the docked task bar is valid */
|
|
/* if (_XfeIsAlive(task_bar) && XfeIsTaskBar(task_bar)) */
|
|
if (_XfeIsAlive(task_bar) && XfeIsToolBar(task_bar))
|
|
{
|
|
result = True;
|
|
}
|
|
else
|
|
{
|
|
_XfeWarning(w,MESSAGE7);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_XfeWarning(w,MESSAGE8);
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
AddFloatingShell(Widget w,Widget shell)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
/* Make sure the floating widgets are valid before adding them */
|
|
if (!CheckFloatingWidgets(w,shell))
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* Assign the global floating widget for our convenience */
|
|
/* The target widget is the first child of the floating shell */
|
|
/* The docked taskbar is the first descendant of task bar class */
|
|
dp->floating_shell = shell;
|
|
dp->floating_target = _XfemChildren(shell)[0];
|
|
dp->floating_task_bar = XfeDescendantFindByClass(shell,
|
|
xfeToolBarWidgetClass,
|
|
XfeFIND_ALIVE,
|
|
False);
|
|
|
|
/* Handle changes in view window structure */
|
|
XtAddEventHandler(dp->floating_shell,
|
|
StructureNotifyMask,
|
|
False,
|
|
FloatingShellEH,
|
|
(XtPointer) w);
|
|
|
|
/* Handle floating window closing */
|
|
XfeShellAddCloseCallback(dp->floating_shell,
|
|
FloatingCloseCB,
|
|
(XtPointer) w);
|
|
|
|
XtAddCallback(dp->floating_shell,XmNdestroyCallback,
|
|
DestroyCB,(XtPointer) w);
|
|
|
|
XtAddCallback(dp->floating_task_bar,XmNdestroyCallback,
|
|
DestroyCB,(XtPointer) w);
|
|
|
|
XtAddCallback(dp->floating_target,XmNdestroyCallback,
|
|
DestroyCB,(XtPointer) w);
|
|
|
|
if (IsDocked(w))
|
|
{
|
|
dp->docked = True;
|
|
|
|
if (CheckFloatingWidgets(w,dp->floating_shell))
|
|
{
|
|
XtUnmanageChild(dp->floating_target);
|
|
}
|
|
|
|
if (_XfeIsAlive(dp->docked_task_bar))
|
|
{
|
|
XtManageChild(dp->docked_task_bar);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dp->docked = False;
|
|
|
|
if (CheckFloatingWidgets(w,dp->floating_shell))
|
|
{
|
|
dp->docked = False;
|
|
|
|
XtManageChild(dp->floating_target);
|
|
|
|
if (_XfeIsAlive(dp->docked_task_bar))
|
|
{
|
|
XtUnmanageChild(dp->docked_task_bar);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
RemoveFloatingShell(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
if (dp->floating_task_bar && dp->floating_shell)
|
|
{
|
|
/* Handle changes in view window structure */
|
|
XtRemoveEventHandler(dp->floating_shell,
|
|
StructureNotifyMask,
|
|
False,
|
|
FloatingShellEH,
|
|
(XtPointer) w);
|
|
|
|
/* Dont need to handle floating window closing any more */
|
|
XfeShellRemoveCloseCallback(dp->floating_shell,
|
|
FloatingCloseCB,
|
|
(XtPointer) w);
|
|
}
|
|
|
|
dp->floating_task_bar = NULL;
|
|
dp->floating_target = NULL;
|
|
dp->floating_shell = NULL;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
ManagerStaticChildren(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
_XfemLayoutFrozen(w) = True;
|
|
|
|
if (IsDocked(w))
|
|
{
|
|
if (dp->docked_task_bar)
|
|
{
|
|
if (dp->show_docked_task_bar)
|
|
{
|
|
XtManageChild(dp->docked_task_bar);
|
|
}
|
|
else
|
|
{
|
|
XtUnmanageChild(dp->docked_task_bar);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_XfeIsAlive(dp->floating_target))
|
|
{
|
|
XtManageChild(dp->floating_target);
|
|
}
|
|
|
|
if (dp->docked_task_bar)
|
|
{
|
|
XtUnmanageChild(dp->docked_task_bar);
|
|
}
|
|
}
|
|
|
|
_XfemLayoutFrozen(w) = False;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Dimension
|
|
MaxComponentHeight(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
Dimension max_height = 0;
|
|
|
|
if (SHOW_TOOL_BAR(dp))
|
|
{
|
|
max_height = _XfeHeight(dp->tool_bar);
|
|
}
|
|
|
|
if (SHOW_PROGRESS_BAR(dp))
|
|
{
|
|
max_height = XfeMax(max_height,_XfeHeight(dp->progress_bar));
|
|
}
|
|
|
|
if (SHOW_STATUS_BAR(dp))
|
|
{
|
|
max_height = XfeMax(max_height,_XfeHeight(dp->status_bar));
|
|
}
|
|
|
|
if (ShowDockedTaskBar(w))
|
|
{
|
|
max_height = XfeMax(max_height,_XfeHeight(dp->docked_task_bar));
|
|
}
|
|
|
|
return max_height;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
LayoutToolBar(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
assert( SHOW_TOOL_BAR(dp) );
|
|
|
|
/* Layout the tool bar all the way to the left */
|
|
_XfeConfigureWidget(dp->tool_bar,
|
|
|
|
_XfemOffsetLeft(w),
|
|
|
|
_XfemOffsetTop(w),
|
|
|
|
_XfeWidth(dp->tool_bar),
|
|
|
|
dp->max_component_height);
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
LayoutProgressBar(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
Position x;
|
|
|
|
assert( SHOW_PROGRESS_BAR(dp) );
|
|
|
|
if (SHOW_TOOL_BAR(dp))
|
|
{
|
|
x = _XfeX(dp->tool_bar) +
|
|
_XfeWidth(dp->tool_bar) +
|
|
dp->spacing;
|
|
}
|
|
else
|
|
{
|
|
x = _XfemOffsetLeft(w);
|
|
}
|
|
|
|
if (_XfeWidth(dp->progress_bar) > 0)
|
|
{
|
|
_XfeConfigureWidget(dp->progress_bar,
|
|
|
|
x,
|
|
|
|
_XfemOffsetTop(w),
|
|
|
|
_XfeWidth(dp->progress_bar),
|
|
|
|
dp->max_component_height);
|
|
}
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
LayoutDockedTaskBar(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
if (!_XfeIsAlive(dp->docked_task_bar))
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* If the taskbar is empty, hide it */
|
|
if (DockedTaskBarEmpty(w))
|
|
{
|
|
XtVaSetValues(dp->docked_task_bar,XmNmappedWhenManaged,False,NULL);
|
|
}
|
|
else
|
|
{
|
|
XtVaSetValues(dp->docked_task_bar,XmNmappedWhenManaged,True,NULL);
|
|
}
|
|
|
|
/* If the taskbar is not mapped when managed, dont do layout for it */
|
|
if (!_XfeMappedWhenManaged(dp->docked_task_bar))
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* Layout the task bar and status bar according to docking state */
|
|
if (ShowDockedTaskBar(w))
|
|
{
|
|
/* Layout the docked task bar to the far right */
|
|
_XfeConfigureWidget(dp->docked_task_bar,
|
|
|
|
_XfeWidth(w) -
|
|
_XfemOffsetRight(w) -
|
|
_XfeWidth(dp->docked_task_bar),
|
|
|
|
_XfemOffsetTop(w),
|
|
|
|
_XfeWidth(dp->docked_task_bar),
|
|
|
|
dp->max_component_height);
|
|
|
|
/*
|
|
* Raise the taskbar so that it will always show even when the
|
|
* dashboard display is tiny
|
|
*/
|
|
if (XtIsRealized(dp->docked_task_bar))
|
|
{
|
|
XRaiseWindow(XtDisplay(dp->docked_task_bar),
|
|
_XfeWindow(dp->docked_task_bar));
|
|
}
|
|
}
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
LayoutStatusBar(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
Position x1;
|
|
Position x2;
|
|
|
|
assert( SHOW_STATUS_BAR(dp) );
|
|
|
|
/* Compute the right-most coordinate */
|
|
if (ShowDockedTaskBar(w) && !DockedTaskBarEmpty(w))
|
|
|
|
{
|
|
x2 = _XfeX(dp->docked_task_bar) - dp->spacing;
|
|
}
|
|
else
|
|
{
|
|
x2 = _XfeWidth(w) - _XfemOffsetRight(w);
|
|
}
|
|
|
|
if (SHOW_PROGRESS_BAR(dp))
|
|
{
|
|
x1 =
|
|
_XfeX(dp->progress_bar) +
|
|
_XfeWidth(dp->progress_bar) +
|
|
dp->spacing;
|
|
}
|
|
else if (SHOW_TOOL_BAR(dp))
|
|
{
|
|
x1 =
|
|
_XfeX(dp->tool_bar) +
|
|
_XfeWidth(dp->tool_bar) +
|
|
dp->spacing;
|
|
}
|
|
else
|
|
{
|
|
x1 = _XfemOffsetLeft(w);
|
|
}
|
|
|
|
|
|
if (x2 > x1)
|
|
{
|
|
/* Use the full extent of the widget */
|
|
_XfeConfigureWidget(dp->status_bar,
|
|
|
|
x1,
|
|
|
|
_XfemOffsetLeft(w),
|
|
|
|
x2 - x1,
|
|
|
|
dp->max_component_height);
|
|
}
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static Boolean
|
|
IsDocked(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
return !(_XfeIsAlive(dp->floating_target) &&
|
|
XtIsManaged(dp->floating_target));
|
|
|
|
/* return !(dp->floating_task_bar && XtIsManaged(dp->floating_task_bar)); */
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
UpdateUndockPixmap(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
#if 0
|
|
if (dp->docked_task_bar)
|
|
{
|
|
if (_XfePixmapGood(dp->undock_pixmap))
|
|
{
|
|
XtVaSetValues(dp->docked_task_bar,
|
|
XmNactionPixmap, dp->undock_pixmap,
|
|
NULL);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
Undock(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
Boolean invoke_callback = dp->docked;
|
|
|
|
/* Undock only if a floating shell has been installed */
|
|
if (CheckFloatingWidgets(w,dp->floating_shell))
|
|
{
|
|
dp->docked = False;
|
|
|
|
/* XtManageChild(dp->floating_task_bar); */
|
|
if (CheckFloatingWidgets(w,dp->floating_shell))
|
|
{
|
|
XtManageChild(dp->floating_target);
|
|
}
|
|
|
|
if (_XfeIsAlive(dp->docked_task_bar))
|
|
{
|
|
XtUnmanageChild(dp->docked_task_bar);
|
|
}
|
|
}
|
|
|
|
if (invoke_callback)
|
|
{
|
|
/* printf("Undock(%s,%p)\n",XtName(XtParent(XtParent(w))),XtParent(XtParent(w))); */
|
|
|
|
_XfeInvokeCallbacks(w,dp->undock_callback,XmCR_UNDOCK,NULL,False);
|
|
|
|
}
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
Dock(Widget w)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
Boolean invoke_callback = !dp->docked;
|
|
|
|
dp->docked = True;
|
|
|
|
if (CheckFloatingWidgets(w,dp->floating_shell))
|
|
{
|
|
/* XtUnmanageChild(dp->floating_task_bar); */
|
|
XtUnmanageChild(dp->floating_target);
|
|
}
|
|
|
|
if (_XfeIsAlive(dp->docked_task_bar))
|
|
{
|
|
XtManageChild(dp->docked_task_bar);
|
|
}
|
|
|
|
if (invoke_callback)
|
|
{
|
|
/* printf("Dock(%s,%p)\n",XtName(XtParent(XtParent(w))),XtParent(XtParent(w))); */
|
|
|
|
_XfeInvokeCallbacks(w,dp->dock_callback,XmCR_DOCK,NULL,False);
|
|
}
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* Floating shell / task bar event handlers and callbacks. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
FloatingShellEH(Widget shell,
|
|
XtPointer client_data,
|
|
XEvent * event,
|
|
Boolean * cont)
|
|
{
|
|
Widget w = (Widget) client_data;
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(w);
|
|
|
|
if (event)
|
|
{
|
|
switch(event->type)
|
|
{
|
|
case MapNotify:
|
|
|
|
Undock(w);
|
|
|
|
_XfeInvokeCallbacks(w,dp->floating_map_callback,
|
|
XmCR_FLOATING_MAP,event,False);
|
|
|
|
break;
|
|
|
|
case UnmapNotify:
|
|
|
|
Dock(w);
|
|
|
|
_XfeInvokeCallbacks(w,dp->floating_unmap_callback,
|
|
XmCR_FLOATING_UNMAP,event,False);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
*cont = True;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
DestroyCB(Widget child,XtPointer client_data,XtPointer call_data)
|
|
{
|
|
Widget w = (Widget) client_data;
|
|
|
|
RemoveFloatingShell(w);
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static void
|
|
FloatingCloseCB(Widget child,XtPointer client_data,XtPointer call_data)
|
|
{
|
|
Widget w = (Widget) client_data;
|
|
|
|
Dock(w);
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* */
|
|
/* XfeDashBoard Public Methods */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
Widget
|
|
XfeCreateDashBoard(Widget parent,char *name,Arg *args,Cardinal count)
|
|
{
|
|
return (XtCreateWidget(name,xfeDashBoardWidgetClass,parent,args,count));
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
/* extern */ Widget
|
|
XfeDashBoardGetComponent(Widget dashboard,XfeDashBoardComponent component)
|
|
{
|
|
XfeDashBoardPart * dp = _XfeDashBoardPart(dashboard);
|
|
Widget cw = NULL;
|
|
|
|
switch(component)
|
|
{
|
|
case XfeDASH_BOARD_TOOL_BAR:
|
|
cw = dp->tool_bar;
|
|
break;
|
|
|
|
case XfeDASH_BOARD_DOCKED_TASK_BAR:
|
|
cw = dp->docked_task_bar;
|
|
break;
|
|
|
|
case XfeDASH_BOARD_FLOATING_TASK_BAR:
|
|
cw = dp->floating_task_bar;
|
|
break;
|
|
|
|
case XfeDASH_BOARD_FLOATING_SHELL:
|
|
cw = dp->floating_shell;
|
|
break;
|
|
|
|
case XfeDASH_BOARD_PROGRESS_BAR:
|
|
cw = dp->progress_bar;
|
|
break;
|
|
|
|
case XfeDASH_BOARD_STATUS_BAR:
|
|
cw = dp->status_bar;
|
|
break;
|
|
}
|
|
|
|
return cw;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|