/* 

 * Motif

 *

 * Copyright (c) 1987-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

 */ 

/* 

 * HISTORY

*/ 

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: DragBS.c /main/29 1998/03/18 15:10:28 csn $"

#endif

#endif

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

/*

*  (c) Copyright 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */

/*****************************************************************************

 *

 *  The purpose of the routines in this module is to cache frequently needed

 *  data on window properties to reduce roundtrip server requests.

 *

 *  The data is stored on window properties of motifWindow, a persistent,

 *  override-redirect, InputOnly child window of the display's default root

 *  window.  A client looks for the motifWindow id on the "_MOTIF_DRAG_WINDOW"

 *  property of the display's default root window.  If it finds the id, the

 *  client saves it in its displayToMotifWindowContext.  Otherwise, the 

 *  client creates the motifWindow and stores its id on that root property

 *  and saves the id in its displayToMotifWindowContext.  MotifWindow is

 *  mapped but is not visible on the screen.

 *

 *  Two sets of data are stored on motifWindow properties:

 *

 *    1. an atom table, and

 *    2. a targets list table.

 *

 *  The "_MOTIF_DRAG_ATOMS" property on motifWindow contains an atoms table,

 *  consisting of pairs of atoms and timestamps.  The atoms are interned

 *  once and are available for clients to use without repeated roundtrip

 *  server requests to intern them.  A timestamp of 0 indicates that the 

 *  atom is available.  A nonzero timestamp indicates when the atom was last

 *  allocated to a client.  The atoms table initially contains only atom

 *  "_MOTIF_ATOM_0" with timestamp 0.  A client requests an atom by calling

 *  _XmAllocMotifAtom() with a timestamp.  _XmAllocMotifAtom() tries to find

 *  an available atom in the table.  If it succeeds it sets the atom's

 *  timestamp to the value specified and returns the atom.  If no atom is

 *  available, _XmAllocMotifAtom() adds an atom to the table with the

 *  specified timestamp, updates the "_MOTIF_DRAG_ATOMS" property on

 *  motifWindow, and returns the new atom.  These new atoms are named

 *  "_MOTIF_ATOM_n" where n is 1, 2, 3, ... .  The routine _XmGetMotifAtom()

 *  returns the atom from the atoms table with nonzero timestamp less than

 *  but closest to a specified value.  It does not change the atoms table.

 *  A client frees an atom by calling _XmFreeMotifAtom(), which sets the 

 *  atom's timestamp to 0 and updates the "_MOTIF_DRAG_ATOMS" property on

 *  motifWindow.  To minimize property access, the client saves the address

 *  of its current atoms table on the displayToAtomsContext context.

 *

 *  The "_MOTIF_DRAG_TARGETS" property on motifWindow contains a targets

 *  table, consisting of a sequence of target lists to be shared among

 *  clients.  These target lists are sorted into ascending order to avoid

 *  permutations.  By sharing the targets table, clients may pass target

 *  lists between themselves by passing instead the corresponding target

 *  list indexes.  The routine _XmInitTargetsTable() initializes the atoms

 *  table on the "_MOTIF_DRAG_ATOMS" property, then initializes the targets

 *  table on the "_MOTIF_DRAG_TARGETS" property to contain only two lists:

 *

 *		{ 0,		}, and

 *		{ XA_STRING,	} 

 *

 *  A client adds a target list to the targets table by passing the target

 *  list to _XmTargetsToIndex().  _XmTargetsToIndex() first sorts the target

 *  list into ascending order, then searches the targets table for a match.

 *  If it finds a match, it returns the index of the matching targets table

 *  entry.  Otherwise, it adds the sorted target list to the table, updates

 *  the "_MOTIF_DRAG_TARGETS" property on motifWindow, and returns the index

 *  of the new targets table entry.  A client uses _XmIndexToTargets() to

 *  map a targets table index to a target list.  To minimize property access,

 *  the client saves the address of its current targets table on the

 *  displayToTargetsContext context.

 *

 *  The "_MOTIF_DRAG_PROXY_WINDOW" property on motifWindow contains the

 *  window id of the DragNDrop proxy window.  The routine

 *  _XmGetDragProxyWindow() returns the window id stored there.

 ***************************************************************************/

#include <Xm/XmP.h>

#include "XmI.h"

#include "DragICCI.h"

#include "DragBSI.h"

#include "MessagesI.h"

#include <Xm/MwmUtil.h>

#include <X11/Xatom.h>

#include <X11/Xresource.h>

#include <stdio.h>

#ifndef X_NOT_STDC_ENV

#include <stdlib.h>

#endif

#undef _XmIndexToTargets

#undef _XmTargetsToIndex

#define MAXSTACK	1200

#define MAXPROPLEN	100000L

/* structures to improve portability of WriteTargets */

typedef struct {

    CARD32 value B32;

} CARD32Item;

typedef struct {

    CARD16 value B16;

    CARD16 pad B16;

} CARD16Item;

#define MESSAGE1	_XmMMsgDragBS_0000

#define MESSAGE2	_XmMMsgDragBS_0001

#define MESSAGE3	_XmMMsgDragBS_0002

#define MESSAGE4	_XmMMsgDragBS_0003

#define MESSAGE5	_XmMMsgDragBS_0004

#define MESSAGE6	_XmMMsgDragBS_0005

#define MESSAGE7	_XmMMsgDragBS_0006

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

static int LocalErrorHandler( 

                        Display *display,

                        XErrorEvent *error) ;

static void StartProtectedSection( 

                        Display *display,

                        Window window) ;

static void EndProtectedSection( 

                        Display *display) ;

static Window GetMotifWindow( 

                        Display *display) ;

static void SetMotifWindow( 

                        Display *display,

                        Window motifWindow) ;

static xmTargetsTable GetTargetsTable( 

                        Display *display) ;

static void SetTargetsTable( 

                        Display *display,

                        xmTargetsTable targetsTable) ;

static xmAtomsTable GetAtomsTable( 

                        Display *display) ;

static void SetAtomsTable( 

                        Display *display,

                        xmAtomsTable atomsTable) ;

static Window ReadMotifWindow( 

                        Display *display) ;

static Window CreateMotifWindow( 

                        Display *display) ;

static void WriteMotifWindow( 

                        Display *display,

                        Window *motifWindow) ;

static void WriteAtomsTable( 

                        Display *display,

                        xmAtomsTable atomsTable) ;

static Boolean ReadAtomsTable( 

                        Display *display,

                        xmAtomsTable atomsTable) ;

static void WriteTargetsTable( 

                        Display *display,

                        xmTargetsTable targetsTable) ;

static Boolean ReadTargetsTable( 

                        Display *display,

                        xmTargetsTable targetsTable) ;

static xmTargetsTable CreateDefaultTargetsTable( 

                        Display *display) ;

static xmAtomsTable CreateDefaultAtomsTable( 

                        Display *display) ;

static int AtomCompare( 

                        XmConst void *atom1,

                        XmConst void *atom2) ;

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

static Boolean		bad_window;

static XErrorHandler	oldErrorHandler = NULL;

static unsigned long	firstProtectRequest;

static Window		errorWindow;

static XContext 	displayToMotifWindowContext = (XContext) NULL;

static XContext 	displayToTargetsContext = (XContext) NULL;

static XContext		displayToAtomsContext = (XContext) NULL;

/*****************************************************************************

 *

 *  LocalErrorHandler ()

 *

 ***************************************************************************/

static int 

LocalErrorHandler(

        Display *display,

        XErrorEvent *error )

{

    int ret_val;

    _XmProcessLock();

    if (error->error_code == BadWindow &&

	error->resourceid == errorWindow &&

	error->serial >= firstProtectRequest) {

        bad_window = True;

	_XmProcessUnlock();

	return 0;

    }

    if (oldErrorHandler == NULL) {

	_XmProcessUnlock();

        return 0;  /* should never happen */

    }

    ret_val = (*oldErrorHandler)(display, error);

    _XmProcessUnlock();

    return ret_val;

}

/*****************************************************************************

 *

 *  StartProtectedSection ()

 *

 *  To protect against reading or writing to a property on a window that has

 *  been destroyed.

 ***************************************************************************/

static void 

StartProtectedSection(

        Display *display,

        Window window )

{

    bad_window = False;

    oldErrorHandler = XSetErrorHandler (LocalErrorHandler);

    firstProtectRequest = NextRequest (display);

    errorWindow = window;

}

/*****************************************************************************

 *

 *  EndProtectedSection ()

 *

 *  Flushes any generated errors on and restores the original error handler.

 ***************************************************************************/

static void 

EndProtectedSection(

        Display *display )

{

    XSync (display, False);

    XSetErrorHandler (oldErrorHandler);

    oldErrorHandler = NULL;

}

/*****************************************************************************

 *

 *  GetMotifWindow ()

 *

 *  Get the motifWindow id from the displayToMotifWindowContext.

 ***************************************************************************/

static Window 

GetMotifWindow(

        Display *display )

{

    Window	motifWindow;

    XContext	loc_context;

    _XmProcessLock();

    if (displayToMotifWindowContext == (XContext) NULL) {

        displayToMotifWindowContext = XUniqueContext();

    }

    loc_context = displayToMotifWindowContext;

    _XmProcessUnlock();

    if (XFindContext(display, 

                     DefaultRootWindow (display),

		     loc_context, 

		     (char **)&motifWindow)) {

        motifWindow = None;

    }

    return (motifWindow);

}

/*****************************************************************************

 *

 *  SetMotifWindow ()

 *

 *  Set the motifWindow id into the displayToMotifWindowContext.

 ***************************************************************************/

static void 

SetMotifWindow(

        Display *display,

        Window motifWindow )

{

    Window oldMotifWindow;

    XContext loc_context;

    _XmProcessLock();

    if (displayToMotifWindowContext == (XContext) NULL) {

        displayToMotifWindowContext = XUniqueContext();

    }

    loc_context = displayToMotifWindowContext;

    _XmProcessUnlock();

    /*

     * Save window data.

     * Delete old context if one exists.

     */

    if (XFindContext (display, DefaultRootWindow (display),

			loc_context,

			(char **) &oldMotifWindow)) {

	XSaveContext(display, 

                        DefaultRootWindow (display),

			loc_context, 

			(char *) motifWindow);

    }

    else if (oldMotifWindow != motifWindow) {

	XDeleteContext (display, DefaultRootWindow (display),

			loc_context);

	XSaveContext(display, 

                        DefaultRootWindow (display),

			loc_context, 

			(char *) motifWindow);

    }

}

/*****************************************************************************

 *

 *  GetTargetsTable ()

 *

 *  Get the targets table address from the displayToTargetsContext.

 ***************************************************************************/

static xmTargetsTable 

GetTargetsTable(

        Display *display )

{

    xmTargetsTable	targetsTable;

    XContext		loc_context;

    _XmProcessLock();

    if (displayToTargetsContext == (XContext) NULL) {

        displayToTargetsContext = XUniqueContext();

    }

    loc_context = displayToTargetsContext;

    _XmProcessUnlock();

    if (XFindContext(display, 

                     DefaultRootWindow (display),

		     loc_context, 

		     (char **)&targetsTable)) {

        targetsTable = NULL;

    }

    return (targetsTable);

}

/*****************************************************************************

 *

 *  SetTargetsTable ()

 *

 *  Set the targets table address into the displayToTargetsContext.

 ***************************************************************************/

static void 

SetTargetsTable(

        Display *display,

        xmTargetsTable targetsTable )

{

    xmTargetsTable oldTargetsTable;

    XContext	loc_context;

    _XmProcessLock();

    if (displayToTargetsContext == (XContext) NULL) {

        displayToTargetsContext = XUniqueContext();

    }

    loc_context = displayToTargetsContext;

    _XmProcessUnlock();

    /*

     * Save targets data.

     * Delete old context if one exists.

     */

    if (XFindContext (display, DefaultRootWindow (display),

			loc_context,

			(char **) &oldTargetsTable)) {

	if (targetsTable)

	XSaveContext(display, 

                        DefaultRootWindow (display),

			loc_context, 

			(char *) targetsTable);

    }

    else if (oldTargetsTable != targetsTable) {

	XDeleteContext (display, DefaultRootWindow (display),

			loc_context);

        {

          unsigned i = 0 ;

          while(    i < oldTargetsTable->numEntries    )

            {

              XtFree( (char *) oldTargetsTable->entries[i++].targets) ;

            }

          XtFree( (char *) oldTargetsTable->entries) ;

          XtFree( (char *) oldTargetsTable) ;

        }

	if (targetsTable)

	XSaveContext(display, 

                        DefaultRootWindow (display),

			loc_context, 

			(char *) targetsTable);

    }

}

/*****************************************************************************

 *

 *  GetAtomsTable ()

 *

 *  Get the atomsTable address from the displayToAtomsContext.

 ***************************************************************************/

static xmAtomsTable 

GetAtomsTable(

        Display *display )

{

    xmAtomsTable	atomsTable;

    XContext		loc_context;

    _XmProcessLock();

    if (displayToAtomsContext == (XContext) NULL) {

	displayToAtomsContext = XUniqueContext();

    }

    loc_context = displayToAtomsContext;

    _XmProcessUnlock();

    if (XFindContext (display, 

                      DefaultRootWindow (display),

		      loc_context,

		      (XPointer *)&atomsTable)) {

        atomsTable = NULL;

    }

    return (atomsTable);

}

/*****************************************************************************

 *

 *  SetAtomsTable ()

 *

 *  Set the atoms table address into the displayToAtomsContext.

 ***************************************************************************/

static void 

SetAtomsTable(

        Display *display,

        xmAtomsTable atomsTable )

{

    xmAtomsTable oldAtomsTable;

    XContext loc_context;

    _XmProcessLock();

    if (displayToAtomsContext == (XContext) NULL) {

        displayToAtomsContext = XUniqueContext();

    }

    loc_context = displayToAtomsContext;

    _XmProcessUnlock();

    /*

     * Save atom data.

     * Delete old context if one exists.

     */

    if (XFindContext (display, DefaultRootWindow (display),

			loc_context,

			(char **) &oldAtomsTable)) {

	if (atomsTable)

	XSaveContext(display, 

                        DefaultRootWindow (display),

	                loc_context,

			(char *) atomsTable);

    }

    else if (oldAtomsTable != atomsTable) {

	XDeleteContext (display, DefaultRootWindow (display),

			loc_context);

        XtFree( (char *) (oldAtomsTable->entries)) ;

        XtFree( (char *) oldAtomsTable) ;

	if (atomsTable)

	XSaveContext(display, 

                        DefaultRootWindow (display),

	                loc_context,

			(char *) atomsTable);

    }

}

/*****************************************************************************

 *

 *  ReadMotifWindow ()

 *

 ***************************************************************************/

static Boolean RMW_ErrorFlag;

/*ARGSUSED*/

static int

RMW_ErrorHandler(Display *display, /* unused */

		 XErrorEvent* event) /* unused */

{

    _XmProcessLock();

    RMW_ErrorFlag = True;

    _XmProcessUnlock();

    return 0 ; /* unused */

}

static Window 

ReadMotifWindow(

        Display *display )

{

    Atom            motifWindowAtom;

    Atom            type;

    int             format;

    unsigned long   lengthRtn;

    unsigned long   bytesafter;

    Window         *property = NULL;

    Window	    motifWindow = None;

    XErrorHandler old_Handler;

    /* Setup error proc and reset error flag */

    old_Handler = XSetErrorHandler((XErrorHandler) RMW_ErrorHandler);

    _XmProcessLock();

    RMW_ErrorFlag = False;

    _XmProcessUnlock();

    motifWindowAtom = XInternAtom (display, XmI_MOTIF_DRAG_WINDOW, False);

    if ((XGetWindowProperty (display,

                             RootWindow (display, 0),

                             motifWindowAtom,

                             0L, MAXPROPLEN,

			     False,

                             AnyPropertyType,

                             &type,

			     &format,

			     &lengthRtn,

			     &bytesafter, 

			     (unsigned char **) &property) == Success) &&

         (type == XA_WINDOW) &&

	 (format == 32) &&

	 (lengthRtn == 1)) {

	motifWindow = *property;

    }

    if (property) {

	XFree ((char *)property);

    }

    XSetErrorHandler(old_Handler);

    _XmProcessLock();

    if (RMW_ErrorFlag) motifWindow = None;

    _XmProcessUnlock();

    return (motifWindow);

}

/*****************************************************************************

 *

 *  CreateMotifWindow ()

 *

 *  Creates a persistent window to hold the target list and atom pair

 *  properties.  This window is not visible on the screen.

 *

 ***************************************************************************/

static Window 

CreateMotifWindow(

        Display *display )

{

    Display	         *ndisplay;

    XSetWindowAttributes sAttributes;

    Window	         motifWindow;

    if ((ndisplay = XOpenDisplay(XDisplayString(display))) == NULL) {

	XmeWarning( (Widget) XmGetXmDisplay (display), MESSAGE3);

	return None;

    }

    XGrabServer(ndisplay);

    XSetCloseDownMode (ndisplay, RetainPermanent);

    sAttributes.override_redirect = True;

    sAttributes.event_mask = PropertyChangeMask;

    motifWindow = XCreateWindow (ndisplay,

                                 DefaultRootWindow (ndisplay),

			         -100, -100, 10, 10, 0, 0,

			         InputOnly,

			         CopyFromParent,

			         (CWOverrideRedirect |CWEventMask),

			         &sAttributes);

    XMapWindow (ndisplay, motifWindow);

    WriteMotifWindow (ndisplay, &motifWindow);

    XCloseDisplay(ndisplay);

    return (motifWindow);

}

/*****************************************************************************

 *

 *  WriteMotifWindow ()

 *

 ***************************************************************************/

static void 

WriteMotifWindow(

        Display *display,

        Window *motifWindow )

{

    Atom	motifWindowAtom;

    motifWindowAtom = XInternAtom (display, XmI_MOTIF_DRAG_WINDOW, False);

    XChangeProperty (display,

                     RootWindow (display, 0),

                     motifWindowAtom,

		     XA_WINDOW,

		     32,

		     PropModeReplace,

		     (unsigned char *) motifWindow,

		     1);

}

/*****************************************************************************

 *

 *  WriteAtomsTable ()

 *

 ***************************************************************************/

static void 

WriteAtomsTable(

        Display *display,

        xmAtomsTable atomsTable )

{

    BYTE			stackData[MAXSTACK];

    struct _propertyRec {

	xmMotifAtomsPropertyRec	info;

	xmMotifAtomsTableRec	entry[1];

    } *propertyRecPtr;

    Atom                	atomsTableAtom;

    int	       			i;

    Window			motifWindow;

    size_t			dataSize;

    if (!atomsTable) {

	XmeWarning( (Widget) XmGetXmDisplay (display), MESSAGE4);

	return;

    }

    /* If the data is bigger than the default stack allocation, then 

     * allocate heap storage, else use automatic storage.

     */

    dataSize = sizeof(xmMotifAtomsPropertyRec) + 

      atomsTable->numEntries * sizeof(xmMotifAtomsTableRec) ;

    if ( dataSize > MAXSTACK ) {

	propertyRecPtr = (struct _propertyRec *)XtMalloc( dataSize );

    } else {

	propertyRecPtr = (struct _propertyRec *)stackData;

    }

    propertyRecPtr->info.byte_order = (BYTE) _XmByteOrderChar;

    propertyRecPtr->info.protocol_version = (BYTE) _MOTIF_DRAG_PROTOCOL_VERSION;

    propertyRecPtr->info.num_atoms = atomsTable->numEntries;

    propertyRecPtr->info.heap_offset = dataSize;

    /* write each entry's atom and time */

    for (i = 0; i < atomsTable->numEntries; i++) {

        propertyRecPtr->entry[i].atom = atomsTable->entries[i].atom;

        propertyRecPtr->entry[i].time = atomsTable->entries[i].time;

    }

    /*

     *  Write the buffer to the property within a protected section.

     */

    atomsTableAtom = XInternAtom (display, XmI_MOTIF_DRAG_ATOMS, False);

    motifWindow = GetMotifWindow (display);

    _XmProcessLock();

    StartProtectedSection (display, motifWindow);

    XChangeProperty (display, 

                     motifWindow,

		     atomsTableAtom,

		     atomsTableAtom,

		     8,

		     PropModeReplace, 

		     (unsigned char *)propertyRecPtr,

		     dataSize );

    /* If we had to use a heap buffer, free it. */

    if (propertyRecPtr != (struct _propertyRec *)stackData) {

        XtFree((char *)propertyRecPtr);

    }

    EndProtectedSection (display);

    if (bad_window) {

	XmeWarning( (Widget) XmGetXmDisplay (display), MESSAGE1);

    }

    _XmProcessUnlock();

}

/*****************************************************************************

 *

 *  ReadAtomsTable ()

 *

 ***************************************************************************/

static Boolean 

ReadAtomsTable(

        Display *display,

        xmAtomsTable atomsTable )

{

    struct { 

	xmMotifAtomsPropertyRec info;

	xmMotifAtomsTableRec	entry[1];

    } *propertyRecPtr = NULL;

    Atom                        atomsTableAtom;

    int				format;

    unsigned long 		bytesafter, lengthRtn; 

    Atom			type;

    int				i;

    Boolean			ret;

    Window			motifWindow;

    atomsTableAtom = XInternAtom (display, XmI_MOTIF_DRAG_ATOMS, False);

    motifWindow = GetMotifWindow (display);

    _XmProcessLock();

    StartProtectedSection (display, motifWindow);

    ret = ((XGetWindowProperty (display, 	/* display* */

    				motifWindow,	/* window */

			        atomsTableAtom,	/* property atom */

			        0L, MAXPROPLEN,	/* long_offset, long_length */

			        False,		/* delete flag */

			        atomsTableAtom,	/* property type */

			        &type,		/* returned actual type */

			        &format,	/* returned actual format */

			        &lengthRtn,	/* returned item count */

			        &bytesafter,	/* returned bytes remaining */

			        (unsigned char **) &propertyRecPtr)

						/* returned data */

	    == Success) &&

           (lengthRtn >= sizeof(xmMotifAtomsPropertyRec)));

    EndProtectedSection (display);

    if (bad_window) {

	static Boolean first_time = True;

	/*

	 * Try to recreate the motifWindow. We could have gotten an invalid

	 * window id from the _MOTIF_DRAG_WINDOW property.

	 */

	if (first_time) {

	    motifWindow = CreateMotifWindow (display);

	    SetMotifWindow (display, motifWindow);

	    first_time = False;

	} else

	    XmeWarning( (Widget) XmGetXmDisplay (display), MESSAGE1);

	ret = False;

    }

    _XmProcessUnlock();

    if (ret) {

	if (propertyRecPtr->info.protocol_version != 

	    _MOTIF_DRAG_PROTOCOL_VERSION) {

	    XmeWarning( (Widget) XmGetXmDisplay (display), MESSAGE2);

	}

	if (propertyRecPtr->info.byte_order != _XmByteOrderChar) {

	    swap2bytes(propertyRecPtr->info.num_atoms);

	    swap4bytes(propertyRecPtr->info.heap_offset);

	}

        if (atomsTable == NULL)

        {

            atomsTable = (xmAtomsTable) XtMalloc(sizeof(xmAtomsTableRec));

            atomsTable->numEntries = 0;

            atomsTable->entries = NULL;

            SetAtomsTable (display, atomsTable);

        }

	if (propertyRecPtr->info.num_atoms > atomsTable->numEntries) {

            /*

	     *  expand the atoms table

	     */

            atomsTable->entries = (xmAtomsTableEntry) XtRealloc(

	        (char *)atomsTable->entries,	/* NULL ok */

		sizeof(xmAtomsTableEntryRec) * propertyRecPtr->info.num_atoms);

	}

	/*

	 *  Read the atom table entries.

	 */

	for (i = 0; i < (int)propertyRecPtr->info.num_atoms; i++) {

	    if (propertyRecPtr->info.byte_order != _XmByteOrderChar) {

		swap4bytes(propertyRecPtr->entry[i].atom);

		swap4bytes(propertyRecPtr->entry[i].time);

	    }

            atomsTable->entries[i].atom = (Atom) propertyRecPtr->entry[i].atom;

            atomsTable->entries[i].time = (Time) propertyRecPtr->entry[i].time;

	}

        atomsTable->numEntries = propertyRecPtr->info.num_atoms;

    }      

    /*

     *  Free any memory that Xlib passed us.

     */

    if (propertyRecPtr) {

        XFree((char *)propertyRecPtr);

    }

    return (ret);

}

/*****************************************************************************

 *

 *  WriteTargetsTable ()

 *

 ***************************************************************************/

static void 

WriteTargetsTable(

        Display *display,

        xmTargetsTable targetsTable )

{

    BYTE		stackData[MAXSTACK], *fill;

    struct _propertyRec {

	xmMotifTargetsPropertyRec	info;

    } *propertyRecPtr;

    Atom                targetsTableAtom;

    int			i, j;

    Window		motifWindow;

    size_t		dataSize;

    CARD16Item		shortItem;

    CARD32Item		longItem;

    if (!targetsTable) {

	XmeWarning( (Widget) XmGetXmDisplay (display), MESSAGE5);

	return;

    }

    /* Calculate the total size of the property. */