/*
 * 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
 */
/* $TOG: File.c /main/22 1999/12/09 13:05:50 mgreess $ */
/************************************<+>*************************************
 ****************************************************************************
 *
 *   FILE:           File.c
 *
 *   COMPONENT_NAME: Desktop File Manager (dtfile)
 *
 *   Description:    File processing functions.
 *
 *   FUNCTIONS: ABS
 *		AddFileIcons
 *		BuildObjectPositions
 *		CommitWorkProcUpdates
 *		CompressObjectList
 *		CopyOrderedEntries
 *		CreateNameChangeDialog
 *		CreateTreeIcons
 *		DeselectAllFiles
 *		DeselectFile
 *		DestroyIconName
 *		DisplaySomeIcons
 *		DisplayWorkProc
 *		DragFinishCB
 *		DrawingAreaRedisplay
 *		DropOnRootCB
 *		EraseTreeLines
 *		EstimateIconSize
 *		FileConvertCB
 *		FileDateAscending
 *		FileDateDescending
 *		FileIconMotion
 *		FileIsSelected
 *		FileNameAscending
 *		FileNameDescending
 *		FileSizeAscending
 *		FileSizeDescending
 *		FileTypeAscending
 *		FileTypeDescending
 *		FilterFiles
 *		FindCurrentPosition
 *		FlattenTree
 *		FmPopup
 *		FreeLayoutData
 *		GetAncestorInfo
 *		GetBottomOfStack
 *		GetDirName
 *		GetDragIcon
 *		GetDragIconMask
 *		GetExtraHeight
 *		GetFullName
 *		GetIconLayoutParms
 *		GetInsertPosition
 *		GetLevel
 *		GetPositionalData
 *		GetSelectedCount
 *		GetStrcollProc
 *		GetTopOfStack
 *		GetTreebtnPixmap
 *		HorizontalScrollbarIsVisible
 *		IconCallback
 *		InMultipleObjectRegion
 *		InitiateIconDrag
 *		IntersectRects
 *		IsButtonOrMotion
 *		IsDesktopPtr
 *		LayoutDesktopIcons
 *		LayoutFileIcons
 *		MakeReuseList
 *		NewConvertDelete
 *		NewConvertFileName
 *		OrderChildrenList
 *		OrderFiles
 *		PositionDesktopIcon
 *		PositionFileView
 *		RedisplayUsingStackingOrder
 *		RedrawOneGadget
 *		RedrawTreeLines
 *		RegisterDesktopHotspots
 *		RelocateDesktopIcon
 *		ReorderChildrenList
 *		RepaintDesktop
 *		RepairFileWindow
 *		RepairStackingPointers
 *		RepositionIcons
 *		RepositionUpInStack
 *		RestorePositionalData
 *		SavePositionalData
 *		SelectAllFiles
 *		SelectFile
 *		SetFileSelected
 *		SetFileUnselected
 *		SetHotRects
 *		SetToNormalColors
 *		SetToSelectColors
 *		SpecialCases
 *		StartDrag
 *		StrCaseCmp
 *		ToBeManaged
 *		TreeBtnCallback
 *		TreeLX
 *		TreeOneWd
 *		TreeWd
 *		TypeToAction
 *		TypeToDropOperations
 *		UnmanageFileIcons
 *		UnpostTextField
 *		UnpostTextPath
 *		UpdateFileIcons
 *		UpdateOneFileIcon
 *		UpdateOneIconLabel
 *		VerticalScrollbarIsVisible
 *		WidgetCmp
 *		YSPACING
 *		_UpdateFileIcons
 *		InputForGadget
 *		InputInGadget
 *
 *   (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 <string.h>
#include <locale.h>
#include <ctype.h>
#include <fnmatch.h>

#include <Xm/XmP.h>
#include <Xm/Xm.h>
#include <Xm/BulletinB.h>
#include <Xm/MwmUtil.h>
#include <X11/ShellP.h>
#include <X11/Shell.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#ifndef XK_MISCELLANY
#define XK_MISCELLANY
#endif
#include <X11/keysymdef.h>

#ifdef SHAPE
#include <X11/extensions/shape.h>
#endif

#include <Xm/DrawingA.h>
#include <Xm/DrawingAP.h>
#include <Xm/RowColumn.h>
#include <Xm/LabelG.h>
#include <Xm/PushBG.h>
#include <Xm/ToggleBG.h>
#include <Xm/SeparatoG.h>
#include <Xm/ScrollBar.h>
#include <Xm/ScrolledW.h>
#include <Xm/TextF.h>
#include <Xm/Frame.h>
#include <Xm/Screen.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <Dt/Icon.h>
#include <Dt/IconP.h>
#include <Dt/IconFile.h>

#include <Xm/DragIcon.h>
#include <Xm/DragC.h>
#include <Dt/Dnd.h>

#include <time.h>
#include <utime.h>

#include <Dt/Action.h>
#include <Dt/Connect.h>
#include <Dt/Wsm.h>
#include <Dt/DtNlUtils.h>
#include <Dt/HourGlass.h>
#include <Dt/Dts.h>
#include <Dt/UserMsg.h>
#include <Dt/SharedProcs.h>

#include <Tt/tttk.h>

#include <Xm/XmPrivate.h> /* _XmIsEventUnique _XmSetInDragMode _XmRecordEvent */

#include "Encaps.h"
#include "SharedProcs.h"
#include "FileMgr.h"
#include "Desktop.h"
#include "Main.h"
#include "Prefs.h"
#include "Common.h"
#include "Filter.h"
#include "Help.h"
#include "SharedMsgs.h"


extern Widget _DtDuplicateIcon ( Widget, Widget, XmString, String, XtPointer, Boolean );

/* absolute value macro */
#ifndef ABS
#define ABS(x) (((x) > 0) ? (x) : (-(x)))
#endif

#define INIT_VALUE 5

/*
 * MAXWINSIZE: maximum width of the file window
 *
 * Note: the file window width and height can't exceed the maximum value
 * for a short (32767), because x and y coords of the icon gadgets placed
 * in the file window are stored as short's by the Xt library (the
 * Position type is a short).
 *   Furthermore, somewhere in the code for registering icon drop sites
 * in libDt or libXm calculations are done that overflow if the window
 * size is too close to the maximum of 32767.  The symptom is observed
 * most easily in tree mode on a directory large enough for icons to
 * overflow into a second column: for values of MAXWINSIZE of 32767,
 * none of the icons are sensitive as drop sites any more.  The value
 * for MAXWINSIZE defined below has been found to be "safe" by experiment.
 */
#define MAXWINSIZE 32600

/********    Static Function Declarations    ********/

static int FileNameAscending(
                        FileViewData **t1,
                        FileViewData **t2) ;
static int FileNameDescending(
                        FileViewData **t1,
                        FileViewData **t2) ;
static int FileTypeAscending(
                        FileViewData **t1,
                        FileViewData **t2) ;
static int FileTypeDescending(
                        FileViewData **t1,
                        FileViewData **t2) ;
static int FileSizeAscending(
                        FileViewData **t1,
                        FileViewData **t2) ;
static int FileSizeDescending(
                        FileViewData **t1,
                        FileViewData **t2) ;
static int FileDateAscending(
                        FileViewData **t1,
                        FileViewData **t2) ;
static int FileDateDescending(
                        FileViewData **t1,
                        FileViewData **t2) ;
static void CompressObjectList (
                        ObjectPosition ** object_positions,
                        int num_objects,
                        int starting_index) ;
static ObjectPosition *GetPositionalData (
                        FileMgrData * file_mgr_data,
                        FileViewData * object,
                        Dimension max_width,
                        Boolean create) ;
static void RedisplayUsingStackingOrder (
                        FileMgrData * file_mgr_data,
                        Widget w,
                        register XEvent *event,
                        Region region) ;
static void ReorderChildrenList (
                        XmManagerWidget file_window,
                        Widget * manage,
                        int manageCount,
                        Widget * unmanage,
                        int unmanageCount) ;
static Boolean IsDesktopPtr (
                        FileViewData * fileViewData,
                        FileMgrData ** fileMgrData,
                        DesktopRec ** desktopRec) ;
static Boolean IntersectRects(
                        Position x1,
                        Position y1,
                        Dimension w1,
                        Dimension h1,
                        Position x2,
                        Position y2,
                        Dimension w2,
                        Dimension h2 ) ;
static void InitiateIconDrag(
                        FileViewData * fileViewData,
                        int rootX,
                        int rootY,
                        XEvent * event );
static void RelocateDesktopIcon(
                        DesktopRec * desktopRec,
                        int root_x,
                        int root_y);
static void BuildObjectPositions(
                        FileMgrData *file_mgr_data);
static void moveCopyLinkCancel(
                        Widget w,
                        XtPointer client_data,
                        XtPointer call_data );
static void moveCopyLinkOK(
                        Widget w,
                        XtPointer client_data,
                        XtPointer call_data );
static void DropOnRootCB (
                        Widget w,
                        XtPointer client_data,
                        XtPointer call_data);
static void _UpdateFileIcons(
                        FileMgrRec *file_mgr_rec,
                        FileMgrData *file_mgr_data,
                        Boolean new_directory,
                        DirectorySet * add_dir_set );
static void CreateTreeIcons(
                        Widget w);
static void TreeBtnCallback(
                        Widget w,
                        XtPointer clientData,
                        XmAnyCallbackStruct * callData );
static void LayoutDesktopIcons(
                        FileMgrRec *file_mgr_rec,
                        FileMgrData *file_mgr_data,
                        FileViewData ** order_list,
                        int order_count,
                        Boolean turn_off_hourglass);
static XmGadget InputInGadget (
			Widget w,
                        register int x,
			register int y);
static XmGadget InputForGadget (
                        Widget cw,
                        int x,
                        int y);

/********    End Static Function Declarations    ********/

/* cursor for double-click-drag (@@@ should be a resource) */
static Cursor loc_cursor1 = None;
static Cursor loc_cursor2 = None;
#define DBLCLICK_DRAG_THRESHOLD 20

/* layout constants (@@@ could be made resources) */
#define MARGIN          5
#define XSPACING        5
#define YSPACING(fmd)                                                              \
  (fmd->layout_data?                                                               \
    (fmd->view != BY_NAME? - ((IconLayoutData *)fmd->layout_data)->highlight:      \
                           - ((IconLayoutData *)fmd->layout_data)->highlight + 2): \
    0)
#define TreeSep         5
#define TreeOffset      15
#define TreeOneWd(sz)     (TreeOffset + TreeBtnWd[sz]/2)
#define TreeLX(level,sz)  (TreeBtnWd[sz]/2 + ((level) - 1)*TreeOneWd(sz))
#define TreeWd(level,sz)  \
  (TreeLX(level,sz) + TreeOffset + TreeBtnWd[sz] + TreeSep)

/* maximum size of the small, medium, and large tree buttons */
static int TreeBtnWd[3] = { 0, 0, 0 };
static int TreeBtnHt[3] = { 0, 0, 0 };

static int TreeNilWd[3] = { 0, 0, 0 };
static int TreeNilHt[3] = { 0, 0, 0 };

/* tree expansion circle pixmap indices */
typedef enum {
  tpxNotRead,    /* dotted circle */
  tpxError,      /* crossed circle */
  tpxMore,       /* "+" circle */
  tpxLess,       /* "-" circle */
  tpxBoth,       /* "+/-" circle */
  tpxEmpty,      /* empty circle */
  tpxNil,        /* empty-set symbol */
  tpxN
} TreePxId;

/* pixmaps for expand circles in tree mode */
static struct TreePx {
  char *name;            /*   name of pixmap file */
  Pixmap px[3];          /*   small, medium, and large pixmap */
} TreePxTab[tpxN] =
{
  { "Dttvnor", 0 },
  { "Dttverr", 0 },
  { "Dttvmor", 0 },
  { "Dttvlss", 0 },
  { "Dttvbth", 0 },
  { "Dttvemp", 0 },
  { "Dttvnil", 0 },
};

static char *TreePxSuffix[3] = { ".s", ".m", ".l" };

/* value need to to convert drop position to icon placement */
static int dragIconPixmapOffsetX;
static int dragIconPixmapOffsetY;

/*  Local defines  */

#define FILE_MOVE       0
#define FILE_COPY       1
#define FILE_INVALID    2


FileMgrPopup fileMgrPopup = {NULL};


/* Obsolete Motif highlighting and unhighlighting routines */
extern void _XmHighlightBorder(Widget w);
extern void _XmUnhighlightBorder(Widget w);

extern void SelectDTFile (DesktopRec *desktopWindow);

/************************************************************************
 ************************************************************************
 *
 *      Comparison functions used for sorting the files
 *
 ************************************************************************
 ************************************************************************/
/* only use when LANG=C on platforms that don't
provide strcasecmp().   Otherwise, use strcoll() */
static int
StrCaseCmp (
              const char  *s1,
              const char  *s2)
{
  /* Note: This is not really a string case insensitive compare. So don't
     even think of replacing it with any other library routines.
  */
  char *s1a = (char *)s1, *s2a = (char *)s2;

  if (s1 == s2) return  0;

  for (; tolower(*s1) == tolower(*s2); ++s1, ++s2) {
    if (*s1 == '\0' )
    {
      /* File Manager depends heavily on this routine to position the
         icons in its window.
         We want case INSENSITIVE comparision, however when we have
         2 same size and case equivalent strings i.e.   "A" and "a", we
         need this routine to behave like a case SENSITIVE comparision, so
         the position of the icon is constant so "A" is always
         before "a".
      */
      if (*s2 == 0x0)
      {
        for (; *s1a == *s2a; ++s1a, ++s2a) {
          if (*s1 == '\0' )
            return 0;
        }
        return *s1a - *s2a;
      }
      else
        return 0;
    }
  }

  return tolower(*s1) - tolower(*s2);
}

StrcollProc FMStrcoll = NULL;

StrcollProc
GetStrcollProc(void)
{
  int Clang = 0;
#if defined(__hpux)
  struct locale_data * li;
#else
  char * locale;
#endif

#define C_LANG  "C"

   /* if locale is C, use the explicit case insensitive compare */
#if defined(__hpux)
  li = getlocale(LOCALE_STATUS);
  if ( NULL == li->LC_COLLATE_D || strcmp(C_LANG,li->LC_COLLATE_D) == 0 )
    Clang = 1;
#else
  locale = setlocale(LC_COLLATE,NULL); /* put locale in buf */
  if (strcmp(locale,C_LANG) == 0)
    Clang = 1;
#endif

  if (Clang)
    return StrCaseCmp;

  return ((StrcollProc)strcoll);
}

static Boolean
SpecialCases(
             FileViewData **t1,
             FileViewData **t2,
             int *rc )
{
  /* Tree mode */
  if (((FileMgrData *)((DirectorySet *)((*t1)->directory_set))->file_mgr_data)
      ->show_type == MULTIPLE_DIRECTORY)
  {
    if (!(*t1)->file_data->is_subdir && (*t2)->file_data->is_subdir)
      *rc = -1;
    else if ((*t1)->file_data->is_subdir && !(*t2)->file_data->is_subdir)
      *rc = 1;
    else
      return False;
    return True;
  }







  /* Special files */
  if (FMStrcoll ((*t1)->file_data->file_name, "." ) == 0 )
  {
    *rc = -1;
    return True;
  }

  if (FMStrcoll ((*t1)->file_data->file_name, "..") == 0 )
  {
    if ( FMStrcoll ((*t2)->file_data->file_name, ".") == 0 )
      *rc = 1;
    else
      *rc = -1;
    return True;
  }

  if (FMStrcoll ((*t2)->file_data->file_name, ".") == 0 || FMStrcoll ((*t2)->file_data->file_name, "..") == 0)
  {
    *rc = 1;
    return True;
  }








  /* Directories */
  if (!(*t1)->file_data->is_subdir && (*t2)->file_data->is_subdir)
  {
    *rc = 1;
    return True;
  }

  if ((*t1)->file_data->is_subdir && !(*t2)->file_data->is_subdir)
  {
    *rc = -1;
    return True;
  }

  return False;
}

static int
FileNameAscending(
        FileViewData **t1,
        FileViewData **t2 )
{
  int rc;

  if( SpecialCases( t1, t2, &rc ) )
    return rc;

  if((*t1)->file_data->action_name == NULL)
  {
     if((*t2)->file_data->action_name == NULL)
        rc = FMStrcoll((*t1)->file_data->file_name,
                                              (*t2)->file_data->file_name);
     else
        rc = FMStrcoll((*t1)->file_data->file_name,
                                              (*t2)->file_data->action_name);
  }
  else
  {
     if((*t2)->file_data->action_name != NULL)
        rc = FMStrcoll((*t1)->file_data->action_name,
                                              (*t2)->file_data->action_name);
     else
        rc = FMStrcoll((*t1)->file_data->action_name,
                                              (*t2)->file_data->file_name);
  }

  return rc;
}

static int
FileNameDescending(
        FileViewData **t1,
        FileViewData **t2 )
{
   int rc;

   if( SpecialCases( t1, t2, &rc ) )
     return rc;

   if((*t1)->file_data->action_name == NULL)
   {
      if((*t2)->file_data->action_name == NULL)
         rc = FMStrcoll((*t1)->file_data->file_name,
                                              (*t2)->file_data->file_name);
      else
         rc = FMStrcoll((*t1)->file_data->file_name,
                                              (*t2)->file_data->action_name);
   }
   else
   {
      if((*t2)->file_data->action_name != NULL)
         rc = FMStrcoll((*t1)->file_data->action_name,
                                              (*t2)->file_data->action_name);
      else
         rc = FMStrcoll((*t1)->file_data->action_name,
                                              (*t2)->file_data->file_name);
   }

   if (rc <= -1)
     return 1;

   if (rc >= 1)
     return -1;

   return 0;
}

static int
FileTypeAscending(
        FileViewData **t1,
        FileViewData **t2 )
{
  int rc;

  if( SpecialCases( t1, t2, &rc ) )
    return rc;

  rc = strcoll( (*t1)->file_data->logical_type, (*t2)->file_data->logical_type );
  if( rc == 0 )
    rc = FileNameAscending( t1, t2 );
  return rc;
}


static int
FileTypeDescending(
        FileViewData **t1,
        FileViewData **t2 )
{
  int rc;

  if( SpecialCases( t1, t2, &rc ) )
    return rc;

   rc = strcoll( (*t1)->file_data->logical_type, (*t2)->file_data->logical_type );

   if (rc <= -1)
     return 1;

   if (rc >= 1)
     return -1;

   rc = FileNameDescending( t1, t2 );

   return rc;
}

static int
FileSizeAscending(
        FileViewData **t1,
        FileViewData **t2 )
{
  int rc;

  if( SpecialCases( t1, t2, &rc ) )
    return rc;

  if ((*t1)->file_data->stat.st_size < (*t2)->file_data->stat.st_size)
    return -1;

  else if ((*t1)->file_data->stat.st_size > (*t2)->file_data->stat.st_size)
    return 1;

  return 0;
}

static int
FileSizeDescending(
        FileViewData **t1,
        FileViewData **t2 )
{
  int rc;

  if( SpecialCases( t1, t2, &rc ) )
    return rc;

  if ((*t1)->file_data->stat.st_size < (*t2)->file_data->stat.st_size)
    return 1;

  if ((*t1)->file_data->stat.st_size > (*t2)->file_data->stat.st_size)
    return -1;

  return 0;
}

static int
FileDateAscending(
        FileViewData **t1,
        FileViewData **t2 )
{
  int rc;

  if( SpecialCases( t1, t2, &rc ) )
    return rc;

  if ((*t1)->file_data->stat.st_mtime < (*t2)->file_data->stat.st_mtime)
    return -1;

  if ((*t1)->file_data->stat.st_mtime > (*t2)->file_data->stat.st_mtime)
    return 1;

  return 0;
}

static int
FileDateDescending(
        FileViewData **t1,
        FileViewData **t2 )
{

  int rc;

  if( SpecialCases( t1, t2, &rc ) )
    return rc;

  if ((*t1)->file_data->stat.st_mtime < (*t2)->file_data->stat.st_mtime)
    return 1;

  if ((*t1)->file_data->stat.st_mtime > (*t2)->file_data->stat.st_mtime)
    return -1;

  return 0;
}





/************************************************************************
 *
 *  OrderFiles
 *      Sort the file display list according to the ordering data.
 *
 ************************************************************************/

void
OrderFiles(
        FileMgrData *file_mgr_data,
        DirectorySet *directory_set )
{
   FileViewData ** file_view_data;
   int             file_count;
   FileViewData ** order_list;
   int * sort;
   int * sub_sort;
   register int i;
   register int start;

   file_view_data = directory_set->file_view_data;
   file_count = directory_set->file_count;


   /*  Allocate an ordering list  */

   if (directory_set->order_list != NULL)
   {
      XtFree ((char *) directory_set->order_list);
       directory_set->order_list = NULL;
   }

   if (file_count > 0)
      directory_set->order_list = order_list =
         (FileViewData **) XtMalloc (sizeof (FileViewData **) * file_count);
   else
      directory_set->order_list = order_list = NULL;

   /*  Get pointers to all of the file data into the order list  */

   for (i = 0; i < file_count; i++)
      order_list[i] = file_view_data[i];

   /*  Set up the sorting functions according to the order and direction.  */

   sub_sort = NULL;

   if (file_mgr_data->order == ORDER_BY_FILE_TYPE)
   {
      if (file_mgr_data->direction == DIRECTION_ASCENDING)
      {
         sort = (int *) FileTypeAscending;
         sub_sort = (int *) FileNameAscending;
      }
      else
      {
         sort = (int *) FileTypeDescending;
         sub_sort = (int *) FileNameDescending;

      }
   }
   else if (file_mgr_data->order == ORDER_BY_ALPHABETICAL)
   {
      if (file_mgr_data->direction == DIRECTION_ASCENDING)
         sort = (int *) FileNameAscending;
      else
         sort = (int *) FileNameDescending;
   }
   else if (file_mgr_data->order == ORDER_BY_DATE)
   {
      if (file_mgr_data->direction == DIRECTION_ASCENDING)
         sort = (int *) FileDateAscending;
      else
         sort = (int *) FileDateDescending;

   }
   else if (file_mgr_data->order == ORDER_BY_SIZE)
   {
      if (file_mgr_data->direction == DIRECTION_ASCENDING)
         sort = (int *) FileSizeAscending;
      else
         sort = (int *) FileSizeDescending;
   }


   /*  Sort the files and if the sub_sort function is non-null,  */
   /*  sort sets of the files broken according to file type.     */

   qsort (order_list, file_count, sizeof (FileViewData *), (int (*)())sort);

   if (sub_sort != NULL)
   {
      start = 0;
      i = 0;

      while (i < file_count)
      {
         if (order_list[start]->file_data->logical_type !=
             order_list[i]->file_data->logical_type)
         {
            qsort (order_list + start, i - start,
                   sizeof (FileViewData *), (int (*)())sub_sort);
            start = i;
         }

         i++;
      }

      qsort (order_list + start, i - start, sizeof (FileViewData *),
                                                         (int (*)())sub_sort);
   }
}



/************************************************************************
 *
 *  FilterFiles
 *      Filter out the files which do not match the filtering criteria.
 *
 *      The `mustMatch' flag is used to determine whether the user has
 *      requested that the files which match the specification are to
 *      be displayed, or instead, filtered out.
 *
 ************************************************************************/

void
FilterFiles(
        FileMgrData *file_mgr_data,
        DirectorySet *directory_set )
{
   FileViewData **file_view_data;
   FilterData *   filter_data;
   register int   i, j, k;
   Boolean        show_hidden;
   String         filter;
   Boolean        mustMatch, matches;
   int            filterCount = 0;
   int            invisibleCount = 0;
   FileViewData  *sub_root;
#ifdef DT_PERFORMANCE
   struct timeval update_time_s;
   struct timeval update_time_f;

   printf("   Begin FilterFiles\n");
   gettimeofday(&update_time_s, NULL);

    /* added by Rafi */
    _DtPerfChkpntMsgSend("Begin Filtering Files");

#endif

   file_view_data = directory_set->file_view_data;

   filter_data = (FilterData *)(file_mgr_data->filter_active->data);
   show_hidden = filter_data->show_hidden;
   filter = filter_data->filter;
   mustMatch = filter_data->match_flag;

   /* set the show hidden boolean depending on the filter specification */
   if (show_hidden)
      file_mgr_data->show_hid_enabled = True;
   else
      file_mgr_data->show_hid_enabled = False;

   /*  Filter out all files not matching the specifications  */

   for (i = 0; i < directory_set->file_count; i++)
   {
      /* Initially assume the file is not filtered out */

      file_view_data[i]->filtered = False;

      /* If in tree mode, explicitly filter out . and ..  */
      if (file_mgr_data->show_type == MULTIPLE_DIRECTORY &&
         (strcmp(file_view_data[i]->file_data->file_name, ".") == 0 ||
          strcmp(file_view_data[i]->file_data->file_name, "..") == 0))
      {
         filterCount++;
         file_view_data[i]->filtered = True;
         continue;
      }

      /* filter out any files that have their attributes "invisible"   */
      /* field set to false                                            */
      if((_DtCheckForDataTypeProperty(
             file_view_data[i]->file_data->logical_type,
             "invisible")) &&
         (file_mgr_data != trashFileMgrData))
      {
         filterCount++;
         file_view_data[i]->filtered = True;
         ++invisibleCount;
         continue;
      }

      /* Filter hidden files, according to the user setting */

      if (file_view_data[i]->file_data->file_name[0] == '.')
      {
         if(strcmp(file_mgr_data->current_directory, "/") == 0  &&
              strcmp(file_view_data[i]->file_data->file_name, "..") == 0)
         {
            filterCount++;
            file_view_data[i]->filtered = True;
            continue;
         }
         if(file_mgr_data->restricted_directory != NULL)
         {
           if((strcmp(file_mgr_data->restricted_directory,
                            file_mgr_data->current_directory) == 0 &&
                       (strcmp(file_view_data[i]->file_data->file_name, ".") == 0 || strcmp(file_view_data[i]->file_data->file_name, "..") == 0 )) ||
             (strncmp(file_mgr_data->restricted_directory,file_mgr_data->current_directory, strlen(file_mgr_data->restricted_directory)) == 0 &&
               strcmp(file_view_data[i]->file_data->file_name, ".") == 0 ))
           {
             filterCount++;
             file_view_data[i]->filtered = True;
             continue;
           }
         }
      }

      if( restrictMode  &&
           (strcmp(file_view_data[i]->file_data->file_name, "..") == 0 ||
            strcmp(file_view_data[i]->file_data->file_name, ".") == 0))
      {
         char *tempName;

         tempName = (char *)XtMalloc( strlen(file_mgr_data->current_directory) + 3);
         sprintf( tempName, "%s/", file_mgr_data->current_directory );
         if( strcmp(users_home_dir, tempName) == 0 ||
             strcmp(users_home_dir, file_mgr_data->current_directory) == 0)
         {
            filterCount++;
            file_view_data[i]->filtered = True;
            XtFree(tempName);
            continue;
         }
         XtFree(tempName);
      }


      /* if we want to show the hidden files no more should be filtered out */
      if(show_hidden)
         continue;

      /* don't show .trashinfo in the trash directory */
      if(trashFileMgrData == file_mgr_data &&
        (strcmp(file_view_data[i]->file_data->file_name, ".trashinfo") == 0))
      {
         filterCount++;
         file_view_data[i]->filtered = True;
         continue;
      }

      /* Check for a match against the filter expression string, except for
       * files in the trash directory and sub directories in tree mode. */

      matches = False;
      if (strcmp(filter, "") != 0 &&
          file_mgr_data != trashFileMgrData &&
          !(file_mgr_data->show_type == MULTIPLE_DIRECTORY &&
            file_view_data[i]->file_data->is_subdir))
      {
         /* Special case for ".." that need not be filtered */
         if( !strcmp( file_view_data[i]->file_data->file_name, ".." )
             || !strcmp( file_view_data[i]->file_data->file_name, "." ) )
         {
         }
         else if (file_view_data[i]->file_data->action_name)
         {
            if(fnmatch((const char *)filter,
                       (const char *)file_view_data[i]->file_data->action_name,
                       0) == 0)
            {
                if ( mustMatch )
                {
                    filterCount++;
                    file_view_data[i]->filtered = True;
                    continue;
                }
                else
                    matches = True;
            }
         }
         else if (fnmatch((const char *)filter,
             (const char *)file_view_data[i]->file_data->file_name, 0) == 0)
         {
            if ( mustMatch )
            {
               filterCount++;
               file_view_data[i]->filtered = True;
               continue;
            }
            else
               matches = True;
         }
      }

      /* now lets check through the filter filetypes and if the file is  */
      /* filtered, filter it out                                         */
      if(file_mgr_data != trashFileMgrData)
      {
         /* This is for the case of files likes 'action' files which
            do not have a logical_type */

         if(strcmp(file_view_data[i]->file_data->file_name,file_view_data[i]->
                    file_data->logical_type) == 0)
         {
            if(!filter_data->match_flag)
            {
              if(!matches)
              {
               filterCount++;
               file_view_data[i]->filtered = True;
              }
            }
         }
         else
           for(j = 0; j < filter_data->count; j++)
           {
             if(strcmp(filter_data->user_data[j]->filetype,
                       file_view_data[i]->file_data->logical_type) == 0)
             {
                if((filter_data->user_data[j]->selected == True &&
                                                   filter_data->match_flag) ||
                (filter_data->user_data[j]->selected == False &&
                                                   !filter_data->match_flag))
                {
                   if(!matches)
                   {
                      filterCount++;
                      file_view_data[i]->filtered = True;
                   }
                }
                break;
             }
          }
      }
   }

   /* update ndir, nfile counts for this sub directory */
   directory_set->filtered_file_count = filterCount;
   directory_set->invisible_file_count = invisibleCount;
   sub_root = directory_set->sub_root;
   sub_root->ndir = sub_root->nfile = 0;
   sub_root->nnew = 0;

   for (i = 0; i < directory_set->file_count; i++)
   {
     if (!file_view_data[i]->filtered)
     {
       if (file_view_data[i]->file_data->is_subdir)
         sub_root->ndir++;
       else
         sub_root->nfile++;
     }
   }

   UpdateBranchState(file_mgr_data, sub_root, BRANCH_UPDATE, False);

#ifdef DT_PERFORMANCE
   gettimeofday(&update_time_f, NULL);
   if (update_time_s.tv_usec > update_time_f.tv_usec) {
      update_time_f.tv_usec += 1000000;
      update_time_f.tv_sec--;
   }
   printf("    done FilterFiles, time: %ld.%ld\n\n", update_time_f.tv_sec - update_time_s.tv_sec, update_time_f.tv_usec - update_time_s.tv_usec);

   /* added by Rafi */
   _DtPerfChkpntMsgSend("Done  Filtering Files");

#endif
}




/************************************************************************
 *
 *  GetAncestorInfo, GetLevel, GetFullName
 *
 ************************************************************************/

void
GetAncestorInfo(
        FileMgrData *file_mgr_data,
        FileViewData *ip,
        int *levelp,
        char *path,
        Bool *morep)
/*
 * Get information related to the ancestory of an entry:
 *  - tree depth level
 *  - full path name
 *  - for each level: flag indicating whether there are additional siblings
 *    to be diplayed after this entry
 */
{
  FileViewData *pp, *pa[256];
  int i, l, level;
  char *p;

  /* determine tree depth level of this entry */
  level = 0;
  for (pp = ip->parent; pp; pp = pp->parent)
    level++;
  if (levelp)
    *levelp = level;

  /* get a list of all ancestors (including ip) in top down order */
  l = level;
  for (pp = ip; pp; pp = pp->parent)
    pa[l--] = pp;

  /* construct path name of this entry */
  if (path) {
    strcpy(path, file_mgr_data->current_directory);
    p = path + strlen(path);
    for (l = 1; l <= level; l++) {
      if (p[-1] != '/')
        *p++ = '/';
      strcpy(p, pa[l]->file_data->file_name);
      p += strlen(p);
    }
  }

  /* compile more array */
  if (morep) {
    for (l = 0; l <= level; l++) {
      DirectorySet *ds = (DirectorySet *)pa[l]->directory_set;
      morep[l] = False;
            if (ds->order_list == NULL)
        continue;
      for (i = 0; i < ds->file_count; i++)
        if (ds->order_list[i] == pa[l])
          break;
      for (i = i + 1; i < ds->file_count; i++) {
        if (ds->order_list[i]->displayed) {
          morep[l] = True;
          break;
        }
      }
    }
  }
}


void
GetFullName(
        FileMgrData *file_mgr_data,
        FileViewData *ip,
        char *path)
{
  GetAncestorInfo(file_mgr_data, ip, NULL, path, NULL);
}


void
GetDirName(
        FileMgrData *file_mgr_data,
        FileViewData *ip,
        char *path)
{
  char *p;

  GetAncestorInfo(file_mgr_data, ip, NULL, path, NULL);
  p = strrchr(path, '/');
  *p = 0;
}


void
GetLevel(
        FileViewData *ip,
        int *levelp)
{
  int level = 0;
  for (ip = ip->parent; ip; ip = ip->parent)
    level++;
  *levelp = level;
}


/************************************************************************
 *
 *  FlattenTree
 *
 ************************************************************************/

static void
CopyOrderedEntries(
        FileViewData *ip,
        FileViewData *fvd_array[],
        int *index)
/*
 * Copy all entries from the tree to an array
 */
{
  DirectorySet *directory_set;
  int i;

  fvd_array[*index] = ip;
  (*index)++;

  if (ip->desc)
  {
    directory_set = (DirectorySet *)ip->desc->directory_set;
    for (i = 0; i < directory_set->file_count; i++)
      CopyOrderedEntries(directory_set->order_list[i], fvd_array, index);
  }
}


void
FlattenTree(
        FileMgrData *file_mgr_data,
        FileViewData ***file_view_data,
        int *file_count)
{
  int i;

  *file_count = 1;
  for (i = 0; i < file_mgr_data->directory_count; i++)
    *file_count += file_mgr_data->directory_set[i]->file_count;

  *file_view_data =
    (FileViewData **) XtMalloc (*file_count * sizeof(FileViewData *));
  i = 0;
  CopyOrderedEntries(file_mgr_data->tree_root, *file_view_data, &i);
}


/************************************************************************
 *
 *  IconCallback
 *      Callback function invoked upon an action occuring on an icon.
 *
 ************************************************************************/

static Bool
IsButtonOrMotion(
  Display *disp,
  XEvent *ep,
  char *arg)
{
  return (ep->type == MotionNotify || ep->type == ButtonRelease);
}


void
IconCallback(
        Widget w,
        XtPointer clientData,
        XtPointer callData )
{
   XmAnyCallbackStruct * callback;
   XButtonEvent * event;
   FileViewData * fileViewData;
   FileMgrData  * fileMgrData;
   static Boolean highlightType = INIT_VALUE;
   static Widget highlightWidget = NULL;
   char * logicalType;
   char * command;
   DesktopRec * desktopRec;
   Boolean dragged;
   Window root;
   XEvent bevent;
   int dx, dy;
   WindowPosition position;

   static int adjustState=-1;
   XrmValue value_return;
   char *str_type_return;


   if( adjustState == -1)
   {
      if (XrmGetResource(XrmGetDatabase(XtDisplay(w)), "*enableBtn1Transfer", "*EnableBtn1Transfer",&str_type_return, &value_return) && !strcmp(value_return.addr,"True") )
        {
             adjustState=True;
        }
      else
             adjustState=False;
   }

   callback = (XmAnyCallbackStruct *) callData;
   fileViewData = (FileViewData *) clientData;
   event = (XButtonEvent *) callback->event;

   if (callback->reason == XmCR_DRAG && event->button == bMenuButton)
      callback->reason = XmCR_POPUP;

   if(callback->reason != XmCR_UNHIGHLIGHT)
   {
      /*  Get the directory data and the file manager data  */
      (void)IsDesktopPtr(fileViewData, &fileMgrData, &desktopRec);
   }

   /*  Process the different callback types  */
   if ((callback->reason == XmCR_ARM) || (callback->reason == XmCR_SELECT))
   {
      /*
       * Both ARM and SELECT are generated using Button1. We pass on these
       * requests to the code responsible for processing button 1 selects
       * and drags.
       */
      FileMgrRec  * fileMgrRec;
      DtIconGadget new = (DtIconGadget)w;

      if( event->type == KeyPress )
      {
        /* if a keypress we only want to select on an SELECT */
        if( callback->reason == XmCR_ARM )
          return;
        else
        {
          XKeyEvent *kevent;
          KeySym keysym;
          int offset;

          kevent = (XKeyEvent *)event;
          if (kevent->state & ShiftMask)
            offset = 1;
          else
            offset = 0;

          keysym = XLookupKeysym((XKeyEvent *)kevent, offset);

          if( keysym == XK_Return )
            goto run_default_action;
        }
      }

      if (callback->reason == XmCR_ARM)
         new->icon.armed = False;

      if (desktopRec)
      {
         B1DragPossible = False;
         B2DragPossible = False;
         XtCallCallbacks(desktopRec->drawA, XmNinputCallback, callData);
      }
      else
      {
         B1DragPossible = False;
         B2DragPossible = False;

         fileMgrRec = (FileMgrRec *)fileMgrData->file_mgr_rec;
         XtCallCallbacks(fileMgrRec->file_window, XmNinputCallback, callData);
      }

      if (callback->reason == XmCR_ARM)
         new->icon.armed = True;
   }
   else if (callback->reason==XmCR_DISARM)
   {
      /*
       * DISARM is generated as the result of a button 1 up event.
       * If we are in the middle of a button 2 drag, then we'll ignore this;
       * otherwise, we now know a drag will not start, so clear all state flags.
       */
      if (B2DragPossible)
         return;

      B1DragPossible = False;
      B2DragPossible = False;
      ProcessBtnUp = False;
   }
   else if (callback->reason == XmCR_DROP)
   {
      /*
       * DROP is generated as the result of a button 2 up event.
       * If we are in the middle of a button 1 drag, then we'll ignore this;
       * otherwise, we now know a drag will not start, so clear all state flags.
       */
      if (B1DragPossible)
         return;

      B1DragPossible = False;
      B2DragPossible = False;
      ProcessBtnUp = False;
   }
   else if (callback->reason == XmCR_DEFAULT_ACTION)
   {
      Boolean Error;

      if(event->type == KeyPress)
      {
         XKeyEvent *kevent;
         KeySym keysym;
         int offset;

         kevent = (XKeyEvent *)event;
         if (kevent->state & ShiftMask)
            offset = 1;
         else
            offset = 0;

         keysym = XLookupKeysym((XKeyEvent *)kevent, offset);

         if (keysym == XK_Escape)
         {
            /* an escape unposts the name change text widget */
            if(desktopRec)
               UnpostDTTextField();
            else
               UnpostTextField(fileMgrData);
            return;
         }
         else
         {
           KeySym SpaceKeySym = XStringToKeysym( "space" );
           if( keysym == SpaceKeySym )
             return;
         }
      }

      run_default_action:

      Error = False;

      /*
       * If DEFAULT_ACTION was generated by button press,
       * wait for the button release
       */
      dragged = False;
      if(event->type == ButtonPress)
      {
        if (loc_cursor1 == None)
          loc_cursor1 = XCreateFontCursor(XtDisplay(w), 40);
        if (loc_cursor2 == None)
          loc_cursor2 = XCreateFontCursor(XtDisplay(w), 34);

        root = RootWindowOfScreen(XtScreen(w));
        XGrabPointer(XtDisplay(w), root,
                     False, ButtonReleaseMask | PointerMotionMask,
                     GrabModeAsync, GrabModeAsync,
                     None, loc_cursor1, CurrentTime);
        do {
          XIfEvent(XtDisplay(w), &bevent, IsButtonOrMotion, NULL);
          if (!dragged && bevent.type == MotionNotify) {
            dx = event->x_root - bevent.xmotion.x_root; if (dx < 0) dx = -dx;
            dy = event->y_root - bevent.xmotion.y_root; if (dy < 0) dy = -dy;
            if (dx > DBLCLICK_DRAG_THRESHOLD || dy > DBLCLICK_DRAG_THRESHOLD) {
              DPRINTF(("dragged!\n"));
              XGrabPointer(XtDisplay(w), root,
                           False, ButtonReleaseMask | PointerMotionMask,
                           GrabModeAsync, GrabModeAsync,
                           None, loc_cursor2, CurrentTime);
              dragged = True;
            }
          }
        } while (bevent.type != ButtonRelease);

        XUngrabPointer(XtDisplay(w), CurrentTime);
        XFlush(XtDisplay(w));

        position.x = bevent.xbutton.x_root;
        position.y = bevent.xbutton.y_root;
      }

      /*
       * DEFAULT_ACTION is generated by a double-click of button 1.
       * We now know a drag will not start, so clear all state flags.
       */
      B1DragPossible = False;
      B2DragPossible = False;
      ProcessBtnUp = False;

      logicalType = fileViewData->file_data->logical_type;
      command = _DtRetrieveDefaultAction(logicalType);

      if (desktopRec)
      {
         /* Any button event unposts the text field */
         UnpostDTTextField();

         if(command)
            RunDTCommand(command, desktopRec, NULL);
         else
            Error = True;
      }
      else
      {
         /* Any button event unposts the text field */
         UnpostTextField(fileMgrData);

         if((openDirType == NEW && strcmp(command, openInPlace) == 0) ||
            (openDirType != NEW && strcmp(command, openNewView) == 0))
         {
            unsigned int modifiers = event->state;

            RunCommand (openNewView, fileMgrData, fileViewData,
                        dragged? &position: NULL, NULL, NULL);
            if((modifiers != 0) && ((modifiers & ControlMask) != 0))
            {
               DialogData  *dialog_data;

               dialog_data = _DtGetInstanceData(fileMgrData->file_mgr_rec);
               CloseView(dialog_data);
            }
         }
         else
         {
            if(command)
            {
               if ((fileMgrData->show_type == MULTIPLE_DIRECTORY || dragged) &&
                   strcmp(command, openInPlace) == 0)
               {
                 RunCommand (openNewView, fileMgrData, fileViewData,
                             dragged? &position: NULL, NULL, NULL);
               }
               else
                 RunCommand (command, fileMgrData, fileViewData,
                             NULL, NULL, NULL);
            }
            else
               Error = True;
         }
      }

      XtFree(command);

      if(Error)
      {
         char * title;
         char msg[512];
         char * tmpStr;

         tmpStr = (GETMESSAGE(9,6, "Action Error"));
         title = (char *)XtMalloc(strlen(tmpStr) + 1);
         strcpy(title, tmpStr);

         (void) sprintf (msg,
              (GETMESSAGE(9,7, "There are no actions defined for %s\n")),
              logicalType);
         if(desktopRec)
            _DtMessage (desktopRec->shell, title, msg, NULL, HelpRequestCB);
         else
            _DtMessage (fileViewData->widget, title, msg, NULL, HelpRequestCB);
         XtFree(title);
      }
   }
   else if (callback->reason == XmCR_DRAG)
   {
      /*
       * DRAG is generated by a button 2 down event. It flags that
       * the user may possible be initiating a drag; we won't know
       * for sure until the drag threshold is surpassed.
       * Ignore this if a Button 1 drag is ramping up.
       */
      if (B1DragPossible)
         return;

      /* Any button event unposts the text field */
      if (desktopRec)
      {
         UnpostDTTextField();
         if(!DTFileIsSelected(desktopRec, fileViewData) && adjustState)
             SelectDTFile(desktopRec);
      }
      else
      {
         if( fileMgrData && !FileIsSelected(fileMgrData,fileViewData) &&
             adjustState
           )
           {
             SelectFile(fileMgrData, fileViewData);
           }
         UnpostTextField(fileMgrData);
      }

      /* Save starting X & Y, in case a drag really starts */
      initialDragX = event->x;
      initialDragY = event->y;
      B2DragPossible = True;
      memcpy((char *) &desktop_data->event, (char *) event,
             (int) sizeof(XButtonEvent));
   }
   else if (callback->reason == XmCR_POPUP)
   {
      if(!desktopRec)
      {
         FmPopup (w, clientData, (XEvent *)event, fileMgrData);
      }
   }
   else if (callback->reason == XmCR_HIGHLIGHT)
   {
      DtIconGadget g = (DtIconGadget)w;

      if (dragActive)
      {
         if ((g->icon.border_type == DtRECTANGLE) || (!g->icon.pixmap))
           _XmUnhighlightBorder(w);

         B1DragPossible = False;
         B2DragPossible = False;
         return;
      }

      if ((g->icon.border_type == DtRECTANGLE) || (!g->icon.pixmap))
         return;

      if ((highlightType != INIT_VALUE) && (highlightWidget))
      {
         if (desktopRec)
         {
            if (highlightType == NOT_DESKTOP)
               DrawUnhighlight(highlightWidget, NOT_DESKTOP);
            else if (highlightWidget != w)
               DrawUnhighlight(highlightWidget, DESKTOP);
         }
         else
         {
            if (highlightType == DESKTOP)
               DrawUnhighlight(highlightWidget, DESKTOP);
            else if (highlightWidget != w)
               DrawUnhighlight(highlightWidget, NOT_DESKTOP);
         }
      }

      if (desktopRec)
      {
         DrawHighlight(w, NULL, NULL, DESKTOP);
         highlightType = DESKTOP;
      }
      else
      {
         DrawHighlight(w, fileViewData, fileMgrData, NOT_DESKTOP);
         highlightType = NOT_DESKTOP;
      }
      highlightWidget = w;
   }
   else if (callback->reason == XmCR_UNHIGHLIGHT)
   {
      DtIconGadget g = (DtIconGadget)w;

      if (dragActive)
      {
        if ((g->icon.border_type == DtRECTANGLE) || (!g->icon.pixmap))
          _XmHighlightBorder(w);

        B1DragPossible = False;
        B2DragPossible = False;
        return;
      }

      if ((g->icon.border_type == DtRECTANGLE) || (!g->icon.pixmap))
        return;

      if (w == highlightWidget)
      {
         if (highlightType == DESKTOP)
            DrawUnhighlight(w, DESKTOP);
         else
            DrawUnhighlight(w, NOT_DESKTOP);

         highlightType = INIT_VALUE;
         highlightWidget = NULL;
      }
   }
   else if (callback->reason == XmCR_SHADOW)
      DrawShadowTh(w, NULL, DESKTOP);

}

static int
GetSelectedCount(
        FileViewData * fileViewData,
        FileMgrData * fileMgrData,
        DesktopRec * desktopRec,
        int * dt)
{
   int selectedCount;
   char * wsName;
   Atom pCurrent;

   /*  If the initiation of the drag occured upon an      */
   /*  already selected icon, check for a multiple drag.  */

   if ((desktopRec == NULL) && FileIsSelected(fileMgrData, fileViewData))
      selectedCount = fileMgrData->selected_file_count;
   else if (desktopRec == NULL)
      selectedCount = 1;
   else
   {
      if (DTFileIsSelected(desktopRec, fileViewData))
      {
         if(DtWsmGetCurrentWorkspace(XtDisplay(desktopRec->shell),
                               RootWindowOfScreen(XtScreen(desktopRec->shell)),
                               &pCurrent) == Success)
         {
            wsName = XGetAtomName(XtDisplay(desktopRec->shell), pCurrent);
            CleanUpWSName(wsName);
         }
         else
            wsName = XtNewString("One");

         for(*dt = 0; *dt < desktop_data->numWorkspaces; (*dt)++)
         {
            if(strcmp(wsName, desktop_data->workspaceData[*dt]->name) == 0)
            {
               selectedCount = desktop_data->workspaceData[*dt]->files_selected;
               break;
            }
         }
         XtFree(wsName);
      }
      else
         selectedCount = 1;
   }

   return(selectedCount);
}


static Pixmap
GetDragIconMask(
        Widget w,
        unsigned int wid,
        unsigned int hei)
{
   Pixmap dragMask;
   Display *dpy = XtDisplay(w);
   unsigned char flags;
   XRectangle pRect, lRect;
   GC fillGC;
   XGCValues values;
   Arg args[8];
   Dimension shadowThickness;
   Dimension marginWidth, marginHeight;
   int minX, minY;
   Boolean minXUndefined, minYUndefined;

   dragMask = XCreatePixmap(dpy, RootWindowOfScreen (XtScreenOfObject(w)),
                            wid, hei, 1);

  /* Create a GC for drawing 0's into the pixmap */
   fillGC = XCreateGC(dpy, dragMask, 0, (XGCValues *) NULL);

   XFillRectangle(dpy, dragMask, fillGC, 0, 0, wid, hei);

   values.foreground = 1;
   XChangeGC(dpy, fillGC, GCForeground, &values);

  /* Create the drag pixmap, and the associated mask bitmap */
   _DtIconGetIconRects((DtIconGadget)w, &flags, &pRect, &lRect);

   minX= 0;
   minY= 0;
   minXUndefined = minYUndefined = True;
   if (flags & XmPIXMAP_RECT)
   {
       minX = pRect.x;
       minY = pRect.y;
       minXUndefined = minYUndefined = False;
   }
   if (flags & XmLABEL_RECT)
   {
      if ((lRect.x < minX) || minXUndefined)
         minX = lRect.x;
      if ((lRect.y < minY) || minYUndefined)
         minY = lRect.y;
   }

    XtSetArg (args[0], XmNshadowThickness, &shadowThickness);
    XtSetArg (args[1], XmNmarginWidth, &marginWidth);
    XtSetArg (args[2], XmNmarginHeight, &marginHeight);
    XtGetValues (w, args, 3);

    if (flags & XmPIXMAP_RECT)
       XFillRectangle(dpy, dragMask, fillGC,
                      pRect.x - minX + shadowThickness + marginWidth,
                      pRect.y - minY + shadowThickness + marginHeight,
                      pRect.width - 2*marginWidth,
                      pRect.height - 2*marginHeight);
    if (flags & XmLABEL_RECT)
    {
      XFillRectangle(dpy, dragMask, fillGC,
                     lRect.x - minX + shadowThickness + marginWidth,
                     lRect.y - minY + shadowThickness + marginHeight,
                     lRect.width - 2*marginWidth,
                     lRect.height - 2*marginHeight);
    }
    XFreeGC(dpy, fillGC);

    return (dragMask);
}

static Widget
GetDragIcon(
        Widget w,
        FileViewData * fileViewData )
{
   XmManagerWidget mw = (XmManagerWidget) XtParent(w);
   Widget screen_object = (Widget) XmGetXmScreen(XtScreenOfObject(w));
   Arg args[11];
   register int n;
   unsigned int wid, hei, d, junk;
   Widget dragIcon;
   Pixmap dragPixmap;
   Pixmap dragMask;

   dragPixmap = _DtIconDraw (w, 0, 0, 0, False);

   XGetGeometry (XtDisplay(w), dragPixmap,
                 (Window *) &junk,             /* returned root window */
                 (int *) &junk, (int *) &junk, /* x, y of pixmap */
                 &wid, &hei,                   /* width, height of pixmap */
                 &junk,                        /* border width */
                 &d);                          /* depth */

   if (initiating_view
       && ((FileMgrData *)initiating_view)->view == BY_ATTRIBUTES)
   {
     XmFontList fontList;
     XmString fileNameString;
     DtIconGadget g = (DtIconGadget)w;


     XtSetArg( args[0], XmNfontList, &fontList );
     XtGetValues( fileViewData->widget, args, 1 );

     fileNameString = XmStringCreateLocalized( fileViewData->file_data->file_name );
     wid = XmStringWidth( fontList, fileNameString )
           + g->icon.pixmap_width
           + g->icon.cache->margin_width
           + g->icon.cache->spacing
           + G_ShadowThickness(g)
           + G_HighlightThickness(g);
     XmStringFree( fileNameString );
   }

   dragMask = GetDragIconMask(w, wid, hei);

   n = 0 ;
   XtSetArg(args[n], XmNhotX, 0);  n++;
   XtSetArg(args[n], XmNhotY, 0);  n++;
   XtSetArg(args[n], XmNwidth, wid);  n++;
   XtSetArg(args[n], XmNheight, hei);  n++;
   XtSetArg(args[n], XmNmaxWidth, wid);  n++;
   XtSetArg(args[n], XmNmaxHeight, hei);  n++;
   XtSetArg(args[n], XmNdepth, d);  n++;
   XtSetArg(args[n], XmNpixmap, dragPixmap);  n++;
   XtSetArg(args[n], XmNmask, dragMask);  n++;
   XtSetArg(args[n], XmNforeground, mw->core.background_pixel);  n++;
   XtSetArg(args[n], XmNbackground, mw->manager.foreground);  n++;
   dragIcon = XtCreateWidget("drag_icon", xmDragIconObjectClass,
                             screen_object, args, n);

   return(dragIcon);
}



/* The following function is called if the completeMove flag is   */
/* set to TRUE. Internally, dtfile sets this to FALSE; thus, only */
/* receiving clients that set this to true will get this function */
/* called for them.                                               */
/* This function will delete the files/dirs that were dropped     */
/* on the receiving client.                                       */

static void
NewConvertDelete(
        Widget w,
        FileViewData * fileViewData,
        char ** fileList,
        int numFiles)
{
      static char *pname = "NewConvertDelete";
      int     i;
      int     child_pid = 0;

      DPRINTF(("%s: Entering function\n", pname));

      /* fork a background child process to honor the Move Completion */
       child_pid = fork();

       if (child_pid == -1)
       {
	    char *msg, *tmpStr, *title;

	    DBGFORK(("%s: Cannot create child process\n", pname));

	    tmpStr = GETMESSAGE(11,59, 
			"Cannot create a child process to delete the dropped files.");
	    msg = XtNewString(tmpStr);
	    title = XtNewString((GETMESSAGE(11,58,"Process Create Error")));

	   /* Display Error message */
	    _DtMessage(toplevel, title, msg, NULL, HelpRequestCB);
	    XtFree(msg);
	    XtFree(title);
	    return;
       }


       /* In the Child Process, we simply erase the files   */
       /* and directories that were dropped on the receiver */
       if (child_pid == 0)
       {
	    DBGFORK(("%s:  child forked\n", pname));

	    for (i = 0; i < numFiles; i++)
	    {
	     DPRINTF(("%s: Erasing file %s\n", pname, fileList[i]));
	     EraseObject(fileList[i]);
	    }

	    DBGFORK(("%s:  child exiting\n", pname));

            exit(0);
       }

       DBGFORK(("%s:  forked child<%d>\n", pname, child_pid));

}


static void
NewConvertFileName(
        Widget w,
        FileViewData * fileViewData,
        char ** fileList,
        Cardinal *numFiles)
{
   FileMgrData * fileMgrData;
   DesktopRec * desktopRec;
   int selectedCount;
   int dt, i, count;
   char * directoryName;
   char * fileName;
   char * path;

   if(fileViewData != NULL)
   {
      (void)IsDesktopPtr(fileViewData, &fileMgrData, &desktopRec);
      selectedCount = GetSelectedCount(fileViewData, fileMgrData, desktopRec, &dt);
   }
   else
   {
      /* If fileViewData is NULL, then the file no long exists */
      fileMgrData = (FileMgrData *)initiating_view;
      desktopRec = NULL;
      if(fileMgrData)
	selectedCount = fileMgrData->selected_file_count;
      else
        selectedCount = 0;
   }

   if (selectedCount > 1)
   {
      for (i = (selectedCount-1); i >= 0; i--)
      {
         if (desktopRec)
         {
            fileViewData = desktop_data->workspaceData[dt]->
                                 selectedDTWindows[i]->file_view_data;
            directoryName = desktop_data->workspaceData[dt]->
                                 selectedDTWindows[i]->dir_linked_to;
            fileName = fileViewData->file_data->file_name;
         }
         else
         {
            fileViewData = fileMgrData->selection_list[i];
            directoryName = ((DirectorySet *)fileViewData->directory_set)->name;
            fileName = fileViewData->file_data->file_name;
         }
         path = (char *)XtMalloc(strlen(directoryName) + strlen(fileName) + 2);
         sprintf(path,"%s/%s", directoryName, fileName);

         if ((!desktopRec) && (fileMgrData->toolbox))
            path = _DtResolveAppManPath(path,
                                        fileMgrData->restricted_directory);

         fileList[i] = DtEliminateDots(path);
      }
   *numFiles = selectedCount;
   }
   else
   {
      if (desktopRec)
      {
         directoryName = desktopRec->dir_linked_to;
         fileName = fileViewData->file_data->file_name;
      }
      else if(fileViewData)
      {
         directoryName = ((DirectorySet *)fileViewData->directory_set)->name;
         fileName = fileViewData->file_data->file_name;
      }
      else
      {
         directoryName = fileMgrData->current_directory;
         fileName = NULL;
      }
      path = (char *)XtMalloc(strlen(directoryName) + strlen(fileName) + 2);
      sprintf(path,"%s/%s", directoryName, fileName);

      if ((!desktopRec) && (fileMgrData->toolbox))
         path = _DtResolveAppManPath(path, fileMgrData->restricted_directory);

      fileList[0] = DtEliminateDots( path );
      *numFiles = 1;
   }

#ifdef DEBUG
   if (debug)
   {
     printf("NewConvertFileName: returns %d files\n", selectedCount);
     for (i = 0; i < selectedCount; i++) {
       printf("\t\"%s\"\n", fileList[i]);
     }
     if (selectedCount == 0)
       printf("\t\"%s\"\n", fileList[0]);
   }
#endif

}

/* ARGSUSED */
static void
FileConvertCB(
        Widget w,
        XtPointer client,
        XtPointer call)
{
    FileViewData * fileViewData = (FileViewData *) client;
    DtDndConvertCallback cb = (DtDndConvertCallback) call;
    FileMgrData *fmd = (FileMgrData *)initiating_view;

    if(fmd)
    {
       fileViewData = fmd->drag_file_view_data;
       fmd->drag_file_view_data = NULL;
    }
    if (cb->reason == DtCR_DND_CONVERT_DATA)
    {
       if(fmd && !fmd->selected_file_count && fileViewData == NULL)
       {
	   cb->status = DtDND_FAILURE;
	   cb->dragData->numItems = 0; /* Just to be on safe side */
	   return;
       }
       NewConvertFileName(w, fileViewData,
                       cb->dragData->data.files, &cb->dragData->numItems);
    } else if (cb->reason == DtCR_DND_CONVERT_DELETE)
    {
       NewConvertDelete(w, fileViewData,
                       cb->dragData->data.files, cb->dragData->numItems);
    }
}


/* This callback procedure removes the icons when the drop is complete */
/* ARGSUSED */
static void
DragFinishCB(Widget w, XtPointer client, XtPointer call)
{
   DtDndDragFinishCallback cb = (DtDndDragFinishCallback) call;
   int                  i;
   static Window root = 0;

   DPRINTF(("DragFinishCB: dragActive -> False\n"));

   dragActive = False;
   initialDragX = -1;
   initialDragY = -1;
   B1DragPossible = False;
   B2DragPossible = False;
   ProcessBtnUp = False;

   if (cb->sourceIcon)
      XtDestroyWidget(cb->sourceIcon);

   DPRINTF (("DragFinishCB: Number of items being freed are %d\n",
              cb->dragData->numItems));
   for (i = 0; i < cb->dragData->numItems; i++) {

      DPRINTF(("DragFinishCB: Freeing %s\n", cb->dragData->data.files[i]));
      XtFree(cb->dragData->data.files[i]);
      cb->dragData->data.files[i] = NULL;
   }

}

/* ARGSUSED */
void
StartDrag(
        Widget w,
        FileViewData * fileViewData,
        XEvent * event)
{
   static XtCallbackRec fileConvertCB[] = { {FileConvertCB, NULL},
                                           {NULL, NULL} };
   static XtCallbackRec dragFinishCB[] = { {DragFinishCB, NULL},
                                           {NULL, NULL} };
   static XtCallbackRec dropOnRootCB[] = { {DropOnRootCB, NULL},
                                           {NULL, NULL} };
   Widget drag_icon;
   Arg                  args[2];
   int                  numArgs;
   FileMgrData *        fileMgrData = NULL;
   DesktopRec *         desktopRec = NULL;
   int                  selectedCount;
   int                  dt;
   Boolean              desktopObj;
   unsigned char        operations;

   if (event->type == INVALID_TYPE) return;

   if (fileViewData == NULL) return;

   fileConvertCB[0].closure = (XtPointer)fileViewData;
   dropOnRootCB[0].closure = (XtPointer)fileViewData;

   desktopObj = IsDesktopPtr(fileViewData, &fileMgrData, &desktopRec);
   selectedCount = GetSelectedCount(fileViewData, fileMgrData,
                                    desktopRec, &dt);

   if (selectedCount > 1)
      drag_icon = NULL;
   else
      drag_icon = GetDragIcon(w, fileViewData);

   numArgs = 0;
   XtSetArg(args[numArgs], DtNsourceIcon, drag_icon);                numArgs++;
   XtSetArg(args[numArgs], DtNdropOnRootCallback, dropOnRootCB);     numArgs++;

   if ((desktopObj && desktopRec->toolbox) ||
       (!desktopObj && fileMgrData->toolbox))
     operations = XmDROP_COPY;
   else
     operations = XmDROP_MOVE | XmDROP_COPY | XmDROP_LINK;

   if (DtDndDragStart(w, event, DtDND_FILENAME_TRANSFER, selectedCount,
                        operations,
                        fileConvertCB, dragFinishCB, args, numArgs) == NULL) {
      DPRINTF(("StartDrag: dragActive -> False\n"));

      dragActive = False;
      initialDragX = -1;
      initialDragY = -1;
      B1DragPossible = False;
      B2DragPossible = False;
      ProcessBtnUp = False;
   }
}


/*
 * This function is capable of initiating either a button 1 or button 2
 * drag operation; which one gets started is dependent upon which of the
 * two state flags (B1DragPossible or B2DragPossible) is set.
 */

static void
InitiateIconDrag(
        FileViewData * fileViewData,
        int rootX,
        int rootY,
        XEvent * event )

{
   FileMgrData * fileMgrData;
   DtIconGadget iconG;
   Widget dragIcon;
   char * typeSet;
   char * fileSet;
   char * directoryName;
   Pixmap dragPixmap;
   XRectangle dragMask[2];
   Pixel  bg;
   XRectangle pRect, lRect;
   unsigned char flags;
   int stringSize;
   register int i;
   Arg args[10];
   Boolean allowDropInInitiatingWindow;
   int rectCount;
   int minX, minY;
   Boolean minXUndefined, minYUndefined;
   DesktopRec * desktopRec;
   int btn;
   char * hostName;
   Boolean spaces = False;
   Boolean trash = False;
   char *tmpStr, *link_path, *ptr;

   /* Don't allow multi-drags to start */
   if (dragActive)
   {
      initialDragX = -1;
      initialDragY = -1;
      B1DragPossible = False;
      B2DragPossible = False;
      ProcessBtnUp = False;
      return;
   }
   else
      dragActive = True;

   DPRINTF(("InitiateIconDrag: dragActive -> True\n"));

   dragIcon = fileViewData->widget;
   (void)IsDesktopPtr(fileViewData, &fileMgrData, &desktopRec);

   /* if what we are dragging is a trash item, we want the objects to be
    * real objects, not their links
    */
   if(fileMgrData == trashFileMgrData && trashFileMgrData != NULL)
      trash = True;

   /*
    * We need to mark the icon which initiated the drag as no longer
    * being 'armed', since it will not receive the button up event,
    * because we will have release the drag.
    */
   iconG = (DtIconGadget)dragIcon;
   iconG->icon.armed = False;

   /*
    * Remember the posistion of the icon pixmap within the drag icon.
    */
   dragIconPixmapOffsetX = G_ShadowThickness(iconG) + G_MarginWidth(iconG);
   dragIconPixmapOffsetY = G_ShadowThickness(iconG) + G_MarginHeight(iconG);

   if(desktopRec)
   {
      initiating_view = (XtPointer) NULL;
      widget_dragged = dragIcon;
   }
   else
   {
      initiating_view = (XtPointer) fileMgrData;
      widget_dragged = NULL;
   }
   StartDrag(dragIcon, fileViewData, event);
}


/*
 * These are replacements for the corresponding libXm functions.  They allow
 * us to treat icon gadgets as non-rectangular, so that input processing
 * is handled correctly.
 */

static XmGadget
InputInGadget (
   Widget w,
   register int x,
   register int y)

{
   CompositeWidget cw = (CompositeWidget)w;
   static Region r = NULL;
   FileMgrData * file_mgr_data;
   Boolean simpleCheck = False;
   register int i;
   unsigned char flags;
   XRectangle pRect, lRect;
   register Widget widget;

   file_mgr_data = ReturnDesktopPtr((Widget)cw);

   /*
    * Tree views and attribute views do not have the non-rectangular
    * hotspots, so we can resort to the standard checking algorithm.
    */
   if ((file_mgr_data == NULL) ||
       (file_mgr_data->show_type != SINGLE_DIRECTORY) ||
       (file_mgr_data->view == BY_ATTRIBUTES))
   {
      simpleCheck = True;
   }

   for (i = 0; i < cw->composite.num_children; i++)
   {
      widget = cw->composite.children[i];

      if (XmIsGadget(widget) && XtIsManaged(widget))
      {
         if (simpleCheck)
         {
            if (x >= widget->core.x && y >= widget->core.y &&
              (Position) x < (Position) (widget->core.x + widget->core.width) &&
              (Position) y < (Position) (widget->core.y + widget->core.height))
            {
               return ((XmGadget) widget);
            }
         }
         else
         {
            /* Initialize the region to be empty */
            if (r == NULL)
               r = XCreateRegion();
            else
               XSubtractRegion(r, r, r);

            _DtIconGetIconRects((DtIconGadget)widget, &flags, &pRect, &lRect);

            if (flags & XmPIXMAP_RECT)
               XUnionRectWithRegion(&pRect, r, r);

            if (flags & XmLABEL_RECT)
               XUnionRectWithRegion(&lRect, r, r);

            if (XPointInRegion(r, x, y))
               return ((XmGadget) widget);
         }
      }
   }

   return(NULL);
}


/*
 * This function is identical to the libXm version; it needs to be here
 * so that it will call our InputInGadget() instead of the libXm
 * version, which was bundled together with it in GadgetUtil.c
 */

static XmGadget
InputForGadget (
   Widget cw,
   int x,
   int y)
{
   XmGadget gadget;

   gadget = InputInGadget (cw, x, y);

   if (!gadget  ||  !XtIsSensitive ((Widget)gadget))
   {
      return ((XmGadget) NULL);
   }

   return (gadget);
}


/*
 * This function processes motion events anytime a B1 or B2 drag operation
 * has the potential of starting for a file icon.  When the drag threshold
 * is surpassed, a drag operation will be started.
 */

void
FileIconMotion(
               Widget w,
               XtPointer clientData,
               XEvent *event)
{
   int diffX, diffY;
   FileViewData * fileViewData = NULL;
   Position rootX, rootY;
   DirectorySet * directoryData = NULL;
   Arg args[10];
   int i;
   Widget dragIcon;

   if ((B1DragPossible && (event->xmotion.state & Button1Mask)) ||
       (B2DragPossible && (event->xmotion.state & Button2Mask)))
   {
      /* Have we passed the drag threshold? */
      diffX = initialDragX - event->xmotion.x;
      diffY = initialDragY - event->xmotion.y;

      if ((ABS(diffX) >= dragThreshold) || (ABS(diffY) >= dragThreshold))
      {
         /* Map the original (x,y) into a gadget Id */
         if (dragIcon =(Widget)InputForGadget(w, initialDragX, initialDragY))
         {
            /* Map the icon into its fileViewData structure */
            /* Check for desktop icon first */
            for (i = 0, fileViewData = NULL; i<desktop_data->numIconsUsed; i++)
            {
               if (desktop_data->desktopWindows[i]->iconGadget == dragIcon)
               {
                 fileViewData = desktop_data->desktopWindows[i]->file_view_data;
                 break;
               }
            }
            if (fileViewData == NULL)
            {
               /* Not a desktop icon */
               XtSetArg(args[0], XmNuserData, (XtPointer) &directoryData);
               XtGetValues(dragIcon, args, 1);
               for (i = 0; i < directoryData->file_count; i++)
               {
                  if (directoryData->file_view_data[i]->widget == dragIcon &&
                             directoryData->file_view_data[i]->displayed)
                  {
                     fileViewData = directoryData->file_view_data[i];
                     break;
                  }
               }
            }


            /* Map to root coordinates */
            XtTranslateCoords(w, (Position)initialDragX, (Position)initialDragY,
                              &rootX, &rootY);

	       if(directoryData)
	       {
	         FileMgrData *fmd;
	         fmd = (FileMgrData *)(directoryData->file_mgr_data);
	         if(fmd)
		      fmd->drag_file_view_data = fileViewData;
	       }
             InitiateIconDrag(fileViewData, (int)rootX, (int)rootY, event);
         }
         else
         {
            /*
             * The file manager view must have changed between the time
             * the user did the button down, and the time they moved
             * enough to pass the drag threshold, because there is now
             * no icon located where the drag initiated.  Therefore,
             * we'll just clean up, because there is much else we can do.
             */
            B1DragPossible = False;
            B2DragPossible = False;
            ProcessBtnUp = False;
         }

         /* Force the button up to be ignored */
         initialDragX = -1;
         initialDragY = -1;
      }
   }
}


/* Compute position of desktop icon shell for given a drop position */
static void
PositionDesktopIcon(
   int drop_x,
   int drop_y,
   int *root_x,
   int *root_y)

{
  int pixmap_offset_x;
  int pixmap_offset_y;
  DtIconGadget g;

  /*
   * We want to position the shell, so that the icon pixmap in the icon
   * gadget will appear at the same spot that the icon pixmap of the drag
   * cursor was when the drop occurred.
   */

  /* First we caculate the top left corner of the drag pixmap by adding
   * the offset of the pixmap within the drag icon to the drop position. */
  drop_x += dragIconPixmapOffsetX;
  drop_y += dragIconPixmapOffsetY;

  /* In order to calculate the correct position of the dektop icon shell
   * such that the pixmap within the icon gadget will end up at the desired
   * position, we need to know the offset of the gadget's icon pixmap relative
   * to the desktop icon shell.
   *   Since a desktop icon consists a frame widget, a drawing area and an
   * icon gadget (all within a popup shell), this offset is computed by adding
   * the frame width and and drawing area margins to the icon gadget's
   * highlight thickness.
   *   The frame width is 3 and and and the drawing area margin width is 1
   * (both hardcoded in Desktop.c).  We determine the remaining components
   * by looking at one of the existing desktop icon gadgets. */
  if (desktop_data != NULL &&
      desktop_data->numIconsUsed + desktop_data->numCachedIcons > 0)
  {
     g = (DtIconGadget) desktop_data->desktopWindows[0]->iconGadget;
     pixmap_offset_x =
      pixmap_offset_y = 3 + 1 + G_HighlightThickness(g) + G_ShadowThickness(g);
     pixmap_offset_x += G_MarginWidth(g);
     pixmap_offset_y += G_MarginHeight(g);
  }
  else
  {
     /* don't have an icon gadget; assume default values */
     pixmap_offset_x = pixmap_offset_y = 3 + 1 + 2 + 2 + 2;
  }

  /* Finally, calculate the position of the dektop icon shell by
   * subtracting the offset of the gadget's icon pixmap from the
   * desired pixmap position */
  *root_x = drop_x - pixmap_offset_x;
  *root_y = drop_y - pixmap_offset_y;
}


/* Code to reposition a desktop icon after a drag */

static void
RelocateDesktopIcon(
   DesktopRec * desktopRec,
   int root_x,
   int root_y)

{
   Widget pu_shell;
   Dimension width, height;
   Arg args[10];
   XSizeHints wmSizeHints;

   pu_shell = desktopRec->shell;


   XtSetArg (args[0], XmNwidth, &width);
   XtSetArg (args[1], XmNheight, &height);
   XtGetValues(pu_shell, args, 2);

   RegisterInGrid((int)width, (int)height,
                  desktopRec->root_x,
                  desktopRec->root_y,
                  desktopRec->workspace_num,
                  False);

   XtSetArg (args[0], XmNx, root_x);
   XtSetArg (args[1], XmNy, root_y);

   XtSetValues (pu_shell, args, 2);
   XRaiseWindow(XtDisplay(pu_shell), XtWindow(pu_shell));
   XSync(XtDisplay(pu_shell), False);

   RegisterInGrid((int)width, (int)height, root_x, root_y,
                  desktopRec->workspace_num, True);

   desktopRec->root_x = root_x;
   desktopRec->root_y = root_y;
   SaveDesktopInfo(NORMAL_RESTORE);
}


/************************************************************************
 *
 *  FileIsSelected
 *      Loop through the file selection list to see if the specified
 *      file is selected.
 *
 ************************************************************************/

Boolean
FileIsSelected(
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data )
{
   return file_view_data->selected;
}




/************************************************************************
 *
 *  SetFileSelected
 *      Display the icon representing file_data as selected.
 *
 ************************************************************************/

static void
SetFileSelected(
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data )
{
   /* mark selected */
   file_view_data->selected = True;

   /* if this file has an up-to-date gadget, change its colors */
   if (!file_view_data->need_update)
   {
      if (file_view_data->file_data->link == NULL)
         SetToSelectColors (file_view_data->widget,
              (Widget)((FileMgrRec *)file_mgr_data->file_mgr_rec)->file_window,
              0);
      else
         SetToSelectColors (file_view_data->widget,
              (Widget)((FileMgrRec *)file_mgr_data->file_mgr_rec)->file_window,
              LINK_FILE);
      if (PositioningEnabledInView(file_mgr_data))
         RedrawOneGadget(file_view_data->widget, NULL, NULL);
   }
}

/************************************************************************
 *
 *  SetFileUnselected
 *      Display the icon representing file_data as not selected.
 *
 ************************************************************************/

static void
SetFileUnselected(
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data )
{
   /* mark selected */
   file_view_data->selected = False;

   /* if this file has an up-to-date gadget, change its colors */
   if (!file_view_data->need_update)
   {
      if (file_view_data->file_data->link != NULL)
         SetToNormalColors (file_view_data->widget,
                    ((FileMgrRec *)(file_mgr_data->file_mgr_rec))->file_window,
                    ((FileMgrRec *)(file_mgr_data->file_mgr_rec))->main,
                    LINK_FILE);
      else
         SetToNormalColors (file_view_data->widget,
                    ((FileMgrRec *)(file_mgr_data->file_mgr_rec))->file_window,
                    ((FileMgrRec *)(file_mgr_data->file_mgr_rec))->main,
                    0);

      if (PositioningEnabledInView(file_mgr_data))
         RedrawOneGadget(file_view_data->widget, NULL, NULL);
   }
}

/************************************************************************
 *
 *  SelectFile
 *      Add the file to the selection list.
 *
 ************************************************************************/

void
SelectFile(
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data )
{
   int selection_count;
   int i;

   /* Add to the front of the selection list */
   selection_count = file_mgr_data->selected_file_count;
   file_mgr_data->selected_file_count++;

   file_mgr_data->selection_list = (FileViewData **)
      XtRealloc ((char *) file_mgr_data->selection_list,
                 sizeof(FileViewData *) * (selection_count + 2));

   for (i = file_mgr_data->selected_file_count; i > 0; i--)
      file_mgr_data->selection_list[i] = file_mgr_data->selection_list[i-1];

   file_mgr_data->selection_list[0] = file_view_data;

   /* mark selected */
   SetFileSelected(file_mgr_data, file_view_data);
}




/************************************************************************
 *
 *  DeselectFile
 *      Remove the file from the selection list.
 *
 ************************************************************************/

void
DeselectFile(
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data,
        Boolean valid)
{
   int selection_count;
   register int i;
   register int j;


   selection_count = file_mgr_data->selected_file_count;
   file_mgr_data->selected_file_count--;

   for (i = 0; i < selection_count; i++)
      if (file_mgr_data->selection_list[i] == file_view_data)
         break;

   for (j = i; j < selection_count - 1; j++)
      file_mgr_data->selection_list[j] = file_mgr_data->selection_list[j + 1];

   file_mgr_data->selection_list = (FileViewData **)
      XtRealloc ((char *) file_mgr_data->selection_list,
                  sizeof(FileViewData *) * selection_count);
   file_mgr_data->selection_list[selection_count - 1] = NULL;

   if (valid)
     SetFileUnselected(file_mgr_data, file_view_data);
   else
     file_view_data->selected = False;
}




/************************************************************************
 *
 *  DeselectAllFiles
 *      Unselect all of the selected icons within the file manager data
 *
 ************************************************************************/

void
DeselectAllFiles(
        FileMgrData *file_mgr_data )
{
   FileViewData * file_view_data;
   register int i, j, k;
   ObjectPtr bottom;
   FileViewData ** repaint_list;


   /*  Get the color to reset the icons.  */

   /*  Loop through the selection set, resetting the visuals for  */
   /*  each selected icon.                                        */

   if (!PositioningEnabledInView(file_mgr_data))
   {
      for (i = 0; i < file_mgr_data->selected_file_count; i++)
      {
         file_view_data = file_mgr_data->selection_list[i];
         SetFileUnselected(file_mgr_data, file_view_data);
      }
   }
   else if (file_mgr_data->selected_file_count > 0)
   {
      /*
       * We can't simply redraw the selected files; we must also redraw
       * any unselected files which are higher on the stacking order.
       */

      repaint_list = (FileViewData **)XtMalloc(sizeof(FileViewData *) *
                     file_mgr_data->selected_file_count);

      /* Order the objects to be unselected */
      for (i = 0; i < file_mgr_data->selected_file_count; i++)
      {
         file_view_data = file_mgr_data->selection_list[i];
         for (j = 0; j < i; j++)
         {
            if (file_view_data->position_info->stacking_order <
                repaint_list[j]->position_info->stacking_order)
            {
               /* Insert here, pushing down all lower entries */
               for (k = file_mgr_data->selected_file_count - 1; k > j; k--)
                  repaint_list[k] = repaint_list[k-1];

               repaint_list[j] = file_view_data;
               break;
            }
         }

         /* Insert at end, if necessary */
         if (j >= i)
            repaint_list[i] = file_view_data;
      }

      /* Start the redraw process */
      i = file_mgr_data->selected_file_count - 1;
      bottom = repaint_list[i]->position_info;

      while(bottom)
      {
         if ((i >= 0) && (bottom == repaint_list[i]->position_info))
         {
            /* Unselect this object */
            SetFileUnselected(file_mgr_data, bottom->file_view_data);
            i--;
         }
         if(bottom->file_view_data != NULL &&
            !bottom->file_view_data->need_update)
         {
            RedrawOneGadget(bottom->file_view_data->widget, NULL, NULL);
         }
         bottom = bottom->prev;
      }

      XtFree((char *)repaint_list);
      repaint_list = NULL;
   }

   if (file_mgr_data->selection_list != NULL)
   {
      XtFree ((char *) file_mgr_data->selection_list);
      file_mgr_data->selection_list = NULL;
   }

   file_mgr_data->selection_list =
      (FileViewData **) XtMalloc (sizeof (FileViewData *));
   file_mgr_data->selection_list[0] = NULL;
   file_mgr_data->selected_file_count = 0;

}




/************************************************************************
 *
 *  SelectAllFiles
 *      Select all of the files within the file manager data.
 *
 ************************************************************************/

void
SelectAllFiles(
        FileMgrData *file_mgr_data )
{
   DirectorySet * directory_data;
   FileViewData ** order_list;
   int directory_count;
   int selection_count;
   register int i;
   register int j;
   ObjectPtr top;
   FileViewData ** selection_list;


   if (PositioningEnabledInView(file_mgr_data))
   {
      /* Force selection list order to match stacking order */
      selection_list = (FileViewData **)XtMalloc(sizeof(FileViewData *) *
             (file_mgr_data->num_objects));

      top = GetTopOfStack(file_mgr_data);
      selection_count = 0;
      for (i = 0; i < file_mgr_data->num_objects; i++)
      {
         /* If the there isn't file_view_data for it
            Or if it's a parent folder (..go up)
            Don't bother to select them
         */
         if( top->file_view_data != NULL
             && strcmp( top->name, ".." ) != 0 )
         {
           selection_list[selection_count] = top->file_view_data;
           ++selection_count;
         }
         top = top->next;
      }
      selection_list[selection_count] = NULL;

      /* Force redraw in bottom to top order */
      for (i = selection_count - 1; i >= 0; i--)
      {
         if (!FileIsSelected(file_mgr_data, selection_list[i]))
            SetFileSelected(file_mgr_data, selection_list[i]);
         }

      /* Free old selection list, and save new one */
      XtFree ((char *) file_mgr_data->selection_list);
      file_mgr_data->selection_list = selection_list;
   }
   else
   {
      /*  Free up any current selection and get the selection color.  */

      if (file_mgr_data->selection_list != NULL)
      {
        DeselectAllFiles( file_mgr_data );
      }

      if (file_mgr_data->show_type == SINGLE_DIRECTORY)
         directory_count = 1;
      else
         directory_count = file_mgr_data->directory_count;


      /*  Loop through the set of directories checking each file view   */
      /*  structure to see if the icon is filtered.  If not, select it  */
      /*  and increment the selection count.                            */

      selection_count = 0;

      /* For tree mode the index has to be -1 */

      i = (file_mgr_data->show_type == MULTIPLE_DIRECTORY)?-1:0;
      for (; i < directory_count; i++)
      {
         directory_data = file_mgr_data->directory_set[i];
         order_list = directory_data->order_list;

         for (j = 0; j < directory_data->file_count; j++)
         {
            /* If the file is being filtered out
               Or if it's a parent folder (..go up)
               Don't bother to select them
            */
            if (order_list[j]->filtered == True
                || strcmp( order_list[j]->file_data->file_name, ".." ) == 0 )
               continue;

            selection_count++;

            file_mgr_data->selection_list = (FileViewData **)
                XtRealloc ((char *) file_mgr_data->selection_list,
                           sizeof(FileViewData *) * (selection_count + 1));

            file_mgr_data->selection_list[selection_count] = NULL;
            file_mgr_data->selection_list[selection_count - 1] = order_list[j];
            SetFileSelected(file_mgr_data, order_list[j]);
         }
      }
   }

   file_mgr_data->selected_file_count = selection_count;

   if(file_mgr_data != trashFileMgrData)
   {
      if (selection_count == 0)
         ActivateNoSelect ((FileMgrRec *)file_mgr_data->file_mgr_rec);
      else if (selection_count == 1)
      {
         ActivateSingleSelect ((FileMgrRec *)file_mgr_data->file_mgr_rec,
                    file_mgr_data->selection_list[0]->file_data->logical_type);
      }
      else
         ActivateMultipleSelect ((FileMgrRec *)file_mgr_data->file_mgr_rec);
   }
}




/************************************************************************
 *
 *  SetToSelectColors
 *      Set a single icon widget to selected colors.
 *
 ************************************************************************/

void
SetToSelectColors(
        Widget widget,
        Widget file_window,
        int type)
{
   int j;
   Pixel background_color;
   Arg args[3];


   /*  Get the select color to be used as the background of  */
   /*  the icon gadgets.                                     */

   j = 0;
   XtSetArg (args[j], XmNbackground, &background_color); j++;
   XtGetValues (file_window, args, j);

   j = 0;
   if (background_color == white_pixel)
   {
      XtSetArg (args[j], XmNbackground, black_pixel); j++;
      XtSetArg (args[j], XmNforeground, white_pixel); j++;
   }
   else if (background_color == black_pixel)
   {
      XtSetArg (args[j], XmNbackground, white_pixel); j++;
      XtSetArg (args[j], XmNforeground, black_pixel); j++;
   }
   else
   {
      XtSetArg (args[j], XmNbackground, white_pixel); j++;
      XtSetArg (args[j], XmNforeground, black_pixel); j++;
   }

   XtSetValues (widget, args, j);
}

/************************************************************************
 *
 *  SetToNormalColors
 *      Set a single icon widget to normal colors.
 *
 ************************************************************************/

void
SetToNormalColors(
        Widget widget,
        Widget bg_fg_colors,
        Widget top_shadow_colors,
        int type)
{
   int j;
   Pixel  background_color;
   Pixel  foreground_color;
   Pixel  pixmap_background;
   DtIconGadget new = (DtIconGadget)widget;
   Arg args[5];

   /*  Get the colors to be used for drawing the icons  */

   j = 0;
   XtSetArg (args[j], XmNbackground, &background_color); j++;
   XtSetArg (args[j], XmNforeground, &foreground_color); j++;
   XtGetValues (bg_fg_colors, args, j);

   j = 0;
   XtSetArg (args[j], XmNtopShadowColor, &pixmap_background); j++;
   XtGetValues (top_shadow_colors, args, j);

   j = 0;
#ifdef _SHOW_LINK
   if(type == LINK_FILE)
      XtSetArg (args[j], XmNforeground, pixmap_background); j++;
   else
#endif
      XtSetArg (args[j], XmNforeground, foreground_color); j++;

   if (background_color == white_pixel)
   {
       XtSetArg (args[j], XmNbackground, white_pixel); j++;
   }
   else if (background_color == black_pixel)
   {
       XtSetArg (args[j], XmNbackground, black_pixel); j++;
   }
   else
   {
       XtSetArg (args[j], XmNbackground, background_color); j++;
   }

   /* we want to make sure the armed value is off so that it will get
      the correct GC */
   if(new->icon.armed == True)
   {
      new->icon.armed = False;
   }

   XtSetValues (widget, args, j);
}


/*
 * When a text widget is destroyed, we need to free up the string we
 * attached as userData.
 */

void
DestroyIconName (
   Widget w,
   XtPointer client_data,
   XtPointer call_data)
{
   char * str;
   Arg args[1];

   XtSetArg(args[0], XmNuserData, &str);
   XtGetValues(w, args, 1);
   XtFree(str);
}


int
#ifdef _NO_PROTO
GetInsertPosition( x1, x2, fontList, name )
   int x1;
   int x2;
   XmFontList fontList;
   char * name;
#else
GetInsertPosition( int x1, int x2, XmFontList fontList, char * name )
#endif
{
  int i, width, stringWidth;
  char * tmp;
  char savedChar;
#ifdef MULTIBYTE
  int len;
#endif /* MULTIBYTE */

  width = x2 - x1;

#ifdef MULTIBYTE
  i = 0;
  tmp = name;
  while ((len = mblen(tmp, MB_CUR_MAX)) > 0)
#else /* MULTIBYTE */
  for( tmp = name + 1, i = 0;
       *tmp != 0x0;
       ++tmp, ++i )
#endif /* MULTIBYTE */
  {
    XmString string;

#ifdef MULTIBYTE
    tmp += len;
#endif /* MULTIBYTE */

    savedChar = *tmp;
    *tmp = 0x0;
    string = XmStringCreateLocalized( name );
    stringWidth = XmStringWidth( fontList, string );
    XmStringFree( string );
    *tmp = savedChar;
    if( stringWidth > width )
      break;
#ifdef MULTIBYTE
    else
      i++;
#endif /* MULTIBYTE */
  }

  return( i );
}

void
CreateNameChangeDialog (
   Widget w,
   FileViewData *file_view_data,
   XtPointer client_data,
   int type)
{
   XRectangle textExtent;
   FileMgrData * file_mgr_data;
   DesktopRec * desktopWindow;
   Widget parent = XtParent(w);
   Widget text;
   Arg args[8];
   int n;
   Position x, y;
   Widget frame, shell;
   Dimension fHeight, sHeight;
#ifdef SHAPE
   Dimension tWidth, tHeight;
#endif
   char * name;
   XtTranslations trans_table;
   XmFontList fontList;
   Dimension stringWidth;
   XmString fileNameString;
   char tmpBuf[MAX_PATH];

   _DtIconGetTextExtent_r(w, &textExtent);

   if(type == DESKTOP)
   {
      char buf[MAXPATHLEN];

      desktopWindow = (DesktopRec *)client_data;
      if(desktopWindow->text != NULL)
         return;

      sprintf( buf, "%s:%s", home_host_name, root_title );

      /*
       * If the object is on the DESKTOP and its name is root_title, then
       * the user can't rename it.
       */
      if( strcmp( buf, desktopWindow->title ) == 0
          && strcmp( desktopWindow->dir_linked_to, "/" ) == 0
          && strcmp( desktopWindow->file_name, "." ) == 0 )
        return;
   }
   else
      file_mgr_data = (FileMgrData *)client_data;

   /* if the object is in the trash, can't rename it */
   if( type != DESKTOP
       && file_mgr_data == trashFileMgrData )
      return;

   /* if the object is an action, can't rename it */
   if( DtDtsDataTypeIsAction( file_view_data->file_data->logical_type ) )
   {
     char *tmpStr, *title, *msg;

     tmpStr = GETMESSAGE(10, 39, "Rename error");
     title = XtNewString(tmpStr);
     tmpStr = GETMESSAGE(10, 40, "This object is an Action.\nAction icon labels cannot be directly renamed." );
     msg = XtNewString(tmpStr);

     _DtMessage(toplevel, title, msg, NULL, HelpRequestCB);
     XtFree(title);
     XtFree(msg);
     return;
   }
   else if(file_view_data->file_data->action_name)
   {
     char *tmpStr, *title, *msg;

     tmpStr = GETMESSAGE(10, 39, "Rename error");
     title = XtNewString(tmpStr);
     tmpStr = GETMESSAGE(11, 32, "Cannot rename %s");
     msg = XtMalloc(strlen(tmpStr)+strlen(file_view_data->file_data->
                  action_name) +1);
     sprintf(msg,tmpStr,file_view_data->file_data->action_name);

     _DtMessage(toplevel, title, msg, NULL, HelpRequestCB);
     XtFree(title);
     XtFree(msg);
     return;
   }

   /*
    * The selected objects name is attached as 'userData' to text field,
    * to aid us in mapping back to the original object later.
    */
   if( type == DESKTOP &&
       ( (strcmp(".", file_view_data->file_data->file_name) == 0)
         || strcmp("..", file_view_data->file_data->file_name) == 0) )
   {
      name = XtNewString(desktopWindow->file_name);
   }
   else if ( strcmp(".", file_view_data->file_data->file_name) == 0 ||
             strcmp("..", file_view_data->file_data->file_name) == 0 )
   {
      return;
   }
   else
      name = XtNewString(file_view_data->file_data->file_name);

   /* set up translations in main edit widget */
   trans_table = XtParseTranslationTable(translations_escape);

   /* We need to set the width of the text widget.
      Can't use XmNcolumns because of the double-byte.
   */
   {
     XtSetArg( args[0], XmNfontList, &fontList );
     XtGetValues( file_view_data->widget, args, 1 );

     sprintf( tmpBuf, "%s    ", file_view_data->file_data->file_name );
     fileNameString = XmStringCreateLocalized( tmpBuf );
     stringWidth = XmStringWidth( fontList, fileNameString );
     XmStringFree( fileNameString );

     n = 0;
     XtSetArg(args[n], XmNuserData, name);                   n++;
     XtSetArg(args[n], XmNmarginHeight, 0);                  n++;
     XtSetArg(args[n], XmNmarginWidth, 0);                   n++;
     XtSetArg(args[n], XmNvalue, name);                      n++;
     XtSetArg(args[n], XmNwidth, stringWidth);               n++;
   }

   if(type == DESKTOP)
   {
      text = XmCreateTextField(parent, "nameChangeT_DT", args, n);
      XtAddCallback (text, XmNactivateCallback, ChangeIconNameDT,
                                                 (XtPointer)desktopWindow);
      XtAddCallback(text, XmNhelpCallback, (XtCallbackProc)DTHelpRequestCB,
                    HELP_NAMECHANGE_DIALOG_STR);
      desktopWindow->text = text;

      frame = XtParent(parent);
      shell = XtParent(frame);
      XtSetArg(args[0], XmNheight, &fHeight);
      XtGetValues(frame, args, 1);
      XtSetArg(args[0], XmNheight, &sHeight);
      XtGetValues(shell, args, 1);
   }
   else
   {
      text = XmCreateTextField(parent, "nameChangeT", args, n);
      file_mgr_data->renaming = file_view_data;
      XtAddCallback (text, XmNmotionVerifyCallback,
                     (XtCallbackProc)ChangeIconName,
                     (XtPointer)file_mgr_data);
      XtAddCallback (text, XmNmodifyVerifyCallback,
                     (XtCallbackProc)ChangeIconName,
                     (XtPointer)file_mgr_data);
      XtAddCallback (text, XmNactivateCallback,
                     (XtCallbackProc)ChangeIconName,
                     (XtPointer)file_mgr_data);
      XtAddCallback(text, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
                    HELP_NAMECHANGE_DIALOG_STR);
   }

   XtAddCallback (text, XmNdestroyCallback, DestroyIconName, (XtPointer)NULL);

   /* set up translations in main edit widget */
   XtOverrideTranslations(text, trans_table);

   if(type == DESKTOP && sHeight > fHeight) {
       /* status area has been attached in multi-byte case */
       x = 0;
       y = textExtent.y;
   }
   else {
       x = textExtent.x;
       y = textExtent.y - (Dimension)(text->core.height - textExtent.height);
   }

   {
     Window rootWindow, childWindow;
     int pX, pY, rootX, rootY, insertPosition;
     unsigned int mask;

     XQueryPointer( XtDisplay( parent ), XtWindow( file_view_data->widget ),
                    &rootWindow, &childWindow, &rootX, &rootY, &pX, &pY,
                    &mask );
     if( pX == 0 )
       insertPosition = strlen( name );
     else
     {
       if( type != DESKTOP )
       {
         if( pX > (int) x && pX < (int) x + (int) stringWidth )
           insertPosition = GetInsertPosition( x, pX, fontList, name );
         else
           insertPosition = strlen( name );
       }
       else
         insertPosition = GetInsertPosition( x, x + pX, fontList, name );
     }
     n = 0;
     XtSetArg( args[n], XmNcursorPosition, insertPosition);     n++;
     XtSetArg( args[n], XmNx, x);                               n++;
     XtSetArg( args[n], XmNy, y);                               n++;
     XtSetValues (text, args, n);
   }

#ifdef SHAPE
   if(shapeExtension)
      if(type == DESKTOP)
      {
         Dimension shadowThickness;
         XRectangle rect[2];
         unsigned char flags;

         XtSetArg (args[0], XmNwidth, &tWidth);
         XtSetArg (args[1], XmNheight, &tHeight);
         XtGetValues (text, args, 2);

         XtSetArg (args[0], XmNshadowThickness, &shadowThickness);
         XtGetValues (desktopWindow->iconGadget, args, 1);

         _DtIconGetIconRects((DtIconGadget)desktopWindow->iconGadget,
                                                &flags, &rect[0], &rect[1]);
        /* 1 */
         rect[0].x += 1;
         rect[0].y += 1;
         rect[0].width += 2*shadowThickness;
         rect[0].height += 2*shadowThickness;

        /* 2 */
         if(type == DESKTOP && sHeight > fHeight) {
             /* status area has been attached in multi-byte case */
             rect[1].x = x + 1;
             rect[1].y = y + 1;
             rect[1].width = 2*shadowThickness + tWidth;
             rect[1].height = sHeight - y - 1;
         }
         else {
             rect[1].x += 1;
             rect[1].y += 1;
             rect[1].width = shadowThickness + tWidth;
             rect[1].height = tHeight;
         }

         if(rect[0].width > rect[1].width)
           rect[1].width = rect[0].width;

         XShapeCombineRectangles(XtDisplay(desktopWindow->shell),
                                 XtWindow(desktopWindow->shell),
                                 ShapeBounding, 0, 0, &rect[0], 2,
                                 ShapeSet, Unsorted);
      }
#endif
   XtManageChild(text);
   XmProcessTraversal(text, XmTRAVERSE_CURRENT);

   if(type != DESKTOP)
   {
      FileMgrRec *file_mgr_rec;

      file_mgr_rec = (FileMgrRec *)file_mgr_data->file_mgr_rec;
      file_mgr_rec->menuStates &= ~RENAME;
   }
}

/************************************************************************
 *
 *  SavePositionalData
 *      Save the desktop icon positional data.
 *
 ************************************************************************/

void
SavePositionalData (
   int fd,
   FileMgrData * file_mgr_data,
   char ** name_list,
   char * name)
{
   int i;
   FILE * fd_stream = fdopen(fd, "w");
   ObjectPosition * ptr;


   if(file_mgr_data->positionEnabled == RANDOM_ON &&
                  file_mgr_data->object_positions &&
                  file_mgr_data->show_type == SINGLE_DIRECTORY &&
                  file_mgr_data->host != NULL)
   {
      /* Number of object positions */
      fprintf(fd_stream, "*%s.%s.%s.%s:   %d\n#\n", name_list[0], name_list[1],
               name, "num_positions", file_mgr_data->num_objects);

      for (i = 0; i < file_mgr_data->num_objects; i++)
      {
         ptr = file_mgr_data->object_positions[i];
         fprintf(fd_stream, "*%s.%s.%s.%s%d:   %s %d %d %d\n",
                   name_list[0], name_list[1], name, "object", i,
                   ptr->name,
                   ptr->x,
                   ptr->y,
                   ptr->stacking_order);
      }
   }
   else
   {
      /* Number of object positions */
      fprintf(fd_stream, "*%s.%s.%s.%s:   %d\n#\n", name_list[0], name_list[1],
               name, "num_positions", 0);
   }

   fflush(fd_stream);
}



/************************************************************************
 *
 *  RestorePositionalData
 *      Restore the desktop icon positional data.
 *
 ************************************************************************/

void
RestorePositionalData (
   XrmDatabase db,
   char ** name_list,
   FileMgrData * file_mgr_data,
   char * name)
{
   XrmName xrm_name[10];
   int i = 0;
   int j;
   char objectName[20];
   XrmRepresentation rep_type;
   XrmValue value;
   int num_objects;
   char * str;
   char * obj_name;
   ObjectPosition * ptr;
   int x, y;
   int s_order;

   while (name_list[i])
   {
      xrm_name[i] = XrmStringToQuark(name_list[i]);
      i++;
   }
   xrm_name[i++] = XrmStringToQuark(name);
   xrm_name[i] = XrmStringToQuark("num_positions");
   xrm_name[i+1] = '\0';

   /* Find out how many objects there are to be loaded */
   file_mgr_data->object_positions = NULL;
   num_objects = 0;
   if (XrmQGetResource (db, xrm_name, NULL, &rep_type, &value))
   {
      if ((num_objects = atoi (value.addr)) <= 0)
         num_objects = 0;
      else
      {
         file_mgr_data->object_positions = (ObjectPosition **)XtMalloc(
                             sizeof(ObjectPosition *) * num_objects);
      }
   }

   file_mgr_data->num_objects = num_objects;

   for (j = 0; j < num_objects; j++)
   {
      sprintf(objectName, "object%d", j);
      xrm_name[i] = XrmStringToQuark(objectName);
      ptr = file_mgr_data->object_positions[j] = (ObjectPosition *)
                                     XtMalloc(sizeof(ObjectPosition));

      XrmQGetResource (db, xrm_name, NULL, &rep_type, &value);
      str = (char *)value.addr;
      obj_name = XtMalloc(strlen(str) + 1);
      sscanf((char *)value.addr, "%s %d %d %d", obj_name, &x, &y, &s_order);
      ptr->name = obj_name;
      ptr->x = x;
      ptr->y = y;
      ptr->stacking_order = s_order;
      ptr->in_use = False;
      ptr->late_bind = False;
      ptr->file_view_data = NULL;
      ptr->next = NULL;
      ptr->prev = NULL;
   }

   /* Repair all of the next and prev pointers */
   RepairStackingPointers(file_mgr_data);
}


void
UnpostTextField (
   FileMgrData * file_mgr_data)

{
   XmManagerWidget file_window;
   int i;
   FileMgrRec * file_mgr_rec;

   file_mgr_data->renaming = NULL;

   file_mgr_rec = (FileMgrRec *)file_mgr_data->file_mgr_rec;
   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   for (i = 0; i < file_window->composite.num_children; i++)
   {
      if (XmIsTextField(file_window->composite.children[i]) &&
          !file_window->composite.children[i]->core.being_destroyed)
      {
         XtUnmanageChild(file_window->composite.children[i]);
         XtDestroyWidget(file_window->composite.children[i]);
         return;
      }
   }
}


void
UnpostTextPath (
   FileMgrData * file_mgr_data)

{
  FileMgrRec * file_mgr_rec;
  Arg args[2];

  file_mgr_rec = (FileMgrRec *)file_mgr_data->file_mgr_rec;

  XtSetArg (args[0], XmNallowShellResize, False);
  XtSetValues(file_mgr_rec->shell, args, 1);

  XtUnmanageChild(file_mgr_rec->current_directory_text);

  XtSetArg (args[0], XmNallowShellResize, True);
  XtSetValues(file_mgr_rec->shell, args, 1);

  file_mgr_data->fast_cd_enabled = False;
}


/*
 * Function to force a redraw of a single gadget.
 */

void
RedrawOneGadget (
   Widget child,
   XEvent * event,
   Region region)

{
   if (child->core.widget_class->core_class.expose)
      (*(child->core.widget_class->core_class.expose))(child, event, region);
}


/*
 * Given a region describing the area to be repainted, repaint all icons,
 * in bottom to top order, which fall into this region.
 */

void
RepaintDesktop (
   FileMgrData * file_mgr_data,
   XEvent * event,
   Region region)

{
   Widget child;
   ObjectPosition * bottom = GetBottomOfStack(file_mgr_data);

   /* Redraw all affected gadgets */
   while(bottom)
   {
      if (!bottom->late_bind)
      {
         if (bottom->file_view_data != NULL &&
             !bottom->file_view_data->need_update)
         {
            child = bottom->file_view_data->widget;
            if (XRectInRegion(region, child->core.x, child->core.y,
                              child->core.width, child->core.height))
            {
               RedrawOneGadget(child, event, region);
            }
         }
      }

      bottom = bottom->prev;
   }
}


/*
 * This function will extract all exposure events intended for this file
 * window, combine them into a single region, and then determine which of
 * the file icons need to be redrawn.  It is a two step process, as
 * described by the comments in the code.
 */

static void
RedisplayUsingStackingOrder (
   FileMgrData * file_mgr_data,
   Widget w,
   register XEvent *event,
   Region region)

{
   register Widget child;
   FileViewData * file_view_data;
   ObjectPosition * bottom;
   ObjectPosition * top;
   Region redrawRegion = XCreateRegion();
   XRectangle rect;
   XEvent expEvent;
   int numChildren = 0;
   Widget * children = NULL;
   Region widget_region;
   Region tmp_region;

   /* Get the initial region to redraw */
   if (region)
      XUnionRegion(redrawRegion, region, redrawRegion);
   else if (event)
   {
      rect.x = event->xexpose.x;
      rect.y = event->xexpose.y;
      rect.height = event->xexpose.height;
      rect.width = event->xexpose.width;

      XUnionRectWithRegion(&rect, redrawRegion, redrawRegion);
   }

   /*
    * Capture and encompass any other exposure events which are destined for
    * us, but are waiting in the wings.
    */
   while (XCheckWindowEvent(XtDisplay(w), XtWindow(w), ExposureMask, &expEvent))
   {
      rect.x = expEvent.xexpose.x;
      rect.y = expEvent.xexpose.y;
      rect.height = expEvent.xexpose.height;
      rect.width = expEvent.xexpose.width;

      XUnionRectWithRegion(&rect, redrawRegion, redrawRegion);
   }

   /* Nothing to do if the redraw region is empty */
   if (XEmptyRegion(redrawRegion))
   {
      XDestroyRegion(redrawRegion);
      return;
   }

   /*
    * Starting at the top of the stack, find any items which fall into
    * the redraw region.  As items are found which need to be redrawn,
    * subtract them from the redraw region, so that any items lower on the
    * stack which might be under these gadgets, but are within the region,
    * are not redrawn.
    *
    * The second phase is to start at the bottom of the stack, and start
    * redrawing the gadgets which fell into the region, along with any
    * other gadgets on top of these (since they too now need to be redrawn.
    */
   top = GetTopOfStack(file_mgr_data);
   children = NULL;
   numChildren = 0;

   while (top)
   {
      if (!top->late_bind)
      {
         file_view_data = top->file_view_data;
         if(file_view_data != NULL)
         {
            child = file_view_data->widget;

            if (child && XmIsGadget(child) && XtIsManaged(child))
            {
               widget_region = XCreateRegion();
               WidgetRectToRegion(file_mgr_data, child, widget_region);
               XIntersectRegion(redrawRegion, widget_region, widget_region);
               if (!XEmptyRegion(widget_region))
               {
                  XSubtractRegion(redrawRegion, widget_region, redrawRegion);
                  children = (Widget *)XtRealloc((char *)children,
                                         (numChildren + 1) * sizeof(Widget));
                  children[numChildren] = child;
                  numChildren++;
               }
               XDestroyRegion(widget_region);
            }
         }
      }
      top = (ObjectPosition *)top->next;
   }

   /* Now, start redrawing, in bottom to top order */
   bottom = GetBottomOfStack(file_mgr_data);
   numChildren--;
   while (bottom)
   {
      if (!bottom->late_bind)
      {
         file_view_data = bottom->file_view_data;
         if(file_view_data != NULL)
         {
            child = file_view_data->widget;

            if (child && XmIsGadget(child) && XtIsManaged(child))
            {
               widget_region = XCreateRegion();
               WidgetRectToRegion(file_mgr_data, child, widget_region);
               if ((numChildren >= 0) && (children[numChildren] == child))
               {
                  XUnionRegion(redrawRegion, widget_region, redrawRegion);
                  RedrawOneGadget(child, event, redrawRegion);
                  numChildren--;
               }
               else
               {
                  /* Do we overlap something which was previously redrawn? */
                  tmp_region = XCreateRegion();
                  XIntersectRegion(redrawRegion, widget_region, tmp_region);
                  if (!XEmptyRegion(tmp_region))
                  {
                     XUnionRegion(redrawRegion, widget_region, redrawRegion);
                     RedrawOneGadget(child, event, redrawRegion);
                  }
                  XDestroyRegion(tmp_region);
               }
               XDestroyRegion(widget_region);
            }
         }
      }
      bottom = (ObjectPosition *)bottom->prev;
   }

   XDestroyRegion(redrawRegion);
   XtFree((char *)children);
   children = NULL;
}


/*
 * This is the function which we use to override the class expose function
 * for the drawing area widget.  It allows us to catch exposure events
 * intended for the desktop, so that we can force the redrawing of the
 * gadgets to occur occording to the stacking order.
 */

void
DrawingAreaRedisplay (
   Widget wid,
   XEvent *event,
   Region region)

{
   XmDrawingAreaWidget da = (XmDrawingAreaWidget) wid;
   XmDrawingAreaCallbackStruct cb;
   FileMgrData * file_mgr_data;

   cb.reason = XmCR_EXPOSE;
   cb.event = event;
   cb.window = XtWindow (da);

   DPRINTF2(("DrawingAreaRedisplay: event %d, x/y %d/%d, wd/ht %d/%d\n",
             event->xany.type,
             event->xexpose.x, event->xexpose.y,
             event->xexpose.width, event->xexpose.height));

   file_mgr_data = ReturnDesktopPtr(wid);

   if (file_mgr_data && PositioningEnabledInView(file_mgr_data))
      RedisplayUsingStackingOrder(file_mgr_data, (Widget)da, event, region);
   else
      XmeRedisplayGadgets((Widget)da, event, region);

   XtCallCallbackList ((Widget)da, da->drawing_area.expose_callback, &cb);
}


/*
 * Return the bottom of the stacking order list.
 */

ObjectPtr
GetBottomOfStack (
   FileMgrData * file_mgr_data)

{
   int i;
   ObjectPtr bottom;

   for (i = 0, bottom = NULL; i < file_mgr_data->num_objects; i++)
   {
      if (file_mgr_data->object_positions[i]->next == NULL)
      {
         bottom = file_mgr_data->object_positions[i];
         break;
      }
   }

   return(bottom);
}


/*
 * Return the top of the stacking order list.
 */

ObjectPtr
GetTopOfStack (
   FileMgrData * file_mgr_data)
{
   int i;
   ObjectPtr top;

   for (i = 0, top = NULL; i < file_mgr_data->num_objects; i++)
   {
      if (file_mgr_data->object_positions[i]->prev == NULL)
      {
         top = file_mgr_data->object_positions[i];
         break;
      }
   }

   return(top);
}


/*
 * Move an object up in the stacking order.  Will not work for moving an
 * object further down in the stacking order, but we currently have no
 * need for doing that.
 *
 * NOTE: The top of the stack is '1', not '0'!!
 */

void
RepositionUpInStack (
   FileMgrData * file_mgr_data,
   int oldPos,
   int newPos)

{
   ObjectPtr ptr, ptr2, savePtr;
   register int i, j;
   XmManagerWidget file_window;

   if (oldPos == newPos)
      return;

   ptr = GetTopOfStack(file_mgr_data);

   /* Find where item is to be inserted */
   while (ptr->stacking_order != newPos)
      ptr = ptr->next;

   /* Find where item currently is */
   ptr2 = ptr;
   while (ptr2->stacking_order != oldPos)
      ptr2 = ptr2->next;

   savePtr = ptr2;

   if(savePtr->file_view_data == NULL)
      return;

   /* Remove from its current location */
   if (ptr2->prev)
      ptr2->prev->next = ptr2->next;
   if (ptr2->next)
      ptr2->next->prev = ptr2->prev;

   /* Link into new position */
   ptr2->prev = ptr->prev;
   ptr2->next = ptr;
   if (ptr->prev)
      ptr2->prev->next = ptr2;
   ptr->prev = ptr2;

   /* Update the stacking order value */
   for (i = newPos; i <= oldPos; i++)
   {
      ptr2->stacking_order = i;
      ptr2 = ptr2->next;
   }

   /* Update the children's list for the file window */
   file_window = (XmManagerWidget)
                  (((FileMgrRec *)file_mgr_data->file_mgr_rec)->file_window);

   /* Find the affect child */
   for (i = 0; (i < file_window->composite.num_children) &&
       (file_window->composite.children[i] != savePtr->file_view_data->widget);
       i++);

   /* Push intervening entries down */
   for (j = i; j >= newPos; j--)
      file_window->composite.children[j] = file_window->composite.children[j-1];

   /* Insert into new position in children list */
   file_window->composite.children[newPos-1] = savePtr->file_view_data->widget;
}


/*
 * Reorder the file window's children list so that it matches the stacking
 * order.
 */

static void
ReorderChildrenList (
   XmManagerWidget file_window,
   Widget * manage,
   int manageCount,
   Widget * unmanage,
   int unmanageCount)

{
   Widget * children = file_window->composite.children;
   register int i, j;

   for (i = 0; i < manageCount; i++)
      children[i] = manage[i];

   for (j = 0; j < unmanageCount; j++)
      children[i++] = unmanage[j];
}


/*
 * If positional information is available for the indicated file, then
 * return it; if not, then return NULL.
 */

ObjectPtr
FindCurrentPosition (
   FileMgrData * file_mgr_data,
   char * file_name)

{
   int i;

   for (i = 0; i < file_mgr_data->num_objects; i++)
   {
      if (strcmp(file_name, file_mgr_data->object_positions[i]->name) == 0)
      {
         /* Found a match */
         file_mgr_data->object_positions[i]->in_use = True;
         return(file_mgr_data->object_positions[i]);
      }
   }

   return(NULL);
}


void
RepairStackingPointers (
   FileMgrData * file_mgr_data)

{
   int i;
   int j;
   ObjectPosition * ptr;
   ObjectPosition * prev;

   for (i = 1, prev = NULL; i <= file_mgr_data->num_objects; i++)
   {
      for (j = 0; j < file_mgr_data->num_objects; j++)
      {
         ptr = file_mgr_data->object_positions[j];
         if (ptr->stacking_order == i)
         {
            if (prev)
            {
               ptr->prev = prev;
               prev->next = ptr;
            }
            prev = ptr;
            break;
         }
      }
   }
}

/*
 * Reorder the children's list for the file_window, so that it matches
 * the stacking order.  Also, set up all next and previous pointers.
 */

void
OrderChildrenList (
   FileMgrData * file_mgr_data)

{
   FileMgrRec * file_mgr_rec = (FileMgrRec *) file_mgr_data->file_mgr_rec;
   XmManagerWidget file_window;
   Widget * managed;
   Widget * unmanaged;
   int num_managed;
   int num_unmanaged;
   ObjectPosition * top;
   int i, j;

   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   managed = (Widget *)XtMalloc(sizeof(Widget *) *
                        file_window->composite.num_children);
   unmanaged = (Widget *)XtMalloc(sizeof(Widget *) *
                        file_window->composite.num_children);
   num_managed = num_unmanaged = 0;

   top = GetTopOfStack(file_mgr_data);
   while(top)
   {
      if (top->file_view_data != NULL && top->file_view_data->widget != NULL)
         managed[num_managed++] = top->file_view_data->widget;
      top = top->next;
   }

   /* All the rest get put at the end of the children's list */
   for (i = 0; i < file_window->composite.num_children; i++)
   {
      for (j = 0; j < num_managed; j++)
      {
         if (managed[j] == file_window->composite.children[i])
            break;
      }

      if (j >= num_managed)
         unmanaged[num_unmanaged++] = file_window->composite.children[i];
   }

   ReorderChildrenList(file_window, managed, num_managed, unmanaged,
                       num_unmanaged);
   XtFree( (char *)managed );
   XtFree( (char *)unmanaged );
}


/*
 * SetHotRects
 */

void
SetHotRects (
   FileViewData  * file_view_data,
   XtCallbackProc callback,
   XtPointer callback_data)

{
   Arg args[3];

   if (file_view_data->displayed)
   {
      /*************************/
      /* icon gadget displayed */
      /*************************/
      DtIconGadget g = (DtIconGadget) file_view_data->widget;
      unsigned char operations;

         /* find defined operations (M/C/L) for file type */
      operations = TypeToDropOperations(
                             file_view_data->file_data->logical_type);

      /* if icon gadget not yet registered as a drop site, do so now */
      if (!file_view_data->registered)
      {
         /* register drop site for MCL but make drop site inactive */
         XtSetArg (args[0], XmNdropSiteOperations,
                   XmDROP_COPY | XmDROP_MOVE | XmDROP_LINK);
         XtSetValues (file_view_data->widget, args, 1);

         file_view_data->registered = True;
      }

      if (operations)
      {
         /***********************************/
         /* file has associated MCL actions */
         /***********************************/
         XRectangle rects[2];
         unsigned char flags;
         int numRects = 0;
         Cardinal n = 0;
         Dimension s_t, adj_xy, adj_size;

         /* ensure drop site operations and drop area are correct */
         _DtIconGetIconRects(g, &flags, &rects[0], &rects[1]);

         /*
          * Compute adjustments to the drop area:
          *
          *  - Add shadowThickness to the drop area:
          *    The icon gadget leaves space of width shadowThickness around
          *    the pixmap and label; use this space to make the drop zone
          *    larger.
          *
          *  - Compensate for bug in drop zone registration/drawing:
          *    For some reason the drop zone displayed on the screen is
          *    actually smaller than the rectangle we register:
          *    The drag&drop library seems to reduce the size of the drop
          *    area by the value of highlightThickness at the top and left
          *    border and by highlightThickness-1 at the bottom and right.
          *    Is this a Motif drag&drop bug?
          *    We compensate by registering a larger rectangle.
          */
         s_t = G_ShadowThickness(g);
         adj_xy = s_t + G_HighlightThickness(g);
         adj_size = adj_xy + s_t + G_HighlightThickness(g) - 1;

         if (flags & XmPIXMAP_RECT)
         {
            rects[0].x -= g->rectangle.x + adj_xy;
            rects[0].y -= g->rectangle.y + adj_xy;
            rects[0].width += adj_size;
            rects[0].height += adj_size;
            numRects++;
          }

         if (flags & XmLABEL_RECT)
         {
            rects[1].x -= g->rectangle.x + adj_xy;
            rects[1].y -= g->rectangle.y + adj_xy;
            rects[1].width += adj_size;
            rects[1].height += adj_size;
            if (!numRects) rects[0] = rects[1];
               numRects++;
          }

          if (numRects)
          {
             XtSetArg(args[n], XmNdropRectangles, rects);        n++;
             XtSetArg(args[n], XmNnumDropRectangles, numRects);  n++;
          }
          XtSetArg (args[n], XmNdropSiteOperations, operations); n++;

          XmDropSiteUpdate (file_view_data->widget, args, n);
          g->icon.operations = operations;

          /* add client data */
          XtRemoveAllCallbacks(file_view_data->widget, XmNdropCallback);
          XtAddCallback(file_view_data->widget, XmNdropCallback,
                      callback, callback_data);
      }
      else
      {
         /*********************************************/
         /* file does not have associated MCL actions */
         /*********************************************/
         /* make drop site inactive */
         XtSetArg (args[0], XmNdropSiteOperations, XmDROP_NOOP);
         XmDropSiteUpdate (file_view_data->widget, args, 1);
         XtRemoveAllCallbacks(file_view_data->widget, XmNdropCallback);
      }
    }
    else
    {
      /*****************************/
      /* icon gadget not displayed */
      /*****************************/
      if (file_view_data->registered)
      {
         /***************************************/
         /* icon gadget registered as drop site */
         /***************************************/
         /* make drop site inactive */
         XtSetArg (args[0], XmNdropSiteOperations, XmDROP_NOOP);
         XmDropSiteUpdate (file_view_data->widget, args, 1);
         XtRemoveAllCallbacks(file_view_data->widget, XmNdropCallback);
      }
   }
}



/*
 * TypeToDropOperations
 */

unsigned char
TypeToDropOperations (
   char * file_type)

{
   unsigned char operations = 0L;
   char *action;

   /* does object have MOVE, COPY, and/or LINK actions */
   /*    -- or no actions at all                       */
   if (action = DtDtsDataTypeToAttributeValue(file_type,
                                              DtDTS_DA_MOVE_TO_ACTION,
                                              NULL))
   {
      operations = operations | XmDROP_MOVE;
      DtDtsFreeAttributeValue(action);
   }
   if (action = DtDtsDataTypeToAttributeValue(file_type,
                                              DtDTS_DA_COPY_TO_ACTION,
                                              NULL))
   {
      operations = operations | XmDROP_COPY;
      DtDtsFreeAttributeValue(action);
   }
   if (action = DtDtsDataTypeToAttributeValue(file_type,
                                              DtDTS_DA_LINK_TO_ACTION,
                                              NULL))
   {
      operations = operations | XmDROP_LINK;
      DtDtsFreeAttributeValue(action);
   }

   return(operations);
}


/*
 * TypeToAction
 */

char *
TypeToAction (
   unsigned char dropOperation,
   char * logical_type)
{
   char * action;

   /* retrieve action from database based on dropOperation */
   switch(dropOperation)
   {
      case XmDROP_MOVE:
         action = DtDtsDataTypeToAttributeValue(logical_type,
                                                DtDTS_DA_MOVE_TO_ACTION,
                                                NULL);
         break;
      case XmDROP_COPY:
         action = DtDtsDataTypeToAttributeValue(logical_type,
                                                DtDTS_DA_COPY_TO_ACTION,
                                                NULL);
         break;
      case XmDROP_LINK:
         action = DtDtsDataTypeToAttributeValue(logical_type,
                                                DtDTS_DA_LINK_TO_ACTION,
                                                NULL);
         break;
      default:
         action = NULL;
         break;
   }

   return(action);
}


/*
 * Given a fileViewData pointer, determine if it is part of a FileMgrData,
 * or a DesktopRec; return the appropriate pointer.
 */

static
Boolean
IsDesktopPtr (
   FileViewData * fileViewData,
   FileMgrData ** fileMgrData,
   DesktopRec ** desktopRec)
{
   int i;

   *desktopRec = NULL;
   *fileMgrData = NULL;

   for (i = 0; i < desktop_data->numIconsUsed; i++)
   {
      if (desktop_data->desktopWindows[i]->file_view_data == fileViewData)
      {
         *desktopRec = desktop_data->desktopWindows[i];
         return(True);
      }
   }

   *fileMgrData = (FileMgrData *)
                ((DirectorySet *)fileViewData->directory_set)->file_mgr_data;
   return(False);
}


/******************************************************************
 *
 *  PositionFileView -
 *        Given a particular file, position the file view that file
 *        is in on that particular file.
 *
 ********************************************************************/
void
PositionFileView(
     FileViewData *file_view_data,
     FileMgrData *file_mgr_data)
{
   Position x, y;
   Arg args[1];
   int value, size, increment, page, max;
   FileMgrRec * file_mgr_rec = (FileMgrRec *)(file_mgr_data->file_mgr_rec);
   Widget p;

   /* if the file is filtered we can't highlight it! */
   if(!file_view_data->displayed)
      return;

   /* Get the y location of the icon_gadget */
   y = file_view_data->y - file_mgr_data->grid_height;

   /* Two things:
    * 
    * 1) not sure exactly how slow this is, but there seems to be no other
    *    way to do this. (CDExc23427)
    * 2) XmScrollVisible does not work if the work window is not managed...
    *    so, we call it, and then get the appropriate x,y back from the
    *    scroll bars and set them (CDExc23428) */
   p = XtVaCreateManagedWidget("positionicon", xmGadgetClass, 
			       file_mgr_rec->file_window,
			       XmNmappedWhenManaged, False,
			       XmNx, file_view_data->x,
			       XmNy, y, 
			       XmNwidth, file_mgr_data->grid_width,
			       XmNheight, file_mgr_data->grid_height,
			       NULL);

   XmScrollVisible(file_mgr_rec->scroll_window, p,
		   XSPACING, YSPACING(file_mgr_data));

   XtDestroyWidget(p);

   XmScrollBarGetValues(file_mgr_rec->horizontal_scroll_bar,
			&value, &size, &increment, &page);
   x = -((Position) value);

   XmScrollBarGetValues(file_mgr_rec->vertical_scroll_bar,
			&value, &size, &increment, &page);
   y = -((Position) value);

   XtVaSetValues(file_mgr_rec->file_window, XmNx, x, XmNy, y, NULL);
}


static Boolean
InMultipleObjectRegion (FileMgrData * file_mgr_data, FileViewData * fileViewData)
{
  register int i;
  for( i = 0; i < file_mgr_data->selected_file_count; ++i )
    if( strcmp( file_mgr_data->selection_list[i]->file_data->file_name, fileViewData->file_data->file_name ) == 0 )
      return True;
  return False;
}

void
FmPopup (
      Widget w,
      XtPointer client_data,
      XEvent *event,
      FileMgrData *file_mgr_data)
{
   FileMgrRec      *file_mgr_rec;
   Arg             args[2];
   FileViewData    *fileViewData = NULL;
   int             i, num_of_children, obj_btns;
   XmManagerWidget action_pane;
   XmString        label_string;


   /* set number of popup children based on annotation */
   num_of_children = FM_POPUP_CHILDREN_NA;
   obj_btns = OBJ_BTNS_NA;

   /* attach the popup widget info to the menu */
   file_mgr_rec = (FileMgrRec *)file_mgr_data->file_mgr_rec;
   XtSetArg(args[0], XmNuserData, file_mgr_rec);
   XtSetValues(fileMgrPopup.menu, args, 1);

   if(file_mgr_data)
     file_mgr_data->popup_menu_icon = NULL;

   /* we are dealing with a white space popup */
   if((w == NULL)
      && (client_data == NULL)
/*
      && (file_mgr_data->selected_file_count == 0)
*/
      )
   {
      DirectorySet *directory_set;

      /* retrieve the fileViewData for the current directory */
      directory_set = file_mgr_data->directory_set[0];
      for (i = 0; i < directory_set->file_count; i++)
      {
         if(strcmp(directory_set->order_list[i]->file_data->file_name, ".")
            == 0)
         {
            fileViewData = directory_set->order_list[i];
            break;
         }
      }

      /* manage the white space buttons and unmanage the object buttons */
      XtManageChildren(fileMgrPopup.wsPopup, WS_BTNS);
      XtUnmanageChildren(fileMgrPopup.objPopup, obj_btns);
      XtUnmanageChildren(fileMgrPopup.trash_objPopup, TRASH_OBJ_BTNS);

      XtUnmanageChild(fileMgrPopup.wsPopup[BTN_UNSELECTALL]);

      if(file_mgr_data == trashFileMgrData)
      {
         /* Set popup menu label */
         label_string = XmStringCreateLocalized ((GETMESSAGE(33, 2, "Current Folder")));
         XtSetArg (args[0], XmNlabelString, label_string);
         XtSetValues (fileMgrPopup.title, args, 1);
         XtManageChild(fileMgrPopup.title);
         XmStringFree (label_string);

         /* trash white space popup -- unmanage the properties and show */
         /* hidden files buttons */
         XtUnmanageChild(fileMgrPopup.wsPopup[BTN_PROPERTIES]);
         XtUnmanageChild(fileMgrPopup.wsPopup[BTN_FIND]);
         XtUnmanageChild(fileMgrPopup.wsPopup[BTN_SHOWHIDDEN]);

         /* align the remaining buttons */
         XtSetArg(args[0], XmNmarginLeft, 0);
         if( PositioningEnabledInView( file_mgr_data ) )
         {
           file_mgr_rec->menuStates |= CLEAN_UP;
           XtSetValues(fileMgrPopup.wsPopup[BTN_CLEANUP], args, 1);
         }
         else
         {
           file_mgr_rec->menuStates &= ~(CLEAN_UP);
           XtUnmanageChild( fileMgrPopup.wsPopup[BTN_CLEANUP] );
         }
         XtSetValues(fileMgrPopup.wsPopup[BTN_SELECTALL], args, 1);

         /* unmanage the action portion of the popup menu */
         XtUnmanageChild(fileMgrPopup.action_separator);

         action_pane = (XmManagerWidget) fileMgrPopup.menu;
         for(i=num_of_children; i<action_pane->composite.num_children; i++)
            XtUnmanageChild(action_pane->composite.children[i]);
      }
      else
      {
         Dimension margin;

         /* manage the properties and show hidden files buttons */
         if( file_mgr_data->toolbox )
           XtUnmanageChild(fileMgrPopup.wsPopup[BTN_PROPERTIES]);
         else
           XtManageChild(fileMgrPopup.wsPopup[BTN_PROPERTIES]);
         XtManageChild(fileMgrPopup.wsPopup[BTN_FIND]);
         XtManageChild(fileMgrPopup.wsPopup[BTN_SHOWHIDDEN]);

         /* Set popup menu label */
         label_string = XmStringCreateLocalized ((GETMESSAGE(33, 2, "Current Folder")));
         XtSetArg (args[0], XmNlabelString, label_string);
         XtSetValues (fileMgrPopup.title, args, 1);
         XtManageChild(fileMgrPopup.title);
         XmStringFree (label_string);

         /* align the menu buttons */
         action_pane = (XmManagerWidget) fileMgrPopup.menu;
         XtSetArg(args[0], XmNmarginLeft, &margin);
         XtGetValues(fileMgrPopup.wsPopup[BTN_SHOWHIDDEN], args, 1);
         XtSetArg(args[0], XmNmarginLeft, margin);

         if( PositioningEnabledInView( file_mgr_data ) )
         {
           file_mgr_rec->menuStates |= CLEAN_UP;
           XtSetValues(fileMgrPopup.wsPopup[BTN_CLEANUP], args, 1);
         }
         else
         {
           file_mgr_rec->menuStates &= ~(CLEAN_UP);
           XtUnmanageChild( fileMgrPopup.wsPopup[BTN_CLEANUP] );
         }

         XtSetValues(fileMgrPopup.wsPopup[BTN_SELECTALL], args, 1);

         if(showFilesystem )
         {
           if (file_mgr_data->show_hid_enabled)
             XmToggleButtonGadgetSetState(fileMgrPopup.wsPopup[BTN_SHOWHIDDEN], True, False);
           else
             XmToggleButtonGadgetSetState(fileMgrPopup.wsPopup[BTN_SHOWHIDDEN], False, False);
         }

         /* ensure that there was fileViewData for the current directory */
         if(fileViewData != NULL)
         {
            /* attach the current fileViewData to the 'Properties' button */
           if( ! file_mgr_data->toolbox )
           {
             XtRemoveAllCallbacks(fileMgrPopup.wsPopup[BTN_PROPERTIES],
                                  XmNactivateCallback);
             XtAddCallback (fileMgrPopup.wsPopup[BTN_PROPERTIES],
                            XmNactivateCallback,
                            ShowModAttrDialog, (XtPointer) fileViewData);

             /* sensitize the 'Properties' option */
             XtSetSensitive(fileMgrPopup.wsPopup[BTN_PROPERTIES], True);
           }
            /* update the actions portion of the popup menu */
            XtManageChild(fileMgrPopup.action_separator);

            XtFree(fileMgrPopup.action_pane_file_type);
            fileMgrPopup.action_pane_file_type =
                XtNewString(fileViewData->file_data->logical_type);

            UpdateActionMenuPane ((XtPointer)fileViewData, file_mgr_rec,
                                  fileViewData->file_data->logical_type,
                                  FM_POPUP, num_of_children,
                                  fileMgrPopup.menu,
                                  fileViewData->file_data->physical_type);

            /* align actions portion of the popup menu */
            for(i=num_of_children; i<action_pane->composite.num_children; i++)
              XtSetValues(action_pane->composite.children[i], args, 1);
         }
         else
         {
           if( ! file_mgr_data->toolbox )
           {
             /* remove callback from 'Properties' button */
             XtRemoveAllCallbacks(fileMgrPopup.wsPopup[BTN_PROPERTIES],
                                  XmNactivateCallback);

             /* desensitize the 'Properties' button */
             XtSetSensitive(fileMgrPopup.wsPopup[BTN_PROPERTIES], False);
           }

            /* unmanage the action portion of the popup menu */
            XtUnmanageChild(fileMgrPopup.action_separator);

            for(i=num_of_children; i<action_pane->composite.num_children; i++)
               XtUnmanageChild(action_pane->composite.children[i]);
         }
      }
   }

   /* we are dealing with an object popup */
   else
   {
      char label[MAX_PATH];

      /* retrieve the fileViewData for the selected icon */
      if (client_data)
         fileViewData = (FileViewData *) client_data;
      else if (file_mgr_data->selected_file_count != 0)
         fileViewData = file_mgr_data->selection_list[0];


      /* unmanage the white space buttons */
      XtUnmanageChildren(fileMgrPopup.wsPopup, WS_BTNS);

      if(file_mgr_data == trashFileMgrData)
      {
          file_mgr_data->popup_menu_icon = fileViewData;

         /* Set popup menu label */
         if( file_mgr_data->selected_file_count > 1
             && InMultipleObjectRegion(file_mgr_data, fileViewData))
         {

           label_string = XmStringCreateLocalized ((GETMESSAGE(33,1, "Multiple Objects")));
         }
         else
         {
           char *tmp_label;

           if (fileViewData->file_data->action_name)
              tmp_label = fileViewData->file_data->action_name;
           else
              tmp_label = fileViewData->file_data->file_name;

           if( strlen( tmp_label ) > 20 )
             sprintf( label, "%-20.20s...", tmp_label );
           else
             sprintf( label, "%s", tmp_label );

           label_string = XmStringCreateLocalized (label);
         }
         XtSetArg (args[0], XmNlabelString, label_string);
         XtSetValues (fileMgrPopup.title, args, 1);
         XtManageChild(fileMgrPopup.title);
         XmStringFree (label_string);

         /* trash popup--unmanage the non-trash buttons, manage the trash */
         XtUnmanageChildren(fileMgrPopup.objPopup, obj_btns);
         XtManageChildren(fileMgrPopup.trash_objPopup, TRASH_OBJ_BTNS);

         /* adjust callbacks */
         XtRemoveAllCallbacks(fileMgrPopup.trash_objPopup[BTN_RESTORE],
                              XmNactivateCallback);
         XtAddCallback(fileMgrPopup.trash_objPopup[BTN_RESTORE],
                       XmNactivateCallback, Restore, (XtPointer) fileViewData);

         XtRemoveAllCallbacks(fileMgrPopup.trash_objPopup[BTN_REMOVE],
                              XmNactivateCallback);
         XtAddCallback(fileMgrPopup.trash_objPopup[BTN_REMOVE],
                       XmNactivateCallback, ConfirmRemove,
                       (XtPointer) fileViewData);

         /* unmanage the action portion of the popup menu */
         XtUnmanageChild(fileMgrPopup.action_separator);

         action_pane = (XmManagerWidget) fileMgrPopup.menu;
         for(i=num_of_children; i<action_pane->composite.num_children; i++)
            XtUnmanageChild(action_pane->composite.children[i]);
      }
      else
      {
         /* non-trash popup--manage the non-trash buttons, unmanage the trash */
         XtManageChildren(fileMgrPopup.objPopup, obj_btns);
         XtUnmanageChildren(fileMgrPopup.trash_objPopup, TRASH_OBJ_BTNS);
         if( file_mgr_data->toolbox )
           XtUnmanageChild(fileMgrPopup.objPopup[BTN_PROPERTIES]);

         if(file_mgr_data->selected_file_count > 1
            && InMultipleObjectRegion(file_mgr_data, fileViewData))
         {
            /* we have many files selected; remove callbacks from the  */
            /* 'Properties', 'Put on Desktop', and 'Review' buttons    */
            /* and attach the selection list to the remaining buttons; */
            /* desensitize the 3 buttons listed above; unmanage the    */
            /* actions part of the popup menu                          */

           /* adjust callbacks */
           if( ! file_mgr_data->toolbox )
             XtRemoveAllCallbacks(fileMgrPopup.objPopup[BTN_PROPERTIES],
                                  XmNactivateCallback);

           XtRemoveAllCallbacks(fileMgrPopup.objPopup[BTN_PUTON],
                                XmNactivateCallback);
           XtAddCallback(fileMgrPopup.objPopup[BTN_PUTON], XmNactivateCallback,
                         PutOnDTCB, (XtPointer) fileViewData);

           XtRemoveAllCallbacks(fileMgrPopup.objPopup[BTN_TRASH],
                                XmNactivateCallback);
           XtAddCallback(fileMgrPopup.objPopup[BTN_TRASH], XmNactivateCallback,
                         TrashFiles, (XtPointer) fileViewData);

           if( file_mgr_data->toolbox && geteuid() != root_user &&
                   access(file_mgr_data->current_directory,W_OK|X_OK) != 0)
             XtSetSensitive(fileMgrPopup.objPopup[BTN_TRASH], False);


           /* sensitize buttons */
           if( !file_mgr_data->toolbox )
             XtSetSensitive(fileMgrPopup.objPopup[BTN_PROPERTIES], False);

           XtSetSensitive(fileMgrPopup.objPopup[BTN_HELP], False);

           /* Set popup menu label */
           label_string = XmStringCreateLocalized ((GETMESSAGE(33, 1, "Multiple Objects")));
           XtSetArg (args[0], XmNlabelString, label_string);
           XtSetValues (fileMgrPopup.title, args, 1);
           XtManageChild(fileMgrPopup.title);
           XmStringFree (label_string);


           /* unmanage actions */
           XtUnmanageChild(fileMgrPopup.action_separator);
           action_pane = (XmManagerWidget) fileMgrPopup.menu;
           for(i = num_of_children;
               i < action_pane->composite.num_children;
               i++)
             XtUnmanageChild(action_pane->composite.children[i]);
         }
         else
         {
           char *tmp_label;

           /* we have one file selected; attach fileViewData to buttons; */
           /* sensitize any desensitized buttons; update the actions     */
           /* part of the popup menu                                     */

           /* adjust callbacks */
           if( ! file_mgr_data->toolbox )
           {
             XtRemoveAllCallbacks(fileMgrPopup.objPopup[BTN_PROPERTIES],
                                  XmNactivateCallback);
             XtAddCallback(fileMgrPopup.objPopup[BTN_PROPERTIES],
                           XmNactivateCallback, ShowModAttrDialog, (XtPointer) fileViewData);
           }

            XtRemoveAllCallbacks(fileMgrPopup.objPopup[BTN_PUTON],
                                 XmNactivateCallback);
            XtAddCallback(fileMgrPopup.objPopup[BTN_PUTON],
                 XmNactivateCallback, PutOnDTCB, (XtPointer) fileViewData);

            XtRemoveAllCallbacks(fileMgrPopup.objPopup[BTN_TRASH],
                                 XmNactivateCallback);
            XtAddCallback(fileMgrPopup.objPopup[BTN_TRASH],
                 XmNactivateCallback, TrashFiles, (XtPointer) fileViewData);

           if ( file_mgr_data->toolbox && geteuid() != root_user &&
                   access(file_mgr_data->current_directory,W_OK|X_OK) != 0 )
             XtSetSensitive(fileMgrPopup.objPopup[BTN_TRASH], False);
           else
             XtSetSensitive(fileMgrPopup.objPopup[BTN_TRASH], True);


            XtRemoveAllCallbacks(fileMgrPopup.objPopup[BTN_HELP],
                                 XmNactivateCallback);
            XtAddCallback(fileMgrPopup.objPopup[BTN_HELP],
                 XmNactivateCallback, ObjectHelp, (XtPointer) fileViewData->widget);

            /* sensitize buttons */
            if( ! file_mgr_data->toolbox )
              XtSetSensitive(fileMgrPopup.objPopup[BTN_PROPERTIES], True);

            XtSetSensitive(fileMgrPopup.objPopup[BTN_PUTON], True);
            XtSetSensitive(fileMgrPopup.objPopup[BTN_HELP], True);

            if (fileViewData->file_data->action_name)
               tmp_label = fileViewData->file_data->action_name;
            else
               tmp_label = fileViewData->file_data->file_name;

            if( strlen( tmp_label ) > 20 )
              sprintf( label, "%-20.20s...", tmp_label );
            else
              sprintf( label, "%s", tmp_label );

            /* Set popup menu label */
            label_string = XmStringCreateLocalized (label);
            XtSetArg (args[0], XmNlabelString, label_string);
            XtSetValues (fileMgrPopup.title, args, 1);
            XtManageChild(fileMgrPopup.title);
            XmStringFree (label_string);


            /* update actions */
            XtManageChild(fileMgrPopup.action_separator);

            XtFree(fileMgrPopup.action_pane_file_type);
            fileMgrPopup.action_pane_file_type =
                XtNewString(fileViewData->file_data->logical_type);

            UpdateActionMenuPane ((XtPointer)fileViewData, file_mgr_rec,
                                  fileViewData->file_data->logical_type,
                                  FM_POPUP, num_of_children,
                                  fileMgrPopup.menu,
                                  fileViewData->file_data->physical_type);

            /* align actions */
            action_pane = (XmManagerWidget) fileMgrPopup.menu;
            XtSetArg(args[0], XmNmarginLeft, 0);
            for(i = num_of_children; i < action_pane->composite.num_children; i++)
              XtSetValues(action_pane->composite.children[i], args, 1);
         }
      }
   }


   /* position and manage popup menu */
   if(event == NULL)
   {
      Position x, y;
      Dimension width, height;
      Dimension gWidth, gHeight;
      int displayWidth, displayHeight;
      DtIconGadget  g = (DtIconGadget)w;

      XtSetArg (args[0], XmNwidth, &width);
      XtSetArg (args[1], XmNheight, &height);
      XtGetValues(XtParent(fileMgrPopup.menu), args, 2);

      gWidth = g->icon.pixmap_width;
      gHeight = g->icon.pixmap_height;

      displayWidth = DisplayWidth(XtDisplay(w), DefaultScreen(XtDisplay(w)));
      displayHeight =DisplayHeight(XtDisplay(w), DefaultScreen(XtDisplay(w)));

      x = file_mgr_rec->shell->core.x +
          file_mgr_rec->scroll_window->core.x +
          w->core.x + gWidth/2;;

      y = file_mgr_rec->shell->core.y +
          file_mgr_rec->header_frame->core.y +
          file_mgr_rec->header_frame->core.height +
          file_mgr_rec->scroll_window->core.y +
          w->core.y + gHeight/2;;

      if((Dimension)(x + width) > (Dimension)displayWidth)
         x = displayWidth - width - 4;
      if((Dimension)(y + height) > (Dimension)displayHeight)
         y = displayHeight - height - 4;

      XtSetArg (args[0], XmNx, x);
      XtSetArg (args[1], XmNy, y);
      XtSetValues(XtParent(fileMgrPopup.menu), args, 2);
   }
   else
   {
     if(( event->type == ButtonPress || event->type == ButtonRelease) ||
        ( ( event->type == KeyPress || event->type == KeyRelease) &&
          _XmIsEventUnique(event) ) )
     {
       XmMenuPosition(fileMgrPopup.menu, (XButtonPressedEvent *)event);
     }
   }

   XtManageChild(fileMgrPopup.menu);

   if( event->type == KeyPress || event->type == KeyRelease )
   {
     /* Specify that the focus is being moved by key, NOT mouse
     */
     _XmSetInDragMode(fileMgrPopup.menu,False);

     XmProcessTraversal(fileMgrPopup.menu,XmTRAVERSE_CURRENT);

     /* This function is being called twice.
        Record this event so the above check _XmIsEventUnique will work
     */
     _XmRecordEvent(event);
   }
}


static void
DropOnRootCB (
     Widget w,
     XtPointer client_data,
     XtPointer call_data)
{
   DtDndDropCallbackStruct *fileList = (DtDndDropCallbackStruct *)call_data;
   char * ptr;
   char ** file_set = NULL;
   char ** host_set = NULL;
   FileMgrRec * file_mgr_rec;
   FileMgrData * file_mgr_data;
   char   *next;
   int i, j;
   int wsNum;
   String end;
   String tmpStr;
   int numFiles;
   int effScreenWidth;
   int effScreenHeight;
   int start_x, start_y;
   int root_x, root_y;
   int step, dstep;

   /* Check the protocol, set to failure if not the */
   /* File Transfer protocol                        */
   if (fileList->dropData->protocol != DtDND_FILENAME_TRANSFER)
     {
       fileList->status = DtDND_FAILURE;
       return;
     }


   numFiles = fileList->dropData->numItems;

   DPRINTF (("DropOnRoot: Number of files dropped are %d\n", numFiles));

   if(fileList->reason != DtCR_DND_DROP_ANIMATE)
   {
      /* set the complete move flag to False since it is not required to be called */
      /* In case when the drag is from non File manager client */
      if(!dragActive)
	initiating_view = NULL;

      fileList->completeMove = False;

      _DtSetDroppedFileInfo(fileList, &file_set, &host_set);

      if(initiating_view != NULL)
      {
         file_mgr_rec = (FileMgrRec *)
                     (((FileMgrData *) initiating_view)->file_mgr_rec);
         file_mgr_data = (FileMgrData *) initiating_view;
      }
      else
         file_mgr_data = NULL;

      /* get the correct position for the desktop icon shell */
      PositionDesktopIcon(fileList->x, fileList->y, &root_x, &root_y);

      if (numFiles > 1)
      {
         /*
          * We will place the icons by marching down a diagonal starting
          * at the drop point.  But we don't want to march off-screen
          * if there are too many icons.  So ...
          *  - We choose a step width of 20, 10, 5, or 2 depending
          *    on the number of icons dropped.
          *  - When we run into the edge of the screen, we start a new
          *    diagonal shifted one step to the right.
          *  - If all icons still won't fit, we move the starting point
          *    closer to the top left corner of the screen.
          */

         /* compute effective screen size (largest x,y where an icon
          * can be placed without going off-screen) */
         effScreenWidth = WidthOfScreen(XtScreen(w)) - (4 + 4+48+4 + 5);
         effScreenHeight = HeightOfScreen(XtScreen(w)) - (4 + 4+48+3+15+4 + 5);

         /* chosee step depending on number of icons */
         if (numFiles <= 200)
           step = 20;
         else if (numFiles <= 400)
           step = 10;
         else  if (numFiles <= 1000)
           step = 5;
         else
           step = 2;
         dstep = 40 + 4+48+4 + 5;

         /* choose starting point so at least two icons will fit */
         if (root_x <= effScreenWidth - step)
           start_x = root_x;
         else
           start_x = effScreenWidth - step;

         if (root_y <= effScreenWidth - step)
           start_y = root_y;
         else
           start_y = effScreenWidth - step;

         DPRINTF(("DropOnRootCB: numFiles %d, root_x %d, root_y %d, step %d\n",
                  numFiles, root_x, root_y, step));

         /* check if all icons will fit */
         for (;;)
         {
           /* cacluclate how many will fit (add up icons on all diagonals) */
           int n = 0, nd = 0;
           for (root_x = start_x; root_x <= effScreenWidth; root_x += dstep)
           {
             int nx = (effScreenWidth - root_x)/step + 1;
             int ny = (effScreenHeight - start_y)/step + 1;
             n += (nx <= ny)? nx: ny;
             nd++;
           }

           DPRINTF(("start_x %d, start_y %d, nd %d, n %d\n",
                    start_x, start_y, nd, n));

           /* if everything fits - great! */
           if (n >= numFiles)
             break;

           /* move the start point closer to the top left corner */
           if (effScreenWidth - start_x < effScreenHeight - start_y &&
               start_x >= step)
           {
             /* move left so more icons will fit */
             start_x -= step;
           }
           else if (effScreenWidth - start_x > effScreenHeight - start_y &&
                    start_y >= step)
           {
             /* move up so one more icon will fit in each diagonal */
             start_y -= step;
           }
           else if (start_x > 0 || start_y > 0)
           {
             /* move left and up */
             if (start_x >= step)
               start_x -= step;
             else
               start_x = 0;
             if (start_y >= step)
               start_y -= step;
             else
               start_y = 0;
           }
           else
             /* ran out of space - too bad! */
             break;
         }
         root_x = start_x;
         root_y = start_y;
      }

      /* the icon that was dropped on the root window was an
         icon that was already on the root window */
      if (file_mgr_data == NULL)
      {
         DPRINTF(("DropOnRoot: Object already on Desktop\n"));

         /* loop through the existing desktop icons to determine which
            ones are being dragged, then change their location */
         for(i=0; i < desktop_data->numIconsUsed; i++)
         {
            if((Widget)desktop_data->desktopWindows[i]->iconGadget ==
                                                   (Widget)widget_dragged)
            {
               if (DTFileIsSelected(desktop_data->desktopWindows[i],
                      desktop_data->desktopWindows[i]->file_view_data))
               {
                 for(j=0;j< desktop_data->numWorkspaces;j++)
                   if(desktop_data->workspaceData[j]->number ==
                      desktop_data->desktopWindows[i]->workspace_num)
                     break;
                 wsNum = j;
                 for (j = 0;
                      j < desktop_data->workspaceData[wsNum]->files_selected;
                      j++)
                 {
                   RelocateDesktopIcon(desktop_data->workspaceData[wsNum]->
                                       selectedDTWindows[j],
                                       root_x, root_y);
                   root_x += step;
                   root_y += step;
                   if (root_x > effScreenWidth || root_y > effScreenHeight)
                   {
                     start_x += dstep;
                     if (start_x > effScreenWidth)
                       start_x = 0;
                     root_x = start_x;
                     root_y = start_y;
                   }
                 }
               }
               else
               {
                  RelocateDesktopIcon(desktop_data->desktopWindows[i],
                                      root_x, root_y);
                  break;
               }
            }
         }
      }
      else if( file_mgr_data == trashFileMgrData )
      {
         /* if the file manager data is the trash, we want to tell the
            user that they can't drop trash on the desktop
         */
         char * msg;
         char * tmpStr;

         DPRINTF(("DropOnRoot: Attempting to Drag Trash Object to Desktop\n"));
         file_mgr_rec = (FileMgrRec *)trashFileMgrData->file_mgr_rec;
         tmpStr = (GETMESSAGE(11,37, "You can't drop files from\nthe Trash Can on to the Workspace.\nTo remove an object from Trash,\n   -Select the object, and\n   -Choose 'Put Back'\nfrom the File menu or the object's popup menu.\nYou can then drag the object out of File Manager and drop it on\nthe Workspace backdrop."));
         msg = XtNewString(tmpStr);
         FileOperationError (file_mgr_rec->main, msg, NULL);
         XtFree(msg);
         return;
      }
      else /* it was dropped on the root window so lets process it */
      {
        int EndIndex = desktop_data->numIconsUsed;

        for(i = 0; i < numFiles; i++)
        {
          ptr = strrchr(file_set[i], '/');
          if( strcmp(file_mgr_data->current_directory, file_set[i]) == 0)
          {
            SetupDesktopWindow(XtDisplay(file_mgr_rec->shell),
                               file_mgr_data, file_mgr_rec,
                               ".", host_set[i], file_set[i],
                               root_x, root_y,
                               NULL,EndIndex);
          }
          else if(strncmp(file_mgr_data->current_directory, file_set[i], strlen(file_set[i]) ) == 0 )
          {
            SetupDesktopWindow(XtDisplay(file_mgr_rec->shell),
                               file_mgr_data, file_mgr_rec,
                               "..", host_set[i],file_mgr_data->current_directory,
                               root_x, root_y,
                               NULL,EndIndex);
          }
          else
          {
            *ptr = '\0';
            if(*(file_set[i]) == 0)
            {
              SetupDesktopWindow(XtDisplay(file_mgr_rec->shell),
                                 file_mgr_data, file_mgr_rec,
                                 ptr + 1, host_set[i], "/",
                                 root_x, root_y,
                                 NULL,EndIndex);
            }
            else
            {
              SetupDesktopWindow(XtDisplay(file_mgr_rec->shell),
                                 file_mgr_data, file_mgr_rec,
                                 ptr + 1, host_set[i], file_set[i],
                                 root_x, root_y,
                                 NULL,EndIndex);
            }
          }
          root_x += step;
          root_y += step;
          if (root_x > effScreenWidth || root_y > effScreenHeight)
          {
            start_x += dstep;
            if (start_x > effScreenWidth)
              start_x = 0;
            root_x = start_x;
            root_y = start_y;
          }
        }
        initiating_view = (XtPointer)NULL;
      }

      _DtFreeDroppedFileInfo(numFiles, file_set, host_set);

      return;
   }
}

/************************************************************************
 *
 *  FreeLayoutData
 *
 ************************************************************************/

void
FreeLayoutData(XtPointer p)
{
   IconLayoutData *layout_data;

   if (p == NULL)
      return;

   layout_data = (IconLayoutData *)p;

   if (layout_data->work_id != 0)
   {
      DPRINTF(("FreeLayoutData: removing workproc\n"));
      XtRemoveWorkProc(layout_data->work_id);
      XmDropSiteEndUpdate(layout_data->drop_site_w);
   }

   XtFree((char *)layout_data->order_list);
   layout_data->order_list = NULL;
   XtFree((char *)layout_data->reuse_icons);
   layout_data->reuse_icons = NULL;
   XtFree((char *)layout_data->reuse_btns);
   layout_data->reuse_btns = NULL;
   XtFree((char *)layout_data->manage);
   layout_data->manage = NULL;

   XtFree((char *)layout_data);
   layout_data = NULL;
}

/************************************************************************
 *
 *  UnmanageFileIcons
 *      Unmanage a subset of the file icons.
 *
 ************************************************************************/

void UnmanageFileIcons(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data)
{
   XmManagerWidget file_window;
   FileViewData **order_list;
   int order_count;
   int i, n;
   Widget *unmanage;
   Widget child;
   Arg args[20];


   /*  Set the size of the file window BIG so that it does not  */
   /*  try to force positioning on its children.                */

   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   XtResizeWidget ((Widget)file_window, 32767, 32767, 0);


   /*  Set the scrolled window and file window appropriately  */
   /*  to prevent a lot of gyrations.                         */

   XtSetArg (args[0], XmNscrollBarDisplayPolicy, XmSTATIC);
   XtSetValues (file_mgr_rec->scroll_window, args, 1);

   order_list = ((IconLayoutData *)file_mgr_data->layout_data)->order_list;
   order_count = ((IconLayoutData *)file_mgr_data->layout_data)->order_count;

   unmanage = (Widget *)XtMalloc(2*order_count*sizeof(Widget));
   n = 0;
   for (i = 0; i < order_count; i++)
   {
     if (order_list[i]->filtered)
       continue;

     if ((n > 0 || order_list[i] == file_view_data) &&
         !order_list[i]->need_update)
     {
       unmanage[n++] = order_list[i]->widget;
       if (order_list[i]->treebtn)
         unmanage[n++] = order_list[i]->treebtn;
     }
   }

   /* remember which icon currently has the focus */
   if (XtIsManaged(file_mgr_rec->file_window))
   {
      /* see if the focus is inside the file window */
      child = XmGetFocusWidget(file_mgr_rec->file_window);
      if (child != NULL && XtParent(child) == file_mgr_rec->file_window)
         file_mgr_rec->focus_widget = child;
   }

   /* unmanage the selected children */
   if (n > 0)
      XtUnmanageChildren(unmanage, n);

   XtFree((char *)unmanage);
}


/************************************************************************
 *
 *  UpdateFileIcons
 *      Create or reuse a set of file icons used to get the files
 *      displayed.  This is never called for the desktop.
 *
 ************************************************************************/

void
UpdateFileIcons(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        Boolean new_directory)
{
  _UpdateFileIcons(file_mgr_rec, file_mgr_data, new_directory, NULL);
}

void
AddFileIcons(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        DirectorySet * add_dir_set)
{
  _UpdateFileIcons(file_mgr_rec, file_mgr_data, False, add_dir_set);
}


/*--------------------------------------------------------------------
 * MakeReuseList
 *
 *   Background information:
 *     After a refresh on a directory we want to reuse old icon and tree
 *   button widgets instead of destroying the old widgets and creating
 *   new ones.  Fourthermore, we want to reuse the same widgets for the
 *   same files, so that if the icon and/or label didn't change, less
 *   work needs to be done in _UpdateFileIcons().
 *     For this reason, after a refresh the GetFileData() routine copies
 *   Widgets from the old FileViewData list to the new FileViewData list
 *   for files that are both on the old and new list (i.e., files that
 *   already existed before the refresh and are still there after the
 *   refresh).  This allows _UpdateFileIcons() to reuse the old
 *   widget.
 *
 *   The purpose of MakeReuseList() is to find widgets that are no
 *   longer found in the new FileViewData list.  These are widgets
 *   from files that disappeared after the refresh (either because the
 *   file was deleted or because file is now filtered out).  These
 *   widgets can then be reused by _UpdateFileIcons()for new files that
 *   just appeared after the refresh.
 *
 *------------------------------------------------------------------*/

/* compare function for qsort and bsearch */
static int
WidgetCmp(Widget *w1, Widget *w2)
{
  return *w1 - *w2;
}

static void
MakeReuseList(
        Widget *children,
        int num_children,
        FileViewData **order_list,
        int order_count,
        Widget **reuse_icons,
        Widget **reuse_btns)
{
#ifdef DEBUG
   int n_old, n_filtered, del_icon, del_btn;
#endif
   Widget *sorted_chilren = NULL;
   Boolean *reuse = NULL;
   int icon_count;
   int btn_count;
   int i;
   Widget *p;
   Widget w;

   /* allocate widget arrays */
   *reuse_icons = (Widget *)XtMalloc((num_children + 1)*sizeof(Widget));
   *reuse_btns = (Widget *)XtMalloc((num_children + 1)*sizeof(Widget));
   icon_count = btn_count = 0;

   /* only figure things out if we already have children */
   if (num_children > 0) {
     /* create a sorted list of children */
     sorted_chilren = (Widget *)XtMalloc(num_children * sizeof(Widget));
     memcpy(sorted_chilren, children, num_children * sizeof(Widget));
     qsort(sorted_chilren, num_children, sizeof(Widget), (int (*)())WidgetCmp);

     /* create reuse flags; initially assume all children can be reused */
     reuse = (Boolean *)XtMalloc(num_children * sizeof(Boolean));
     for (i = 0; i < num_children; i++)
       reuse[i] = True;

   /* reset reuse flag for all widgets found in order_list */
#ifdef DEBUG
     n_old = n_filtered = del_icon = del_btn = 0;
#endif
     for (i = 0; i < order_count; i++)
       {
	 if (order_list[i]->filtered &&
	     strcmp(order_list[i]->file_data->file_name, ".") != 0)
	   {
	     /* don't reuse this widget later */
#ifdef DEBUG
	     n_filtered++;
	     if (order_list[i]->widget)
	       del_icon++;
	     if (order_list[i]->treebtn)
	       del_btn++;
#endif
	     order_list[i]->widget =
	       order_list[i]->treebtn = NULL;
	   }
	 else
	   {
	     if (order_list[i]->widget)
	       {
		 p = bsearch(&order_list[i]->widget,
			     sorted_chilren, num_children, sizeof(Widget),
			     (int (*)())WidgetCmp);
		 if (p)
		   {
		     /* don't reuse this widget for any other file */
		     reuse[p - sorted_chilren] = False;
#ifdef DEBUG
		     n_old++;
#endif
		   }
		 else
		   {
		     /* don't reuse this widget later */
		     order_list[i]->widget = NULL;
#ifdef DEBUG
		     del_icon++;
#endif
		   }
	       }

	     if (order_list[i]->treebtn)
	       {
		 p = bsearch(&order_list[i]->treebtn,
			     sorted_chilren, num_children, sizeof(Widget),
			     (int (*)())WidgetCmp);
		 if (p)
		   {
		     /* don't reuse this widget for any other file */
		     reuse[p - sorted_chilren] = False;
		   }
		 else
		   {
		     /* don't reuse this widget later */
		     order_list[i]->treebtn = NULL;
#ifdef DEBUG
		     del_btn++;
#endif
		   }
	       }
	   }
       }

     /* copy reusable widgets into widget arrays */
     for (i = 0; i < num_children; i++)
       {
	 if (reuse[i])
	   {
	     /* this widget can be reused for new files */
	     w = sorted_chilren[i];
	     if (XtClass(w) == dtIconGadgetClass)
	       {
#ifndef DELAYED_UNREGISTER
		 Arg args[1];

		 XtSetArg (args[0], XmNdropSiteOperations, XmDROP_NOOP);
		 XtRemoveAllCallbacks(w, XmNdropCallback);
		 XtSetValues (w, args, 1);
#endif
		 (*reuse_icons)[icon_count++] = w;
	       }
	     else if (XtClass(w) == xmPushButtonGadgetClass)
	       (*reuse_btns)[btn_count++] = w;
	   }
       }
   }

   /* null-terminate the arrays */
   (*reuse_icons)[icon_count] = NULL;
   (*reuse_btns)[btn_count] = NULL;

   /* free storage */
   XtFree((char *)sorted_chilren);
   XtFree((char *)reuse);

   DPRINTF(("MakeReuseList: count %d (%d new, %d old, %d filtered)\n",
            order_count, order_count - n_filtered - n_old, n_old, n_filtered));
   DPRINTF(("               reuse %d + %d, del %d + %d\n",
            icon_count, btn_count, del_icon, del_btn));
}


/*--------------------------------------------------------------------
 * UpdateOneIconLabel
 *------------------------------------------------------------------*/

static void
UpdateOneIconLabel(
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data)
{
   char *label;
   char *s;

   /*  Get the label and icon to be used for the widget  */
   if (file_mgr_data->view != BY_ATTRIBUTES)
   {
      if (strcmp(file_view_data->file_data->file_name, "..") == 0)
      {
         /* label = ".. (go up)" */
         s = GetSharedMessage(UP_ONE_LEVEL_LABEL);
         label = (char *)XtMalloc(2 + strlen(s) + 1);
         strcpy(label, "..");
         strcat(label, s);
      }
      else if (file_mgr_data->view == BY_NAME &&
               file_view_data->file_data->physical_type == DtDIRECTORY &&
               file_mgr_data->show_type != MULTIPLE_DIRECTORY)
      {
         /* label = "name/" */
         label = (char *)XtMalloc(
                             strlen(file_view_data->file_data->file_name) + 2);
         strcpy(label, file_view_data->file_data->file_name);
         strcat(label, "/");
      }
      else if (file_mgr_data->view == BY_NAME &&
               file_view_data->file_data->physical_type == DtEXECUTABLE)
      {
         /* label = "name*" */
         label = (char *)XtMalloc(
                             strlen(file_view_data->file_data->file_name) + 2);
         strcpy(label, file_view_data->file_data->file_name);
         strcat(label, "*");
      }
      else if(file_view_data->file_data->action_name != NULL)
         /* label = action name */
         label = XtNewString(file_view_data->file_data->action_name);
      else
         /* label = file name */
         label = XtNewString(file_view_data->file_data->file_name);
   }
   else /* file_mgr_data->view == BY_ATTRIBUTES */
   {
      /* label = file name + attributes */
      label = GetLongName(file_view_data->file_data);
      if (strcmp(file_view_data->file_data->file_name, "..") == 0)
      {
         s = GetSharedMessage(UP_ONE_LEVEL_LABEL);
         label = (char *)XtRealloc(label, strlen(label) + strlen(s) + 1);
         strcat(label, s);
      }
   }

   /* store new label */
   XtFree(file_view_data->label);
   file_view_data->label = label;
}


/*--------------------------------------------------------------------
 * UpdateOneFileIcon
 *------------------------------------------------------------------*/

static void
UpdateOneFileIcon(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data)
{
   XmString icon_label;
   char *logical_type;
   PixmapData *pixmapData;
   Widget icon_widget;
   Widget btn_widget;
   Boolean is_instance_icon;
   Boolean instance_icon_changed;
   Arg args[35];
   int n_color_args;
   int argi_imageName;
   int n;

   XmManagerWidget file_window = (XmManagerWidget) file_mgr_rec->file_window;
   DirectorySet *directory_set = (DirectorySet *)file_view_data->directory_set;
   IconLayoutData *layout_data = (IconLayoutData *)file_mgr_data->layout_data;

   /* Get the label and icon to be used for the widget */
   if (!file_view_data->label)
     UpdateOneIconLabel(file_mgr_data, file_view_data);

   icon_label = XmStringCreateLocalized(file_view_data->label);

   /*  Get the icon name based on the file type  */

   logical_type = file_view_data->file_data->logical_type;

   if (file_mgr_data->view == BY_NAME)
      pixmapData = NULL;
   else if (openDirType == NEW &&
               file_view_data->file_data->physical_type == DtDIRECTORY)
   {
      pixmapData = CheckForOpenDirectory(file_view_data,
                                         directory_set,
                                         file_mgr_data,
                                         logical_type);
   }
   else
   {
      if (file_mgr_data->view == BY_NAME_AND_ICON)
         pixmapData = _DtRetrievePixmapData(
                         logical_type,
                         file_view_data->file_data->file_name,
                         directory_set->name,
                         (Widget) file_window,
                         LARGE);
      else
         pixmapData = _DtRetrievePixmapData(
                         logical_type,
                         file_view_data->file_data->file_name,
                         directory_set->name,
                         (Widget) file_window,
                         SMALL);
   }

   /* check if this is an instance icon */
   is_instance_icon = False;
   if (pixmapData != NULL)
   {
     char tmp[1024];

     strcpy(tmp, directory_set->name);
     strcat(tmp, "/");
     strcat(tmp, file_view_data->file_data->file_name);
     if (strcmp(pixmapData->iconFileName, tmp) == 0)
        is_instance_icon = True;
   }

   /* check if instance icon was modified */
   instance_icon_changed = False;
   if (is_instance_icon)
   {
     if (file_view_data->icon_mtime != file_view_data->file_data->stat.st_mtime)
     {
        if (file_view_data->icon_mtime != 0)
           instance_icon_changed = True;
        file_view_data->icon_mtime = file_view_data->file_data->stat.st_mtime;
     }
   }
   else
     file_view_data->icon_mtime = 0;

   /* Build the arg list for color resources.  */
   n = 0;
   XtSetArg (args[n], XmNarmColor, white_pixel);                     n++;

   if (layout_data->background == white_pixel)
   {
      if (file_view_data->selected)
      {
         XtSetArg (args[n], XmNbackground, black_pixel);             n++;
         XtSetArg (args[n], XmNforeground, white_pixel);             n++;
      }
      else
      {
         XtSetArg (args[n], XmNbackground, white_pixel);             n++;
         XtSetArg (args[n], XmNforeground, layout_data->foreground); n++;
      }
      XtSetArg (args[n], XmNpixmapBackground, white_pixel);          n++;
      XtSetArg (args[n], XmNpixmapForeground, black_pixel);          n++;
   }
   else if (layout_data->background == black_pixel)
   {
      if (file_view_data->selected)
      {
         XtSetArg (args[n], XmNbackground, white_pixel);             n++;
         XtSetArg (args[n], XmNforeground, black_pixel);             n++;
      }
      else
      {
         XtSetArg (args[n], XmNbackground, black_pixel);             n++;
         XtSetArg (args[n], XmNforeground, layout_data->foreground); n++;
      }
      XtSetArg (args[n], XmNpixmapBackground, white_pixel);          n++;
      XtSetArg (args[n], XmNpixmapForeground, black_pixel);          n++;
   }
   else
   {
      if (file_view_data->selected)
      {
         XtSetArg (args[n], XmNbackground, white_pixel);             n++;
         XtSetArg (args[n], XmNforeground, black_pixel);             n++;
         XtSetArg (args[n], XmNpixmapBackground, white_pixel);       n++;
         XtSetArg (args[n], XmNpixmapForeground, black_pixel);       n++;
      }
      else
      {
         XtSetArg (args[n], XmNbackground, layout_data->background); n++;
         XtSetArg (args[n], XmNforeground, layout_data->foreground); n++;
         XtSetArg (args[n], XmNpixmapBackground, layout_data->pixmap_back); n++;
         XtSetArg (args[n], XmNpixmapForeground, layout_data->pixmap_fore); n++;
      }
   }

   n_color_args = n;

   /* Build the rest of the arg list and either create or reuse the widget. */

   XtSetArg (args[n], XmNstring, icon_label);                        n++;
   argi_imageName = n;
   if (pixmapData)
     XtSetArg (args[n], XmNimageName, pixmapData->iconFileName);
   else
     XtSetArg (args[n], XmNimageName, NULL);
   n++;
   XtSetArg (args[n], XmNmaxPixmapWidth, layout_data->pixmap_width);   n++;
   XtSetArg (args[n], XmNmaxPixmapHeight, layout_data->pixmap_height); n++;
   XtSetArg (args[n], XmNuserData, directory_set);                     n++;
   XtSetArg (args[n], XmNunderline, False);                            n++;
   XtSetArg (args[n], XmNfillMode, XmFILL_TRANSPARENT);                n++;
   if (file_mgr_data->view == BY_NAME_AND_ICON &&
       file_mgr_data->show_type != MULTIPLE_DIRECTORY)
      XtSetArg (args[n], XmNpixmapPosition, XmPIXMAP_TOP);
   else
      XtSetArg (args[n], XmNpixmapPosition, XmPIXMAP_LEFT);            n++;

   /* See if we can re-use the same or some other icon gadget */
   if (file_view_data->widget)
      icon_widget = file_view_data->widget;
   else if (*layout_data->next_icon_to_use)
      icon_widget = *layout_data->next_icon_to_use++;
   else
      icon_widget = NULL;

   /* See if we found an available icon gadget */
   if (icon_widget)
   {
      /* reuse the icon gadget */
      if (icon_widget != file_view_data->widget || file_mgr_data->newSize)
      {
         XtSetArg (args[n], XmNdropSiteOperations, XmDROP_NOOP);n++;
         XtRemoveAllCallbacks(icon_widget, XmNdropCallback);
         file_view_data->registered = False;
      }
      XtRemoveAllCallbacks (icon_widget, XmNcallback);

      /* if instance_icon_changed, force destroy of old pixmap */
      if (instance_icon_changed)
         XtSetArg (args[argi_imageName], XmNimageName, NULL);

      /*
       * Move the gadget off the visible area; this avoids unnecessary
       * redraw events at the old position when the gadget is moved to
       * the correct position once it is determined in LayoutFileIcons.
       */
      icon_widget->core.x = -999;
      icon_widget->core.y = -999;
      XtSetValues (icon_widget, args, n);

      if (instance_icon_changed && pixmapData)
      {
         XtSetArg (args[0], XmNimageName, pixmapData->iconFileName);
         XtSetValues (icon_widget, args, 1);
      }
   }
   else
   {
      /* create a new or duplicate an existing widget */
      XtSetArg (args[n], XmNshadowThickness, 2);             n++;
      XtSetArg (args[n], XmNdropSiteOperations, XmDROP_NOOP);n++;
      XtSetArg (args[n], XmNfontList, user_font);            n++;
      if( keybdFocusPolicy == XmEXPLICIT)
      {
         XtSetArg (args[n], XmNtraversalOn, True);           n++;
      }
      else
      {
         XtSetArg (args[n], XmNtraversalOn, False);          n++;
         XtSetArg (args[n], XmNhighlightThickness, 0);       n++;
      }
      XtSetArg (args[n], XmNborderType, DtNON_RECTANGLE);   n++;

      if (layout_data->dup_icon_widget == NULL)
      {
#ifdef HARDCODED_ICON_MARGINS
         XtSetArg (args[n], XmNmarginWidth, 0);  n++;
         XtSetArg (args[n], XmNmarginHeight, 0); n++;
#endif
         XtSetArg (args[n], XmNx, -999);  n++;
         XtSetArg (args[n], XmNy, -999);  n++;
         icon_widget = layout_data->dup_icon_widget =
                   _DtCreateIcon ((Widget)file_window, "icon", args, n);
      }
      else
      {
         DtIconGadget g;
         int i = n_color_args;

         icon_widget = _DtDuplicateIcon ((Widget)file_window,
                       layout_data->dup_icon_widget,
                       icon_label,
                       (pixmapData? pixmapData->iconFileName: NULL),
                       (XtPointer)directory_set, /* userData */
                       False);                   /* underline */
         g = (DtIconGadget)icon_widget;
         g->gadget.highlighted = False;
         g->gadget.highlight_drawn = False;

         /*
          * Move the gadget off the visible area; this avoids unnecessary
          * redraw events at the old position when the gadget is moved to
          * the correct position once it is determined in LayoutFileIcons.
          */
         icon_widget->core.x = -999;
         icon_widget->core.y = -999;

         /* make sure colors, drop operations, and clipping are right */
         XtSetArg(args[i], XmNdropSiteOperations, XmDROP_NOOP);             i++;
         XtSetArg(args[i], XmNmaxPixmapWidth, layout_data->pixmap_width);   i++;
         XtSetArg(args[i], XmNmaxPixmapHeight, layout_data->pixmap_height); i++;
         XtSetValues (icon_widget, args, i);
      }
      XtAddCallback(icon_widget, XmNhelpCallback,
                    (XtCallbackProc)HelpRequestCB, NULL);
      file_view_data->registered = False;
   }

   if (file_mgr_data->view != BY_NAME)
      _DtCheckAndFreePixmapData(logical_type,
                                (Widget) file_window,
                                (DtIconGadget) icon_widget,
                                pixmapData);

#ifdef _SHOW_LINK
   if (file_view_data->file_data->link != 0)
   {
      XtSetArg (args[0], XmNforeground, layout_data->topshadow);
      XtSetValues (icon_widget, args, 1);
   }
#endif

   /*
    * If viewing by attributes, adjust spacing between the icon pixmap and
    * the file name so that all file names are aligned.
    */
   if (file_mgr_data->view != BY_NAME_AND_ICON ||
       file_mgr_data->show_type == MULTIPLE_DIRECTORY)
   {
     Dimension pixmap_width = ((DtIconGadget)icon_widget)->icon.pixmap_width;

     if (pixmap_width < layout_data->pixmap_width)
     {
        XtSetArg (args[0], XmNspacing,
              layout_data->spacing + layout_data->pixmap_width - pixmap_width);
        XtSetValues (icon_widget, args, 1);
     }
   }


   file_view_data->file_data->is_broken = False;
   file_view_data->widget = icon_widget;
   XtAddCallback (icon_widget, XmNcallback, (XtCallbackProc)IconCallback,
                  file_view_data);

   XmStringFree (icon_label);

   /* Check if we need a button for tree branch expand */

   if (file_mgr_data->show_type != MULTIPLE_DIRECTORY ||
       !file_view_data->file_data->is_subdir)
   {
     /* no tree branch expand button needed */
     file_view_data->treebtn = NULL;
   }
   else
   {
     /* create a tree branch expand button */
     Pixmap px = GetTreebtnPixmap(file_mgr_data, file_view_data);

     n = 0;
     XtSetArg(args[n], XmNlabelType, XmPIXMAP);                 n++;
     XtSetArg(args[n], XmNlabelPixmap, px);                     n++;
     XtSetArg(args[n], XmNbackground, layout_data->background); n++;
     XtSetArg(args[n], XmNtraversalOn, False);                  n++;
     XtSetArg(args[n], XmNhighlightThickness, 0);               n++;
     XtSetArg(args[n], XmNshadowThickness, 0);                  n++;
     XtSetArg(args[n], XmNmarginWidth, 0);                      n++;
     XtSetArg(args[n], XmNmarginHeight, 0);                     n++;
     XtSetArg(args[n], XmNuserData, file_mgr_data);             n++;
     XtSetArg(args[n], XmNx, -999);                             n++;
     XtSetArg(args[n], XmNy, -999);                             n++;

     /* See if we can re-use the same or some other button gadget */
     if (file_view_data->treebtn)
        btn_widget = file_view_data->treebtn;
     else if (*layout_data->next_btn_to_use)
        btn_widget = *(layout_data->next_btn_to_use)++;
     else
        btn_widget = NULL;

     /* See if we found an available button gadget */
     if (btn_widget) {
        XtRemoveAllCallbacks (btn_widget, XmNactivateCallback);
        XtSetValues (btn_widget, args, n);
     }
     else
     {
       btn_widget = XmCreatePushButtonGadget((Widget)file_window,
                                             "tree_button", args, n);
     }
     XtAddCallback(btn_widget, XmNactivateCallback,
                    (XtCallbackProc)TreeBtnCallback, file_view_data);

     file_view_data->treebtn = btn_widget;
   }

   /* this entry is now up-to-date */
   file_view_data->need_update = False;
}


/*--------------------------------------------------------------------
 * _UpdateFileIcons
 *------------------------------------------------------------------*/

static void
_UpdateFileIcons(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        Boolean new_directory,
        DirectorySet * add_dir_set)
{
   XmManagerWidget file_window;
   FileViewData **order_list;
   int order_count;
   Widget child;
   Arg args[5];
   IconLayoutData *layout_data;
   int i;

#ifdef DT_PERFORMANCE
   struct timeval update_time_s;
   struct timeval update_time_f;
#endif

   DPRINTF(("_UpdateFileIcons(\"%s\", new_dir %c, add_dir_set %p) ...\n",
            file_mgr_data->current_directory,
            new_directory? 'T': 'F', add_dir_set));

   /*  Set the size of the file window BIG so that it does not  */
   /*  try to force positioning on its children.                */
   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   XtResizeWidget ((Widget)file_window, 32767, 32767, 0);

   /*  Set the scrolled window and file window appropriately  */
   /*  to prevent a lot of gyrations.                         */

   XtSetArg (args[0], XmNscrollBarDisplayPolicy, XmSTATIC);
   XtSetValues (file_mgr_rec->scroll_window, args, 1);

   /* For faster updates, unmanage all the icons */
   if (XtIsManaged(file_mgr_rec->file_window))
   {
      /* see if the focus is inside the file window */
      child = XmGetFocusWidget(file_mgr_rec->file_window);
      if (child != NULL)
      {
        if (new_directory)
        {
          file_mgr_rec->focus_widget = file_mgr_rec->file_window;
        }
        else if( XtParent(child) == file_mgr_rec->file_window )
        {
          /* remember which widget had the focus */
          file_mgr_rec->focus_widget = child;
        }
      }

      DPRINTF(("  focus_widget = %p (%s)\n",
               file_mgr_rec->focus_widget,
               file_mgr_rec->focus_widget?
                  XtName(file_mgr_rec->focus_widget): "nil"));
      XtUnmanageChild(file_mgr_rec->file_window);
   }

   XtUnmanageChildren(file_window->composite.children,
                      file_window->composite.num_children);

   /* if this is a new directory, scroll to the top */
   if (new_directory)
   {
      XtSetArg (args[0], XmNx, 0);
      XtSetArg (args[1], XmNy, 0);
      XtSetValues ((Widget)file_window, args, 2);
   }

   /*
    * Don't leave the view in a munged state for too long.
    * Only do if we are not creating a new view.  This is because the
    * view is not yet in the 'view_list', and so the redisplay code
    * may not use the correct redisplay function.
    */
   if (ReturnDesktopPtr(file_mgr_rec->file_window))
   {
      UpdateHeaders(file_mgr_rec, file_mgr_data, False);
      XFlush (XtDisplay (file_window));
      XmUpdateDisplay ((Widget)file_window);
   }

   /* free any old layout data */
   FreeLayoutData(file_mgr_data->layout_data);
   file_mgr_data->layout_data = NULL;

   /* if directory-read still in progress, don't do anything more now */
   if (file_mgr_data->busy_status != not_busy)
   {
      DPRINTF(("done (busy)\n"));
      return;
   }

#ifdef DT_PERFORMANCE
   printf("   Beginning UpdateFileIcons\n");
   gettimeofday(&update_time_s, NULL);

   /* added by Rafi */
   _DtPerfChkpntMsgSend("Begin Update Icons");

#endif

   /* set up new layout data */
   layout_data = (IconLayoutData *)XtCalloc(1, sizeof(IconLayoutData));
   file_mgr_data->layout_data = (XtPointer)layout_data;

   FlattenTree(file_mgr_data, &order_list, &order_count);
   layout_data->order_list = order_list;
   layout_data->order_count = order_count;

   MakeReuseList(file_window->composite.children,
                 file_window->composite.num_children,
                 order_list, order_count,
                 &layout_data->reuse_icons,
                 &layout_data->reuse_btns);
   layout_data->next_icon_to_use = layout_data->reuse_icons;
   layout_data->next_btn_to_use = layout_data->reuse_btns;

   layout_data->manage = (Widget *)XtMalloc(2*order_count*sizeof(Widget));
   layout_data->manage_count = 0;

   layout_data->i_do_next_vis = 0;
   layout_data->i_do_next_all = 0;

   /*
    * Iterate through the file list and mark all entries to be in
    * need of update.  We also construct icon labels at this time,
    * since they are need by LayoutFileIcons to estimate icon gadget
    * sizes.
    */

   if (add_dir_set)
   {
     /* only need to iterate throught the new entries */;
     order_list = add_dir_set->order_list;
     order_count = add_dir_set->file_count;
   }

   for (i = 0; i < order_count; i++)
   {
      order_list[i]->need_update = True;
      order_list[i]->selected = False;
      UpdateOneIconLabel(file_mgr_data, order_list[i]);
   }

   /* set selected flag on all files in selection_list */
   for (i = 0; i < file_mgr_data->selected_file_count; i++)
      file_mgr_data->selection_list[i]->selected = True;

#ifdef DT_PERFORMANCE
   gettimeofday(&update_time_f, NULL);
   if (update_time_s.tv_usec > update_time_f.tv_usec) {
      update_time_f.tv_usec += 1000000;
      update_time_f.tv_sec--;
   }
   printf("    done UpdateFileIcons, time: %ld.%ld\n\n", update_time_f.tv_sec - update_time_s.tv_sec, update_time_f.tv_usec - update_time_s.tv_usec);

   /* added by Rafi */
   _DtPerfChkpntMsgSend("Done  Update Icons");
#endif

   DPRINTF(("done\n"));
}




/************************************************************************
 *
 *  CreateTreeIcons
 *      Create icons for tree-branch-expand buttons.
 *
 ************************************************************************/

static void
CreateTreeIcons(Widget w)
{
  Arg args[20];
  Pixel  background_color = 0;
  Pixel  foreground_color = 0;
  int i, j;
  TreePxId px;
  char pxname[128];
  unsigned int width, height, dummy;

  XtSetArg (args[0], XmNbackground, &background_color);
  XtSetArg (args[1], XmNforeground, &foreground_color);
  XtGetValues (w, args, 2);

  for (i = 0; i < 3; i++)
  {
    TreeBtnWd[i] = 5;
    TreeBtnHt[i] = 5;
    for (j = 0; j < tpxN; j++)
    {
      strcpy(pxname, TreePxTab[j].name);
      strcat(pxname, TreePxSuffix[i]);
      TreePxTab[j].px[i] = _DtGetPixmap(XtScreen(w), pxname,
                                     foreground_color, background_color);
      width = height = 0;
      XGetGeometry(XtDisplay(w), TreePxTab[j].px[i],
                   (Window *) &dummy,               /* returned root window */
                   (int *) &dummy, (int *) &dummy,  /* x, y of pixmap */
                   &width, &height,                 /* pixmap width, height */
                   &dummy, &dummy);                 /* border width, depth */
      if (j == tpxNil)
      {
         TreeNilWd[i] = width;
         TreeNilHt[i] = height;
      }
      else
      {
         if (width > TreeBtnWd[i])
           TreeBtnWd[i] = width;
         if (height > TreeBtnHt[i])
           TreeBtnHt[i] = height;
      }
    }
  }
}


/************************************************************************
 *
 *  GetTreebtnPixmap
 *      Get icon for tree-branch-expand buttons.
 *
 ************************************************************************/

Pixmap GetTreebtnPixmap(
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data)
{
   TreePxId pxid;

   /* if not yet done, create tree button icons */
   /* @@@ do this earlier from main? */
   if (TreeBtnWd[0] == 0)
     CreateTreeIcons(((FileMgrRec *)file_mgr_data->file_mgr_rec)->file_window);

   if (file_view_data->ts == tsNotRead)
     pxid = tpxNotRead;
   else if (file_view_data->ts == tsError)
     pxid = tpxError;
   else if (file_view_data->ndir == 0 &&
            (file_view_data->nfile == 0 ||
             file_mgr_data->tree_files == TREE_FILES_NEVER)
             && (file_view_data->ts == tsNone || !showEmptySet))
     pxid = tpxEmpty;
   else if (file_view_data->ts == tsNone)
     pxid = tpxMore;
   else if (file_view_data->ts == tsDirs)
     pxid = (file_view_data->nfile == 0 ||
             file_mgr_data->tree_files == TREE_FILES_NEVER)? tpxLess:
            (file_view_data->ndir == 0)?  tpxMore:
                                          tpxBoth;
   else if (file_view_data->ts == tsAll)
     pxid = tpxLess;

   if (file_mgr_data->view == BY_NAME)
     return TreePxTab[pxid].px[0];   /* small pixmap */
   else if (file_mgr_data->view == BY_NAME_AND_ICON)
     return TreePxTab[pxid].px[2];   /* large pixmap */
   else
     return TreePxTab[pxid].px[1];   /* medium  pixmap */
}


/************************************************************************
 *
 *  GetIconSize
 *      Compute maximum icon size.
 *
 ************************************************************************/

static void
GetIconLayoutParms(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        IconLayoutData *ld)
{
   DirectorySet *directory_set;
   int file_count;
   FileViewData **file_list;
   int i;
   DtIconGadget g;
   Arg args[10];
   Dimension shadowThickness;
   Dimension marginWidth;
   Dimension maxWidth = ld->pixmap_width;
   Dimension gadgetWidth;

   /* determine pixmap size */
   if (file_mgr_data->view == BY_NAME)
   {
      /* no pixmap */
      ld->pixmap_width = 0;
      ld->pixmap_height = 0;
   }
   else if (file_mgr_data->view == BY_NAME_AND_ICON)
   {
      /* large pixmap */
      ld->pixmap_width = largeIconWidth;
      ld->pixmap_height = largeIconHeight;
   }
   else
   {
      /* small pixmap */
      ld->pixmap_width = smallIconWidth;
      ld->pixmap_height = smallIconHeight;
   }

   /* find the icon gadget for "." */
   directory_set = file_mgr_data->directory_set[0];
   file_count = directory_set->file_count;
   file_list = directory_set->file_view_data;

   g = NULL;
   for (i = 0; i < file_count; i++)
   {
      if (strcmp(file_list[i]->file_data->file_name, ".") == 0)
      {
         g = (DtIconGadget)file_list[i]->widget;
         break;
      }
   }

   /* get layout parameters from "." */
   if (g)
   {
      XtSetArg(args[0], XmNhighlightThickness, &ld->highlight);
      XtSetArg(args[1], XmNshadowThickness, &shadowThickness);
      XtSetArg(args[2], XmNmarginWidth, &marginWidth);
      XtSetArg(args[3], XmNspacing, &ld->spacing);
      XtSetArg(args[4], XmNalignment, &ld->alignment);
      XtSetArg(args[5], XmNpixmapPosition, &ld->pixmap_position);
      XtGetValues((Widget)g, args, 6);

      if (g->icon.pixmap_width < maxWidth)
         ld->spacing = ld->spacing - (maxWidth - g->icon.pixmap_width);

      ld->width = ((Widget)g)->core.width +
                                     ld->pixmap_width  - g->icon.pixmap_width;
      ld->height = ((Widget)g)->core.height +
                                     ld->pixmap_height - g->icon.pixmap_height;

      ld->char_width = (g->icon.string_width)/strlen(file_list[i]->label);
      if (ld->pixmap_position != XmPIXMAP_TOP)
         ld->width -= g->icon.string_width;
      ld->margin = ld->highlight + shadowThickness + marginWidth;
   }
   else
   {
      /* No icon gadget for "." found: strange!  Guess some defaults.  */
      ld->char_width = 8;
      ld->margin = 2 + 1 + 1;
      ld->spacing = 2;
      ld->highlight = (keybdFocusPolicy == XmEXPLICIT)? 2: 0;
      ld->alignment = XmALIGNMENT_END;
      if (file_mgr_data->view == BY_NAME_AND_ICON &&
          file_mgr_data->show_type != MULTIPLE_DIRECTORY)
      {
         ld->pixmap_position = XmPIXMAP_TOP;
         ld->width = 2*ld->margin + ld->pixmap_width;
         ld->height = 2*ld->margin + ld->pixmap_height + ld->spacing + 14;
      }
      else
      {
         ld->pixmap_position = XmPIXMAP_LEFT;
         ld->width = 2*ld->margin + ld->pixmap_width +
                                                 ld->spacing + ld->char_width;
         ld->height = 2*ld->margin + ld->pixmap_height;
      }
   }

   /* determine which size tree buttons to use */
   if (file_mgr_data->show_type != MULTIPLE_DIRECTORY)
      ld->treebtn_size = 0;   /* no tree buttons needed */
   else if (file_mgr_data->view == BY_NAME)
      ld->treebtn_size = 0;   /* small size */
   else if (file_mgr_data->view == BY_NAME_AND_ICON)
      ld->treebtn_size = 2;   /* large size */
   else
      ld->treebtn_size = 1;   /* medium size */
}


static void
EstimateIconSize(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        IconLayoutData *layout_data,
        FileViewData *file_view_data,
        Dimension *width,
        Dimension *height)
{
   int label_len;
   int label_width;

   if (file_view_data == NULL)
      label_len = 1;
   else if (file_view_data->label == NULL)
      label_len = strlen(file_view_data->file_data->file_name);
   else
      label_len = strlen(file_view_data->label);

   if (layout_data->pixmap_position == XmPIXMAP_TOP)
   {
      label_width = 2*layout_data->margin + label_len*layout_data->char_width;
      if ((Dimension)label_width > layout_data->width)
         *width = label_width;
      else
         *width = layout_data->width;
   }
   else
        *width = layout_data->width + (label_len) * layout_data->char_width;
   *height = layout_data->height;
}


/************************************************************************
 *
 *  GetExtraHeight
 *    Compute extra height for drawing nil symbol for empty tree branches.
 *
 ************************************************************************/

static Dimension
GetExtraHeight(
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data,
        int treebtn_size)
{
   if (showEmptySet &&
       file_view_data->file_data->is_subdir &&
       file_view_data->ts >= tsDirs &&
       file_view_data->ndir == 0 &&
       (file_view_data->nfile == 0 ||
        file_mgr_data->tree_files == TREE_FILES_NEVER))
   {
      return YSPACING(file_mgr_data) + TreeNilHt[treebtn_size];
   }
   else
      return 0;
}


/************************************************************************
 *
 *  EraseTreeLines
 *    Erase connecting lines in tree mode from a specified icon widget
 *    on down; called when a tree branch is expanded or collapsed to
 *    erase previous tree lines before drawing new icons and tree lines.
 *
 ************************************************************************/

void
EraseTreeLines(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        FileViewData *file_view_data)
{
   XmManagerWidget file_window;
   Dimension fw_width, fw_height;
   Position x, y;

   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   if (!XtIsManaged((Widget)file_window))
      return;

   /* get upper left corner of grid space for the icon widget */
   x = file_view_data->x;
   y = file_view_data->y - file_mgr_data->grid_height;

   /*  Get file window width and height */
   fw_width = file_window->core.width;
   fw_height = file_window->core.height;

   DPRINTF2(("EraseTreeLines(\"%s\"): x/y %d/%d (widget %d/%d)\n",
             file_view_data->file_data->file_name, x, y,
             file_view_data->widget->core.x,
             file_view_data->widget->core.y));

   /* clear area from icon widget to bottom of file window */
   XClearArea(XtDisplay(file_window), XtWindow(file_window),
              x, y, fw_width - x, fw_height - y, False);

   /*
    * clear area to the right and above the icon widget
    * (necessary if there are multiple columns, which happens if
    *  there are more icons than fit into a single column of
    *  maximum height 32767)
    */
   if (y > 0  &&  (Dimension)(x + file_mgr_data->grid_width) < fw_width)
   {
     x += file_mgr_data->grid_width;
     XClearArea(XtDisplay(file_window), XtWindow(file_window),
                x, 0, fw_width - x, y, False);
   }
}


/************************************************************************
 *
 *  RedrawTreeLines
 *      Redraw connecting lines in tree mode.
 *
 ************************************************************************/

void
RedrawTreeLines(
        Widget w,
        int ex, int ey, int ewidth, int eheight, int ecount,
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data)
{
   static char *empty_msg = NULL;

   FileViewData *file_view_data;
   IconLayoutData *layout_data;
   Dimension grid_width, grid_height;
   Dimension extra_height, e_height;
   int sz;
   FileViewData **order_list;
   int order_count;
   GC solid_gc, dash_gc;
   int i, k;
   Position x, xl;
   Position y, y0, y1;
   int level;
   Bool more[256];
   XFontSetExtents *extents;
   int font_height;
   int font_yoffset;
   int tmp;

   if (!XtIsManaged(w))
      return;

   /*  get layout parameters  */
   layout_data = (IconLayoutData *)file_mgr_data->layout_data;
   order_list = layout_data->order_list;
   order_count = layout_data->order_count;
   grid_width = file_mgr_data->grid_width;
   grid_height = file_mgr_data->grid_height;
   sz = layout_data->treebtn_size;

   DPRINTF2(("RedrawTreeLines(x %d, y %d, wd %d, ht %d, count %d)\n",
             ex, ey, ewidth, eheight, ecount));

   if (grid_width == 0 || grid_height == 0)
      /* layout probably not yet done */
      return;

   /* if not yet done, create tree button icons */
   /* @@@ do this earlier from main? */
   if (TreeBtnWd[0] == 0)
     CreateTreeIcons(((FileMgrRec *)file_mgr_data->file_mgr_rec)->file_window);

   /* select line styles */
   if (file_mgr_data->view == BY_NAME) {
     solid_gc = file_mgr_data->tree_solid_thin_gc;
     dash_gc = file_mgr_data->tree_dash_thin_gc;
   } else {
     solid_gc = file_mgr_data->tree_solid_thick_gc;
     dash_gc = file_mgr_data->tree_dash_thick_gc;
   }

   x = MARGIN;
   y = MARGIN;

   for (k = 0; k < order_count; k++)
   {
      if (!order_list[k]->displayed)
         continue;

      /* determine the height of this item */
      file_view_data = order_list[k];
      extra_height = GetExtraHeight(file_mgr_data, file_view_data, sz);
      GetLevel(file_view_data, &level);

      /* check if we need to go to the next column */
      tmp = (int)y + grid_height + extra_height + YSPACING(file_mgr_data);
      if (tmp + MARGIN > MAXWINSIZE)
      {
        /* window would exceed height limit; go to the next column */
        x += grid_width + XSPACING;
        y = MARGIN;
        tmp = (int)y + grid_height + extra_height + YSPACING(file_mgr_data);
      }

      /* check if current item intersects the exposed region */
      y0 = y - YSPACING(file_mgr_data)
             - grid_height
             + (Dimension)(grid_height - TreeBtnHt[sz])/(Dimension)2
             + TreeBtnHt[sz];
      y1 = y + grid_height + extra_height + YSPACING(file_mgr_data);
      if (x  <= ex + ewidth  && x + TreeWd(level, sz) > ex &&
          y0 <= ey + eheight && y1 > ey)
      {
         GetAncestorInfo(file_mgr_data, file_view_data, NULL, NULL, more);

         /* draw vertical connecting lines for upper tree levels */
         for (i = 0; i < level; i++) {
           if (more[i])
             XDrawLine(XtDisplay(w), XtWindow(w), solid_gc,
                       x + TreeLX(i, sz), y0,
                       x + TreeLX(i, sz), y1);
         }

         /* draw vertical connecting line for this tree level */
         xl = x + TreeLX(level, sz);
         if (level > 0) {
           XDrawLine(XtDisplay(w), XtWindow(w), solid_gc,
                     xl, y0,
                     xl, more[level]? y1: y + grid_height/2);

           if (file_view_data->file_data->is_subdir || !more[level]) {
             /* draw horizontal line */
             XDrawLine(XtDisplay(w), XtWindow(w),
                       (file_view_data->file_data->is_subdir &&
                        file_view_data->ts == tsNotRead)? dash_gc: solid_gc,
                       xl, y + grid_height/2,
                       xl + TreeOffset, y + grid_height/2);
           }
         }

         /* draw nil symbol for empty subdirs */
         if (extra_height)
         {
            xl += TreeOneWd(sz);
            y0 += grid_height + YSPACING(file_mgr_data);
            y1 = y + grid_height + YSPACING(file_mgr_data);
            e_height = extra_height - YSPACING(file_mgr_data);

            XDrawLine(XtDisplay(w), XtWindow(w), solid_gc,
                      xl, y0,
                      xl, y1 + e_height/2);

            XDrawLine(XtDisplay(w), XtWindow(w), solid_gc,
                      xl, y1 + e_height/2,
                      xl + TreeOffset, y1 + e_height/2);

            xl = x + TreeWd(level, sz) + TreeBtnWd[sz];
            XCopyArea(XtDisplay(w), TreePxTab[tpxNil].px[sz],
                      XtWindow(w), solid_gc,
                      0, 0, TreeNilWd[sz], TreeNilHt[sz],
                      xl, y1);
/*
            if (empty_msg == NULL)
               empty_msg = XtNewString("(empty)");

            if (file_mgr_data->cd_fonttype == XmFONT_IS_FONTSET)
            {
                extents = XExtentsOfFontSet(file_mgr_data->cd_fontset);
                font_yoffset = extents->max_logical_extent.y;
                font_height = extents->max_logical_extent.height;
            }
            else
            {
                font_yoffset = file_mgr_data->cd_font->ascent;
                font_height = file_mgr_data->cd_font->ascent +
                                file_mgr_data->cd_font->descent;
            }

            XDrawImageString(XtDisplay(w), XtWindow(w), solid_gc,
                      xl + TreeNilWd[sz] + 2,
                      y1 + (TreeNilHt[sz] - font_height)/2 + font_yoffset,
                      empty_msg, strlen(empty_msg));
*/
         }
      }

      /* goto next item */
      y = (Position)tmp;
   }
}


/************************************************************************
 *
 *  DisplaySomeIcons
 *    Check if any incons or widgets in the area given by ex, ey, ewd,
 *    and eht need to be updated.
 *
 ************************************************************************/

#ifdef DEBUG
static int g_workCount1 = 0;
static int g_workCount2 = 0;
static int g_callCount = 0;
#endif

static Boolean
ToBeManaged(
        IconLayoutData *layout_data,
        FileViewData *file_view_data)
{
   int i;

   for (i = 0; i < layout_data->manage_count; i++)
      if (layout_data->manage[i] == file_view_data->widget)
         return True;

   return False;
}


static int
DisplaySomeIcons(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        int ex, int ey, int ewd, int eht,
        int workLimit,
        Boolean doAll)
{
#ifdef DT_PERFORMANCE
   struct timeval update_time_s;
   struct timeval update_time_f;
#endif
   XmManagerWidget file_window;
   FileViewData **order_list;
   int order_count;
   Arg args[10];
   Arg args_dso_get[1];
   Arg args_dso_set[1];
   IconLayoutData *layout_data;
   FileViewData **change;
   int changeCount;
   Widget *manage;
   int manageCount;
   int workCount1;
   int workCount2;
   Dimension grid_width, grid_height;
   Dimension icon_width, icon_height;
   Dimension extra_height;
   int i, k;
   Position x, y;
   FileViewData  *file_view_data;
   Boolean changed;
   Widget child;
   DtIconGadget g;
   int level;
   unsigned char operations;
   Widget *wp;
   ObjectPosition *position_data;
   XRectangle textExtent;

   /* Get a list of icon and button widgets we can re-use */
   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   layout_data = (IconLayoutData *)file_mgr_data->layout_data;
   order_list = layout_data->order_list;
   order_count = layout_data->order_count;
   manage = layout_data->manage + layout_data->manage_count;

   /* allocate storage for list of changed icons */
   change = (FileViewData **)XtMalloc(order_count * sizeof(FileViewData *));

   /*  Find the maximum values for the icon heights and widths  */
   grid_width = file_mgr_data->grid_width;
   grid_height = file_mgr_data->grid_height;


#ifdef DT_PERFORMANCE
   printf("   Begin Part 1, DisplaySomeIcons (update icons)\n");
   gettimeofday(&update_time_s, NULL);

   /* added by Rafi */
   _DtPerfChkpntMsgSend("Begin Display Icons");
#endif

   DPRINTF2((
     "DisplaySomeIcons(\"%s\", x/y %d/%d, wd/ht %d/%d, i %d:%d) ...\n",
     file_mgr_data->current_directory, ex, ey, ewd, eht,
     layout_data->i_do_next_vis,
     layout_data->i_do_next_all));

   /* set up args for querying/unregistering drop sites */
   XtSetArg (args_dso_get[0], XmNdropSiteOperations, &operations);
   XtSetArg (args_dso_set[0], XmNdropSiteOperations, XmDROP_NOOP);

   /*
    * Iterate through the list of files and create/update and position
    * all visible icon gadgets for which this work hasn't been done yet
    * (need_update flag set).
    */

   changeCount = 0;
   manageCount = 0;
   workCount1 = 0;

   if (doAll)
      k = layout_data->i_do_next_all;
   else
      k = layout_data->i_do_next_vis;
   for ( ; k < order_count && workCount1 < workLimit; k++)
   {
      /*
       * Process focus widget before everything else so that we can restore
       * the focus when we manage the file_window again.  If a file was
       * being renamed, we do that one first.
       */
      if (!layout_data->focus_done)
      {
         /* search for focus widget in order_list and see if still displayed */
        file_view_data = NULL;
        if (file_mgr_rec->focus_widget != NULL)
        {
          if (file_mgr_rec->focus_widget == file_mgr_rec->file_window)
          {
            for (i = 0; i < order_count; i++)
              if (order_list[i]->displayed)
              {
                file_view_data = order_list[i];
                break;
              }
          }
          else
          {
            for (i = 0; i < order_count; i++)
              if (order_list[i]->widget == file_mgr_rec->focus_widget)
              {
                if (order_list[i]->displayed)
                  file_view_data = order_list[i];
                break;
              }
          }
        }

         /* if not found, focus could be on a rename text widget */
        if (file_view_data == NULL)
          file_view_data = file_mgr_data->renaming;

        layout_data->focus_done = True;

        if (file_view_data)
        {
          k--;
          /* decrement loop index, so that the entry that was supposed to be
             processed here will be looked at again in the next iteration
          */
          goto do_this_entry;
        }
      }


      /* ignore files that are filtered */
      file_view_data = order_list[k];
      if (file_view_data->filtered &&
          strcmp(file_view_data->file_data->file_name, ".") != 0)
      {
         continue;
      }

      /*
       * If the file is not currenly displayed (collapsed tree branch) or
       * is currenly scrolled out of view, we don't need to do anything
       * at this time.  Except ...
       */
      if (!file_view_data->displayed ||
          ((int)file_view_data->x + (int)grid_width) < ex  ||
          file_view_data->x >= ex + ewd ||
          file_view_data->y < ey ||
          ((int)file_view_data->y - (int)grid_height) >= (ey + eht))
      {
         /*
          * ... if this file still has an old icon widget, AND if the
          * old icon position is visible, AND if the icon was registered
          * as a drop site, we will have a "ghost drop zone" showing up where
          * the icon used to be.  The old icon gadget is unmanaged and will
          * remain unmanaged until later when we update it and move it to the
          * correct positon (happens only when the user scrolls to the new
          * position).  In the meantime, even though the gadget is unmanged,
          * its old position still remains registered as a drop site,
          * so we have to either unregister it or move the gadget to
          * its new position now.
          */
         child = file_view_data->widget;
         if (child != NULL &&
             (Position)(child->core.x + child->core.width) >= (Position)ex  &&
             child->core.x < ex + ewd &&
             (Position)(child->core.y + child->core.height) >= (Position)ey &&
             child->core.y < ey + eht)
         {
            if (!file_view_data->displayed)
            {
               XtGetValues (child, args_dso_get, 1);
               if (operations != XmDROP_NOOP)
               {
                  XtSetValues (child, args_dso_set, 1);
                  workCount1++;
                  file_view_data->registered = False;
               }
               continue;
            }

         } else
           continue;
      }

do_this_entry:
      /*
       * If not yet done, create/update the icon gadget for this file
       */
      if (file_view_data->need_update)
      {
         UpdateOneFileIcon(file_mgr_rec, file_mgr_data, file_view_data);
         child = file_view_data->widget;

         /*
          * We may need to adjust the icon position based on the difference
          * between estimated size and actual size.
          */
         if (layout_data->alignment == XmALIGNMENT_CENTER &&
             file_mgr_data->view == BY_NAME_AND_ICON)
         {
            EstimateIconSize(file_mgr_rec, file_mgr_data, layout_data,
                             file_view_data, &icon_width, &icon_height);

            if (child->core.width != icon_width)
            {
               file_view_data->x = file_view_data->x
                 - (Dimension)(grid_width - icon_width)/(Dimension)2
                 + (Dimension)(grid_width - child->core.width)/(Dimension)2;
            }
         }

         if (PositioningEnabledInView(file_mgr_data))
         {
            position_data = file_view_data->position_info;
            if (position_data->late_bind)
            {
               /*
                * When new objects are dropped on the random placement window,
                * they do not yet have a widget, so the drop_y could not be
                * adjusted to take into account the height of the icon;
                * this must be done now, after the object has an icon.
                */
/*
               position_data->y -= child->core.height/2;
*/
               position_data->late_bind = False;
               file_view_data->y = position_data->y + child->core.height;
            }
            else if (child->core.height != grid_height)
            {
               /* @@@ ??? @@@
                * Not quite right: have to distinguish two cases:
                *  (1) position_data->y read from .!xxx file
                *      file_view_data->y computed by adding grid_height
                *  (2) file_view_data->y from layout
                *      position_data->y computed by subtracting grid_height
                * In case (1) have to recompute file_view_data->y; in case
                * (2) have to recompute position_data->y.  Code below only
                * works for case (2).
                */
/*
               position_data->y = file_view_data->y - child->core.height;
*/
            }
         }

         changed = True;
      }
      else
         changed = False;


      /* if focus is supposed to be in the file window, focus on this widget */
      if (file_mgr_rec->focus_widget == file_mgr_rec->file_window)
         file_mgr_rec->focus_widget = file_view_data->widget;


      /* determine desired icon postition */
      child = file_view_data->widget;

      if (PositioningEnabledInView(file_mgr_data))
      {
         x = file_view_data->position_info->x;
         y = file_view_data->position_info->y;
      }
      else if (file_mgr_data->show_type != MULTIPLE_DIRECTORY)
      {
         x = file_view_data->x;
         y = file_view_data->y - child->core.height;
      }
      else /* file_mgr_data->show_type == MULTIPLE_DIRECTORY */
      {
         GetLevel(file_view_data, &level);
         extra_height = GetExtraHeight(file_mgr_data, file_view_data,
                                       layout_data->treebtn_size);

         /* check position of tree button, if any */
         if (file_view_data->treebtn)
         {
           child = file_view_data->treebtn;

           x = file_view_data->x
                 + TreeLX(level, layout_data->treebtn_size) + TreeOffset;
           y = file_view_data->y
               - grid_height
               + (Dimension)(grid_height - child->core.height)/(Dimension)2;

           if (child->core.x != x || child->core.y != y)
              XmeConfigureObject(child, x, y, child->core.width,
				 child->core.height, child->core.border_width);

           child = file_view_data->widget;
         }

         if (child->core.height < grid_height)
         {
            x = file_view_data->x + TreeWd(level, layout_data->treebtn_size);
            y = file_view_data->y
                - grid_height
                +(Dimension)(grid_height - child->core.height)/(Dimension)2;
         }
         else
         {
            x = file_view_data->x + TreeWd(level, layout_data->treebtn_size);
            y = file_view_data->y - grid_height;
         }
      }

      if (child->core.x != x || child->core.y != y)
      {
	  XmeConfigureObject(child, x, y, child->core.width,
			     child->core.height, child->core.border_width);
	  changed = True;
      }

      /* make sure the icon gadget and tree button, if any, are managed */
      if (!XtIsManaged(child) && !ToBeManaged(layout_data, file_view_data))
      {
         manage[manageCount++] = child;
         if (file_view_data->treebtn)
            manage[manageCount++] = file_view_data->treebtn;
         changed = True;
      }

      if (changed)
      {
         /* remember which icons were changed */
         change[changeCount++] = file_view_data;
         workCount1++;

         /*
          * If the icon we just changed was being renamed, make sure
          * the corresponding text widget is positioned correctly.
          */
         if (file_view_data == file_mgr_data->renaming)
         {
            for (i = 0; i < file_window->composite.num_children; i++)
            {
               child = file_window->composite.children[i];
               if (XmIsTextField(child))
               {
                  /* Check if the text field is still needed */
                  if (!child->core.being_destroyed)
                  {
                     /* move to the correct position */
                     _DtIconGetTextExtent_r(file_view_data->widget,
					    &textExtent);
                     x = textExtent.x;
                     y = textExtent.y -
                         (Dimension)(child->core.height - textExtent.height)/(Dimension)2;
		     XmeConfigureObject(child, x, y, child->core.width,
					child->core.height,
					child->core.border_width);

                     /* manage it */
                     manage[manageCount++] = child;
                  }
                  break;
               }
            }
         }
      }
   }

   /* remember where we left off ... */
   if (doAll)
      layout_data->i_do_next_all = k;
   else
      layout_data->i_do_next_vis = k;

#ifdef DT_PERFORMANCE
   gettimeofday(&update_time_f, NULL);
   if (update_time_s.tv_usec > update_time_f.tv_usec) {
      update_time_f.tv_usec += 1000000;
      update_time_f.tv_sec--;
   }
   printf("    done Part 1, DisplaySomeIcons, time: %ld.%ld\n\n",
          update_time_f.tv_sec - update_time_s.tv_sec,
          update_time_f.tv_usec - update_time_s.tv_usec);

   /* the following message send call added by Rafi */
   _DtPerfChkpntMsgSend("Done  Display Icons");
#endif

#ifdef DT_PERFORMANCE
   printf("   Begin Part 2, DisplaySomeIcons (register drop sites)\n");
   gettimeofday(&update_time_s, NULL);

   /* added by Rafi  */
   _DtPerfChkpntMsgSend("Begin Register drop sites");
#endif

   /* unregister drop sites of unused icon gadgets */
   workCount2 = 0;
#ifdef DELAYED_UNREGISTER
   for (wp = layout_data->next_icon_to_use;
        (child = *wp) != NULL;
        wp++)
   {
      if ((Position)(child->core.x + child->core.width) >= (Position)ex  &&
          child->core.x < ex + ewd &&
          (Position)(child->core.y + child->core.height) >= (Position)ey &&
          child->core.y < ey + eht)
      {
         XtGetValues (child, args_dso_get, 1);
         if (operations != XmDROP_NOOP)
         {
            XtSetValues (child, args_dso_set, 1);
            workCount2++;

            if (workCount2/2 >= workLimit)
               break;
         }
      }
   }
#endif

   /*
    * Register drop sites
    *
    * Note: in "as placed" mode, we defer this work and do it in
    * CommitWorkProcUpdates instead.  Reason: need to re-register
    * all drop sites in top-to-bottom stacking order at that time.
    */
   if (! PositioningEnabledInView(file_mgr_data) &&
       file_mgr_data != trashFileMgrData)
   {
      for (k = 0; k < changeCount; k++)
      {
         SetHotRects(change[k],
                     (XtCallbackProc) DropOnObject,
                     (XtPointer) change[k]);
      }
   }

   /* free storage */
   XtFree((char *)change);
   change = NULL;

   /* update count of children to be managed */
   layout_data->manage_count += manageCount;


#ifdef DT_PERFORMANCE
   gettimeofday(&update_time_f, NULL);
   if (update_time_s.tv_usec > update_time_f.tv_usec) {
      update_time_f.tv_usec += 1000000;
      update_time_f.tv_sec--;
   }
   printf("    done Part 2 DisplaySomeIcons, time: %ld.%ld\n\n",
          update_time_f.tv_sec - update_time_s.tv_sec,
          update_time_f.tv_usec - update_time_s.tv_usec);

   /* the following message send call added by Rafi */
   _DtPerfChkpntMsgSend("Done  Register drop sites");
#endif

   DPRINTF2((" ... %d+%d changed (%d managed)\n",
             workCount1, workCount2, manageCount));

#ifdef DEBUG
   g_workCount1 += workCount1;
   g_workCount2 += workCount2;
   g_callCount++;
#endif

   return (workCount1 >= workCount2)? workCount1: workCount2;
}


/************************************************************************
 *
 *  Display work procedure
 *
 ************************************************************************/

static void
CommitWorkProcUpdates(
  FileMgrRec *file_mgr_rec,
  FileMgrData * file_mgr_data,
  Boolean reset)
{
   XmManagerWidget file_window;
   IconLayoutData *layout_data;
   Widget w;
   int i;

   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   layout_data = (IconLayoutData *)file_mgr_data->layout_data;

   if (layout_data == NULL)
     return;

   DPRINTF((
    "CommitWorkProcUpdates: %d+%d updates (m %d, n %d, i %d:%d, reset %d)\n",
            g_workCount1,
            g_workCount2,
            layout_data->manage_count,
            g_callCount,
            layout_data->i_do_next_vis,
            layout_data->i_do_next_all,
            reset));

#ifdef DEBUG
   g_workCount1 = 0;
   g_workCount2 = 0;
   g_callCount = 0;
#endif

   if (reset)
   {
      layout_data->i_do_next_vis = 0;
      layout_data->i_do_next_all = 0;
   }

   /* if work proc no longer active, everything should already be commited */
   if (layout_data->work_id == 0)
     return;

   /* manage new children */
   if (layout_data->manage_count > 0)
   {
      if (PositioningEnabledInView(file_mgr_data))
         OrderChildrenList(file_mgr_data);
      XtManageChildren(layout_data->manage, layout_data->manage_count);
   }

   /*
    * In "as placed" mode, need to register drop sites now.
    * (If not "as placed" mode, this was already done in DisplaySomeIcons.)
    */
   if (PositioningEnabledInView(file_mgr_data))
      RegisterDesktopHotspots(file_mgr_data, file_mgr_rec);

   /* commit drop site updates */
   XmDropSiteEndUpdate(layout_data->drop_site_w);

   /* If not managed yet, manage the file window again */
   if (!XtIsManaged((Widget)file_window))
   {
     XtArgVal incr;
     Arg args[2];

     XtManageChild ((Widget)file_window);
     XtVaGetValues(file_mgr_rec->vertical_scroll_bar,XmNuserData,&incr,NULL);
     if (VerticalScrollbarIsVisible(file_mgr_rec->vertical_scroll_bar,
                                    file_mgr_rec->scroll_window)
         && incr > 0 )
     {
        XtSetArg (args[0], XmNincrement,incr);
        XtSetValues (file_mgr_rec->vertical_scroll_bar, args, 1);
     }
     XmUpdateDisplay ((Widget)file_window);
   }

   /* Try to preserve the focus */
   if (file_mgr_rec->focus_widget)
   {
      /* see if the widget that previously had the focus was just managed */
      w = NULL;
      for (i = 0; i < layout_data->manage_count; i++)
      {
         if (layout_data->manage[i] == file_mgr_rec->focus_widget)
         {
            w = file_mgr_rec->focus_widget;
            break;
         }
      }

      /* if focus widget not found, set focus on file_window */
      if (w == NULL)
         w = (Widget)file_window;

      XmProcessTraversal(w, XmTRAVERSE_CURRENT);

      file_mgr_rec->focus_widget = NULL;
   }

   layout_data->manage_count = 0;

   /* start new update */
   XmDropSiteStartUpdate(layout_data->drop_site_w);
}


static Boolean
DisplayWorkProc(
  XtPointer client_data)
{
   FileMgrRec *file_mgr_rec = (FileMgrRec *)client_data;
   DialogData  * dialog_data;
   FileMgrData * file_mgr_data;
   XmManagerWidget file_window;
   IconLayoutData *layout_data;
   int ex, ey, ewd, eht;
   ObjectPosition *bottom;
   Widget child;
   int n;
   Boolean commit_updates = False;

   int n1 = 1;
   int n2 = 1;

   dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
   if (dialog_data == NULL)
      return False;

   file_mgr_data = (FileMgrData *) dialog_data->data;
   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   layout_data = (IconLayoutData *)file_mgr_data->layout_data;

   /* get the position and size of the currently visible area */
   ex = -file_window->core.x;
   ey = -file_window->core.y;
   ewd = XtParent(file_window)->core.width;
   eht = XtParent(file_window)->core.height;

   /* check if the window scrolled */
   if (ex != layout_data->ex || ey != layout_data->ey)
   {
      layout_data->i_do_next_vis = layout_data->i_do_next_all;
      layout_data->visible_done = False;
   }

   /* first work on icons in the currently visible area */
   if (layout_data->visible_done)
      n = 0;
   else
   {
     n = DisplaySomeIcons(file_mgr_rec, file_mgr_data, ex, ey, ewd, eht, n1, False);
     if (n == 0)
     {
       /* we just finished updating all visible icons */
       DPRINTF(("DisplayWorkProc: visible done.\n"));
       layout_data->visible_done = True;
       commit_updates = True;
     }
   }

   /* if we still have some time left, work on other icons */
   if (layout_data->visible_done && n < n2)
   {
      n = DisplaySomeIcons(file_mgr_rec, file_mgr_data,
                           0, 0, 32767, 32767, n2 - n, True);

      /* check if we are done */
      if (n == 0)
      {
         layout_data->all_done = True;
         commit_updates = True;
      }
      else if (layout_data->manage_count >= 100)
         commit_updates = True;
   }

   if (commit_updates)
   {
      /* manage new children and commit drop site updates */
      CommitWorkProcUpdates(file_mgr_rec, file_mgr_data, False);

      /*
       * In "as placed" mode, icons may overlap.
       * Force redraw in bottom to top stacking order.
       */
      if (PositioningEnabledInView(file_mgr_data))
      {
         for (bottom = GetBottomOfStack(file_mgr_data);
              bottom;
              bottom = (ObjectPosition *)bottom->prev)
         {
            if (bottom->file_view_data != NULL &&
                bottom->file_view_data->displayed &&
                !bottom->file_view_data->need_update)
            {
               child = bottom->file_view_data->widget;
               if ((Position)(child->core.x + child->core.width) >= (Position)ex  &&
                   child->core.x < ex + ewd &&
                   (Position)(child->core.y + child->core.height) >= (Position)ey &&
                   child->core.y < ey + eht)
               {
                  RedrawOneGadget(child, NULL, NULL);
               }
            }
         }
      }
   }

   if (layout_data->all_done)
   {
      /* all work is done; all icons are up-to-date */
      file_mgr_data->newSize = False;
      layout_data->work_id = 0;
      XmDropSiteEndUpdate(layout_data->drop_site_w);

      DPRINTF(("DisplayWorkProc: all done.\n"));

      /* returning True will end the work proc */
      return True;
   }
   else
   {
      /* remember current scroll position */
      layout_data->ex = ex;
      layout_data->ey = ey;
      return False;
   }
}


/************************************************************************
 *
 *  LayoutFileIcons
 *      Position and size the full set of icons for the file mgr data.
 *
 ************************************************************************/

void
LayoutFileIcons(
        FileMgrRec *file_mgr_rec,
        FileMgrData *file_mgr_data,
        Boolean update_scrolling_position,
        Boolean turn_off_hourglass )
{
#ifdef DT_PERFORMANCE
   struct timeval update_time_s;
   struct timeval update_time_f;
#endif
   XmManagerWidget file_window;
   FileViewData ** order_list;
   int order_count;
   int total_icon_count;
   IconLayoutData *layout_data;
   Dimension file_window_width, file_window_height;
   Dimension scrolled_window_width, scrolled_window_height;
   Dimension vert_scrollbar_width, horiz_scrollbar_height;
   Dimension grid_width, grid_height;
   Dimension icon_width, icon_height;
   Dimension extra_height;
   Dimension sw_shadow_thickness, sb_highlight_thickness, space;
   int len, max_len;
   int level, max_level;
   FileViewData *file_view_data;
   Boolean overflow = False;
   int i, j, k;
   Position x, y;
   int row_count;
   int column_count;
   int tmp;
   Arg args[10];
   char *fileType;

   unsigned char operations = 0L;
   static XtCallbackRec dropCB[] = { {DropOnFileWindow, NULL}, {NULL, NULL} };


   /* if directory-read still in progress, don't do anything now */
   if (file_mgr_data->busy_status != not_busy)
      return;

   DPRINTF(("LayoutFileIcons(\"%s\", u_s_p %c, t_o_h %c) ...\n",
            file_mgr_data->current_directory,
            update_scrolling_position? 'T': 'F',
            turn_off_hourglass? 'T': 'F'));

#ifdef DT_PERFORMANCE
   printf("   Begin LayoutFileIcons\n");
   gettimeofday(&update_time_s, NULL);

   /* added by Rafi */
   _DtPerfChkpntMsgSend("Begin Layout Icons");
#endif

   /*
    * Just in case a previous update work proc is still active,
    * we commit pending updates made by the work proc before we
    * start making changes.
    */
   CommitWorkProcUpdates(file_mgr_rec, file_mgr_data, True);

   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   layout_data = (IconLayoutData *)file_mgr_data->layout_data;

   fileType = GetDirectoryLogicalType(file_mgr_data,
                                        file_mgr_data->current_directory);
   operations = TypeToDropOperations(fileType);

   if (!file_mgr_data->dropSite)
   {
       dropCB[0].closure = (XtPointer)file_mgr_data;

       DtDndVaDropRegister((Widget)file_mgr_rec->file_window,
                           DtDND_FILENAME_TRANSFER | DtDND_BUFFER_TRANSFER,
                           operations,
                           dropCB,
                           DtNdropAnimateCallback, dropCB,
                           DtNregisterChildren, True,
                           DtNtextIsBuffer,	True,
                           XmNanimationStyle,	XmDRAG_UNDER_SHADOW_IN,
                           NULL);
       file_mgr_data->dropSite = True;

       if (!operations)
       {
           XtSetArg (args[0], XmNdropSiteOperations, XmDROP_NOOP);
           XmDropSiteUpdate((Widget)file_mgr_rec->file_window, args, 1);
       }
   }
   else
   {
       if (operations)
           XtSetArg (args[0], XmNdropSiteOperations, operations);
       else
           XtSetArg (args[0], XmNdropSiteOperations, XmDROP_NOOP);
       XmDropSiteUpdate((Widget)file_mgr_rec->file_window, args, 1);
   }

   /*  Get the count of the total icon to be displayed.  */
   order_list = layout_data->order_list;
   order_count = layout_data->order_count;
   total_icon_count = 0;
   for (i = 0; i < order_count; i++)
   {
      if (order_list[i]->displayed)
         total_icon_count++;
   }

   /*  Get the colors to be used for drawing the icons  */
   XtSetArg (args[0], XmNbackground, &layout_data->background);
   XtSetArg (args[1], XmNforeground, &layout_data->foreground);
#ifdef _SHOW_LINK
   XtSetArg (args[2], XmNtopShadowColor, &layout_data->topshadow);
   XtGetValues (file_mgr_rec->file_window, args, 3);
#else
   XtGetValues (file_mgr_rec->file_window, args, 2);
#endif
   XtSetArg (args[0], XmNtopShadowColor, &layout_data->pixmap_back);
   XtSetArg (args[1], XmNbottomShadowColor, &layout_data->pixmap_fore);
   XtGetValues (file_mgr_rec->main, args, 2);

   /*
    * Create/update icon gadget for ".".
    * This gadget may not actually be displayed (depends of filter settings;
    * by default it is filtered out), but we need at least one gadget
    * created here so we can figure out fonts and margins used by icon
    * gadgets.  This is necessary to compute the grid spacing.
    */
   for (i = 0; i < order_count; i++)
      if (strcmp(order_list[i]->file_data->file_name, ".") == 0)
      {
         UpdateOneFileIcon(file_mgr_rec, file_mgr_data, order_list[i]);
         order_list[i]->need_update = True;
         break;
      }

   /* Find the icon with the longest label */
   max_len = 0;
   file_view_data = NULL;
   for (i = 0; i < order_count; i++)
   {
      if (!order_list[i]->filtered &&
          (len = strlen(order_list[i]->label)) > max_len)
      {
         file_view_data = order_list[i];
         max_len = len;
      }
   }

   /* get the size of the icon with the longest label */
   GetIconLayoutParms(file_mgr_rec, file_mgr_data, layout_data);
   EstimateIconSize(file_mgr_rec, file_mgr_data, layout_data, file_view_data,
                    &grid_width, &grid_height);

   /* for tree view add space for tree lines and buttons */
   max_level = 0;
   if (file_mgr_data->show_type == MULTIPLE_DIRECTORY)
   {
      for (i = 0; i < order_count; i++)
      {
         if (order_list[i]->displayed)
         {
            GetLevel(order_list[i], &level);
            if (level > max_level)
               max_level = level;
         }
      }
      grid_width += TreeWd(max_level, layout_data->treebtn_size);
   }

   file_mgr_data->grid_height = grid_height;
   file_mgr_data->grid_width = grid_width;

   /*
    * If positioning is enabled in this view, then we need to use the other
    * layout function, which is capable of handling overlapping icons and
    * stacking order.
    */
   if (PositioningEnabledInView(file_mgr_data))
   {
      if (file_mgr_data->object_positions)
      {
         LayoutDesktopIcons(file_mgr_rec, file_mgr_data,
			    order_list, order_count, turn_off_hourglass);
         /* RepairFileWindow(file_mgr_data); *OBSOLETE* */
         goto layout_done;
      }
   }

   /*
    * Position and size the icons according to the show and view types.
    */

   scrolled_window_width = file_mgr_rec->scroll_window->core.width;
   scrolled_window_height = file_mgr_rec->scroll_window->core.height;
   vert_scrollbar_width = file_mgr_rec->vertical_scroll_bar->core.width;
   horiz_scrollbar_height = file_mgr_rec->horizontal_scroll_bar->core.height;

   if (file_mgr_data->show_type == MULTIPLE_DIRECTORY)
   {
     /* if not yet done, create tree button icons */
     if (TreeBtnWd[0] == 0)
       CreateTreeIcons(file_mgr_rec->file_window);

     /* layout for tree mode */
     x = MARGIN;
     y = MARGIN;
     file_window_width = MARGIN + grid_width - TreeOffset + XSPACING;

     for (k = 0; k < order_count; k++)
     {
       if (!order_list[k]->displayed)
         continue;

       /* make sure window height won't exceed limit */
       extra_height = GetExtraHeight(file_mgr_data, order_list[k],
                                     layout_data->treebtn_size);
       tmp = (int)y + grid_height + extra_height + YSPACING(file_mgr_data);
       if (tmp + MARGIN > MAXWINSIZE)
       {
         /* window would exceed height limit; start a new column */
         x += grid_width + XSPACING;
         y = MARGIN;
         file_window_width += grid_width + XSPACING;
         tmp = (int)y + grid_height + extra_height + YSPACING(file_mgr_data);
         overflow = True;
       }

       order_list[k]->x = x;
       order_list[k]->y = y + grid_height;

       /* update y */
       y = (Position)tmp;
     }

     if (overflow)
       file_window_height = MAXWINSIZE;
     else
       file_window_height = y + MARGIN;
   }
   else if (file_mgr_data->view == BY_ATTRIBUTES)
   {
      /* layout for details view, no tree mode */
      x = MARGIN;
      y = MARGIN;
      file_window_width = 2*MARGIN + grid_width;

      for (k = 0; k < order_count; k++)
      {
         if (!order_list[k]->displayed)
            continue;

         /* make sure window height won't exceed limit */
         tmp = (int)y + grid_height + YSPACING(file_mgr_data);
         if (tmp + MARGIN > MAXWINSIZE)
         {
            /* window would exceed height limit; start a new column */
            x += grid_width + XSPACING;
            y = MARGIN;
            file_window_width += grid_width + XSPACING;
            tmp = (int)y + grid_height + YSPACING(file_mgr_data);
            overflow = True;
         }

         order_list[k]->x = x;
         order_list[k]->y = y + grid_height;

         /* update y */
         y = (Position)tmp;
      }

      if (overflow)
         file_window_height = MAXWINSIZE;
      else
         file_window_height = y + MARGIN;
   }
   else  /* show_type == SINGLE_DIRECTORY, view != BY_ATTRIBUTES */
   {
      /* layout for "normal" views (no tree mode, no details) */

      /* calculate how many columns fit in the window width */
     column_count = ((int)scrolled_window_width - 4 - 2*MARGIN + XSPACING) /
       ((int)grid_width + XSPACING);
     if (column_count == 0)
       column_count = 1;  /* need at least one column */

      /*
       * Calculate the window height.  Need to do calculation in int's
       * rather than short (Dimension) because of possible overflow.
       */
     row_count = (total_icon_count + column_count - 1) / column_count;
     tmp = 2*MARGIN - YSPACING(file_mgr_data) +
       row_count * ((int)grid_height + YSPACING(file_mgr_data));

     /* check if the height is larger than the scrolled window */
     if (tmp >= (int)scrolled_window_height - 2*MARGIN)
     {
       /* need to recompute everything because of space for vert scrollbar */
       column_count = ((int)scrolled_window_width - 4 - 2*MARGIN + XSPACING
                       - (int)vert_scrollbar_width)
         / ((int)grid_width + XSPACING);
       if (column_count == 0)
         column_count = 1;
       row_count = (total_icon_count + column_count - 1) / column_count;
       tmp = 2*MARGIN - YSPACING(file_mgr_data) +
         row_count * ((int)grid_height + YSPACING(file_mgr_data));
     }

     /* check if the window height is within the limit */
     if (tmp <= MAXWINSIZE)
       file_window_height = (Dimension)tmp;
     else
     {
       /* window height too large; use more columns */
       overflow = True;
       row_count = (int)(MAXWINSIZE - 2*MARGIN + YSPACING(file_mgr_data)) /
         (int)((int)grid_height + YSPACING(file_mgr_data));
       column_count = (total_icon_count  + row_count - 1) / row_count;
       row_count = (total_icon_count + column_count - 1) / column_count;
       file_window_height = (Dimension) (2*MARGIN - YSPACING(file_mgr_data) +
                                         row_count * ((int)grid_height + YSPACING(file_mgr_data)));
     }

     DPRINTF(("  %d columns, %d rows (scroll_window width %d)\n",
              column_count, row_count,
              scrolled_window_width));

     /* assign positions to all icons */
     y = MARGIN;
     file_window_width = (Dimension)
       (2*MARGIN - XSPACING + column_count*((int)grid_width + XSPACING));

     k = 0;
     for (i = 0; i < row_count; i++)
     {
       x = MARGIN;

       for (j = 0; j < column_count && k < order_count;)
       {
         /* find the next icon to display */
         while (k < order_count && !order_list[k]->displayed)
           k++;
         if (k == order_count)
           break;

         if (layout_data->alignment == XmALIGNMENT_CENTER &&
             file_mgr_data->view == BY_NAME_AND_ICON)
         {
           EstimateIconSize(file_mgr_rec, file_mgr_data, layout_data,
                            order_list[k], &icon_width, &icon_height);
           order_list[k]->x = x +
             (Dimension)(grid_width - icon_width)/(Dimension)2;
         }
         else
           order_list[k]->x = x;
         order_list[k]->y = y + grid_height;

         x += grid_width + XSPACING;
         j++;
         k++;
       }

       y += grid_height + YSPACING(file_mgr_data);
     }
   }

   DPRINTF(("  file_window size: width %d, height %d\n",
            file_window_width, file_window_height));

   /*  Manage/unmanage the scrollbars as needed.  */

   XtSetArg (args[0], XmNwidth, file_window_width);
   XtSetArg (args[1], XmNheight, file_window_height);
   XtSetValues ((Widget)file_window, args, 2);

   XtSetArg (args[0], XmNscrollBarDisplayPolicy, XmAS_NEEDED);
   XtSetValues (file_mgr_rec->scroll_window, args, 1);


   /*  Unmanage the horizontal scrollbar if it is not needed   */
   if (VerticalScrollbarIsVisible(file_mgr_rec->vertical_scroll_bar,
                                  file_mgr_rec->scroll_window))
   {
      if (file_window_width >= (Dimension)(scrolled_window_width - 4 -
                                                         vert_scrollbar_width))
         XtManageChild (file_mgr_rec->horizontal_scroll_bar);
      else
      {
         XtUnmanageChild (file_mgr_rec->horizontal_scroll_bar);
         XtSetArg (args[0], XmNx, 0);
         XtSetValues ((Widget)file_window, args, 1);
      }
   }
   else if (file_window_width >= (Dimension)(scrolled_window_width - 4))
      XtManageChild (file_mgr_rec->horizontal_scroll_bar);
   else
   {
      XtUnmanageChild (file_mgr_rec->horizontal_scroll_bar);
      XtSetArg (args[0], XmNx, 0);
      XtSetValues ((Widget)file_window, args, 1);
   }

   XSync (XtDisplay (file_window), False);

   /*  Set the file window width and height to be at least  */
   /*  the size of the scrolled window.                     */

   if (VerticalScrollbarIsVisible(file_mgr_rec->vertical_scroll_bar,
                                  file_mgr_rec->scroll_window))
   {
      if(file_window_width <= (Dimension)(scrolled_window_width -
                           (vert_scrollbar_width + 4)))

         file_window_width = scrolled_window_width -
                           (vert_scrollbar_width + 4);
   }
   else
   {
      if(file_window_width < (Dimension)(scrolled_window_width - 4))
         file_window_width = scrolled_window_width - 4;
   }

   if (HorizontalScrollbarIsVisible(file_mgr_rec->horizontal_scroll_bar,
                                    file_mgr_rec->scroll_window))
   {
      int pad;

      XtSetArg (args[0], XmNhighlightThickness, &sb_highlight_thickness);
      XtGetValues ((Widget)file_mgr_rec->horizontal_scroll_bar, args, 1);

      XtSetArg (args[0], XmNshadowThickness, &sw_shadow_thickness);
      XtSetArg (args[1], XmNspacing, &space);
      XtGetValues ((Widget)file_mgr_rec->scroll_window, args, 2);

      pad = (int)(((sb_highlight_thickness + sw_shadow_thickness) * 2) + space);

      if(file_window_height < (Dimension)(scrolled_window_height -
                        (horiz_scrollbar_height + pad)))
         file_window_height = scrolled_window_height -
                        (horiz_scrollbar_height + pad);
   }
   else
   {
      if (file_window_height < (Dimension)(scrolled_window_height - 4))
         file_window_height = scrolled_window_height - 4;
   }


   XtSetArg (args[0], XmNwidth, file_window_width);
   XtSetArg (args[1], XmNheight, file_window_height);
   XtSetValues ((Widget)file_window, args, 2);

   if( file_mgr_data->scrollToThisFile == NULL )
   {
     if (update_scrolling_position)
     {
       XtSetArg (args[0], XmNx, 0);
       XtSetArg (args[1], XmNy, 0);
       XtSetValues ((Widget)file_window, args, 2);
     }

     /*  Set the vertical scrollbar's increment to icon height  */
     XtSetArg (args[0], XmNincrement, grid_height + YSPACING(file_mgr_data));
     XtSetArg (args[1], XmNuserData, grid_height + YSPACING(file_mgr_data));
     XtSetValues (file_mgr_rec->vertical_scroll_bar, args, 2);
   }

   if (PositioningEnabledInView(file_mgr_data))
   {
     BuildObjectPositions(file_mgr_data);
     /* RepairFileWindow(file_mgr_data); *OBSOLETE* */
   }

   /*
    * Don't keep up the hourglass; this helps the user to get the impression
    * that all of the work is done.
    */
   if (turn_off_hourglass && !overflow)
      _DtTurnOffHourGlass(file_mgr_rec->shell);


layout_done:


   /*
    * Start up a work proc that will update the display.
    */
   layout_data->visible_done = False;
   layout_data->all_done = False;
   if (layout_data->work_id == 0)
   {
      XtAppContext app_context =
        XtWidgetToApplicationContext(file_mgr_rec->shell);

      DPRINTF(("LayoutFileIcons: starting workproc\n"));
      layout_data->drop_site_w = (Widget)file_mgr_rec->shell;
      XmDropSiteStartUpdate(layout_data->drop_site_w);

      layout_data->work_id =
        XtAppAddWorkProc(app_context, DisplayWorkProc, file_mgr_rec);
   }


   if( file_mgr_data->scrollToThisFile )
   {
     int i;
     DirectorySet * directory_set = NULL;

     file_view_data = NULL;

     for( i = 0; i < file_mgr_data->directory_count; ++i)
     {
       if( strcmp( ((DirectorySet *)file_mgr_data->directory_set[i])->name, file_mgr_data->scrollToThisDirectory ) == 0 )
       {
         directory_set = (DirectorySet *)file_mgr_data->directory_set[i];
         break;
       }
     }

     if( directory_set )
     {
       for( i = 0; i < directory_set->file_count; ++i )
       {
         if( strcmp( directory_set->order_list[i]->file_data->file_name,
                     file_mgr_data->scrollToThisFile ) == 0 )
         {
           file_view_data = directory_set->order_list[i];
           break;
         }
       }
     }

     if( file_view_data
         && file_view_data->filtered == False )
     {
       FileMgrRec * file_mgr_rec = (FileMgrRec *) file_mgr_data->file_mgr_rec;

       DeselectAllFiles( file_mgr_data );
       SelectFile( file_mgr_data, file_view_data );
       ActivateSingleSelect( file_mgr_rec,
             file_mgr_data->selection_list[0]->file_data->logical_type );

       PositionFileView(file_view_data, file_mgr_data);
     }
     else
     {
       if (update_scrolling_position)
       {
         XtSetArg (args[0], XmNx, 0);
         XtSetArg (args[1], XmNy, 0);
         XtSetValues ((Widget)file_window, args, 2);
       }

       /* Set the vertical scrollbar's increment to icon height  */
       XtSetArg (args[0], XmNincrement, grid_height + YSPACING(file_mgr_data));
       XtSetArg (args[1], XmNuserData, grid_height + YSPACING(file_mgr_data));
       XtSetValues (file_mgr_rec->vertical_scroll_bar, args, 2);
     }

     XtFree( file_mgr_data->scrollToThisFile );
     file_mgr_data->scrollToThisFile = NULL;
     XtFree( file_mgr_data->scrollToThisDirectory );
     file_mgr_data->scrollToThisDirectory = NULL;
   }

#ifdef DT_PERFORMANCE
   gettimeofday(&update_time_f, NULL);
   if (update_time_s.tv_usec > update_time_f.tv_usec) {
      update_time_f.tv_usec += 1000000;
      update_time_f.tv_sec--;
   }
   printf("    done LayoutFileIcons, time: %ld.%ld\n\n",
          update_time_f.tv_sec - update_time_s.tv_sec,
          update_time_f.tv_usec - update_time_s.tv_usec);

   /* the following message send call added by Rafi */
   _DtPerfChkpntMsgSend("Done LayoutFileIcons");
#endif

   DPRINTF(("... done\n"));
}



/************************************************************************
 *
 *  TreeBtnCallback
 *      Callback function invoked upon clicking the tree-branch-expand button.
 *
 ************************************************************************/

static void
TreeBtnCallback(
        Widget w,
        XtPointer clientData,
        XmAnyCallbackStruct *callData )
{
  FileMgrRec *file_mgr_rec;
  FileMgrData *file_mgr_data;
  FileViewData *file_view_data = (FileViewData *)clientData;
  Arg args[20];
  Bool expand;

  /* check which mouse button was pressed */
  if ((callData->event->type == ButtonPress ||
       callData->event->type == ButtonRelease) &&
      ((XButtonEvent *)callData->event)->button != Button1)
  {
    return;
  }
  expand = True;

  /* get file mgr data and record */
  XtSetArg (args[0], XmNuserData, &file_mgr_data);
  XtGetValues (w, args, 1);
  file_mgr_rec = (FileMgrRec *) file_mgr_data->file_mgr_rec;

  XmDropSiteStartUpdate(file_mgr_rec->file_window);
  CommitWorkProcUpdates(file_mgr_rec, file_mgr_data, True);
  DirTreeExpand(file_mgr_data, file_view_data, expand);
  DrawCurrentDirectory (file_mgr_rec->current_directory,
                        file_mgr_rec, file_mgr_data);
  LayoutFileIcons(file_mgr_rec, file_mgr_data, False, True);
  XmDropSiteEndUpdate(file_mgr_rec->file_window);
  RedrawTreeLines(file_mgr_rec->file_window,
                  -file_mgr_rec->file_window->core.x,
                  -file_mgr_rec->file_window->core.y,
                  XtParent(file_mgr_rec->file_window)->core.width,
                  XtParent(file_mgr_rec->file_window)->core.height,
                  0, file_mgr_rec, file_mgr_data);
}


/*
 * When a drop occurs on a File Manger window, which now
 * support random placement, what is dropped may not ultimately be what
 * is displayed.  Since the dissolve transition effect has been disabled
 * for drops on the desktop, we can sometimes end up with garbage left on
 * the desktop.  This function will attempt to clear up the leftover garbage,
 * by resetting all areas of the desktop which are not covered by an icon
 * to the background color for the file window.
 *
 * This function is OBSOLETE (?).
 */

void
RepairFileWindow (
   FileMgrData * file_mgr_data)

{
   FileMgrRec * file_mgr_rec;
   Region clipList;
   Region hotspot;
   Region redrawRegion;
   int i;
   XRectangle rect;
   int num_children;
   Widget * children;
   XmManagerWidget file_window;
   GC gc;
   unsigned long mask;
   XGCValues values;

   file_mgr_rec = (FileMgrRec *) file_mgr_data->file_mgr_rec;
   file_window = (XmManagerWidget)file_mgr_rec->file_window;

   /* Initialize the clip region to that of the file window */
   rect.x = 0;
   rect.y = 0;
   rect.height = file_window->core.height;
   rect.width = file_window->core.width;
   clipList = XCreateRegion();
   XUnionRectWithRegion(&rect, clipList, clipList);

   /* Subtract out the hotspots associated with each icon */
   num_children = file_window->composite.num_children;
   children = file_window->composite.children;
   hotspot = XCreateRegion();

   for (i = 0; i < num_children; i++)
   {
      if (XtIsManaged(children[i]) &&
          XtIsSubclass(children[i], dtIconGadgetClass))
      {
         WidgetRectToRegion(file_mgr_data, children[i], hotspot);
         XSubtractRegion(clipList, hotspot, clipList);
      }
   }

   /* Create a GC for doing our drawing */
   mask = GCForeground;
   values.foreground = file_window->core.background_pixel;
   gc = XCreateGC(XtDisplay(file_window), XtWindow(file_window), mask, &values);
   XSetRegion(XtDisplay(file_window), gc, clipList);

   /* Restore the window */
   XFillRectangle(XtDisplay(file_window), XtWindow(file_window), gc, 0, 0,
                  file_window->core.width, file_window->core.height);

   /*
    * Force all icons to redraw, since we are only able to repair the
    * areas where icons are not; the drop image may have extended onto
    * some of the icons.
    */
   rect.x = 0;
   rect.y = 0;
   rect.height = file_window->core.height;
   rect.width = file_window->core.width;
   redrawRegion = XCreateRegion();
   XUnionRectWithRegion(&rect, redrawRegion, redrawRegion);
   (*file_window->core.widget_class->core_class.expose)
             ((Widget)file_window, NULL, redrawRegion);

   /* Clean up */
   XFreeGC(XtDisplay(file_window), gc);
   XDestroyRegion(clipList);
   XDestroyRegion(hotspot);
   XDestroyRegion(redrawRegion);
}




/*
 * Compress the stacking order values, anytime an item is removed.
 */

static void
CompressObjectList (
   ObjectPosition ** object_positions,
   int num_objects,
   int starting_index)
{
   int i;

   for (i = 0; i < num_objects; i++)
   {
      if (object_positions[i]->stacking_order > starting_index)
         object_positions[i]->stacking_order--;
   }
}



/************************************************************************
 *
 *  LayoutDesktopIcons
 *      Position and size the full set of icons for the file mgr data.
 *
 ************************************************************************/

static void
LayoutDesktopIcons (
     FileMgrRec  * file_mgr_rec,
     FileMgrData * file_mgr_data,
     FileViewData ** order_list,
     int order_count,
     Boolean turn_off_hourglass )

{
   XmManagerWidget file_window;
   int directory_count, largest_x, largest_y;
   int value, size, increment, page;
   Dimension current_wd;
   Dimension current_ht;
   Dimension file_window_width;
   Dimension grid_height;
   Dimension grid_width;
   FileViewData * object;
   ObjectPosition * position_data;
   ObjectPosition * bottom;
   ObjectPtr top;
   int i, j, k;
   Boolean set_size = False;
   char * edit_name;
   Arg args[2];
   int sorder;


   /*  Get the grid block size */
   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   grid_height = file_mgr_data->grid_height;
   grid_width = file_mgr_data->grid_width;

   file_window_width = file_mgr_rec->scroll_window->core.width - 4;
   current_ht = file_mgr_rec->file_window->core.height;
   current_wd = file_mgr_rec->file_window->core.width;


   /* Before positioning, mark all position entries as 'not used' */
   for (i = 0; i < file_mgr_data->num_objects; i++)
   {
      file_mgr_data->object_positions[i]->in_use = False;
      file_mgr_data->object_positions[i]->file_view_data = NULL;
   }

   /*
    * Before attempting to place new icons, we need to make sure that
    * all of the existing object_positions entries have had their
    * file_view_data field filled in.  This is so that during placement,
    * we can get the height and width of the associated icons, to help
    * prevent overlap.
    */
   for (i = 0; i < order_count; i++)
   {
      object = order_list[i];
      if (object->displayed)
      {
         if (position_data = GetPositionalData(file_mgr_data, object, 0, False))
         {
            /* Save; used later during redraw */
            position_data->file_view_data = object;
            object->position_info = (ObjectPtr)position_data;
         }
      }
      else if (position_data = GetPositionalData(file_mgr_data, object, 0,
                                                 False))
      {
         /*
          * If an object has position information, but is currently
          * filtered, don't discard its position info; mark it as in-use.
          */
         position_data->file_view_data = object;
         object->position_info = (ObjectPtr)position_data;
      }
   }

   /* Remove any unused position data entries */
   for (i = 0; i < file_mgr_data->num_objects; )
   {
      if (!file_mgr_data->object_positions[i]->in_use)
      {
         /* If this object had a text field, delete it */
         for (k = 0; k < file_window->composite.num_children; k++)
         {
            if (XmIsTextField(file_window->composite.children[k]) &&
                !file_window->composite.children[k]->core.being_destroyed)
            {
               XtSetArg(args[0], XmNuserData, &edit_name);
               XtGetValues(file_window->composite.children[k], args, 1);
               if (strcmp(edit_name,file_mgr_data->object_positions[i]->name)
                        == 0)
               {
                  /* Match */
                  XtUnmanageChild(file_window->composite.children[k]);
                  XtDestroyWidget(file_window->composite.children[k]);
                  break;
               }
            }
         }

         /* Free up the entry; bump up the other array entries */
         /* Update the linked list */
         if (file_mgr_data->object_positions[i]->prev)
         {
            file_mgr_data->object_positions[i]->prev->next = (ObjectPtr)
                file_mgr_data->object_positions[i]->next;
         }
         if (file_mgr_data->object_positions[i]->next)
         {
            file_mgr_data->object_positions[i]->next->prev = (ObjectPtr)
                file_mgr_data->object_positions[i]->prev;
         }
         sorder = file_mgr_data->object_positions[i]->stacking_order;
         XtFree(file_mgr_data->object_positions[i]->name);
         file_mgr_data->object_positions[i]->name = NULL;
         XtFree((char *)file_mgr_data->object_positions[i]);
         file_mgr_data->object_positions[i] = NULL;
         for (j = i; j < file_mgr_data->num_objects - 1; j++)
         {
            file_mgr_data->object_positions[j] =
                                   file_mgr_data->object_positions[j+1];
         }
         file_mgr_data->num_objects--;
         file_mgr_data->object_positions = (ObjectPosition **) XtRealloc(
               (char *)file_mgr_data->object_positions,
               sizeof(ObjectPosition *) * file_mgr_data->num_objects);
         CompressObjectList(file_mgr_data->object_positions,
                            file_mgr_data->num_objects, sorder);
      }
      else
         i++;
   }

   /* Now, it is safe to position any unplaced objects */
   for (i = 0; i < order_count; i++)
   {
      object = order_list[i];
      if (object->displayed)
      {
         position_data = GetPositionalData(file_mgr_data, object,
                                           file_window_width, True);

         /* Save; used later during redraw */
         position_data->file_view_data = object;
         object->position_info = (ObjectPtr)position_data;

         /* record position of bottom left corner for DisplaySomeIcons */
         object->x = position_data->x;
         object->y = position_data->y +
               (object->need_update? grid_height: object->widget->core.height);
      }
   }

   /* Get largest x value */
   largest_x = 0;
   largest_y = 0;
   bottom = GetBottomOfStack(file_mgr_data);
   while (bottom)
   {
      if (bottom->file_view_data != NULL && bottom->file_view_data->displayed)
      {
         if (bottom->file_view_data->position_info->x > largest_x)
            largest_x = bottom->file_view_data->position_info->x;
         if (bottom->file_view_data->position_info->y > largest_y)
            largest_y = bottom->file_view_data->position_info->y;
      }
      bottom = (ObjectPosition *)bottom->prev;
   }
   largest_x += grid_width;
   largest_y += grid_height;

   /* if necessary, shrink the width & height to what we need */
   if (current_wd == 32767)
   {
      current_wd = largest_x;
      set_size = True;
   }

   if (current_ht == 32767)
   {
      current_ht = largest_y;
      set_size = True;
   }

   /*  Get the horizontal and vertical scrollbars.  */
   XtSetArg (args[0], XmNscrollBarDisplayPolicy, XmAS_NEEDED);
   XtSetValues (file_mgr_rec->scroll_window, args, 1);

   /*
    * Typically, dtfile does everything possible to prevent a horizontal
    * scrollbar from being displayed.  However, when random placement is
    * enabled, we don't mind having a horizontal scrollbar, when needed.
    * We need to manually manage this, since the normal dtfile layout
    * code may have forcably unmanaged the scrollbar earlier.
    */
   if (XtIsManaged(file_mgr_rec->horizontal_scroll_bar))
   {
      /* get scroll bar values */
      (void)XmScrollBarGetValues(file_mgr_rec->horizontal_scroll_bar,
                                 &value, &size, &increment, &page);
   }

   if (VerticalScrollbarIsVisible(file_mgr_rec->vertical_scroll_bar,
                                  file_mgr_rec->scroll_window))
   {
      if ((Dimension)largest_x >= (Dimension)(file_mgr_rec->scroll_window->core.width -
                          (file_mgr_rec->vertical_scroll_bar->core.width + 4)))
      {
         XtManageChild(file_mgr_rec->horizontal_scroll_bar);
      }
      else
      {
         /* set scroll bar values changing its position */
         if(value != 0 && XtIsManaged(file_mgr_rec->horizontal_scroll_bar))
            XtManageChild(file_mgr_rec->horizontal_scroll_bar);
         else
         {
            XtUnmanageChild (file_mgr_rec->horizontal_scroll_bar);
            XtSetArg (args[0], XmNx, 0);
            XtSetValues ((Widget)file_window, args, 1);
         }
      }
   }
   else if ((Dimension)largest_x >= (Dimension)(file_mgr_rec->scroll_window->core.width - 4))
      XtManageChild(file_mgr_rec->horizontal_scroll_bar);
   else
   {
      /* set scroll bar values changing its position */
      if(value != 0 && XtIsManaged(file_mgr_rec->horizontal_scroll_bar))
         XtManageChild(file_mgr_rec->horizontal_scroll_bar);
      else
      {
         XtUnmanageChild (file_mgr_rec->horizontal_scroll_bar);
         XtSetArg (args[0], XmNx, 0);
         XtSetValues ((Widget)file_window, args, 1);
      }
   }

   /*  Set the file window width and height to be at least  */
   /*  the size of the scrolled window.                     */
   if ((Dimension)(current_wd) < (Dimension)(file_mgr_rec->scroll_window->core.width - 4))
   {
      if (VerticalScrollbarIsVisible(file_mgr_rec->vertical_scroll_bar,
                                     file_mgr_rec->scroll_window))
         current_wd = file_mgr_rec->scroll_window->core.width -
                           (file_mgr_rec->vertical_scroll_bar->core.width + 4);
      else
         current_wd = file_mgr_rec->scroll_window->core.width - 4;
      set_size = True;
   }

   if ((Dimension)(current_ht) < (Dimension)(file_mgr_rec->scroll_window->core.height - 4))
   {
      current_ht = file_mgr_rec->scroll_window->core.height - 4;
      set_size = True;
   }

   if (set_size)
   {
      XtSetArg (args[0], XmNwidth, current_wd);
      XtSetArg (args[1], XmNheight, current_ht);
      XtSetValues (file_mgr_rec->file_window, args, 2);
   }

   /*  Set the vertical scrollbar's increment to icon height  */
   XtSetArg (args[0], XmNincrement, file_mgr_data->grid_height + 2);
   XtSetValues (file_mgr_rec->vertical_scroll_bar, args, 1);

   /*
    * Don't keep up the hourglass; this helps the user to get the impression
    * that all of the work is done.
    */
   if (turn_off_hourglass)
      _DtTurnOffHourGlass(file_mgr_rec->shell);
}


/***************************************************
 *
 * Given a desktop object, see if it has already been assigned a position;
 * if not, then try to fit it into the next available grid position.
 *
 **************************************************/

static Boolean
IntersectRects(
        Position x1,
        Position y1,
        Dimension w1,
        Dimension h1,
        Position x2,
        Position y2,
        Dimension w2,
        Dimension h2 )

{
   int srcABot, srcBBot;
   int srcARight, srcBRight;
   int dw, dh;
   int dx, dy;

   srcABot = y1 + h1 - 1;
   srcBBot = y2 + h2 - 1;
   srcARight = x1 + w1 - 1;
   srcBRight = x2 + w2 - 1;

   if (x1 >= x2)
      dx = x1;
   else
      dx = x2;

   if (y1 > y2)
      dy = y1;
   else
      dy = y2;

   if (srcARight >= srcBRight)
      dw = srcBRight - dx + 1;
   else
      dw = srcARight - dx + 1;

   if (srcABot > srcBBot)
      dh = srcBBot - dy + 1;
   else
      dh = srcABot - dy + 1;

   if (dw <= 0 || dh <= 0)
      return(FALSE);

   return(TRUE);
}

static ObjectPosition *
GetPositionalData (
   FileMgrData * file_mgr_data,
   FileViewData * object,
   Dimension max_width,
   Boolean create)
{
   int i;
   int k;
   ObjectPosition *entry, *top;
   Position x;
   Position y;
   Dimension grid_height;
   Dimension grid_width;
   Boolean hit;
   ObjectPosition * oP;
   Dimension objWidth, objHeight;
   Dimension oWidth, oHeight;

   /* If object already has positional data, then use it */
   for (i = 0; i < file_mgr_data->num_objects; i++)
   {
      if (strcmp(object->file_data->file_name,
                 file_mgr_data->object_positions[i]->name) == 0)
      {
         /* Found a match */
         file_mgr_data->object_positions[i]->in_use = True;
         return(file_mgr_data->object_positions[i]);
      }
   }

   if (!create)
      return(NULL);

   /* Create a new entry, and place into the grid on the top of the stack */
   entry = (ObjectPosition *) XtMalloc(sizeof(ObjectPosition));
   entry->name = XtNewString(object->file_data->file_name);
   entry->in_use = True;
   entry->late_bind = False;
   entry->stacking_order = 2;
   entry->prev = NULL;
   entry->next = NULL;
   entry->file_view_data = NULL;

   if(file_mgr_data->num_objects == 1)
   {
      top = file_mgr_data->object_positions[0];
      top->next = (ObjectPtr)entry;
      entry->prev = (ObjectPtr)top;
   }
   else
   {
      top = NULL;
      /* Push all other objects down in the stack */
      for (i = 0; i < file_mgr_data->num_objects; i++)
      {
         /* Find the previous top of the stack */
         if (file_mgr_data->object_positions[i]->stacking_order == 1)
         {
            top = file_mgr_data->object_positions[i];
            continue;
         }
         else if (file_mgr_data->object_positions[i]->stacking_order == 2)
         {
            if(top == NULL)
               top = GetTopOfStack(file_mgr_data);
            top->next = (ObjectPtr)entry;
            entry->next = (ObjectPtr)file_mgr_data->object_positions[i];
            entry->prev = (ObjectPtr)top;
            file_mgr_data->object_positions[i]->prev = (ObjectPtr)entry;
         }
         file_mgr_data->object_positions[i]->stacking_order++;
      }
   }

   grid_height = file_mgr_data->grid_height;
   grid_width = file_mgr_data->grid_width;
   x = MARGIN;
   y = MARGIN;

   if (object->widget && !object->need_update)
   {
      objWidth = object->widget->core.width;
      objHeight = object->widget->core.height;
   }
   else
   {
      objWidth = grid_width;
      objHeight = grid_height;
   }

   /* Find the first open spot, which will not cause any overlap */
   do
   {
      hit = False;

      for (i = 0; i < file_mgr_data->num_objects; i++)
      {
         oP = file_mgr_data->object_positions[i];
         if (oP->file_view_data->widget && !oP->file_view_data->need_update)
         {
            oWidth = oP->file_view_data->widget->core.width;
            oHeight = oP->file_view_data->widget->core.height;
         }
         else
         {
            oWidth = grid_width;
            oHeight = grid_height;
         }
         if (oP->file_view_data->displayed &&
             IntersectRects(x, y, objWidth, objHeight,
                            oP->x, oP->y, oWidth, oHeight))
         {
            /* Try next grid spot */
            x += grid_width + XSPACING;

            if ((Dimension)(x + objWidth) >= max_width)
            {
               /* Go to next row */
               y += grid_height + YSPACING(file_mgr_data);
               x = MARGIN;
            }
            hit = True;
            break;
         }
      }
   } while (hit);

   /* Add to the end of the list */
   entry->x = x;
   entry->y = y;
   file_mgr_data->num_objects++;
   file_mgr_data->object_positions = (ObjectPosition **) XtRealloc(
                   (char *)file_mgr_data->object_positions,
                   sizeof(ObjectPosition *) * file_mgr_data->num_objects);

   /* Force the ordered list to be maintained */
   for (i = 0; i < file_mgr_data->num_objects - 1; i++)
   {
      if ((entry->y < file_mgr_data->object_positions[i]->y) ||
          ((entry->y == file_mgr_data->object_positions[i]->y) &&
           (entry->x < file_mgr_data->object_positions[i]->x)))
      {
         /* Fits here; slide later entries down */
         for (k = file_mgr_data->num_objects - 1; k > i; k--)
         {
            file_mgr_data->object_positions[k] =
                file_mgr_data->object_positions[k-1];
         }

         break;
      }
   }

   file_mgr_data->object_positions[i] = entry;
   return(file_mgr_data->object_positions[i]);
}


/*******************************************************************
 *
 *  BuildObjectPositons - builds up the object positions for directories
 *    which have now object position information.
 *
 *********************************************************************/
static void
BuildObjectPositions(
   FileMgrData *file_mgr_data)
{
   int i, j, k, l;
   FileViewData * file_view_data;
   ObjectPosition * ptr;

   file_mgr_data->object_positions = (ObjectPosition **)XtMalloc(
               sizeof(ObjectPosition *) *
               file_mgr_data->directory_set[0]->file_count);

   for (i = 0, j = 0; i < file_mgr_data->directory_set[0]->file_count; i++)
   {
      file_view_data = file_mgr_data->directory_set[0]->order_list[i];

      if (file_view_data->filtered)
         continue;

      ptr = (ObjectPosition *) XtMalloc(sizeof(ObjectPosition));
      ptr->name = XtNewString(file_view_data->file_data->file_name);
      ptr->x = file_view_data->x;
      ptr->y = file_view_data->y -
            (file_view_data->need_update? file_mgr_data->grid_height:
                                          file_view_data->widget->core.height);
      ptr->in_use = True;
      ptr->late_bind = False;
      ptr->stacking_order = j+1;
      ptr->file_view_data = file_view_data;
      file_view_data->position_info = (ObjectPtr)ptr;
      ptr->next = NULL;
      ptr->prev = NULL;

      /* Sort according to left-to-right, top-to-bottom */
      for (k = 0; k < j; k++)
      {
         if ((ptr->y < file_mgr_data->object_positions[k]->y) ||
             ((ptr->y == file_mgr_data->object_positions[k]->y) &&
              (ptr->x < file_mgr_data->object_positions[k]->x)))
         {
            /* Shift others down, to open up a spot */
            for (l = j; l > k; l--)
            {
               file_mgr_data->object_positions[l] =
                     file_mgr_data->object_positions[l - 1];
            }
            break;
         }
      }
      file_mgr_data->object_positions[k] = ptr;
      j++;
   }

   file_mgr_data->num_objects = j;

   /* Repair all of the next and prev pointers */
   RepairStackingPointers(file_mgr_data);
   OrderChildrenList(file_mgr_data);
}


/***********************************
 *
 * When items are dragged around on a random placement window, they will be
 * repositioned at the point where they were dropped.  Multiple drop items
 * will be positioned 'around' where the drop occurred.
 *
 **********************************/

void
RepositionIcons (
   FileMgrData * file_mgr_data,
   char ** file_list,
   int file_count,
   Position drop_x,
   Position drop_y,
   Boolean late_binding_needed)

{
   Position x;
   Position y;
   int i, i2, j, k, l;
   int adj;
   Position orig_x;
   Position orig_y;
   ObjectPosition * save_object;
   char * name;
   FileMgrRec * file_mgr_rec;
   XmManagerWidget file_window;
   Widget textWidget;
   char * edit_name;
   Arg args[10];
   Boolean newEntry;
   int newEntryCount = 0;
   char dot_dir[3] = ".";
   char dotdot_dir[3] = "..";

   /* if random placement is not enabled, positioning doesn't matter */
   if(file_mgr_data->positionEnabled == RANDOM_OFF)
      return;

   file_mgr_rec = (FileMgrRec *)file_mgr_data->file_mgr_rec;

   /*
    * For directory views, no positional data may be present if positioning
    * was disabled for this view.  So ... we must create some now.
    */
   if ((file_mgr_data->num_objects == 0) &&
       (file_mgr_data->directory_set[0]->file_count > 0))
   {
         BuildObjectPositions(file_mgr_data);
   }

   /*
    * Update to the new position.
    * The position needs to be adjusted so that the icon actually ends
    * up where the user dropped it.  This is because the drag icon includes
    * margins and shadow area, but not the highlight area of the icon gadget
    * that was dragged.  Coordinates drop_x, drop_y are the upper left corner
    * of the drag icon when it was dropped.  To convert to icon gadget
    * coordinates we need to subtract the highlight thickness.
    */
   if (file_mgr_data->layout_data != NULL)
     adj = ((IconLayoutData *)file_mgr_data->layout_data)->highlight;
   else
     adj = 0;
   x = drop_x - adj;
   y = drop_y - adj;
   file_window = (XmManagerWidget) file_mgr_rec->file_window;

   /* Process each of the dropped files */
   /* Go from bottom to top, to retain stacking order */
   for (i = file_count - 1; i >= 0; i--)
   {
      textWidget = NULL;

      /*
       * The names typically come in as complete paths; we only want
       * the filename portion.
       * fdt: this check will break for root (/)
       */
      if( strcmp(file_mgr_data->current_directory, file_list[i]) == 0)
         name = dot_dir;
      else if(strncmp(file_mgr_data->current_directory, file_list[i], strlen(file_list[i]) ) == 0 )
        name = dotdot_dir;
      else
      {
        if ((name = strrchr(file_list[i], '/')) == NULL)
          name = file_list[i];
        else
        {
          name++;

         /* Try to gracefully handle root (/) */
          if (*name == '\0')
            name--;
        }
      }

      newEntry = True;

      /* Find the positional data for this object, if any */
      for (j = 0; j < file_mgr_data->num_objects; j++)
      {
         if (strcmp(name, file_mgr_data->object_positions[j]->name) == 0)
         {
            /* Find the associated widget */
            for (k = 0; strcmp(name,
             file_mgr_data->directory_set[0]->file_view_data[k]->file_data->                    file_name); k++);

            newEntry = False;

            /* If this object has a text field, then move it also */
            for (l = 0; l < file_window->composite.num_children; l++)
            {
               if (XmIsTextField(file_window->composite.children[l]) &&
                   !file_window->composite.children[l]->core.being_destroyed)
               {
                  XtSetArg(args[0], XmNuserData, &edit_name);
                  XtGetValues(file_window->composite.children[l], args, 1);
                  if (strcmp(edit_name, name) == 0)
                  {
                     textWidget = file_window->composite.children[l];
                     break;
                  }
               }
            }
            break;
         }
      }

      if (newEntry)
      {
         ObjectPosition * data;

         /* Create positional data at the top of the ordered array */
         newEntryCount++;
         j = 0;
         data = (ObjectPosition *) XtMalloc(sizeof(ObjectPosition));
         data->name = XtNewString(name);
         data->x = 0;
         data->y = 0;
         data->in_use = True;
         data->late_bind = True;
         data->stacking_order = 1;
         data->file_view_data = NULL;
         data->prev = NULL;
         data->next = NULL;

         /* Push all other objects down in the stack */
         for (i2 = 0; i2 < file_mgr_data->num_objects; i2++)
         {
            /* Find the previous top of the stack */
            if (file_mgr_data->object_positions[i2]->stacking_order == 1)
            {
               data->next = (ObjectPtr)file_mgr_data->object_positions[i2];
               file_mgr_data->object_positions[i2]->prev = (ObjectPtr)data;
            }
            file_mgr_data->object_positions[i2]->stacking_order++;
         }

         file_mgr_data->num_objects++;
         file_mgr_data->object_positions = (ObjectPosition **) XtRealloc(
               (char *)file_mgr_data->object_positions,
               sizeof(ObjectPosition *) * file_mgr_data->num_objects);

         /* Add entry to the top of the ordered array */
         for (j = file_mgr_data->num_objects - 1; j > 0; j--)
         {
            file_mgr_data->object_positions[j] =
                    file_mgr_data->object_positions[j - 1];
         }

         file_mgr_data->object_positions[0] = data;
      }
      else
      {
         /* Move item upto top of the stack */
         RepositionUpInStack(file_mgr_data,
                     file_mgr_data->object_positions[j]->stacking_order, 1);
      }

      orig_x = file_mgr_data->object_positions[j]->x;
      orig_y = file_mgr_data->object_positions[j]->y;
      file_mgr_data->object_positions[j]->x = x;
      file_mgr_data->object_positions[j]->y = y;
      save_object = file_mgr_data->object_positions[j];

      /* Move the object */
      if (!newEntry)
      {
         /* We need to force a geometry request */
         XtSetArg(args[0], XmNx, x);
         XtSetArg(args[1], XmNy, y);
         XtSetValues(file_mgr_data->directory_set[0]->file_view_data[k]->widget,
                     args, 2);

         /* Move associated text widget, if there is one */
         if (textWidget)
         {
            Position t_x, t_y;

            t_x = textWidget->core.x + x - orig_x;
            t_y = textWidget->core.y + y - orig_y;

            /* We need to force a geometry request */
            XtSetArg(args[0], XmNx, t_x);
            XtSetArg(args[1], XmNy, t_y);
            XtSetValues(textWidget, args, 2);
         }
      }

      /*
       * Reorder the positional array, so that it remains ordered.
       * Bubble down toward the end of the list if the object has moved
       * farther from the origin; bubble up if it has moved closer to
       * the origin.
       */
      if ((y > orig_y) || ((y == orig_y) && (x > orig_x)))
      {
         /* Bubble down */
         for (k = j + 1; k < file_mgr_data->num_objects; k++)
         {
            if ((y < file_mgr_data->object_positions[k]->y) ||
                ((y == file_mgr_data->object_positions[k]->y) &&
                 (x < file_mgr_data->object_positions[k]->x)))
            {
               /* We fit right here */
               file_mgr_data->object_positions[k - 1] = save_object;
               break;
            }
            else
            {
               /* Bubble */
               file_mgr_data->object_positions[k - 1] =
                     file_mgr_data->object_positions[k];
            }
         }

         /* See if it goes at the end */
         if (k == file_mgr_data->num_objects)
            file_mgr_data->object_positions[k - 1] = save_object;
      }
      else
      {
         /* Bubble up */
         for (k = j - 1; k >= 0; k--)
         {
            if ((y > file_mgr_data->object_positions[k]->y) ||
                ((y == file_mgr_data->object_positions[k]->y) &&
                 (x > file_mgr_data->object_positions[k]->x)))
            {
               /* We fit right here */
               file_mgr_data->object_positions[k + 1] = save_object;
               break;
            }
            else
            {
               /* Bubble */
               file_mgr_data->object_positions[k + 1] =
                     file_mgr_data->object_positions[k];
            }
         }

         /* See if it goes at the end */
         if (k < 0)
            file_mgr_data->object_positions[0] = save_object;
      }

      /* Create position for the next file to be processed */
      x += 20;
      y += 20;
   }
   /*
    * Reregister the desktop hotspots.
    * Even if the caller told us that late binding was needed, if no new
    * objects were specified, then we need to register hotspots now, because
    * the layout function will never be called because the directory never
    * really changed.  This situation can occur when an icon is dropped on
    * the desktop from a regular dtfile view, but that icon is already on
    * the desktop (it thus is just a reposition).
    */
   if (!late_binding_needed ||
       (late_binding_needed && (newEntryCount == 0)))
   {
      RegisterDesktopHotspots(file_mgr_data, file_mgr_rec);
   }
}

void
RegisterDesktopHotspots (
   FileMgrData * file_mgr_data,
   FileMgrRec  * file_mgr_rec)
{
   XmManagerWidget file_window;
   FileViewData  * file_view_data;
   int ex, ey, ewd, eht;
   ObjectPtr top;
   Widget icon;


   file_window = (XmManagerWidget) file_mgr_rec->file_window;
   ex = -file_window->core.x;
   ey = -file_window->core.y;
   ewd = XtParent(file_window)->core.width;
   eht = XtParent(file_window)->core.height;

   /* Set up the icon location information with the drag handler  */
   /* Register in top to bottom stacking order */
   top = GetTopOfStack(file_mgr_data);

   while (top)
   {
      file_view_data = top->file_view_data;

      if (file_view_data != NULL &&
          file_view_data->displayed &&
          !file_view_data->need_update)
      {
         icon = file_view_data->widget;
         if ((Position)(icon->core.x + icon->core.width) >= (Position)ex  &&
             icon->core.x < ex + ewd &&
             (Position)(icon->core.y + icon->core.height) >= (Position)ey &&
             icon->core.y < ey + eht)
         {
            SetHotRects(file_view_data,
                        (XtCallbackProc) DropOnObject,
                        (XtPointer) file_view_data);
         }
      }

      top = top->next;
   }
}


/*
 * Dtfile used to try to determine if the vertical scrollbar was visible
 * by checking to see if it was managed; the assumption here was that the
 * scrolled window widget unmanaged the scrollbar, when it was not needed.
 * Unfortunately, it turns out that instead of unmanaging the scrollbar,
 * the scrolled window simply moves the scrollbar out of sight; it is moved
 * such that the X for the scrollbar is the same as the width of the
 * scrolled window.  So ... in order for us to really determine if the
 * scrollbar is visible, we need to see whether or not its X falls within
 * the visible area of the scrolled window.
 */

Boolean
VerticalScrollbarIsVisible(
        Widget vertSB,
        Widget scrolledWin)

{
   if (vertSB && XtIsManaged(vertSB) &&
       (vertSB->core.x < (Position)scrolledWin->core.width))
   {
      return(True);
   }

   return(False);
}

Boolean
HorizontalScrollbarIsVisible(
        Widget hortSB,
        Widget scrolledWin)

{
   if (hortSB && XtIsManaged(hortSB) &&
       (hortSB->core.y <= (Position)scrolledWin->core.height))
   {
      return(True);
   }

   return(False);
}