falso
/
cdesktopenv
mirror of https://git.code.sf.net/p/cdesktopenv/code
1
0
Fork 0
Code Issues Releases Wiki Activity
cdesktopenv/cde/programs/dtfile/IconWindow.c

3956 lines
156 KiB
C
Raw Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these librararies and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/* $XConsortium: IconWindow.c /main/13 1996/10/15 10:07:48 mustafa $ */
/************************************<+>*************************************
****************************************************************************
*
* FILE: IconWindow.c
*
* COMPONENT_NAME: Desktop File Manager (dtfile)
*
* Description: Processing functions for callbacks from the
* icon display area.
*
* FUNCTIONS: CheckForBtnUp
* DrawHighlight
* DrawRectangle
* DrawShadowTh
* DrawUnhighlight
* FM_XmHighlightBorder
* FM_XmUnhighlightBorder
* FileWindowExposeCallback
* FileWindowInputCallback
* FileWindowMapCallback
* FileWindowResizeCallback
* GetSelectionRectangle
* ProcessSelection
* WidgetRectToRegion
*
* (c) Copyright 1993, 1994, 1995 Hewlett-Packard Company
* (c) Copyright 1993, 1994, 1995 International Business Machines Corp.
* (c) Copyright 1993, 1994, 1995 Sun Microsystems, Inc.
* (c) Copyright 1993, 1994, 1995 Novell, Inc.
*
****************************************************************************
************************************<+>*************************************/
#include <Xm/Xm.h>
#include <Xm/XmP.h>
#include <Xm/DrawP.h>
#include <Xm/TextF.h>
#include <Xm/VirtKeys.h>
#include <Xm/ScrollBar.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <Dt/Icon.h>
#include <Dt/IconP.h>
#include <Dt/Connect.h>
#include <Dt/DtNlUtils.h>
#include <Dt/Action.h>
#include <X11/cursorfont.h>
#include <X11/Xutil.h>
#ifndef XK_MISCELLANY
#define XK_MISCELLANY
#endif
#include <X11/keysymdef.h>
#include <Xm/PrimitiveP.h> /* For HighlightBorder & UnhighlightBorder */
#include "Encaps.h"
#include "FileMgr.h"
#include "Desktop.h"
#include "Main.h"
#include "Prefs.h"
#include "Common.h"
#include "Filter.h"
#include "SharedProcs.h"
/* For HightlightBorder & UnhighlightBorder */
externalref XmPrimitiveClassRec xmPrimitiveClassRec;
Boolean TurnOnTextName;
/******** Static Function Declarations ********/
static Boolean CheckForBtnUp(
Display *display,
XEvent *event,
XtPointer arg) ;
static void GetSelectionRectangle(
Display *display,
Window window,
XButtonEvent *event,
FileMgrRec *file_mgr_rec,
FileMgrData *file_mgr_data,
Boolean toggleSelect) ;
static void DrawRectangle(
Display *display,
Window window,
GC gc,
int x1,
int y1,
int x2,
int y2) ;
static void ProcessSelection(
FileMgrData * file_mgr_data,
Widget icon,
Boolean toggleSelect,
XButtonEvent *event) ;
static void FM_XmHighlightBorder(Widget w);
static void FM_XmUnhighlightBorder(Widget w);
static XmGadget InputForGadget(
Widget wid,
int x,
int y ) ;
/******** End Static Function Declarations ********/
/************************************************************************
*
* FileWindowExposeCallback
* Callback function invoked upon an exposure event occuring
* in the file display area.
*
************************************************************************/
void
FileWindowExposeCallback(
Widget w,
XtPointer client_data,
XtPointer call_data )
{
FileMgrRec * file_mgr_rec;
DialogData * dialog_data;
FileMgrData * file_mgr_data;
XmDrawingAreaCallbackStruct * da_cbs;
register int i;
file_mgr_rec = (FileMgrRec *) client_data;
dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
/* Check for the view already being closed */
if (dialog_data == NULL) return;
file_mgr_data = (FileMgrData *) dialog_data->data;
da_cbs = (XmDrawingAreaCallbackStruct * )call_data;
/* if necessary, redraw tree lines */
if (da_cbs->reason == XmCR_EXPOSE &&
file_mgr_data->show_type == MULTIPLE_DIRECTORY)
{
XExposeEvent *event = (XExposeEvent *)da_cbs->event;
if (event && event->type == Expose)
RedrawTreeLines(w, event->x, event->y, event->width, event->height,
event->count, file_mgr_rec, file_mgr_data);
else
RedrawTreeLines(w, 0, 0, 999999, 999999, 0, file_mgr_rec, file_mgr_data);
}
}
/************************************************************************
*
* FileWindowResizeCallback
* Callback function invoked upon a resize of the file display area.
*
************************************************************************/
void
FileWindowResizeCallback(
Widget w,
XtPointer client_data,
XEvent *event )
{
FileMgrRec * file_mgr_rec;
DialogData * dialog_data;
FileMgrData * file_mgr_data;
if (event->type == ConfigureNotify)
{
XConfigureEvent * cevent = (XConfigureEvent *) event;
file_mgr_rec = (FileMgrRec *) client_data;
/*
* If the incoming size is different than the current size of the
* scrolled window, then ignore this event, since it means that our
* size has changed since this configure notify event was generated;
* we'll wait for the next one to arrive, and try again.
*/
if ((file_mgr_rec->scroll_window->core.height != cevent->height) ||
(file_mgr_rec->scroll_window->core.width != cevent->width))
{
return;
}
dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
if(dialog_data != NULL)
{
file_mgr_data = (FileMgrData *) dialog_data->data;
LayoutFileIcons (file_mgr_rec, file_mgr_data, False, False);
}
}
}
/************************************************************************
*
* FileWindowMapCallback
* Callback function invoked upon a map or unmap of a file
* manager window.
*
************************************************************************/
void
FileWindowMapCallback(
Widget w,
XtPointer client_data,
XEvent *event )
{
FileMgrRec * file_mgr_rec;
DialogData * dialog_data;
FileMgrData * file_mgr_data;
file_mgr_rec = (FileMgrRec *) client_data;
dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
if(dialog_data != NULL)
{
file_mgr_data = (FileMgrData *) dialog_data->data;
if (event->type == MapNotify)
{
file_mgr_data->mapped = True;
FileWindowMapUnmap( file_mgr_data );
}
else if (event->type == UnmapNotify)
{
file_mgr_data->mapped = False;
FileWindowMapUnmap( file_mgr_data );
}
}
}
/************************************************************************
*
* FileWindowInputCallback
* Callback function invoked upon input occuring in the
* file display area, file icon, or within a desktop icon.
*
************************************************************************/
void
FileWindowInputCallback(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
static Boolean first = True;
static KeySym PlusKeysym, MinusKeySym;
static KeySym ActivateKeysym, SpaceKeysym;
static XmKeyBinding SelectBindings;
static int NumSelectKeys = 0;
FileMgrRec * file_mgr_rec;
XmAnyCallbackStruct * callback;
DialogData * dialog_data;
FileMgrData * file_mgr_data;
DirectorySet * directoryData;
XEvent *new_event;
XButtonPressedEvent *event;
XKeyEvent *kevent;
Widget eventIcon;
int i, j;
FileViewData * fileViewData = NULL;
Arg args[10];
DesktopRec * desktopRec;
KeySym keysym;
Modifiers modif;
int offset;
Boolean found;
/* Do nothing if a Button 2 drag is already ramping up */
if (B2DragPossible)
return;
/* Determine if this is a desktop icon or a regular icon */
file_mgr_rec = NULL;
desktopRec = NULL;
for (i = 0; i < desktop_data->numIconsUsed; i++)
{
if (desktop_data->desktopWindows[i] == (DesktopRec *)client_data)
{
desktopRec = (DesktopRec *)client_data;
break;
}
}
if (desktopRec == NULL)
{
file_mgr_rec = (FileMgrRec *) client_data;
dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
file_mgr_data = (FileMgrData *) dialog_data->data;
}
else
file_mgr_data = NULL;
callback = (XmAnyCallbackStruct *) call_data;
new_event = (XEvent *)callback->event;
if (new_event->type == ButtonPress)
{
XButtonEvent *bevent = (XButtonEvent *)new_event;
desktop_data->event = *bevent;
}
else if (new_event->type == KeyPress || new_event->type == KeyRelease)
{
if(first)
{
/* set up the the keysyms we are looking for */
PlusKeysym = XStringToKeysym("plus");
MinusKeySym = XStringToKeysym("minus");
NumSelectKeys = XmeVirtualToActualKeysyms(XtDisplay(w),
osfXK_Select,
&SelectBindings);
ActivateKeysym = XK_Return;
SpaceKeysym = XStringToKeysym("space");
first = False;
}
kevent = (XKeyEvent *)new_event;
if (kevent->state & ShiftMask)
offset = 1;
else
offset = 0;
/*
keysym = XLookupKeysym(kevent, offset);
*/
XmTranslateKey( kevent->display, kevent->keycode, offset?ShiftMask:0,
&modif, &keysym);
}
/* in tree mode '+' and '-' keys expand and collaps tree branches */
if (!desktopRec && new_event->type == KeyPress &&
(keysym == PlusKeysym || keysym == MinusKeySym))
{
/* ignore +/- keys if not in tree mode */
if (file_mgr_data->show_type != MULTIPLE_DIRECTORY)
return;
/* get the gadget that received the input */
if (keybdFocusPolicy == XmEXPLICIT)
eventIcon = (Widget) XmGetFocusWidget(w);
else
eventIcon = (Widget) InputForGadget(w, kevent->x, kevent->y);
if (eventIcon == NULL)
return;
/* find the widget in the file_list */
found = False;
for (i = -1; i < file_mgr_data->directory_count && !found; i++)
{
for (j = 0; j < file_mgr_data->directory_set[i]->file_count; j++)
{
fileViewData = file_mgr_data->directory_set[i]->file_view_data[j];
if (fileViewData->widget == eventIcon ||
fileViewData->treebtn == eventIcon)
{
found = True;
break;
}
}
}
/* if found, expand the branch */
if (found && fileViewData->file_data->is_subdir)
{
XmDropSiteStartUpdate(w);
DirTreeExpand(file_mgr_data, fileViewData, (keysym == PlusKeysym));
DrawCurrentDirectory (file_mgr_rec->current_directory,
file_mgr_rec, file_mgr_data);
LayoutFileIcons(file_mgr_rec, file_mgr_data, False, True);
XmDropSiteEndUpdate(w);
RedrawTreeLines(w, -w->core.x, -w->core.y,
XtParent(w)->core.width, XtParent(w)->core.height,
0, file_mgr_rec, file_mgr_data);
}
}
else if (new_event->type == ButtonPress || (new_event->type == KeyPress &&
keybdFocusPolicy == XmEXPLICIT))
{
/* Any button event unposts the rename text field */
if (desktopRec)
UnpostDTTextField();
else if( file_mgr_data )
{
if( file_mgr_data->fast_cd_enabled )
UnpostTextPath( file_mgr_data );
UnpostTextField( file_mgr_data );
}
if (new_event->type == KeyPress)
{
/* We have a KeyPress: need to check to see if the press is
"return", "space", "select". If it is, need to select the Icon
the focus is in. */
if (keysym == XK_Escape)
{
/* an escape unposts the name change text widget */
if(desktopRec)
UnpostDTTextField();
else
UnpostTextField(file_mgr_data);
return;
}
else if ( keysym != ActivateKeysym
&& keysym != SpaceKeysym
&& keysym != osfXK_Delete
&& keysym != osfXK_EndLine
&& keysym != osfXK_BeginLine
&& keysym != osfXK_PageLeft
&& keysym != osfXK_PageUp
&& keysym != osfXK_PageDown
&& keysym != osfXK_PageRight
&& keysym != osfXK_Menu )
{
Boolean select = FALSE;
int i;
for (i = 0; !select && (i < NumSelectKeys); i++)
select = (keysym == SelectBindings[i].keysym);
if (!select)
return;
}
if (desktopRec)
eventIcon = desktopRec->iconGadget;
else
eventIcon = (Widget) XmGetFocusWidget(file_mgr_rec->file_window);
event = (XButtonPressedEvent *)new_event;
}
else
{
event = (XButtonPressedEvent *)new_event;
if(event->button != Button1)
{
if(event->button == bMenuButton && desktopRec == NULL)
FmPopup (NULL, NULL, (XEvent *)event, file_mgr_data);
return;
}
eventIcon = (Widget) InputForGadget(w, event->x, event->y);
}
/*
* If the event occurred in an icon, then we are either doing
* a selection or a drag. If it started in the file window, then
* we can only be doing a region selection.
*/
if (eventIcon != NULL)
{
/*
* If this icon is currently selected, then we can't yet tell
* whether the user is starting a drag operation, or simply
* redoing the icon selection; we must wait for either the
* drag threshold to be surpassed, or the button up event.
*/
/* Map the icon into its fileViewData structure */
/* Check for desktop icon first */
if (desktopRec)
{
for (i = 0; i<desktop_data->numIconsUsed; i++)
{
if (desktop_data->desktopWindows[i]->iconGadget == eventIcon)
{
fileViewData = desktop_data->desktopWindows[i]->file_view_data;
break;
}
}
}
else
{
/* Not a desktop icon */
XtSetArg(args[0], XmNuserData, (XtPointer) &directoryData);
XtGetValues(eventIcon, args, 1);
if( directoryData != NULL )
{
for (i = 0; i < directoryData->file_count; i++)
{
if (directoryData->file_view_data[i]->widget == eventIcon &&
directoryData->file_view_data[i]->displayed)
{
fileViewData = directoryData->file_view_data[i];
break;
}
}
}
}
if (((file_mgr_rec && FileIsSelected(file_mgr_data, fileViewData)) ||
(desktopRec && DTFileIsSelected(desktopRec, fileViewData))) &&
event->type == ButtonPress)
{
/* Need to wait to determine what to do */
ProcessBtnUp = True;
B1DragPossible = True;
initialDragX = event->x;
initialDragY = event->y;
if((file_mgr_rec && FileIsSelected(file_mgr_data, fileViewData)) &&
file_mgr_data->selected_file_count > 1)
{
if (PositioningEnabledInView(file_mgr_data))
{
ObjectPtr top;
FileViewData ** selection_list;
top = GetTopOfStack(file_mgr_data);
if(top != NULL && top->file_view_data != fileViewData)
{
ObjectPtr savetop, next, prev;
savetop = top;
while(top != NULL && top->file_view_data != fileViewData)
top = top->next;
if(top != NULL)
{
prev = top->prev;
next = top->next;
if (prev)
prev->next = next;
if (next)
next->prev = prev;
top->prev = NULL;
top->next = savetop;
top->stacking_order = 1;
savetop->prev = top;
top = savetop;
for(i = 2; top->prev != NULL; i++)
{
top->stacking_order = i;
if(top->next == NULL)
break;
top = top->next;
}
top = GetTopOfStack(file_mgr_data);
RedrawOneGadget(top->file_view_data->widget,NULL,NULL);
}
}
/* now make it the top of the selection list */
/* Force selection list order to match stacking order */
selection_list = (FileViewData **)XtMalloc(
sizeof(FileViewData *) *
(file_mgr_data->selected_file_count + 1));
i = 0;
if(top->file_view_data != NULL)
selection_list[i++] = top->file_view_data;
for(j = 0;i < file_mgr_data->selected_file_count; j++,i++)
{
if(top->file_view_data !=
file_mgr_data->selection_list[j])
selection_list[i] = file_mgr_data->selection_list[j];
else
i--;
}
selection_list[i] = NULL;
XtFree((char *)file_mgr_data->selection_list);
file_mgr_data->selection_list = selection_list;
}
}
}
else
{
/*
* The icon is not currently selected, so we will select it.
* It is still possible that the user may initiate a drag.
*/
ProcessBtnUp = False;
if (event->type == ButtonPress)
{
B1DragPossible = True;
initialDragX = event->x;
initialDragY = event->y;
}
else
{
B1DragPossible = False;
initialDragX = -1;
initialDragY = -1;
}
switch( keysym )
{
case osfXK_Delete:
{
DtActionArg * action_args;
int arg_count;
if( desktopRec == NULL
&& file_mgr_rec != NULL )
{
if( file_mgr_data->selected_file_count
&& fileViewData
&& FileIsSelected(file_mgr_data, fileViewData) )
{
_DtBuildActionArgsWithSelectedFiles(
file_mgr_data->selection_list,
file_mgr_data->selected_file_count,
&action_args, &arg_count );
}
else
{
_DtBuildActionArgsWithSelectedFiles( &fileViewData, 1,
&action_args,
&arg_count );
}
DtActionInvoke( file_mgr_rec->shell, TRASH_ACTION,
action_args, arg_count, NULL, NULL,
trash_dir, True, NULL, NULL );
}
else if( desktopRec != NULL )
{
int selectedCount = desktop_data->workspaceData[desktopRec->workspace_num - 1]->files_selected;
if( selectedCount )
{
_DtBuildActionArgsWithDTSelectedFiles(
desktop_data->workspaceData[desktopRec->workspace_num - 1]->selectedDTWindows,
selectedCount,
&action_args, &arg_count );
}
else
{
_DtBuildActionArgsWithSelectedFiles( &fileViewData, 1,
&action_args,
&arg_count );
}
DtActionInvoke( desktopRec->shell, TRASH_ACTION,
action_args, arg_count, NULL, NULL,
trash_dir, True, NULL, NULL );
}
_DtFreeActionArgs( action_args, arg_count );
}
break;
case osfXK_Menu:
if(file_mgr_data) /* if not, then it is a desktop object */
FmPopup( NULL, (XtPointer)fileViewData,
(XEvent *)event, file_mgr_data );
break;
case osfXK_EndLine:
if( !desktopRec
&& file_mgr_data->show_type != MULTIPLE_DIRECTORY )
{
Widget child = NULL;
child = XmGetFocusWidget(file_mgr_rec->file_window);
if( child )
{
FileViewData * focusIcon = NULL;
FileViewData **order_list;
int order_count;
order_list = ((IconLayoutData *)file_mgr_data->layout_data)->order_list;
order_count = ((IconLayoutData *)file_mgr_data->layout_data)->order_count;
for (i = 0; i < order_count; ++i)
{
if (order_list[i]->filtered)
continue;
if( order_list[i]->widget == child
&& !order_list[i]->need_update )
{
int j;
int y = order_list[i]->y;
focusIcon = order_list[i];
for( j = i+1; j < order_count; ++j )
{
if (order_list[j]->filtered)
continue;
if( order_list[j]->y == y )
focusIcon = order_list[j];
else
break;
}
break;
}
}
XmProcessTraversal( focusIcon->widget, XmTRAVERSE_CURRENT );
}
}
break;
case osfXK_BeginLine:
if( !desktopRec
&& file_mgr_data->show_type != MULTIPLE_DIRECTORY )
{
Widget child = NULL;
child = XmGetFocusWidget(file_mgr_rec->file_window);
if( child )
{
FileViewData * focusIcon = NULL;
FileViewData **order_list;
int order_count;
order_list = ((IconLayoutData *)file_mgr_data->layout_data)->order_list;
order_count = ((IconLayoutData *)file_mgr_data->layout_data)->order_count;
for (i = 0; i < order_count; ++i)
{
if (order_list[i]->filtered)
continue;
if( order_list[i]->widget == child
&& !order_list[i]->need_update )
{
int j;
int y = order_list[i]->y;
focusIcon = order_list[i];
for( j = i-1; j >= 0; --j )
{
if (order_list[j]->filtered)
continue;
if( order_list[j]->y == y )
focusIcon = order_list[j];
else
break;
}
break;
}
}
XmProcessTraversal( focusIcon->widget, XmTRAVERSE_CURRENT );
}
}
break;
case osfXK_PageUp:
if( !desktopRec )
{
if( VerticalScrollbarIsVisible(
file_mgr_rec->vertical_scroll_bar,
file_mgr_rec->scroll_window))
{
String p;
p = (String) XtMalloc(sizeof(char *));
*p = (char) 0;
XtCallActionProc( file_mgr_rec->vertical_scroll_bar,
"PageUpOrLeft", new_event,
(char **) &p, 1 );
XtFree(p);
}
}
break;
case osfXK_PageDown:
if( !desktopRec )
{
if( VerticalScrollbarIsVisible(
file_mgr_rec->vertical_scroll_bar,
file_mgr_rec->scroll_window))
{
String p;
p = (String) XtMalloc(sizeof(char *));
*p = (char)0;
XtCallActionProc( file_mgr_rec->vertical_scroll_bar,
"PageDownOrRight", new_event, &p, 1 );
XtFree(p);
}
}
break;
default:
if (desktopRec)
ProcessDTSelection(desktopRec, (XButtonEvent *)event);
else
ProcessSelection( file_mgr_data, eventIcon,
((event->state & ControlMask) != 0),
(XButtonEvent *)event);
break;
}
}
}
else
{
/* In file window - start region select */
/* There are no region selects for desktop icons */
ProcessBtnUp = False;
B1DragPossible = False;
initialDragX = -1;
initialDragY = -1;
if (desktopRec == NULL)
{
ProcessSelection(file_mgr_data, NULL,
((event->state & ControlMask) != 0),
(XButtonEvent *)event);
}
}
}
else if(new_event->type == ButtonRelease || (new_event->type == KeyRelease &&
keybdFocusPolicy == XmEXPLICIT))
{
if(new_event->type == KeyRelease)
{
if (keysym != osfXK_Select)
return;
event = (XButtonPressedEvent *)new_event;
}
else
{
event = (XButtonPressedEvent *)new_event;
if(event->button != Button1)
return;
}
/*
* When a button 1 up event is received, we will first see if the
* select occurred in the icon's title; if so, then we will post
* the rename text field. If the icon in which the button down
* occurred was not already selected, then all of the selection
* work was done at button 1 down time, so there is nothing left
* for us to do but return. However, if the icon was already
* selected, then we could not do any select processing at button
* down time, because the user may have been trying to initate
* a drag request; this can't be determined until either the drag
* threshold is surpassed, or the button up occurs.
*/
if (((initialDragX >= 0) && (initialDragY >= 0)) &&
(eventIcon = (Widget) InputForGadget(w, initialDragX,
initialDragY)))
{
/*
* If processing was postponed until the button up, then do it now.
*/
B1DragPossible = False;
if (ProcessBtnUp)
{
XEvent tmpEvent;
tmpEvent.xbutton = *event;
tmpEvent.xbutton.x = initialDragX;
tmpEvent.xbutton.y = initialDragY;
if (desktopRec)
{
ProcessDTSelection(desktopRec, (XButtonEvent *)&tmpEvent);
}
else
{
ProcessSelection(file_mgr_data, eventIcon,
((event->state & ControlMask) != 0),
(XButtonEvent *)&tmpEvent);
}
}
/*
* If the select occurred in the title portion of the icon, then
* put up a text edit field, which can be used to change the name
* of the icon. The last field '0' means its not on the Desktop.
*/
if (_DtIconSelectInTitle(eventIcon, (Position)initialDragX,
(Position)initialDragY) && ProcessBtnUpCD)
{
/* Map the icon into its fileViewData structure */
/* Check for desktop icon first */
if (desktopRec)
{
for (i = 0; i<desktop_data->numIconsUsed; i++)
{
if (desktop_data->desktopWindows[i]->iconGadget == eventIcon)
{
fileViewData =
desktop_data->desktopWindows[i]->file_view_data;
break;
}
}
}
else
{
/* Not a desktop icon */
XtSetArg(args[0], XmNuserData, (XtPointer) &directoryData);
XtGetValues(eventIcon, args, 1);
for (i = 0; i < directoryData->file_count; i++)
{
if (directoryData->file_view_data[i]->widget == eventIcon &&
directoryData->file_view_data[i]->displayed)
{
fileViewData = directoryData->file_view_data[i];
break;
}
}
}
if (desktopRec)
{
CreateNameChangeDialog(eventIcon, fileViewData,
(XtPointer)desktopRec, DESKTOP);
}
else if( file_mgr_data->view != BY_NAME )
{
/* We don't allow users to rename when they are viewing a
directory in 'By Name Only' mode.
Because clicking on the label is the only way for them
to select a file. Popup a text widget to allow rename
would be very confusing
*/
if( file_mgr_data->view != BY_ATTRIBUTES
|| ( file_mgr_data->view == BY_ATTRIBUTES
&& TurnOnTextName ) )
CreateNameChangeDialog(eventIcon, fileViewData,
(XtPointer)file_mgr_data, NOT_DESKTOP);
}
}
}
else
{
/* Clean up */
B1DragPossible = False;
B2DragPossible = False;
ProcessBtnUp = False;
}
ProcessBtnUpCD = True;
}
else if(new_event->type == KeyPress)
{
if (keysym == XK_Escape)
{
/* an escape unposts the name change text widget */
if(desktopRec)
UnpostDTTextField();
else
UnpostTextField(file_mgr_data);
return;
}
}
}
/*
* When a select operation terminates, we need to find the real button
* up event, so that we can get the correct (x,y) for where the select
* operation ended.
*/
static Boolean
CheckForBtnUp(
Display *display,
XEvent *event,
XtPointer arg )
{
if ((event->type == ButtonRelease) && (event->xbutton.button == Button1))
return(True);
return(False);
}
/************************************************************************
*
* GetSelectionRectangle
*
************************************************************************/
static void
GetSelectionRectangle(
Display *display,
Window window,
XButtonEvent *event,
FileMgrRec *file_mgr_rec,
FileMgrData *file_mgr_data,
Boolean toggleSelect)
{
Screen * screen;
static GC draw_gc = 0;
XGCValues gc_values;
Region region;
Region widget_region;
Region intersect_region;
Region redraw_region;
static XRectangle return_rect;
int virt_x, virt_y;
int virt_width, virt_height;
int x1, y1;
int x2, y2;
int x3, y3;
int x4, y4;
int old_x, old_y;
int temp, j, i;
int pixmap_x, pixmap_y, pixmap_x1, pixmap_y1;
int directory_count;
Window root, sub_win;
int win_x, win_y;
unsigned int mask;
XEvent btnUpEvent;
XmManagerWidget file_window;
Dimension current_file_window_width, sw_width;
Dimension current_file_window_height, sw_height;
Dimension file_window_width, file_window_height;
Dimension max_width, max_height;
Dimension min_width, min_height;
Widget hb, vb;
int vb_val_ret = 0;
int vb_slide_size = 0;
int vb_inc_ret = 0;
int vb_pg_inc_ret = 0;
int hb_val_ret = 0;
int hb_slide_size = 0;
int hb_inc_ret = 0;
int hb_pg_inc_ret = 0;
Boolean vsbVisible = False;
Boolean hsbVisible = False;
DirectorySet ** directory_set;
FileViewData *file_view_data;
Position x,y;
Dimension highlightThickness, shadowThickness;
Dimension width, height;
Dimension marginWidth, marginHeight;
Dimension pixmapWidth, pixmapHeight;
Dimension stringWidth, stringHeight;
unsigned char pixmapPosition;
unsigned char alignment;
Arg args[10];
/* Get the horizontal and vertical scrollbars. */
XtSetArg (args[0], XmNhorizontalScrollBar, &hb);
XtSetArg (args[1], XmNverticalScrollBar, &vb);
XtSetArg (args[2], XmNwidth, &sw_width);
XtSetArg (args[3], XmNheight, &sw_height);
XtGetValues (file_mgr_rec->scroll_window, args, 4);
file_window = (XmManagerWidget)file_mgr_rec->file_window;
XtSetArg (args[0], XmNwidth, &file_window_width);
XtSetArg (args[1], XmNheight, &file_window_height);
XtGetValues ((Widget)file_window, args, 2);
file_window_width--;
file_window_height--;
if (VerticalScrollbarIsVisible(vb, file_mgr_rec->scroll_window))
{
vsbVisible = True;
current_file_window_width = sw_width - vb->core.width - 12;
}
else
{
current_file_window_width = sw_width - 9;
}
if (HorizontalScrollbarIsVisible(hb, file_mgr_rec->scroll_window))
{
hsbVisible = True;
current_file_window_height = sw_height - hb->core.height - 12;
}
else
{
current_file_window_height = sw_height - 9;
}
if(vsbVisible)
{
XmScrollBarGetValues(vb, &vb_val_ret, &vb_slide_size,
&vb_inc_ret, &vb_pg_inc_ret);
min_height = vb_val_ret;
max_height = current_file_window_height + min_height;
}
else
{
max_height = current_file_window_height;
min_height = 0;
}
if(hsbVisible)
{
XmScrollBarGetValues(hb, &hb_val_ret, &hb_slide_size,
&hb_inc_ret, &hb_pg_inc_ret);
min_width = hb_val_ret;
max_width = current_file_window_width + min_width;
}
else
{
max_width = current_file_window_width;
min_width = 0;
}
/* Get the gc to be used to draw the bounding rectangle */
if (!draw_gc)
{
unsigned int white_pixel;
screen = XDefaultScreenOfDisplay (display);
gc_values.function = GXxor;
white_pixel = WhitePixelOfScreen (screen);
if( white_pixel )
{
gc_values.foreground = white_pixel;
gc_values.background = BlackPixelOfScreen (screen);
}
else
{
gc_values.background = white_pixel;
gc_values.foreground = BlackPixelOfScreen (screen);
}
draw_gc =
XCreateGC (display, window,
GCForeground | GCBackground | GCFunction, &gc_values);
}
widget_region = XCreateRegion();
intersect_region = XCreateRegion();
redraw_region = XCreateRegion();
x1 = x2 = old_x = event->x;
y1 = y2 = old_y = event->y;
DrawRectangle (display, window, draw_gc, x1, y1, x2, y2);
while (1) /* Set up a loop to catch the select up point. */
{
XQueryPointer (display, window, &root, &sub_win,
&win_x, &win_y, &x2, &y2, &mask);
if ((mask & Button1Mask) == 0)
{
/* Undraw the last rectangle we drew */
x2 = old_x;
y2 = old_y;
DrawRectangle (display, window, draw_gc, x1, y1, x2, y2);
/*
* The real bound of the rectangle is contained in the button up
* event; you can't use the pointer position, because if the system
* is slow, then by the time we query the mouse, the button may have
* been long ago release, and the pointer subsequently moved.
*/
if (XPeekIfEvent(display, &btnUpEvent,(Bool (*)())CheckForBtnUp, NULL))
{
x2 = btnUpEvent.xbutton.x;
y2 = btnUpEvent.xbutton.y;
}
break;
}
if( x2 < 0 ) x2 = 0;
if( y2 < 0 ) y2 = 0;
if ((x2 > old_x && !hsbVisible && (Dimension)old_x < file_window_width) ||
(x2 > old_x && hsbVisible && (Dimension)(hb_val_ret +
hb_slide_size) < (Dimension)(file_window_width + 1)) ||
(x2 < old_x && !hsbVisible && old_x > 0) ||
(x2 < old_x && hsbVisible && hb_val_ret >= 0) ||
(y2 > old_y && !vsbVisible && (Dimension)old_y < file_window_height) ||
(y2 > old_y && vsbVisible && (Dimension)(vb_val_ret +
vb_slide_size) < (Dimension)(file_window_height + 1)) ||
(y2 < old_y && !vsbVisible && old_y > 0) ||
(y2 < old_y && vsbVisible && vb_val_ret >= 0))
{
DrawRectangle (display, window, draw_gc, x1, y1, old_x, old_y);
if((Dimension)x2 >= max_width)
{
if(hsbVisible)
{
hb_val_ret += (x2 - max_width);
if((Dimension)(hb_val_ret + hb_slide_size) <= (Dimension)(file_window_width + 1))
{
XmScrollBarSetValues(hb, hb_val_ret, hb_slide_size,
hb_inc_ret, hb_pg_inc_ret, True);
min_width = (x2 - max_width) + min_width;
max_width = x2;
XmUpdateDisplay ((Widget)file_window);
}
else if((Dimension)(hb_val_ret + hb_slide_size) > (Dimension)(file_window_width + 1) &&
(Dimension)(hb_val_ret - (x2 - max_width)) <
(Dimension)(file_window_width - hb_slide_size))
{
XmScrollBarSetValues(hb,
file_window_width - hb_slide_size + 1,
hb_slide_size, hb_inc_ret, hb_pg_inc_ret, True);
temp = (file_window_width - hb_slide_size + 1) - hb_val_ret;
hb_val_ret = file_window_width - hb_slide_size + 1;
min_width = temp + min_width;
max_width = temp + max_width;
XmUpdateDisplay ((Widget)file_window);
x2 = file_window_width;
}
else
{
hb_val_ret = file_window_width - hb_slide_size + 1;
x2 = max_width = file_window_width;
min_width = max_width - current_file_window_width;
}
}
else
{
if(vsbVisible)
{
if((Dimension)x2 > current_file_window_width)
x2 = current_file_window_width;
}
else
{
if((Dimension)x2 > file_window_width)
x2 = file_window_width;
}
}
}
else if((Dimension)x2 < min_width)
{
if(hsbVisible)
{
if(min_width > 0)
{
hb_val_ret -= (min_width - x2);
if(hb_val_ret >= 0)
{
XmScrollBarSetValues(hb, hb_val_ret, hb_slide_size,
hb_inc_ret, hb_pg_inc_ret, True);
max_width = max_width - (min_width - x2);
min_width = x2;
XmUpdateDisplay (file_mgr_rec->file_window);
}
else if((hb_val_ret < 0) &&
((int)(hb_val_ret + (min_width - x2)) >= (int)0))
{
XmScrollBarSetValues(hb, 0, hb_slide_size,
hb_inc_ret, hb_pg_inc_ret, True);
max_width = current_file_window_width;
XmUpdateDisplay ((Widget)file_window);
x2 = hb_val_ret = min_width = 0;
}
else
{
hb_val_ret = min_width = x2 = 0;
max_width = current_file_window_width;
}
}
else
{
if(x2 < 0)
x2 = 0;
}
}
else
{
if(x2 < 0)
x2 = 0;
}
}
if((Dimension)y2 > max_height)
{
if(vsbVisible)
{
vb_val_ret += (y2 - max_height);
if((Dimension)(vb_val_ret + vb_slide_size) <= (Dimension)(file_window_height + 1))
{
XmScrollBarSetValues(vb, vb_val_ret, vb_slide_size,
vb_inc_ret, vb_pg_inc_ret, True);
min_height = (y2 - max_height) + min_height;
max_height = y2;
XmUpdateDisplay ((Widget)file_window);
}
else if((Dimension)(vb_val_ret + vb_slide_size) > (Dimension)(file_window_height + 1) &&
(Dimension)(vb_val_ret - (y2 - max_height)) <
(Dimension)(file_window_height + 1 - vb_slide_size))
{
XmScrollBarSetValues(vb,
file_window_height + 1 - vb_slide_size,
vb_slide_size, vb_inc_ret, vb_pg_inc_ret, True);
temp = (file_window_height + 1 - vb_slide_size) - vb_val_ret;
vb_val_ret = file_window_height + 1 - vb_slide_size;
min_height = temp + min_height;
max_height = temp + max_height;
XmUpdateDisplay ((Widget)file_window);
y2 = file_window_height;
}
else
{
vb_val_ret = file_window_height + 1 - vb_slide_size;
y2 = max_height = file_window_height;
min_height = max_height - current_file_window_height;
}
}
else
{
if(hsbVisible)
{
if((Dimension)y2 > current_file_window_height)
y2 = current_file_window_height;
}
else
{
if((Dimension)y2 > file_window_height)
y2 = file_window_height;
}
}
}
else if((Dimension)y2 < min_height)
{
if(vsbVisible)
{
if(min_height > 0)
{
vb_val_ret -= (min_height - y2);
if(vb_val_ret >= 0)
{
XmScrollBarSetValues(vb, vb_val_ret, vb_slide_size,
vb_inc_ret, vb_pg_inc_ret, True);
max_height = max_height - (min_height - y2);
min_height = y2;
XmUpdateDisplay (file_mgr_rec->file_window);
}
else if(vb_val_ret < 0 &&
((int)(vb_val_ret + (min_height - y2)) >= (int)0))
{
XmScrollBarSetValues(vb, 0, vb_slide_size,
vb_inc_ret, vb_pg_inc_ret, True);
max_height = current_file_window_height;
XmUpdateDisplay ((Widget)file_window);
y2 = vb_val_ret = min_height = 0;
}
else
{
vb_val_ret = min_height = y2 = 0;
max_height = current_file_window_height;
}
}
else
{
if(y2 < 0)
y2 = 0;
}
}
else
{
if(y2 < 0)
y2 = 0;
}
}
old_x = x2;
old_y = y2;
x3 = x1;
x4 = x2;
y3 = y1;
y4 = y2;
if (x4 < x3)
{
temp = x3;
x3 = x4;
x4 = temp;
}
if (y4 < y3)
{
temp = y3;
y3 = y4;
y4 = temp;
}
virt_x = x3;
virt_y = y3;
virt_width = x4 - x3 + 1;
virt_height = y4 - y3 + 1;
return_rect.x = (short)virt_x;
return_rect.y = (short)virt_y;
return_rect.width = (unsigned short)virt_width;
return_rect.height = (unsigned short)virt_height;
region = XCreateRegion();
XUnionRectWithRegion (&return_rect, region, region);
/* Run through the gadget set to cause each icon within the */
/* rectangle to be selected. */
if (file_mgr_data->show_type == SINGLE_DIRECTORY)
directory_count = 1;
else
directory_count = file_mgr_data->directory_count;
directory_set = file_mgr_data->directory_set;
for (i = 0; i < directory_count; i++)
{
for (j = 0; j < directory_set[i]->file_count; j++)
{
DtIconGadget g;
file_view_data = directory_set[i]->order_list[j];
if (!file_view_data->displayed || file_view_data->need_update)
continue;
g = (DtIconGadget) file_view_data->widget;
highlightThickness = g->gadget.highlight_thickness;
shadowThickness = g->gadget.shadow_thickness;
x = g->rectangle.x;
y = g->rectangle.y;
marginWidth = g->icon.cache->margin_width;
marginHeight = g->icon.cache->margin_height;
pixmapPosition = g->icon.cache->pixmap_position;
alignment = g->icon.cache->alignment;
pixmapWidth = g->icon.pixmap_width;
pixmapHeight = g->icon.pixmap_height;
stringWidth = g->icon.string_width;
stringHeight = g->icon.cache->string_height;
switch ((int) pixmapPosition)
{
case XmPIXMAP_TOP:
if (alignment == XmALIGNMENT_BEGINNING)
pixmap_x = x + highlightThickness;
else if(alignment == XmALIGNMENT_CENTER)
{
if(stringWidth >= pixmapWidth)
pixmap_x = x + highlightThickness +
((Dimension)(stringWidth - pixmapWidth)/(Dimension)2);
else
pixmap_x = x + highlightThickness;
}
break;
case XmPIXMAP_LEFT:
default:
pixmap_x = x + highlightThickness;
break;
}
pixmap_y = y + pixmapHeight;
pixmap_x = pixmap_x + pixmapWidth;
/*
pixmap_x1 = pixmap_x + pixmapWidth;
pixmap_y1 = pixmap_y + pixmapHeight;
*/
if(XPointInRegion(region, pixmap_x, pixmap_y)
/*
&& XPointInRegion(region, pixmap_x1, pixmap_y1)
*/
)
{
if (toggleSelect == True &&
FileIsSelected (file_mgr_data, file_view_data))
DeselectFile (file_mgr_data, file_view_data, True);
else
{
if(!FileIsSelected (file_mgr_data, file_view_data))
SelectFile (file_mgr_data, file_view_data);
}
}
else if (FileIsSelected (file_mgr_data, file_view_data))
DeselectFile (file_mgr_data, file_view_data, True);
}
}
DrawRectangle (display, window, draw_gc, x1, y1, x2, y2);
XDestroyRegion (region);
}
}
XDestroyRegion (widget_region);
XDestroyRegion (intersect_region);
XDestroyRegion (redraw_region);
XSync (display, 0);
return;
}
/************************************************************************
*
* DrawRectangle
* DrawRectangle takes two points as input and draws a rectangle with
* a line width and height of 1 around the rectangle generated
* by the two points. The rectangle is drawn XOR so that it
* can be erased.
*
************************************************************************/
static void
DrawRectangle(
Display *display,
Window window,
GC gc,
int x1,
int y1,
int x2,
int y2 )
{
int x;
int y;
unsigned int width;
unsigned int height;
if (x2 >= x1)
{
x = x1;
width = x2 - x1;
}
else
{
x = x2;
width = x1 - x2;
}
if (y2 >= y1)
{
y = y1;
height = y2 - y1;
}
else
{
y = y2;
height = y1 - y2;
}
XDrawRectangle (display, window, gc, x, y, width, height);
if (width > 2 && height > 2)
XDrawRectangle (display, window, gc, x + 1, y + 1, width - 2, height - 2);
}
/*
* Given a widget, create a region describing the area occupied by the
* widget; it may be a simple rectangle, or a compound region composed
* of two rectangles (the pixmap and the label).
*/
void
WidgetRectToRegion (
FileMgrData * file_mgr_data,
Widget w,
Region region)
{
XRectangle widget_rect;
XRectangle pRect, lRect;
unsigned char flags;
static Region temp_region = NULL;
/* Empty the region */
if (temp_region == NULL)
temp_region = XCreateRegion();
XSubtractRegion(temp_region, temp_region, region);
if (w == NULL)
return;
/* Tree mode and attribute views do not support compound icons */
if ((file_mgr_data->show_type != SINGLE_DIRECTORY) ||
(file_mgr_data->view == BY_ATTRIBUTES))
{
widget_rect.x = (short)w->core.x;
widget_rect.y = (short)w->core.y;
widget_rect.width = (unsigned short)w->core.width;
widget_rect.height = (unsigned short)w->core.height;
XUnionRectWithRegion(&widget_rect, region, region);
}
else
{
_DtIconGetIconRects((DtIconGadget)w, &flags, &pRect, &lRect);
if (flags & XmPIXMAP_RECT)
XUnionRectWithRegion(&pRect, region, region);
if (flags & XmLABEL_RECT)
XUnionRectWithRegion(&lRect, region, region);
}
}
static void
ProcessSelection (
FileMgrData * file_mgr_data,
Widget icon,
Boolean toggleSelect,
XButtonEvent * event)
{
XRectangle * selection_rect;
XRectangle widget_rect;
DirectorySet ** directory_set;
int directory_count;
register int i, j;
Region region;
Region widget_region;
Region intersect_region;
Region redraw_region;
FileMgrRec * file_mgr_rec;
FileViewData * file_view_data;
file_mgr_rec = (FileMgrRec *)file_mgr_data->file_mgr_rec;
/* User is starting a new selection; clear all old ones */
if (!toggleSelect)
{
DeselectAllFiles (file_mgr_data);
file_mgr_data->selected_file_count = 0;
XFlush (XtDisplay (file_mgr_rec->file_window));
XmUpdateDisplay (file_mgr_rec->file_window);
}
/* Get the rectangle to be used as the selection area */
if (icon == NULL && event->type == ButtonPress)
{
/* User is starting a region select */
GetSelectionRectangle (XtDisplay(file_mgr_rec->file_window),
(Window) XtWindow(file_mgr_rec->file_window),
event, file_mgr_rec, file_mgr_data,
toggleSelect);
}
else
{
/* User did a single select either through keyboard or mouse */
if(event->type == KeyPress)
{
widget_rect.x = (short)icon->core.x;
widget_rect.y = (short)icon->core.y;
widget_rect.width = (short)icon->core.width;
widget_rect.height = (short)icon->core.height;
}
else
{
widget_rect.x = (short)event->x;
widget_rect.y = (short)event->y;
widget_rect.width = 1;
widget_rect.height = 1;
}
selection_rect = &widget_rect;
region = XCreateRegion();
widget_region = XCreateRegion();
intersect_region = XCreateRegion();
redraw_region = XCreateRegion();
XUnionRectWithRegion (selection_rect, region, region);
/* Run through the gadget set to cause each icon within the */
/* rectangle to be selected. */
if (file_mgr_data->show_type == SINGLE_DIRECTORY)
{
i = 0;
directory_count = 1;
}
else
{
directory_count = file_mgr_data->directory_count;
i = -1;
}
directory_set = file_mgr_data->directory_set;
for (; i < directory_count; i++)
{
if (PositioningEnabledInView(file_mgr_data))
{
ObjectPtr top = GetTopOfStack(file_mgr_data);
int next_position = 0;
/*
* Stacking order requires us to handle this specially. Objects
* must be searched in top to bottom order when determining if
* they are in the selection rectangle, but they must be drawn
* bottom to top, to guarantee that the visuals are correct.
*/
/* Find set of selected objects */
while (top)
{
if(top->file_view_data == NULL)
{
top = top->next;
continue;
}
if (!top->file_view_data->displayed)
{
top = top->next;
continue;
}
WidgetRectToRegion(file_mgr_data, top->file_view_data->widget,
widget_region);
XIntersectRegion(region, widget_region, intersect_region);
if (!XEmptyRegion(intersect_region))
{
if (toggleSelect &&
FileIsSelected (file_mgr_data, top->file_view_data))
{
DeselectFile(file_mgr_data, top->file_view_data, True);
XUnionRegion(widget_region, redraw_region, redraw_region);
}
else
{
/*
* We don't want to change the icon yet, because we
* need to do it in bottom to top order.
*/
next_position++;
RepositionUpInStack(file_mgr_data, top->stacking_order,
next_position);
}
/* Higher item 'cover' lower ones */
XSubtractRegion(region, widget_region, region);
}
top = top->next;
}
/* Now, select any newly selected files */
if (next_position > 0)
{
/* Find where to start the redraw from */
top = GetTopOfStack(file_mgr_data);
while (next_position - 1 > 0)
{
top = top->next;
next_position--;
}
while(top)
{
if(top->file_view_data != NULL)
SelectFile(file_mgr_data, top->file_view_data);
top = top->prev;
}
}
if (!XEmptyRegion(redraw_region))
RepaintDesktop(file_mgr_data, NULL, redraw_region);
RegisterDesktopHotspots(file_mgr_data, file_mgr_rec);
}
else
{
for (j = 0; j < directory_set[i]->file_count; j++)
{
file_view_data = directory_set[i]->order_list[j];
if (!file_view_data->displayed)
continue;
WidgetRectToRegion(file_mgr_data, file_view_data->widget,
widget_region);
XIntersectRegion (region, widget_region, intersect_region);
if (!XEmptyRegion (intersect_region))
{
if (toggleSelect == True &&
FileIsSelected (file_mgr_data, file_view_data))
DeselectFile (file_mgr_data, file_view_data, True);
else
{
SelectFile (file_mgr_data, file_view_data);
if(file_mgr_data->view == BY_ATTRIBUTES)
{
/*
* Need to determine whether the click was in the
* file or before.
*/
XRectangle textExtent;
Region tmp_region;
XmFontList fontList;
XmString fileNameString;
DtIconGadget g = (DtIconGadget)file_view_data->widget;
_DtIconGetTextExtent_r(file_view_data->widget,
&textExtent);
XtVaGetValues( file_view_data->widget,
XmNfontList,
&fontList,
NULL );
fileNameString = XmStringCreateLocalized( file_view_data->file_data->file_name );
textExtent.width = XmStringWidth( fontList, fileNameString );
XmStringFree( fileNameString );
textExtent.height =
(unsigned short)file_view_data->widget->core.height;
textExtent.x = (short)file_view_data->widget->core.x
+ g->icon.pixmap_width
+ g->icon.cache->margin_width
+ g->icon.cache->spacing;
textExtent.y = (short)file_view_data->widget->core.y;
tmp_region = XCreateRegion();
XUnionRectWithRegion (&textExtent,
tmp_region, tmp_region);
XSubtractRegion (widget_region, tmp_region, tmp_region);
XIntersectRegion (region, tmp_region, intersect_region);
if (XEmptyRegion (intersect_region))
TurnOnTextName = True;
else
TurnOnTextName = False;
XDestroyRegion (tmp_region);
}
}
}
}
}
}
XDestroyRegion (region);
XDestroyRegion (widget_region);
XDestroyRegion (intersect_region);
XDestroyRegion (redraw_region);
}
if(file_mgr_data != trashFileMgrData)
{
if (file_mgr_data->selected_file_count == 0)
ActivateNoSelect (file_mgr_rec);
else if (file_mgr_data->selected_file_count == 1)
{
ActivateSingleSelect (file_mgr_rec,
file_mgr_data->selection_list[0]->file_data->logical_type);
}
else
ActivateMultipleSelect (file_mgr_rec);
}
else
SensitizeTrashBtns();
ProcessBtnUp = False;
}
void
DrawHighlight (
Widget w,
FileViewData *file_view_data,
FileMgrData *file_mgr_data,
int type)
{
int n, num_rectangles;
Position x,y;
Dimension highlightThickness, shadowThickness;
Dimension half_shadowThickness;
Dimension marginWidth, marginHeight;
Dimension pixmapWidth, pixmapHeight;
Dimension stringWidth, stringHeight;
Dimension spacing;
XRectangle rect[10];
unsigned char pixmapPosition;
unsigned char alignment;
Position adj_x, adj_y;
GC gc ;
Arg args[20];
DtIconGadget g = (DtIconGadget)w;
ObjectPtr top;
gc = ((XmManagerWidget)(g->object.parent))->manager.highlight_GC;
#ifdef SHAPE
if(shapeExtension)
if(type == DESKTOP)
{
DrawShadowTh(w, gc, DESKTOP);
return;
}
#endif
/* in in as placed mode need to cycle the icons so the traversal
box doesn't chop up the icons */
if(type == NOT_DESKTOP && file_view_data != NULL)
{
if (PositioningEnabledInView(file_mgr_data))
{
top = GetTopOfStack(file_mgr_data);
if(top != NULL && top->file_view_data != file_view_data)
{
ObjectPtr savetop, next, prev;
int i;
savetop = top;
while(top != NULL && top->file_view_data != file_view_data)
top = top->next;
if(top != NULL)
{
prev = top->prev;
next = top->next;
if (prev)
prev->next = next;
if (next)
next->prev = prev;
top->prev = NULL;
top->next = savetop;
top->stacking_order = 1;
savetop->prev = top;
top = savetop;
for(i = 2; top->prev != NULL; i++)
{
top->stacking_order = i;
if(top->next == NULL)
break;
top = top->next;
}
RedrawOneGadget(w, NULL, NULL);
}
}
}
}
n = 0;
XtSetArg (args[n], XmNhighlightThickness, &highlightThickness); n++;
XtSetArg (args[n], XmNshadowThickness, &shadowThickness); n++;
XtSetArg (args[n], XmNx, &x); n++;
XtSetArg (args[n], XmNy, &y); n++;
XtSetArg (args[n], XmNmarginWidth, &marginWidth); n++;
XtSetArg (args[n], XmNmarginHeight, &marginHeight); n++;
XtSetArg (args[n], XmNpixmapPosition, &pixmapPosition); n++;
XtSetArg (args[n], XmNalignment, &alignment); n++;
XtGetValues (w, args, n);
spacing = (((DtIconGadget)(g)) -> icon.cache -> spacing);
pixmapWidth = g->icon.pixmap_width;
pixmapHeight = g->icon.pixmap_height;
stringWidth = g->icon.string_width;
stringHeight = g->icon.cache->string_height;
adj_x = shadowThickness + highlightThickness + marginWidth;
adj_y = shadowThickness + highlightThickness + marginHeight;
if(shadowThickness != 0)
half_shadowThickness = shadowThickness/2;
else
half_shadowThickness = 0;
num_rectangles = 0;
switch ((int) pixmapPosition)
{
case XmPIXMAP_TOP:
if (alignment == XmALIGNMENT_BEGINNING)
{
/* 1 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y;
rect[num_rectangles].width = pixmapWidth + (2 * adj_x);
rect[num_rectangles++].height = highlightThickness;
if(stringWidth > pixmapWidth)
{
/* 2 */
rect[num_rectangles].x = x + pixmapWidth +
(2 * adj_x) - highlightThickness;
rect[num_rectangles].y = y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = pixmapHeight + spacing;
/* 3 */
rect[num_rectangles].x = x + pixmapWidth +
(2 * adj_x) - highlightThickness;
rect[num_rectangles].y = y + pixmapHeight + spacing;
rect[num_rectangles].width = stringWidth -
pixmapWidth + highlightThickness;
rect[num_rectangles++].height = highlightThickness;
/* 4 */
rect[num_rectangles].x = x + stringWidth + (2 * adj_x)
- highlightThickness;
rect[num_rectangles].y = y + pixmapHeight + spacing;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = stringHeight + (2 * adj_y);
}
else
{
/* 2 */
rect[num_rectangles].x = x + pixmapWidth +
(2 * adj_x) - highlightThickness;
rect[num_rectangles].y = y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = pixmapHeight + (2 * adj_y) -
highlightThickness;
/* 3 */
rect[num_rectangles].x = x + stringWidth +
(2 * adj_x) - highlightThickness;
rect[num_rectangles].y = y + pixmapHeight + (2 * adj_y) -
highlightThickness;
rect[num_rectangles].width = pixmapWidth -
stringWidth + highlightThickness;
rect[num_rectangles++].height = highlightThickness;
/* 4 */
rect[num_rectangles].x = x + stringWidth + (2 * adj_x)
- highlightThickness;
rect[num_rectangles].y = y + pixmapHeight + (2 * adj_y) -
highlightThickness;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = spacing + stringHeight +
highlightThickness;
}
/* 5 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y + pixmapHeight + stringHeight +
spacing + (2 * adj_y) - highlightThickness;
rect[num_rectangles].width = stringWidth + (2 * adj_y);
rect[num_rectangles++].height = highlightThickness;
/* 6 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = pixmapHeight +
stringHeight + spacing + (2 * adj_y);
}
else if (alignment == XmALIGNMENT_CENTER)
{
if(stringWidth > pixmapWidth)
{
/* 1 */
rect[num_rectangles].x = x
+ (Dimension)(stringWidth - pixmapWidth)/(Dimension)2;
rect[num_rectangles].y = y;
rect[num_rectangles].width = pixmapWidth + (2 * adj_x);
rect[num_rectangles++].height = highlightThickness;
/* 2 */
rect[num_rectangles].x = x
+ (Dimension)(stringWidth - pixmapWidth)/(Dimension)2
+ pixmapWidth
+ (2 * adj_x)
- highlightThickness;
rect[num_rectangles].y = y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = pixmapHeight + spacing;
/* 3 */
rect[num_rectangles].x = x
+ (Dimension)(stringWidth - pixmapWidth)/(Dimension)2
+ pixmapWidth
+ (2 * adj_x)
- highlightThickness;
rect[num_rectangles].y = y + pixmapHeight + spacing;
rect[num_rectangles].width = (Dimension)(stringWidth - pixmapWidth)/(Dimension)2
+ (Dimension)(stringWidth - pixmapWidth)%(Dimension)2;
rect[num_rectangles++].height = highlightThickness;
/* 4 */
rect[num_rectangles].x = x + stringWidth + (2 * adj_x)
- highlightThickness;
rect[num_rectangles].y = y + pixmapHeight + spacing;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = stringHeight + (2 * adj_y);
/* 5 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y + pixmapHeight + stringHeight +
spacing + (2 * adj_y) - highlightThickness;
rect[num_rectangles].width = stringWidth + (2 * adj_y);
rect[num_rectangles++].height = highlightThickness;
/* 6 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y + pixmapHeight + spacing;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = stringHeight + (2 * adj_y);
/* 7 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y + pixmapHeight + spacing;
rect[num_rectangles].width = (Dimension)(stringWidth - pixmapWidth)/(Dimension)2
+ highlightThickness;
rect[num_rectangles++].height = highlightThickness;
/* 8 */
rect[num_rectangles].x = x + (Dimension)(stringWidth - pixmapWidth)/(Dimension)2;
rect[num_rectangles].y = y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = pixmapHeight + spacing;
}
else
{
/* 1 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y;
rect[num_rectangles].width = pixmapWidth + (2 * adj_x);
rect[num_rectangles++].height = highlightThickness;
/* 2 */
rect[num_rectangles].x = x + pixmapWidth + (2 * adj_x) -
highlightThickness;
rect[num_rectangles].y = y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = pixmapHeight + spacing +
2 * highlightThickness;
/* 3 */
rect[num_rectangles].x = x + pixmapWidth + adj_x -
(Dimension)(pixmapWidth - stringWidth)/(Dimension)2 + highlightThickness;
rect[num_rectangles].y = y + pixmapHeight + spacing +
highlightThickness + 1;
rect[num_rectangles].width = (Dimension)(pixmapWidth - stringWidth)/(Dimension)2 +
highlightThickness;
rect[num_rectangles++].height = highlightThickness;
/* 4 */
rect[num_rectangles].x = x + stringWidth + adj_x +
(Dimension)(pixmapWidth - stringWidth)/(Dimension)2 + highlightThickness;
rect[num_rectangles].y = y + pixmapHeight + spacing
+ highlightThickness + 1;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = stringHeight + (2 * adj_y)
- highlightThickness - 1;
/* 5 */
rect[num_rectangles].x = x + (Dimension)(pixmapWidth - stringWidth)/(Dimension)2;
rect[num_rectangles].y = y + pixmapHeight + stringHeight +
spacing + (2 * adj_y) - highlightThickness;
rect[num_rectangles].width = stringWidth + (2 * adj_y);
rect[num_rectangles++].height = highlightThickness;
/* 6 */
rect[num_rectangles].x = x + (Dimension)(pixmapWidth - stringWidth)/(Dimension)2;
rect[num_rectangles].y = y + pixmapHeight + spacing +
highlightThickness + 1;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = stringHeight + (2 * adj_y)
- highlightThickness - 1;
/* 7 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y + pixmapHeight + spacing +
highlightThickness + 1;
rect[num_rectangles].width = (Dimension)(pixmapWidth - stringWidth)/(Dimension)2 +
highlightThickness;
rect[num_rectangles++].height = highlightThickness;
/* 8 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = pixmapHeight + spacing +
2 * highlightThickness;
}
}
else
FM_XmHighlightBorder ((Widget)w);
break;
case XmPIXMAP_LEFT:
if((Dimension)(stringHeight + 4) >= pixmapHeight)
FM_XmHighlightBorder ((Widget)w);
else
{
/* 1 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y;
rect[num_rectangles].width = adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2;
rect[num_rectangles++].height = highlightThickness;
/* 2 */
rect[num_rectangles].x = x + adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2;
rect[num_rectangles].y = y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = (Dimension)(pixmapHeight - stringHeight)/(Dimension)2;
/* 3 */
rect[num_rectangles].x = x + adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2;
rect[num_rectangles].y = y + (Dimension)(pixmapHeight - stringHeight)/(Dimension)2;
rect[num_rectangles].width = spacing/2 + stringWidth + adj_x;
rect[num_rectangles++].height = highlightThickness;
/* 4 */
rect[num_rectangles].x = x + adj_x + pixmapWidth + spacing +
stringWidth + adj_x - highlightThickness;
rect[num_rectangles].y = y + (Dimension)(pixmapHeight - stringHeight)/(Dimension)2;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = stringHeight + 2*adj_y;
/* 5 */
rect[num_rectangles].x = x + adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2;
rect[num_rectangles].y = y + (Dimension)(pixmapHeight - stringHeight)/(Dimension)2 +
stringHeight + 2*adj_y - highlightThickness;
rect[num_rectangles].width = spacing/2 + stringWidth + adj_x;
rect[num_rectangles++].height = highlightThickness;
/* 6 */
rect[num_rectangles].x = x + adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2;
rect[num_rectangles].y = y + (Dimension)(pixmapHeight - stringHeight)/(Dimension)2 +
stringHeight + 2*adj_y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = pixmapHeight - stringHeight -
(Dimension)(pixmapHeight - stringHeight)/(Dimension)2;
/* 7 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y + pixmapHeight + 2*adj_y -
highlightThickness;
rect[num_rectangles].width = adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2;
rect[num_rectangles++].height = highlightThickness;
/* 8 */
rect[num_rectangles].x = x;
rect[num_rectangles].y = y;
rect[num_rectangles].width = highlightThickness;
rect[num_rectangles++].height = pixmapHeight + 2*adj_y;
}
break;
case XmPIXMAP_BOTTOM:
case XmPIXMAP_RIGHT:
FM_XmHighlightBorder ((Widget)w);
break;
default:
break;
}
XFillRectangles (XtDisplay (w), XtWindow (w), gc, &rect[0], num_rectangles);
}
void
DrawUnhighlight (
Widget w,
int type)
{
int n;
Position x,y;
Dimension highlightThickness, shadowThickness;
Dimension half_shadowThickness;
Dimension marginWidth, marginHeight;
Dimension pixmapWidth, pixmapHeight;
Dimension stringWidth, stringHeight;
Dimension spacing;
unsigned char pixmapPosition;
unsigned char alignment;
Position adj_x, adj_y;
Arg args[20];
DtIconGadget g = (DtIconGadget)w;
#ifdef SHAPE
if(shapeExtension)
if(type == DESKTOP)
{
DrawShadowTh(w, NULL, DESKTOP);
return;
}
#endif
n = 0;
XtSetArg (args[n], XmNhighlightThickness, &highlightThickness); n++;
XtSetArg (args[n], XmNshadowThickness, &shadowThickness); n++;
XtSetArg (args[n], XmNx, &x); n++;
XtSetArg (args[n], XmNy, &y); n++;
XtSetArg (args[n], XmNmarginWidth, &marginWidth); n++;
XtSetArg (args[n], XmNmarginHeight, &marginHeight); n++;
XtSetArg (args[n], XmNpixmapPosition, &pixmapPosition); n++;
XtSetArg (args[n], XmNalignment, &alignment); n++;
XtGetValues (w, args, n);
spacing = (((DtIconGadget)(g)) -> icon.cache -> spacing);
pixmapWidth = g->icon.pixmap_width;
pixmapHeight = g->icon.pixmap_height;
stringWidth = g->icon.string_width;
stringHeight = g->icon.cache->string_height;
adj_x = shadowThickness + highlightThickness + marginWidth;
adj_y = shadowThickness + highlightThickness + marginHeight;
if(shadowThickness != 0)
half_shadowThickness = shadowThickness/2;
else
half_shadowThickness = 0;
switch ((int) pixmapPosition)
{
case XmPIXMAP_TOP:
if (alignment == XmALIGNMENT_BEGINNING)
{
/* 1 */
XClearArea (XtDisplay (w), XtWindow (w), x, y,
pixmapWidth + (2 * adj_x), highlightThickness, False);
if(stringWidth > pixmapWidth)
{
/* 2 */
XClearArea (XtDisplay (w), XtWindow (w),
x + pixmapWidth + (2 * adj_x) - highlightThickness,
y, highlightThickness,
pixmapHeight + spacing,
False);
/* 3 */
XClearArea (XtDisplay (w), XtWindow (w),
x + pixmapWidth + (2 * adj_x) - highlightThickness,
y + pixmapHeight + spacing,
stringWidth - pixmapWidth + highlightThickness,
highlightThickness,
False);
/* 4 */
XClearArea (XtDisplay (w), XtWindow (w),
x + stringWidth + (2 * adj_x) - highlightThickness,
y + pixmapHeight + spacing,
highlightThickness,
stringHeight + (2 * adj_y),
False);
}
else
{
/* 2 */
XClearArea (XtDisplay (w), XtWindow (w),
x + pixmapWidth + (2 * adj_x) - highlightThickness,
y, highlightThickness,
pixmapHeight + (2 * adj_y) - half_shadowThickness,
False);
/* 3 */
XClearArea (XtDisplay (w), XtWindow (w),
x + stringWidth + (2 * adj_x) - highlightThickness,
y + pixmapHeight + (2 * adj_y) - highlightThickness,
pixmapWidth - stringWidth + highlightThickness,
highlightThickness,
False);
/* 4 */
XClearArea (XtDisplay (w), XtWindow (w),
x + stringWidth + (2 * adj_x) - highlightThickness,
y + pixmapHeight + (2 * adj_y) -
half_shadowThickness,
highlightThickness,
spacing + stringHeight + highlightThickness,
False);
}
/* 5 */
XClearArea (XtDisplay (w), XtWindow (w), x,
y + pixmapHeight + stringHeight +
spacing + (2 * adj_y) - highlightThickness,
stringWidth + (2 * adj_y),
highlightThickness,
False);
/* 6 */
XClearArea (XtDisplay (w), XtWindow (w), x, y,
highlightThickness,
pixmapHeight + stringHeight + spacing + (2 * adj_y),
False);
}
else if (alignment == XmALIGNMENT_CENTER)
{
if(stringWidth > pixmapWidth)
{
/* 1 */
XClearArea (XtDisplay (w), XtWindow (w),
x + (Dimension)(stringWidth - pixmapWidth)/(Dimension)2, y,
pixmapWidth + (2 * adj_x),
highlightThickness,
False);
/* 2 */
XClearArea (XtDisplay (w), XtWindow (w),
x + (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 + pixmapWidth +
(2 * adj_x) - highlightThickness,
y, highlightThickness, pixmapHeight + spacing,
False);
/* 3 */
XClearArea (XtDisplay (w), XtWindow (w),
x + (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 + pixmapWidth +
(2 * adj_x) - highlightThickness,
y + pixmapHeight + spacing,
(Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
(Dimension)(stringWidth - pixmapWidth)%(Dimension)2,
highlightThickness,
False);
/* 4 */
XClearArea (XtDisplay (w), XtWindow (w),
x + stringWidth + (2 * adj_x) - highlightThickness,
y + pixmapHeight + spacing, highlightThickness,
stringHeight + (2 * adj_y),
False);
/* 5 */
XClearArea (XtDisplay (w), XtWindow (w), x,
y + pixmapHeight + stringHeight +
spacing + (2 * adj_y) - highlightThickness,
stringWidth + (2 * adj_y), highlightThickness,
False);
/* 6 */
XClearArea (XtDisplay (w), XtWindow (w), x,
y + pixmapHeight + spacing, highlightThickness,
stringHeight + (2 * adj_y),
False);
/* 7 */
XClearArea (XtDisplay (w), XtWindow (w), x,
y + pixmapHeight + spacing,
(Dimension)(stringWidth - pixmapWidth)/(Dimension)2 + highlightThickness,
highlightThickness,
False);
/* 8 */
XClearArea (XtDisplay (w), XtWindow (w),
x + (Dimension)(stringWidth - pixmapWidth)/(Dimension)2,
y, highlightThickness, pixmapHeight + spacing,
False);
}
else
{
/* 1 */
XClearArea (XtDisplay (w), XtWindow (w), x, y,
pixmapWidth + (2 * adj_x), highlightThickness,
False);
/* 2 */
XClearArea (XtDisplay (w), XtWindow (w),
x + pixmapWidth + (2 * adj_x) - highlightThickness,
y, highlightThickness,
pixmapHeight + spacing + 2 * highlightThickness,
False);
/* 3 */
XClearArea (XtDisplay (w), XtWindow (w),
x + pixmapWidth + adj_x + highlightThickness -
(Dimension)(pixmapWidth - stringWidth)/(Dimension)2,
y + pixmapHeight + spacing + highlightThickness + 1,
(Dimension)(pixmapWidth - stringWidth)/(Dimension)2 + highlightThickness,
highlightThickness,
False);
/* 4 */
XClearArea (XtDisplay (w), XtWindow (w),
x + stringWidth + (Dimension)(pixmapWidth - stringWidth)/(Dimension)2 +
adj_x + highlightThickness,
y + pixmapHeight + spacing + highlightThickness + 1,
highlightThickness,
stringHeight + (2 * adj_y) - highlightThickness -1,
False);
/* 5 */
XClearArea (XtDisplay (w), XtWindow (w),
x + (Dimension)(pixmapWidth - stringWidth)/(Dimension)2,
y + pixmapHeight + stringHeight +
spacing + (2 * adj_y) - highlightThickness,
stringWidth + (2 * adj_y),
highlightThickness,
False);
/* 6 */
XClearArea (XtDisplay (w), XtWindow (w),
x + (Dimension)(pixmapWidth - stringWidth)/(Dimension)2,
y + pixmapHeight + spacing + highlightThickness + 1,
highlightThickness,
stringHeight + (2 * adj_y) - highlightThickness - 1,
False);
/* 7 */
XClearArea (XtDisplay (w), XtWindow (w), x,
y + pixmapHeight + spacing + highlightThickness + 1,
(Dimension)(pixmapWidth - stringWidth)/(Dimension)2 + highlightThickness,
highlightThickness,
False);
/* 8 */
XClearArea (XtDisplay (w), XtWindow (w), x, y,
highlightThickness,
pixmapHeight + spacing + 2 * highlightThickness,
False);
}
}
else
FM_XmUnhighlightBorder ((Widget)w);
break;
case XmPIXMAP_LEFT:
if((Dimension)(stringHeight + 4) >= pixmapHeight)
FM_XmUnhighlightBorder ((Widget)w);
else
{
/* 1 */
XClearArea (XtDisplay (w), XtWindow (w), x, y,
adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2,
highlightThickness,
False);
/* 2 */
XClearArea (XtDisplay (w), XtWindow (w),
x + adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2,
y,
highlightThickness,
(Dimension)(pixmapHeight - stringHeight)/(Dimension)2,
False);
/* 3 */
XClearArea (XtDisplay (w), XtWindow (w),
x + adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2,
y + (Dimension)(pixmapHeight - stringHeight)/(Dimension)2,
spacing/2 + stringWidth + adj_x,
highlightThickness,
False);
/* 4 */
XClearArea (XtDisplay (w), XtWindow (w),
x + adj_x + pixmapWidth + spacing +
stringWidth + adj_x - highlightThickness,
y + (Dimension)(pixmapHeight - stringHeight)/(Dimension)2,
highlightThickness,
stringHeight + 2*adj_y,
False);
/* 5 */
XClearArea (XtDisplay (w), XtWindow (w),
x + adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2,
y + (Dimension)(pixmapHeight - stringHeight)/(Dimension)2 +
stringHeight + 2*adj_y - highlightThickness,
spacing/2 + stringWidth + adj_x,
highlightThickness,
False);
/* 6 */
XClearArea (XtDisplay (w), XtWindow (w),
x + adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2,
y + (Dimension)(pixmapHeight - stringHeight)/(Dimension)2 +
stringHeight + 2*adj_y,
highlightThickness,
pixmapHeight - stringHeight -
(Dimension)(pixmapHeight - stringHeight)/(Dimension)2,
False);
/* 7 */
XClearArea (XtDisplay (w), XtWindow (w), x,
y + pixmapHeight + 2*adj_y - highlightThickness,
adj_x + pixmapWidth + (Dimension)(spacing+1)/(Dimension)2,
highlightThickness,
False);
/* 8 */
XClearArea (XtDisplay (w), XtWindow (w), x, y,
highlightThickness,
pixmapHeight + 2*adj_y,
False);
}
break;
case XmPIXMAP_BOTTOM:
case XmPIXMAP_RIGHT:
FM_XmUnhighlightBorder ((Widget)w);
break;
default:
break;
}
}
void
DrawShadowTh (
Widget w,
GC gc,
int type)
{
int n;
Position x,y;
Dimension highlightThickness, shadowThickness;
Dimension width, height;
Dimension marginWidth, marginHeight;
Dimension pixmapWidth, pixmapHeight;
Dimension stringWidth, stringHeight;
Dimension spacing;
unsigned char pixmapPosition;
unsigned char alignment;
unsigned char shadowType;
GC top_gc, bottom_gc ;
Arg args[20];
XRectangle rect[10];
DtIconGadget g = (DtIconGadget)w;
XmManagerWidget mgr = (XmManagerWidget)XtParent(w);
Boolean s_out = False,
s_etched = False;
n = 0;
XtSetArg (args[n], XmNhighlightThickness, &highlightThickness); n++;
XtSetArg (args[n], XmNshadowThickness, &shadowThickness); n++;
XtSetArg (args[n], XmNx, &x); n++;
XtSetArg (args[n], XmNy, &y); n++;
XtSetArg (args[n], XmNwidth, &width); n++;
XtSetArg (args[n], XmNheight, &height); n++;
XtSetArg (args[n], XmNmarginWidth, &marginWidth); n++;
XtSetArg (args[n], XmNmarginHeight, &marginHeight); n++;
XtSetArg (args[n], XmNpixmapPosition, &pixmapPosition); n++;
XtSetArg (args[n], XmNalignment, &alignment); n++;
XtSetArg (args[n], XmNshadowType, &shadowType); n++;
XtGetValues (w, args, n);
spacing = (((DtIconGadget)(g)) -> icon.cache -> spacing);
pixmapWidth = g->icon.pixmap_width;
pixmapHeight = g->icon.pixmap_height;
stringWidth = g->icon.string_width;
stringHeight = g->icon.cache->string_height;
/* Get shadow attributes.
*/
s_out = (shadowType == XmSHADOW_OUT || shadowType == XmSHADOW_ETCHED_OUT)
? True : False;
s_etched = (shadowType == XmSHADOW_ETCHED_IN ||
shadowType == XmSHADOW_ETCHED_OUT)
? True : False;
if(gc == NULL)
{
if(shadowType == XmSHADOW_ETCHED_OUT)
{
top_gc = (s_out)
? mgr->manager.top_shadow_GC : mgr->manager.bottom_shadow_GC;
bottom_gc = (s_out)
? mgr->manager.bottom_shadow_GC : mgr->manager.top_shadow_GC;
}
else
{
bottom_gc = (s_out)
? mgr->manager.top_shadow_GC : mgr->manager.bottom_shadow_GC;
top_gc = (s_out)
? mgr->manager.bottom_shadow_GC : mgr->manager.top_shadow_GC;
}
}
else
top_gc = bottom_gc = gc;
/* Draw shadow.
*/
if (!s_etched)
{
XmeDrawShadows (XtDisplay(w), XtWindow(w), top_gc, bottom_gc,
x + highlightThickness,
y + highlightThickness,
width - 2*highlightThickness,
height - 2*highlightThickness,
shadowThickness, XmSHADOW_IN);
}
else
{
int half_shadowThickness;
int num_rects;
if (shadowThickness <= 0) return;
if (shadowThickness > (Dimension)(width / 2)) shadowThickness = width / 2;
if (shadowThickness > (Dimension)(height / 2)) shadowThickness = height / 2;
if (shadowThickness <= 0) return;
shadowThickness = (shadowThickness % 2) ?
(shadowThickness-1) : (shadowThickness);
half_shadowThickness = shadowThickness / 2;
switch ((int) pixmapPosition)
{
case XmPIXMAP_TOP:
if (alignment == XmALIGNMENT_BEGINNING)
{
if(type == NOT_DESKTOP)
{
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = pixmapWidth + (2 * shadowThickness) +
(2 * marginWidth) - half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
(2 * marginWidth) + shadowThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + marginHeight +
spacing/2 + shadowThickness +
half_shadowThickness;
if(stringWidth > pixmapWidth)
{
/* 3 */
rect[num_rects].x = x + highlightThickness +
shadowThickness +
pixmapWidth + (2 * marginWidth);
rect[num_rects].y = y + pixmapHeight + 2*marginHeight +
shadowThickness;
rect[num_rects].width = stringWidth - pixmapWidth +
marginWidth - half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + stringWidth + (2 * marginWidth)
+ shadowThickness + highlightThickness;
rect[num_rects].y = y + pixmapHeight + 2*marginHeight +
shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight +
(2*marginHeight) + half_shadowThickness;
}
else
{
/* 3 */
rect[num_rects].x = x + highlightThickness + stringWidth +
(2 * marginWidth) + shadowThickness;
rect[num_rects].y = y + pixmapHeight + 2*marginHeight +
shadowThickness + half_shadowThickness;
rect[num_rects].width = pixmapWidth - stringWidth +
marginHeight - half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness + stringWidth +
(2 * marginWidth) + shadowThickness;
rect[num_rects].y = y + pixmapHeight + 2*marginHeight +
shadowThickness + half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight +
(2*marginHeight);
}
/* 5 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness + pixmapHeight +
stringHeight + spacing + (2*marginHeight) + shadowThickness;
if(stringWidth > pixmapWidth)
rect[num_rects].width = stringWidth + (2 * marginWidth) +
shadowThickness + half_shadowThickness;
else
rect[num_rects].width = stringWidth + (2 * marginWidth) +
shadowThickness + half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 6 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + stringHeight +
spacing + (2 * marginHeight) + shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), top_gc,
&rect[0], num_rects);
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + (2 * marginWidth) +
half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
if(stringWidth > pixmapWidth)
{
/* 2 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
shadowThickness + (2 * marginWidth) +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
if(highlightThickness == 0)
rect[num_rects++].height = pixmapHeight + marginHeight+
shadowThickness + (spacing/2)
+ half_shadowThickness;
else
rect[num_rects++].height = pixmapHeight + marginHeight+
shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness +
shadowThickness +
pixmapWidth + (2 * marginWidth);
rect[num_rects].y = y + pixmapHeight + 2*marginHeight +
shadowThickness + half_shadowThickness;
rect[num_rects].width = stringWidth - pixmapWidth +
marginWidth - shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + stringWidth + (2 * marginWidth) +
shadowThickness + half_shadowThickness
+ highlightThickness;
rect[num_rects].y = y + pixmapHeight + 2*marginHeight +
shadowThickness;
rect[num_rects].width = half_shadowThickness;
if(highlightThickness == 0)
rect[num_rects++].height = stringHeight +
(2*marginHeight) + half_shadowThickness;
else
rect[num_rects++].height = stringHeight +
(2*marginHeight) + shadowThickness
+ half_shadowThickness;
}
else
{
/* 2 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
shadowThickness + (2 * marginWidth) +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + marginHeight +
shadowThickness + (spacing/2)
+ half_shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness + stringWidth +
(2 * marginWidth) + shadowThickness +
half_shadowThickness;
rect[num_rects].y = y + pixmapHeight + 2*marginHeight +
2*shadowThickness;
rect[num_rects].width = pixmapWidth - stringWidth +
marginHeight - half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness + stringWidth +
(2 * marginWidth) + shadowThickness +
half_shadowThickness;
rect[num_rects].y = y + pixmapHeight + 2*marginHeight +
2*shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight +
(2*marginHeight) + half_shadowThickness;
}
/* 5 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness + pixmapHeight +
stringHeight + spacing + (2*marginHeight) +
shadowThickness + half_shadowThickness;
if(stringWidth > pixmapWidth)
rect[num_rects].width = stringWidth + (2 * marginWidth) +
half_shadowThickness + shadowThickness;
else
rect[num_rects].width = stringWidth + (2 * marginWidth) +
(2*shadowThickness);
rect[num_rects++].height = half_shadowThickness;
/* 6 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + stringHeight +
spacing + (2 * marginHeight) + half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), bottom_gc,
&rect[0], num_rects);
}
else
{
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = pixmapWidth + (2 * shadowThickness) +
(2 * marginWidth) + half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + (2 * marginWidth) +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
if(stringWidth > pixmapWidth)
{
/* 3 */
rect[num_rects].x = x + highlightThickness +
shadowThickness +
pixmapWidth + (2 * marginWidth);
rect[num_rects].y = y + highlightThickness +
pixmapHeight + marginHeight +
half_shadowThickness;
rect[num_rects].width = stringWidth - pixmapWidth +
marginWidth + half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness +
shadowThickness +
pixmapWidth + (2 * marginWidth);
rect[num_rects].y = y + highlightThickness +
pixmapHeight + marginHeight
+ shadowThickness;
rect[num_rects].width = stringWidth - pixmapWidth +
marginWidth;
rect[num_rects++].height = half_shadowThickness;
}
/* 5 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + stringHeight +
spacing + (2 * marginHeight) + shadowThickness +
half_shadowThickness;
/* 6 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + stringHeight +
spacing + (2 * marginHeight) + half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), top_gc,
&rect[0], num_rects);
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
(2 * marginWidth) + shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
if(stringWidth > pixmapWidth)
{
if(highlightThickness == 0)
rect[num_rects++].height = pixmapHeight + marginHeight
+ spacing/2;
else
rect[num_rects++].height = pixmapHeight + marginHeight
+ spacing/2;
}
else
{
if(highlightThickness == 0)
rect[num_rects++].height = pixmapHeight + marginHeight
+ spacing/2 + half_shadowThickness + shadowThickness;
else
rect[num_rects++].height = pixmapHeight + marginHeight
+ spacing/2 + half_shadowThickness;
}
/* 2 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
shadowThickness + (2 * marginWidth) + half_shadowThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
if(stringWidth > pixmapWidth)
{
if(highlightThickness == 0)
rect[num_rects++].height = pixmapHeight + marginHeight +
(spacing/2);
else
rect[num_rects++].height = pixmapHeight + marginHeight +
half_shadowThickness;
}
else
{
if(highlightThickness == 0)
rect[num_rects++].height = pixmapHeight + marginHeight +
shadowThickness + (spacing/2)
+ half_shadowThickness;
else
rect[num_rects++].height = pixmapHeight + marginHeight +
shadowThickness + shadowThickness;
}
/* 3 */
if(stringWidth > pixmapWidth)
{
rect[num_rects].x = x + stringWidth + (2 * marginWidth)
+ shadowThickness + highlightThickness;
}
else
{
rect[num_rects].x = x + highlightThickness + pixmapWidth +
(2 * marginWidth) + shadowThickness;
}
rect[num_rects].y = y + highlightThickness +
pixmapHeight + 2*marginHeight +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + highlightThickness +
(2*marginHeight) + 2*shadowThickness;
/* 4 */
if(stringWidth > pixmapWidth)
{
rect[num_rects].x = x + stringWidth + (2 * marginWidth) +
shadowThickness + half_shadowThickness + highlightThickness;
}
else
{
rect[num_rects].x = x + highlightThickness + pixmapWidth +
shadowThickness + (2 * marginWidth) + half_shadowThickness;
}
rect[num_rects].y = y + highlightThickness +
pixmapHeight + 2*marginHeight;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight +
highlightThickness +
(2*marginHeight) + shadowThickness +
half_shadowThickness;
/* 5 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness + pixmapHeight +
stringHeight + spacing + (2*marginHeight) + shadowThickness;
if(stringWidth > pixmapWidth)
rect[num_rects].width = stringWidth + (2 * marginWidth) +
shadowThickness;
else
rect[num_rects].width = pixmapWidth + (2 * marginWidth) +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness + pixmapHeight +
stringHeight + spacing + (2*marginHeight) +
shadowThickness + half_shadowThickness;
if(stringWidth > pixmapWidth)
rect[num_rects].width = stringWidth + (2 * marginWidth) +
half_shadowThickness + shadowThickness;
else
rect[num_rects].width = pixmapWidth + (2 * marginWidth) +
(2*shadowThickness);
rect[num_rects++].height = half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), bottom_gc,
&rect[0], num_rects);
}
}
else if (alignment == XmALIGNMENT_CENTER && type == DESKTOP)
{
if(stringWidth > pixmapWidth)
{
num_rects = 0;
/* 1 */
rect[num_rects].x = x + (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = pixmapWidth + (2 * shadowThickness) +
(2 * marginWidth) + half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness +
(Dimension)(stringWidth -pixmapWidth)/(Dimension)2 + half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + (2 * marginWidth) +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 3 */
rect[num_rects].x = x + (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
highlightThickness + shadowThickness +
pixmapWidth + (2 * marginWidth);
rect[num_rects].y = y + highlightThickness +
pixmapHeight + marginHeight +
half_shadowThickness;
rect[num_rects].width = (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
(Dimension)(stringWidth - pixmapWidth)%(Dimension)2 +
marginWidth + half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
highlightThickness + shadowThickness +
pixmapWidth + (2 * marginWidth);
rect[num_rects].y = y + highlightThickness +
pixmapHeight + marginHeight
+ shadowThickness;
rect[num_rects].width = (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
(Dimension)(stringWidth - pixmapWidth)%(Dimension)2 +
marginWidth;
rect[num_rects++].height = half_shadowThickness;
/* 5 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness +
pixmapHeight + 2*marginHeight +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + highlightThickness +
(2*marginHeight) + 2*shadowThickness;
/* 6 */ rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness + pixmapHeight +
2*marginHeight;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight +
highlightThickness +
(2*marginHeight) + shadowThickness +
half_shadowThickness;
/* 7 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness +
pixmapHeight + marginHeight +
half_shadowThickness;
rect[num_rects].width = (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 8 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness +
pixmapHeight + marginHeight +
shadowThickness;
rect[num_rects].width = (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 9 */
rect[num_rects].x = x + (Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
if(highlightThickness == 0)
rect[num_rects++].height = pixmapHeight + marginHeight
+ spacing/2;
else
rect[num_rects++].height = pixmapHeight + marginHeight
+ spacing/2;
/* 10 */
rect[num_rects].x = x + highlightThickness +
(Dimension)(stringWidth -pixmapWidth)/(Dimension)2 + half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
if(highlightThickness == 0)
rect[num_rects++].height = pixmapHeight + marginHeight +
(spacing/2);
else
rect[num_rects++].height = pixmapHeight + marginHeight +
half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), top_gc,
&rect[0], num_rects);
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
(Dimension)(stringWidth - pixmapWidth)/(Dimension)2 +
(2 * marginWidth) + shadowThickness;
rect[num_rects].y = y + highlightThickness
+ half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
if(highlightThickness == 0)
rect[num_rects++].height = pixmapHeight + marginHeight
+ spacing/2;
else
rect[num_rects++].height = pixmapHeight + marginHeight
+ spacing/2;
/* 2 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
shadowThickness + (2 * marginWidth) + half_shadowThickness +
(Dimension)(stringWidth - pixmapWidth)/(Dimension)2;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
if(highlightThickness == 0)
rect[num_rects++].height = pixmapHeight + marginHeight +
(spacing/2);
else
rect[num_rects++].height = pixmapHeight + marginHeight +
half_shadowThickness;
/* 3 */
rect[num_rects].x = x + stringWidth + (2 * marginWidth)
+ shadowThickness + highlightThickness;
rect[num_rects].y = y + highlightThickness +
pixmapHeight + 2*marginHeight +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + highlightThickness +
(2*marginHeight) + 2*shadowThickness;
/* 4 */
rect[num_rects].x = x + stringWidth + (2 * marginWidth) +
shadowThickness + half_shadowThickness + highlightThickness;
rect[num_rects].y = y + highlightThickness +
pixmapHeight + 2*marginHeight;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight +
highlightThickness +
(2*marginHeight) + shadowThickness +
half_shadowThickness;
/* 5 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness + pixmapHeight +
stringHeight + spacing + (2*marginHeight) + shadowThickness;
rect[num_rects].width = stringWidth + (2 * marginWidth) +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness + pixmapHeight +
stringHeight + spacing + (2*marginHeight) +
shadowThickness + half_shadowThickness;
rect[num_rects].width = stringWidth + (2 * marginWidth) +
half_shadowThickness + shadowThickness;
rect[num_rects++].height = half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), bottom_gc,
&rect[0], num_rects);
}
else
{
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = pixmapWidth + (2 * shadowThickness) +
(2 * marginWidth) + half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + (2 * marginWidth) +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = 2 * highlightThickness +
pixmapHeight + stringHeight + 2 * marginWidth +
spacing;
/* 4 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = 2 * highlightThickness +
pixmapHeight + stringHeight +
2 * marginWidth + spacing -
half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), top_gc,
&rect[0], num_rects);
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
(2 * marginWidth) + shadowThickness;
rect[num_rects].y = y + highlightThickness
+ half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = 2 * highlightThickness +
pixmapHeight + stringHeight + 2 * marginWidth +
spacing - half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
shadowThickness + (2 * marginWidth) + half_shadowThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = 2 * highlightThickness +
pixmapHeight + stringHeight +
2 * marginWidth + spacing;
/* 3 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + 2 * highlightThickness +
pixmapHeight + stringHeight + spacing +
2 * marginHeight;
rect[num_rects].width = pixmapWidth + (2 * shadowThickness) +
(2 * marginWidth) + half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + 2 * highlightThickness +
pixmapHeight + stringHeight + spacing +
2 * marginHeight + half_shadowThickness;
rect[num_rects].width = pixmapWidth + (2 * marginWidth) +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), bottom_gc,
&rect[0], num_rects);
}
}
else
XmeDrawShadows (XtDisplay(w), XtWindow(w), top_gc, bottom_gc,
x + highlightThickness,
y + highlightThickness,
width - 2*highlightThickness,
height - 2*highlightThickness,
shadowThickness, XmSHADOW_IN);
break;
case XmPIXMAP_LEFT:
if(type == NOT_DESKTOP)
{
if((Dimension)(stringHeight+5) >= (Dimension)pixmapHeight)
{
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = pixmapWidth + stringWidth + spacing +
shadowThickness + 2*marginWidth;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + pixmapWidth + stringWidth + spacing +
shadowThickness + 2*marginWidth +
highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + 2*marginHeight +
shadowThickness + half_shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness + stringHeight +
2*marginHeight + shadowThickness;
rect[num_rects].width = pixmapWidth + stringWidth + spacing +
shadowThickness + 2*marginWidth;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + 2*marginHeight +
shadowThickness + half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), top_gc,
&rect[0], num_rects);
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + stringWidth + spacing +
half_shadowThickness + 2*marginWidth;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness + pixmapWidth +
stringWidth + spacing + shadowThickness +
2*marginWidth;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + 2*marginHeight +
2*shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness + stringHeight +
2*marginHeight + shadowThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + stringWidth + spacing +
2*shadowThickness + 2*marginWidth;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + 2*marginHeight +
half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), bottom_gc,
&rect[0], num_rects);
}
else
{
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = pixmapWidth + (2 * shadowThickness) +
(2 * marginWidth) - half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 2*marginWidth -
shadowThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = ((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight - half_shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 2*marginWidth -
shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight -shadowThickness;
rect[num_rects].width = stringWidth + marginWidth +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 3*marginWidth
+ stringWidth - half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + 2*marginHeight +
half_shadowThickness;
/* 5 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 2*marginWidth -
shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
stringHeight + 2*marginHeight +
shadowThickness;
rect[num_rects].width = stringWidth + marginWidth +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 6 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 2*marginWidth -
shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
stringHeight + 2*marginHeight +
shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = ((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight;
/* 7 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness +
pixmapHeight + 2*marginHeight + shadowThickness;
rect[num_rects].width = pixmapWidth + (2 * shadowThickness) +
(2 * marginWidth) - half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 8 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + 2*marginHeight +
shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), top_gc,
&rect[0], num_rects);
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + (2 * marginWidth) +
half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*marginWidth + shadowThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = ((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight - shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*marginWidth + shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
half_shadowThickness;
rect[num_rects].width = stringWidth + marginWidth +
half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
3*marginWidth + 2*shadowThickness +
stringWidth;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2);
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + 2*marginHeight +
2*shadowThickness;
/* 5 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*marginWidth + shadowThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
2*marginHeight + shadowThickness +
stringHeight + half_shadowThickness;
rect[num_rects].width = stringWidth + marginWidth +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 6 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*marginWidth + shadowThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
2*marginHeight + shadowThickness +
stringHeight + half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = ((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight;
/* 7 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness + pixmapHeight +
2*marginHeight + shadowThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + 2*marginWidth +
2*shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 8 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + 2*marginHeight +
half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), bottom_gc,
&rect[0], num_rects);
}
}
else
{
if((Dimension)(stringHeight+5) >= pixmapHeight)
{
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = pixmapWidth + stringWidth + spacing +
2*shadowThickness + 2*marginWidth;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + stringWidth + spacing +
shadowThickness + 2*marginWidth;
rect[num_rects++].height = half_shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
if(pixmapHeight > stringHeight)
rect[num_rects++].height = pixmapHeight + 2*marginHeight +
2*shadowThickness;
else
rect[num_rects++].height = stringHeight + 2*marginHeight +
2*shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
if(pixmapHeight > stringHeight)
rect[num_rects++].height = pixmapHeight + 2*marginHeight +
half_shadowThickness;
else
rect[num_rects++].height = stringHeight + 2*marginHeight +
half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), top_gc,
&rect[0], num_rects);
num_rects = 0;
/* 1 */
rect[num_rects].x = x + pixmapWidth + stringWidth + spacing +
shadowThickness + 2*marginWidth +
highlightThickness;
rect[num_rects].y = y + highlightThickness +
shadowThickness;
rect[num_rects].width = half_shadowThickness;
if(pixmapHeight > stringHeight)
rect[num_rects++].height = pixmapHeight + 2*marginHeight +
shadowThickness;
else
rect[num_rects++].height = stringHeight + 2*marginHeight +
shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness + pixmapWidth +
stringWidth + spacing + shadowThickness +
2*marginWidth;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
if(pixmapHeight > stringHeight)
rect[num_rects++].height = pixmapHeight + 2*marginHeight +
shadowThickness;
else
rect[num_rects++].height = stringHeight + 2*marginHeight +
shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
if(pixmapHeight > stringHeight)
rect[num_rects].y = y + highlightThickness + pixmapHeight +
2*marginHeight + shadowThickness;
else
rect[num_rects].y = y + highlightThickness + stringHeight +
2*marginHeight + shadowThickness;
rect[num_rects].width = pixmapWidth + stringWidth + spacing +
shadowThickness + 2*marginWidth -
half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness;
if(pixmapHeight > stringHeight)
rect[num_rects].y = y + highlightThickness + pixmapHeight +
2*marginHeight + shadowThickness +
half_shadowThickness;
else
rect[num_rects].y = y + highlightThickness + stringHeight +
2*marginHeight + shadowThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + stringWidth + spacing +
2*shadowThickness + 2*marginWidth;
rect[num_rects++].height = half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), bottom_gc,
&rect[0], num_rects);
}
else
{
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = pixmapWidth + (2 * shadowThickness) +
(2 * marginWidth) + half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + (2 * marginWidth) +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 2*marginWidth -
shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight -shadowThickness;
rect[num_rects].width = stringWidth + marginWidth +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*marginWidth + shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
half_shadowThickness;
rect[num_rects].width = stringWidth + marginWidth +
half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 5 */
rect[num_rects].x = x + highlightThickness;
rect[num_rects].y = y + highlightThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + 2*marginHeight +
2*shadowThickness;
/* 6 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = pixmapHeight + 2*marginHeight +
shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), top_gc,
&rect[0], num_rects);
num_rects = 0;
/* 1 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 2*marginWidth -
shadowThickness;
rect[num_rects].y = y + highlightThickness + shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = ((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight - half_shadowThickness -
shadowThickness;
/* 2 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*marginWidth + shadowThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = ((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight - half_shadowThickness -
shadowThickness;
/* 3 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 3*marginWidth
+ stringWidth - half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + 2*marginHeight +
half_shadowThickness;
/* 4 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
3*marginWidth + 2*shadowThickness +
stringWidth;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2);
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = stringHeight + 2*marginHeight +
2*shadowThickness;
/* 5 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 2*marginWidth -
shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
stringHeight + 2*marginHeight +
shadowThickness;
rect[num_rects].width = stringWidth + marginWidth +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 6 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*marginWidth + shadowThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
2*marginHeight + shadowThickness +
stringHeight + half_shadowThickness;
rect[num_rects].width = stringWidth + marginWidth +
shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 7 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*shadowThickness + 2*marginWidth -
shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
stringHeight + 2*marginHeight +
shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = ((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight;
/* 8 */
rect[num_rects].x = x + highlightThickness + pixmapWidth +
2*marginWidth + shadowThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness +
((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
2*marginHeight + shadowThickness +
stringHeight + half_shadowThickness;
rect[num_rects].width = half_shadowThickness;
rect[num_rects++].height = ((Dimension)(pixmapHeight - stringHeight)/(Dimension)2) +
marginHeight;
/* 9 */
rect[num_rects].x = x + highlightThickness + shadowThickness;
rect[num_rects].y = y + highlightThickness +
pixmapHeight + 2*marginHeight + shadowThickness;
rect[num_rects].width = pixmapWidth + shadowThickness +
(2 * marginWidth) - half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
/* 10 */
rect[num_rects].x = x + highlightThickness +
half_shadowThickness;
rect[num_rects].y = y + highlightThickness + pixmapHeight +
2*marginHeight + shadowThickness +
half_shadowThickness;
rect[num_rects].width = pixmapWidth + 2*marginWidth +
shadowThickness + half_shadowThickness;
rect[num_rects++].height = half_shadowThickness;
XFillRectangles (XtDisplay (w), XtWindow (w), bottom_gc,
&rect[0], num_rects);
}
}
break;
case XmPIXMAP_BOTTOM:
case XmPIXMAP_RIGHT:
XmeDrawShadows (XtDisplay(w), XtWindow(w), top_gc, bottom_gc,
x + highlightThickness,
y + highlightThickness,
width - 2*highlightThickness,
height - 2*highlightThickness,
shadowThickness, XmSHADOW_IN);
break;
default:
break;
}
}
}
static void
FM_XmHighlightBorder(
Widget w )
{
if( XmIsPrimitive( w) ) {
(*(xmPrimitiveClassRec.primitive_class.border_highlight))( w) ;
} else {
if( XmIsGadget( w) ) {
(*(xmGadgetClassRec.gadget_class.border_highlight))( w) ;
}
}
return ;
}
static void
FM_XmUnhighlightBorder(
Widget w )
{
if( XmIsPrimitive( w) )
{
(*(xmPrimitiveClassRec.primitive_class.border_unhighlight))( w) ;
}
else
{ if( XmIsGadget( w) )
{
(*(xmGadgetClassRec.gadget_class.border_unhighlight))( w) ;
}
}
return ;
}
static XmGadget
InputForGadget(
Widget wid,
int x,
int y )
{
Widget widget;
widget = XmObjectAtPoint (wid, x, y);
if (!widget || !XtIsSensitive (widget))
return ((XmGadget) NULL);
return ((XmGadget) widget);
}
Reference in New Issue View Git Blame Copy Permalink