/*
 * 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 libraries and programs; if not, write
 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA 02110-1301 USA
 */
/* $TOG: main.c /main/11 1999/09/17 17:22:06 mgreess $ */
/*****************************************************************************/
/*                                                                           */
/*      main.c                                                               */
/*                                                                           */
/*****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <locale.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <Xm/XmAll.h>
#include <Xm/Xm.h>
#include <Xm/Protocols.h>
#include <Xm/VendorSEP.h>
#include <Xm/XmPrivate.h> /* XmeFlushIconFileCache */
#include <Dt/Action.h>
#include <Dt/GetDispRes.h>
#include <Dt/Icon.h>
#include <Dt/EnvControlP.h>
#include <Dt/UserMsg.h>
#include <Dt/Session.h>
#include <Dt/Wsm.h>

#define GETXMSTRING(s, m, d)	XmStringCreateLocalized(GETMESSAGE(s,m,d))
#define CLASS_NAME		"Dtcreate"

/* Copied from Xm/BaseClassI.h */
extern XmWidgetExtData _XmGetWidgetExtData( 
                        Widget widget,
#if NeedWidePrototypes
                        unsigned int extType) ;
#else
                        unsigned char extType) ;
#endif /* NeedWidePrototypes */

#include "dtcreate.h"
#include "ca_aux.h"
#include "cmnrtns.h"
#include "ErrorDialog.h"
#include "fileio.h"

#ifdef __TOOLTALK
#include <Tt/tttk.h>
void DieFromToolTalkError(Widget, char*, Tt_status);
Tt_message ProcessToolTalkMessage( );
#endif

#if !defined(NL_CAT_LOCALE)
#define NL_CAT_LOCALE 0
#endif

/* Global variables declared in dtcreate.h */
ActionData   AD;
ActionData   *pMyCopyAD;
char         *pszFileToEdit;
Cursor       watch_cursor;
Widget       widEditSource;
Boolean      bIconEditorDisplayed;
nl_catd      nlmsg_fd;
char         *pszExecName;
Widget       widSelectedIcon;
Boolean      bLowRes;
IconData     *IconDataList[ICON_NUMBER];

/**********************************************************/
/* CreateActionAppShell  globals.                         */
/**********************************************************/

Widget       CreateActionAppShell;
Widget       ExpertOption;
Widget       ColorMonoOption;
Widget       CA_ActionNameTextField;
Widget       CA_MED_IconGadget;
Widget       CA_SML_IconGadget;
Widget       CA_TINY_IconGadget;
Widget       CA_LRG_IconGadget;
Widget       CA_DblClkText;
Widget       XprtOptionForm;
Widget       CA_XprtActionOpenText;
Widget       CA_FiletypesList;
Widget       CA_WindowTypeArea;
Widget       CA_WindowType;
Widget       CA_Expand;
#if 0
Widget       CA_WindowType_OptionMenuShell;
Widget       CA_WindowType_Pane;
#endif
Widget       CA_WinTypeX;
Widget       CA_WinTypeAutoClose;
Widget       CA_WinTypeManualClose;
Widget       CA_WinTypeNoOutput;
Widget       CA_HelpTextWindow;
Widget       CA_HelpText;
Widget       CA_AllFiletypesToggle;
Widget       CA_FiletypesInListToggle;

/**********************************************************/
/* AddFiletype  globals.                                  */
/**********************************************************/

Widget       AddFiletype;
Widget       AF_FileTypeNameTextField;
Widget       AF_IdCharacteristicsText;
Widget       AF_IdCharacteristicsEdit;
Widget       AF_FiletypePrintCmdTextField;
Widget       AF_OpenCmdText;
Widget       AF_FiletypeHelpText;
Widget       AF_MED_IconGadget;
Widget       AF_TINY_IconGadget;

/**********************************************************/
/* FileCharacteristics  globals                           */
/**********************************************************/

Widget       FileCharacteristics;
Widget       FC_DirectoryToggle;
Widget       FC_FileToggle;
Widget       FC_AndLabel2;
Widget       FC_ContentsPatternText;
Widget       FC_StringToggle;
Widget       FC_ByteToggle;
Widget       FC_ShortToggle;
Widget       FC_LongToggle;
Widget       FC_StartByteTextField;
/*
Widget       FC_EndByteTextField;
*/
Widget       FC_NameOrPathText;
Widget       FC_AndLabel1;
Widget       FC_ReadToggle;
Widget       FC_WriteToggle;
Widget       FC_ExecuteToggle;

Widget       FC_NamePatternLabel;
Widget       FC_PermissionLabel;
Widget       FC_PermissionToggle;
Widget       FC_ContentsLabel;
Widget       FC_ContentsBox;
Widget       FC_TypeRowColumn;
Widget       FC_StartByteLabel;
Widget       FC_TypeLabel;
Widget       FC_ContentsPatternLabel;
/*
Widget       FC_EndByteLabel;
*/
Widget       FC_ContentsToggle;
Widget       FC_NameOrPathToggle;

/**********************************************************/
/* icon_selection_dialog  globals                         */
/**********************************************************/
Widget       ISD_SelectedIconTextField;

/**********************************************************/
/* Other dialog globals                                   */
/**********************************************************/
SessionData  sessiondata;

/*******************************************************************/
/* Global variables that are being initialized.                    */
/*******************************************************************/


enum icon_size_range action_icon_size = None_Selected;
extern enum icon_size_range filetype_icon_size;
int     pidIconEditor = 0;
Boolean bShowPixmaps = TRUE;
Widget  IconSelector = (Widget)NULL;
Boolean DbInitDone = FALSE;
Widget  OpenFile = (Widget)NULL;
Widget  Confirmed = (Widget)NULL;
Widget  QuestionDialog = (Widget)NULL;
Widget  ErrorDialog = (Widget)NULL;
Widget  last_action_pushed = (Widget)NULL;
Widget  last_filetype_pushed = (Widget)NULL;

const char *ca_icon_default = "Dtactn";
const char *ca_full_icon_default =  "/usr/dt/appconfig/icons/C/Dtactn";
const char *ca_lrg_icon_default =  "/usr/dt/appconfig/icons/C/Dtactn.l";
const char *ca_med_icon_default =  "/usr/dt/appconfig/icons/C/Dtactn.m";
const char *ca_sml_icon_default =  "/usr/dt/appconfig/icons/C/Dtactn.s";
const char *ca_tiny_icon_default = "/usr/dt/appconfig/icons/C/Dtactn.t";

const char *af_icon_default = "Dtdata";
const char *af_full_icon_default =  "/usr/dt/appconfig/icons/C/Dtdata";
const char *af_lrg_icon_default =  "/usr/dt/appconfig/icons/C/Dtdata.l";
const char *af_med_icon_default =  "/usr/dt/appconfig/icons/C/Dtdata.m";
const char *af_sml_icon_default =  "/usr/dt/appconfig/icons/C/Dtdata.s";
const char *af_tiny_icon_default = "/usr/dt/appconfig/icons/C/Dtdata.t";



/*----------------------------------------------------
 * UxXt.h needs to be included only when compiling a
 * stand-alone application.
 *---------------------------------------------------*/
#ifndef DESIGN_TIME
#include "UxXt.h"
#endif /* DESIGN_TIME */

XtAppContext    UxAppContext;
Widget          UxTopLevel;
Display         *UxDisplay;
int             UxScreen;

/*----------------------------------------------
 * Insert application global declarations here
 *---------------------------------------------*/

extern XtArgVal /* Dimension */ wintypeheight;

/*  Structure used on a save session to see if a dt is iconic  */
typedef struct {
   int state;
   Window icon;
} WM_STATE;

/*****************************************************************************/
/*                                                                           */
/* Routine:   GetSessionInfo                                                 */
/*                                                                           */
/* Purpose:   get session management saved information                       */
/*                                                                           */
/*****************************************************************************/
void GetSessionInfo( void )
{
    XrmDatabase        db;
    char               *tmpStr, *tmpStr2;
    char               *path;
    XrmName            xrm_name[5];
    XrmRepresentation  rep_type;
    XrmValue           value;
    char               *msgPtr;
    char               *fmtPtr;
    char               *errPtr;

#ifdef DEBUG
  if (debug)
    stat_out("GetSessionInfo\n");
#endif

    /*****************************************/
    /***  Open the resource database file  ***/
    /*****************************************/

    /************************************************************************/
    /*  UxTopLevel is used because CreateActionAppShell isn't created yet...*/
    /*  okay because it only uses it to get a display, not a window         */
    /************************************************************************/
    if (DtSessionRestorePath(UxTopLevel, &path, sessiondata.pszSessionFile) == False)
        path = sessiondata.pszSessionFile;
#ifdef DEBUG
    printf("session file = %s\n", path);
#endif
    if ((db = XrmGetFileDatabase (path)) == NULL)
    {
       msgPtr = GETMESSAGE(5, 162, "Could not restore session from file:");
       fmtPtr = "%s\n %s\n";
       errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
			  strlen(path) + 1) * sizeof(char));
       sprintf(errPtr, fmtPtr, msgPtr, path);
       display_error_message(UxTopLevel, errPtr);
       XtFree(errPtr);
       if (path != sessiondata.pszSessionFile) {
          XtFree(path);
       }
       sessiondata.useSession = False;
       return;
    }
    if (path != sessiondata.pszSessionFile) {
       XtFree(path);
    }

    /*** now get the information we want from the database ***/
    /*** make sure values are at least somewhat reasonable ***/

    xrm_name[1] = '\0';

    /*******************************/
    /* get x position              */
    /*******************************/
    xrm_name[0] = XrmStringToQuark ("x");
    if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value))
        sessiondata.x = (Position)atoi((char *)value.addr);
    else
        sessiondata.x = 100;
    if (sessiondata.x < 0) sessiondata.x = 0;

    /*******************************/
    /* get y position              */
    /*******************************/
    xrm_name[0] = XrmStringToQuark ("y");
    if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value))
        sessiondata.y = (Position)atoi((char *)value.addr);
    else
        sessiondata.y = 100;
    if (sessiondata.y < 0) sessiondata.y = 0;

    /*******************************/
    /* get width                   */
    /*******************************/
    xrm_name[0] = XrmStringToQuark ("width");
    if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value))
        sessiondata.width = (Dimension)atoi((char *)value.addr);
    /*
    else
        sessiondata.width = DEFAULT_WIDTH;
    if (sessiondata.width < DEFAULT_WIDTH) sessiondata.width = DEFAULT_WIDTH;
    */

    /*******************************/
    /* get height                  */
    /*******************************/
    xrm_name[0] = XrmStringToQuark ("height");
    if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value))
        sessiondata.height = (Dimension)atoi((char *)value.addr);
    /*
    else
        sessiondata.height = DEFAULT_HEIGHT;
    if (sessiondata.height < DEFAULT_HEIGHT) sessiondata.height = DEFAULT_HEIGHT;
    */

    /*******************************/
    /* get iconic state            */
    /*******************************/
    xrm_name[0] = XrmStringToQuark ("iconic");
    if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value))
    {
        if ( value.addr!=NULL && strcmp((char *)value.addr, "True")==0 )
            sessiondata.iconicState = IconicState;
        else
            sessiondata.iconicState = NormalState;
    }

    /*******************************/
    /* get expert status           */
    /*******************************/
    xrm_name[0] = XrmStringToQuark ("expert");
    if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value))
    {
	sessiondata.showExpert = ((value.addr != NULL) &&
				  (strcmp((char *)value.addr, "True") == 0));
    }

    /*******************************/
    /* get workspace #             */
    /*******************************/
    xrm_name[0] = XrmStringToQuark ("workspace");
    if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value))
    {
        if ( value.addr!=NULL)
            strcpy(sessiondata.workspaces, value.addr);
        else
            sessiondata.workspaces[0] = '\0';
    }

    /*******************************/
    /* get file name               */
    /*******************************/
    xrm_name[0] = XrmStringToQuark ("file");
    if (XrmQGetResource (db, xrm_name, xrm_name, &rep_type, &value)) {
#ifdef DEBUG
       printf("file to edit = '%s'\n", value.addr);
#endif
       pszFileToEdit = (char *)XtMalloc(strlen(value.addr) + 1);
       strcpy(pszFileToEdit, value.addr);
    }
}
/*****************************************************************************/
/*                                                                           */
/* Routine:   SaveSession                                                    */
/*                                                                           */
/* Purpose:   save state information for session management                  */
/*                                                                           */
/*****************************************************************************/
void SaveSession( void )
{
    char                    *path, *name;
    int                     fd, n;
    char                    *xa_CommandStr[3];
    char                    *tmpStr, *tmpStr2;
    Position                x,y;
    Dimension               width, height;
    char                    *msgPtr, *fmtPtr, *errPtr;
    XmVendorShellExtObject  vendorExt;
    XmWidgetExtData         extData;
    WM_STATE                *wmState;
    Atom                    wmStateAtom, actualType;
    Atom		    *ws_presence = NULL;
    int                     actualFormat, j;
    unsigned long           nitems, leftover, num_workspaces=0;
    char		    all_workspace_names[256];
    char		    *workspace_name;
    Display 		    *display = XtDisplay(CreateActionAppShell);
    FILE		    *fp;

    DtSessionSavePath(CreateActionAppShell, &path, &name);
#ifdef DEBUG
    printf("path = %s\n", path);
    printf("name = %s\n", name);
#endif

    /*  Create the session file  */
    if (((fd = creat(path, S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP)) == -1) ||
	((fp = fdopen(fd, "w")) == (FILE *)NULL))
    {
       msgPtr = GETMESSAGE(5, 160, "Could not save session to file:");
       fmtPtr = "%s\n %s\n";
       errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
			  strlen(path) + 1) * sizeof(char));
       sprintf(errPtr, fmtPtr, msgPtr, path);
       display_error_message(CreateActionAppShell, errPtr);
       XtFree(errPtr);
       if (fd != -1)
       {
	   close(fd);
	   unlink(path);
       }
       XtFree ((char *)path);
       XtFree ((char *)name);
       return;
    }

    /*  Getting the WM_STATE property to see if iconified or not */
#ifdef DEBUG
    printf("getting wm state\n");
#endif
    wmStateAtom = XInternAtom(display, "WM_STATE", False);

#ifdef DEBUG
    printf("getting window property\n");
#endif
    XGetWindowProperty (XtDisplay(CreateActionAppShell),
                        XtWindow(CreateActionAppShell), wmStateAtom, 0L,
                        (long)BUFSIZ, False, wmStateAtom, &actualType,
                        &actualFormat, &nitems, &leftover,
                        (unsigned char **) &wmState);

    if (wmState->state == IconicState)
        fprintf(fp, "*iconic: True\n");
    else
        fprintf(fp, "*iconic: False\n");

    fprintf(fp, "*expert: %s\n",
	    XtIsManaged(XprtOptionForm) ? "True" : "False");

    /*** Get and write out the geometry info for our Window ***/

#ifdef DEBUG
    printf("getting geometry info\n");
#endif

    x = XtX(CreateActionAppShell);
    y = XtY(CreateActionAppShell);
    width = XtWidth(CreateActionAppShell);
    height = XtHeight(CreateActionAppShell);

    /*  Modify x & y to take into account window mgr frames
     *  This is pretty bogus, but I don't know a better way to do it.
     */
    extData = _XmGetWidgetExtData(CreateActionAppShell, XmSHELL_EXTENSION);
    vendorExt = (XmVendorShellExtObject)extData->widget;
    x -= vendorExt->vendor.xOffset;
    y -= vendorExt->vendor.yOffset;

    fprintf(fp, "*x: %d\n", x);
    fprintf(fp, "*y: %d\n", y);
    fprintf(fp, "*width: %d\n", width);
    fprintf(fp, "*height: %d\n", height);

#ifdef DEBUG
    printf("getting workspaces this window is present \n");
#endif

    if (DtWsmGetWorkspacesOccupied (display,
    				    XtWindow(CreateActionAppShell),
				    &ws_presence, &num_workspaces) == Success)
    {
	for (j = 0; j < num_workspaces; j++)
	{
	    workspace_name = XGetAtomName (display, ws_presence[j]);
	    if (j == 0)
		(void) strcpy(all_workspace_names, workspace_name);
	    else
	    {
		(void) strcat(all_workspace_names, "*");
		(void) strcat(all_workspace_names, workspace_name);
	    }
	    XFree ((char *) workspace_name);
	}
	XtFree((char *)ws_presence);
        fprintf(fp, "*workspace: %s\n", all_workspace_names);
    }

    /*  This will be used to indicate what file is currently being edited. */
    if (pszFileToEdit != NULL) {
        fprintf(fp, "*file: %s\n", pszFileToEdit);
    }

    fflush(fp);
    fclose(fp);

    n = 0;
    xa_CommandStr[n] = pszExecName; n++;
    xa_CommandStr[n] =  "-s";       n++;
    xa_CommandStr[n] = name;        n++;

    XSetCommand(XtDisplay(CreateActionAppShell), XtWindow(CreateActionAppShell), xa_CommandStr, n);
    XtFree ((char *)path);
    XtFree ((char *)name);

    /*  Don't exit yet, SM needs time to get the new commandStr.*/
}

/*****************************************************************************/
/*                                                                           */
/* SaveSessionCB                                                             */
/*                                                                           */
/* Session is ending, save session information                               */
/*                                                                           */
/*****************************************************************************/
static void
SaveSessionCB (
        Widget w,
        XtPointer clientData,
        XtPointer callbackArg )
{
  char      *xa_CommandStr[3];
  int       i;

#if 0
  i = 0;
  xa_CommandStr[i] = pszExecName; i++;
  XSetCommand(XtDisplay(CreateActionAppShell), XtWindow(CreateActionAppShell), xa_CommandStr, i);
#endif

  SaveSession();
}

/*****************************************************************************/
/*                                                                           */
/*  GetIconDataFromWid                                                       */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/
IconData *GetIconDataFromWid( Widget wid )
{
  int       i;
  IconData  *pIconData;

  for (i=0; i < ICON_NUMBER; i++) {
     if ((IconDataList[i]) && (IconDataList[i]->wid == wid)) {
        return(IconDataList[i]);
     }
  }
  return((IconData *)NULL);
}

/*****************************************************************************/
/*                                                                           */
/*  GetIconDataFromMsgID                                                     */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/
IconData *GetIconDataFromMsgID( char *msgID )
{
  int       i;
  IconData  *pIconData;

  for (i=0; i < ICON_NUMBER; i++) {
     if (IconDataList[i]->pmMsgID) {
        if (!strcmp(IconDataList[i]->pmMsgID, msgID)) {
           return(IconDataList[i]);
        }
     }
     if (IconDataList[i]->bmMsgID) {
        if (!strcmp(IconDataList[i]->bmMsgID, msgID)) {
           return(IconDataList[i]);
        }
     }
  }
  /*
  for (i=0; i < ICON_NUMBER; i++) {
     if ( ((IconDataList[i]->pmMsgID) &&
           (!strcmp(IconDataList[i]->pmMsgID, msgID))) ||
          ((IconDataList[i]->bmMsgID) &&
           (!strcmp(IconDataList[i]->bmMsgID, msgID))) ) {
        return(IconDataList[i]);
     }
  }
  */
  return((IconData *)NULL);
}

/*****************************************************************************/
/*                                                                           */
/*  RemoveTmpIconFiles                                                       */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/
void RemoveTmpIconFiles( void )
{
  int       i;
  IconData  *pIconData;
  char      maskFile[MAXFILENAME];

  for (i=0; i < ICON_NUMBER; i++) {
     if ( (IconDataList[i]->pmDirtyBit) &&
          (IconDataList[i]->pmFileName[0]) &&
          (strlen(IconDataList[i]->pmFileName)) ) {
#ifdef DEBUG
        printf("RemoveTmpIconFiles: unlink '%s'\n", IconDataList[i]->pmFileName);  /* debug */
#endif
        unlink(IconDataList[i]->pmFileName);
        /* This is bogus.  But just in case the user specified a bitmap */
        /* rather than a pixmap during the edit process, this will make */
        /* sure that file gets removed.  The chance of this occurring   */
        /* is very unlikely.                                            */
        strcpy(maskFile, IconDataList[i]->pmFileName);
        strcat(maskFile, "_m");

#ifdef DEBUG
        printf("Remove maskFile = %s\n", maskFile); /* debug */
#endif
        unlink(maskFile);
     }
     if ( (IconDataList[i]->bmDirtyBit) &&
          (strlen(IconDataList[i]->bmFileName)) ) {
#ifdef DEBUG
        printf("RemoveTmpIconFiles: unlink '%s'\n", IconDataList[i]->bmFileName);  /* debug */
#endif
        unlink(IconDataList[i]->bmFileName);
        strcpy(maskFile, IconDataList[i]->bmFileName);
        strcat(maskFile, "_m");
#ifdef DEBUG
        printf("Remove maskFile = %s\n", maskFile); /* debug */
#endif
        unlink(maskFile);
     }
  }
}

#ifdef __TOOLTALK
/*****************************************************************************/
/*                                                                           */
/*  DieFromToolTalkError                                                     */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/
static void
ExitCB (Widget dialog, XtPointer client_data, XtPointer call_data)
{
    exit((int)(XtArgVal) client_data);
}

void
DieFromToolTalkError(Widget parent, char *errfmt, Tt_status status)
{
    Arg		 args[10];
    Widget	 dialog, dialogShell;
    char	*errmsg, *statmsg, *title;
    XmString	 xms_errmsg, xms_ok, xms_title;
    int		 n;

    if (! tt_is_err(status)) return;

    statmsg = tt_status_message(status);
    /* Solaris dtcreate ignores this so we should too */
    if(status == TT_ERR_PTYPE)
            return;
    errmsg = XtMalloc(strlen(errfmt) + strlen(statmsg) + 2);
    sprintf(errmsg, errfmt, statmsg);

    xms_ok = GETXMSTRING(13, 3, "OK");
    xms_errmsg = XmStringCreateLocalized(errmsg);
    xms_title = GETXMSTRING(13, 1, "Create Action - Error");

    n = 0;
    XtSetArg(args[n], XmNautoUnmanage, False); n++;
    XtSetArg(args[n], XmNokLabelString, xms_ok); n++;
    XtSetArg(args[n], XmNdialogTitle, xms_title); n++;
    XtSetArg(args[n], XmNmessageString, xms_errmsg); n++;
    XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;

    dialog = XmCreateErrorDialog(parent, "IconEditorError", args, n);
    XtAddCallback(dialog, XmNokCallback, ExitCB, (XtPointer) status);
    XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_CANCEL_BUTTON));
    XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));

    /*
     * Disable the frame menu from dialog since we don't want the user
     * to be able to close dialogs with the frame menu
     */
    dialogShell = XtParent(dialog);
    n = 0;
    XtSetArg(args[n], XmNmwmDecorations, MWM_DECOR_ALL | MWM_DECOR_MENU); n++;
    XtSetValues(dialogShell, args, n);
    XtManageChild(dialog);
    XtRealizeWidget(dialogShell);

    _DtSimpleError(CLASS_NAME, DtFatalError, NULL, errmsg);

    XtFree(errmsg);
    XmStringFree(xms_ok);
    XmStringFree(xms_errmsg);
    XmStringFree(xms_title);

    while (TRUE)
      XtAppProcessEvent(XtWidgetToApplicationContext(dialog), XtIMAll);
}

/*****************************************************************************/
/*                                                                           */
/*  ProcessToolTalkMessage                                                   */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/
Tt_message ProcessToolTalkMessage(Tt_message msg,
                                  void* cdata,
                                  Tt_message contract )
{

  int ttMark = tt_mark();

  if( 0 == strcmp( tt_message_op( msg ), "Quit" ) ) {
          /*
           * Do the necessary cleanup, call tt_message_reply(),
           * and exit.  Since this is not yet fully implemented, just
           * call tt_message_reply and exit.
           */

#ifdef DEBUG
          printf("ProcessTTMsg: Quit\n");  /* debug */
#endif
          tt_message_reply(msg);
          RemoveTmpIconFiles();
          exit(1);
  } else {
          /*
           * Any other desktop message ops that one would want
           * to implement would go here.  If
           * a mapped, realized, top-level widget were passed into
           * ttdt_session_join instead of (Widget) 0, then the
           * messages that interact with the X environment
           * Get_Geometry, etc.) would be handled automatically.
           */

#ifdef DEBUG
          printf("ProcessTTMsg: Other\n");
#endif

  }
  tt_release( ttMark );

  return (Tt_message) 0;
}

/*****************************************************************************/
/* NAME:        IconEdit_tt_handler                                          */
/* DESCRIPTION: Handler for Tooltalk conversation about editing icon.        */
/* PARAMETERS:                                                               */
/* RETURN:      none                                                         */
/* CREATION:    02/21/94                                                     */
/* REVISIONS:                                                                */
/*****************************************************************************/
Tt_callback_action IconEdit_tt_handler( Tt_message m, Tt_pattern p )
{
  int             ttMark;
  int             blen;
  int             wlen;
  int             tmpfd = -1;
  Tt_state        mstate;
  char            *msgPtr, *fmtPtr, *errPtr;
  char            tmpbuf[MAXBUFSIZE];
  char*           ttbuf;
  char*           op;
  char            *tmpIconFile;
  char            *msgID;
  IconData        *pIconData;
  Boolean         bIsNewFile = False;

  char            *tmp = (char *)NULL;
  char            *tmp1 = (char *)NULL;
  int             tmplen;

  ttMark = tt_mark( );

  op = tt_message_op(m);
  /************************************************************************/
  /* Edit message...                                                      */
  /************************************************************************/
  if (!strcmp(op, "Edit")) {
#ifdef DEBUG
     printf("IconEdit_tt_handler: Edit tt msg = %p\n", m);  /* debug */
#endif
     mstate = tt_message_state( m );
     switch ((int)mstate) {
         case TT_FAILED:
             TurnOffHourGlassAllWindows();

	     /* INTERNATIONALIZE */
	     msgPtr = "Failed ToolTalk msg";
	     fmtPtr = "%s = %p";
	     errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
				20) * sizeof(char));
             sprintf(errPtr, fmtPtr, msgPtr, m);
             display_error_message(CreateActionAppShell, errPtr);
	     XtFree(errPtr);
#ifdef DEBUG
             printf( "Failed ToolTalk msg = %p\n", m);   /* debug */
#endif
             tt_message_destroy( m );
             break;
         case TT_HANDLED:
             TurnOffHourGlassAllWindows();
#ifdef DEBUG
             printf( "Handled ToolTalk msg = %p\n", m);  /* debug */
#endif
             tt_message_destroy( m );
             break;
#ifdef DEBUG
         case TT_STARTED:
             printf( "Started ToolTalk msg = %p\n", m);  /* debug */
#endif
     }
  } else {
#ifdef DEBUG
     printf("IconEdit_tt_handler: Saved tt msg = %p\n", m);  /* debug */
#endif
     msgID = tt_message_arg_val(m, 1);
     pIconData = GetIconDataFromMsgID(msgID);
#ifdef DEBUG
     printf("msgID = '%s'\n", msgID);  /* debug */
#endif

     /*********************************************************************/
     /* Saved message...                                                  */
     /*********************************************************************/
     if ( (pIconData) && (!strcmp(op, "Saved")) ) {
        tt_message_arg_bval(m, 0, (unsigned char **)&ttbuf, &blen);

        if ( (pIconData->pmMsgID) && (!strcmp(pIconData->pmMsgID, msgID)) ) {
           if (pIconData->pmDirtyBit) {
              tmpIconFile = pIconData->pmFileName;
           } else {
              tmpnam(pIconData->pmFileName);
              bIsNewFile = True;
              tmpIconFile = pIconData->pmFileName;
           }
        } else {
           if (pIconData->bmDirtyBit) {
              tmpIconFile = pIconData->bmFileName;
           } else {
              tmpnam(pIconData->bmFileName);
              bIsNewFile = True;
              tmpIconFile = pIconData->bmFileName;
           }
        }
        if (bIsNewFile) {
            tmpfd = open(tmpIconFile, O_CREAT | O_WRONLY | O_NDELAY, 0666);
        } else {
           tmpfd = open(tmpIconFile, O_TRUNC | O_WRONLY | O_NDELAY, 0666);
        }
        if (tmpfd == -1) {
	   msgPtr = GETMESSAGE(5, 60, "Could not open the following file:");
	   fmtPtr = "%s\n   %s";
	   errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
			      strlen(tmpIconFile) + 1) * sizeof(char));
	   sprintf(errPtr, fmtPtr, msgPtr, tmpIconFile);
	   display_error_message(XtParent(pIconData->wid), errPtr);
	   XtFree(errPtr);
           tt_release( ttMark );
           return (TT_CALLBACK_CONTINUE);
        }

        /*******************************************************************/
        /* Determine if this is a pixmap or bitmap.  If it is a pixmap,    */
        /* handle as a one file buffer.  If a bitmap, then it may be       */
        /* double buffered including the mask.                             */
        /*******************************************************************/

        /*******************************************************************/
        /* Check for Pixmap first.                                         */
        /*******************************************************************/
        if ( (ttbuf) && (!strncmp(ttbuf, "/* XPM */", 9)) ) {
#ifdef DEBUG
           printf("This is a XPM file\n");  /* debug */
#endif
           tmp = strstr(ttbuf, "};");
           if (tmp) {
              tmp += 2;                        /* Go one char past the ";" */
              /*
              tmplen = blen - strlen(tmp) + 1;
              printf("Amro tmplen = %d\n", tmplen);
              */
              tmplen = (char *)tmp - (char *)ttbuf;
#ifdef DEBUG
              printf("Troy tmplen = %d\n", tmplen); /* debug */
#endif
           } else {
              tmplen = blen;
           }
           if ((wlen = write(tmpfd, ttbuf, tmplen)) == tmplen) {
              if (tmpfd > -1) close(tmpfd);
           } else {
	      /* INTERNATIONALIZE */
	      msgPtr = "Could not write to the following file:";
	      fmtPtr = "%s\n   %s";
	      errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
				 strlen(tmpIconFile) + 1) * sizeof(char));
              sprintf(errPtr, fmtPtr, msgPtr, tmpIconFile);
              display_error_message(XtParent(pIconData->wid), errPtr);
	      XtFree(errPtr);
              tt_release( ttMark );
              if (tmpfd > -1) close(tmpfd);
              return (TT_CALLBACK_CONTINUE);
           }

        /*******************************************************************/
        /* Must be a Bitmap.                                               */
        /*******************************************************************/
        } else {
#ifdef DEBUG
           printf("This is a XBM file\n");  /* debug */
           printf("ttbuffer size = %d\n", blen); /* debug */
#endif
           /****************************************************************/
           /* Determine size of first bitmap.                              */
           /****************************************************************/
           tmp = strstr(ttbuf, "};");
           if (tmp) {
              tmp += 2;                        /* Go one char past the ";" */
              /*
              tmplen = blen - strlen(tmp) + 1;
              printf("Amro tmplen = %d\n", tmplen);
              */
              tmplen = (char *)tmp - (char *)ttbuf;
#ifdef DEBUG
              printf("Troy tmplen = %d\n", tmplen); /* debug */
#endif
           } else {
              tmplen = blen;
           }
#ifdef DEBUG
           printf("File 1 size = %d\n", tmplen); /* debug */
#endif

           /****************************************************************/
           /* Write out first bitmap file.                                 */
           /****************************************************************/
#ifdef DEBUG
           printf("Writing first bitmap file\n"); /* debug */
#endif
           if ((wlen = write(tmpfd, ttbuf, tmplen)) == tmplen) {
              if (tmpfd > -1) close(tmpfd);
           } else {
	      /* INTERNATIONALIZE */
	      msgPtr = "Could not write to the following file:";
	      fmtPtr = "%s\n   %s";
	      errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
				 strlen(tmpIconFile) + 1) * sizeof(char));
              sprintf(errPtr, fmtPtr, msgPtr, tmpIconFile);
              display_error_message(XtParent(pIconData->wid), errPtr);
	      XtFree(errPtr);
              tt_release( ttMark );
              if (tmpfd > -1) close(tmpfd);
              return (TT_CALLBACK_CONTINUE);
           }

           /****************************************************************/
           /* Now determine if there is a second bitmap and its size.      */
           /****************************************************************/
           if (tmp) {
              tmp1 = strstr(tmp, "};");
           }
           snprintf(tmpbuf, sizeof(tmpbuf), "%s_m", tmpIconFile);
           if (tmp1) {
              tmp1 += 2;                       /* Go one char past the ";" */
#ifdef DEBUG
              printf("Mask file name = '%s'\n", tmpbuf); /* debug */
#endif
              tmpfd = open(tmpbuf, O_CREAT | O_WRONLY | O_NDELAY, 0666);
              if (tmpfd == -1) {
		 msgPtr =
		     GETMESSAGE(5, 60, "Could not open the following file:");
		 fmtPtr = "%s\n   %s";
		 errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
				    strlen(tmpbuf) + 1) * sizeof(char));
                 sprintf(errPtr, fmtPtr, msgPtr, tmpbuf);
                 display_error_message(XtParent(pIconData->wid), errPtr);
		 XtFree(errPtr);
                 tt_release( ttMark );
                 return (TT_CALLBACK_CONTINUE);
              }

#ifdef DEBUG
              printf("writing mask file \n");
#endif
              /*
              tmplen = strlen(tmp);
              printf("Amro tmplen = %d\n", tmplen);
              */
              tmplen = (char *)tmp1 - (char *)tmp;
#ifdef DEBUG
              printf("Troy tmplen = %d\n", tmplen); /* debug */
#endif
              if ((wlen = write(tmpfd, tmp, tmplen)) == tmplen) {
                 if (tmpfd > -1) close(tmpfd);
              } else {
		 /* INTERNATIONALIZE */
		 msgPtr = "Could not write to the following file:";
		 fmtPtr = "%s\n   %s";
		 errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
				    strlen(tmpbuf) + 1) * sizeof(char));
                 sprintf(errPtr, fmtPtr, msgPtr, tmpbuf);
                 display_error_message(XtParent(pIconData->wid), errPtr);
		 XtFree(errPtr);
                 tt_release( ttMark );
                 if (tmpfd > -1) close(tmpfd);
                 return (TT_CALLBACK_CONTINUE);
              }

           /****************************************************************/
           /* Must not have a mask, so lets clean up any old mask file.    */
           /****************************************************************/
           } else {
#ifdef DEBUG
              printf("Remove maskFile = %s\n", tmpbuf); /* debug */
#endif
              unlink(tmpbuf);
           }
        }

        /****************************************************************/
        /* Set the icon gadget with new icon, and flag the dirty bit.   */
        /****************************************************************/
        if ( ( (pIconData->pmMsgID) &&
               (!strcmp(pIconData->pmMsgID, msgID)) &&
               (bShowPixmaps) )
           ||
             ( (pIconData->bmMsgID) &&
               (!strcmp(pIconData->bmMsgID, msgID)) &&
               (!bShowPixmaps) ) ) {
           XmeFlushIconFileCache(NULL);
#ifdef DEBUG
           printf("Change icon image for widget = %p\n", pIconData->wid); /* debug */
#endif
           SET_ICONGADGET_ICON(pIconData->wid, tmpIconFile);
        }
        if ((pIconData->pmMsgID) && (!strcmp(pIconData->pmMsgID, msgID))) {
           pIconData->pmDirtyBit = True;
        } else {
           pIconData->bmDirtyBit = True;
        }
#ifdef DEBUG
        printf("**********tmp file name = %s\n", tmpIconFile);  /* debug */
#endif
     }
  }
  tt_release( ttMark );
  return( TT_CALLBACK_PROCESSED );
}

/*****************************************************************************/
/* NAME:        UxDoEditPixmap                                               */
/* DESCRIPTION: Loads the icon editor.                                       */
/* PARAMETERS:  none                                                         */
/* RETURN:      none                                                         */
/* CREATION:    02/11/94                                                     */
/* REVISIONS:                                                                */
/*****************************************************************************/
void UxDoEditPixmap(Widget wid, char *fname)
{
  Tt_message     m;         /* ToolTalk message */
  Tt_pattern     p;         /* ToolTalk dynamic pattern */
  Tt_status      ttRc;      /* ToolTalk status  */

  int            fd1 = -1;
  int            fd2 = -1;

  int            lenFile1 = 0, rlenFile1 = 0;
  int            lenFile2 = 0, rlenFile2 = 0;

  int            mark;
  char           *msgID;
  char           **ppMsgID;
  IconData       *pIconData;
  unsigned char  *buffer;
  char           *ptr;

  char           tmpbuf[MAXBUFSIZE];
  char           *errPtr;
  char           *msgPtr;
  char           *fmtPtr;
  char           *mname = (char *)NULL;
  char           *type_name, *size_name;


#ifdef DEBUG
  if (fname) printf("Edit filename: '%s'\n", fname);  /* debug */
#endif

  mark = tt_mark();

  /*********************************************************************/
  /* Create request                                                    */
  /*********************************************************************/
  m = tt_prequest_create( TT_SESSION, "Edit" );
  msgID = tt_message_id(m);
  pIconData = GetIconDataFromWid(wid);
  if (bShowPixmaps) {
     ppMsgID = &(pIconData->pmMsgID);
  } else {
     ppMsgID = &(pIconData->bmMsgID);
  }
  if (*ppMsgID) {
     free(*ppMsgID);
  }
  if (msgID && strlen(msgID)) {
     *ppMsgID = (char *)malloc(strlen(msgID) + 1);
     strcpy(*ppMsgID, msgID);
  }

#ifdef DEBUG
  printf("msgID = '%s'\n", msgID);  /* debug */
  printf("Create Edit msg = %p\n", m);  /* debug */
#endif

  /*********************************************************************/
  /* Add arguments to message                                          */
  /*********************************************************************/
  if (fname) {
     fd1 = open(fname, O_RDONLY);
     if (fd1 == -1) {
        /* Error opening icon file! */
	msgPtr = GETMESSAGE(5, 60, "Could not open the following file:");
	fmtPtr = "%s\n   %s";
	errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
			   strlen(fname) + 1) * sizeof(char));
        sprintf(errPtr, fmtPtr, msgPtr, fname);
        display_error_message(XtParent(wid), errPtr);
	XtFree(errPtr);
        return;
     } else {
        /***************************************/
        /* Find out how big a buffer is needed */
        /***************************************/
        lenFile1 = lseek(fd1, 0, SEEK_END);
        (void) lseek(fd1, 0, SEEK_SET);

        /*************************************************************/
        /* Read first few bytes to determine what kind of file it is */
        /*************************************************************/
        read(fd1, tmpbuf, 10);
        (void) lseek(fd1, 0, SEEK_SET);

        /******************************************************************/
        /* If the file is a bitmap, then check for its mask file and add. */
        /******************************************************************/
        if ( strncmp(tmpbuf, "/* XPM */", 9) ) {

           mname = CreateMaskName(fname);

           /***************************************************************/
           /* Check if mask file exists.                                  */
           /***************************************************************/
           if ((mname) && (check_file_exists(mname))) {
              fd2 = open(mname, O_RDONLY);
              if (fd2 == -1) {
                 /* Error opening icon file! */
		 msgPtr =
		     GETMESSAGE(5, 60, "Could not open the following file:");
		 fmtPtr = "%s\n   %s";
		 errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
				    strlen(mname) + 1) * sizeof(char));
                 sprintf(errPtr, fmtPtr, msgPtr, mname);
                 display_error_message(XtParent(wid), errPtr);
		 XtFree(errPtr);
                 XtFree(mname);
                 if (fd1 > -1) close(fd1);
                 return;
              } else {
                 /***************************************/
                 /* Find out how big a buffer is needed */
                 /***************************************/
                 lenFile2 = lseek(fd2, 0, SEEK_END);
                 (void) lseek(fd2, 0, SEEK_SET);
              }
           }
        }
        /******************************************************************/
        /* Create 1 big buffer                                            */
        /******************************************************************/
#ifdef DEBUG
        printf("Size of file 1 = %d\n", lenFile1); /* debug */
        printf("Size of file 2 = %d\n", lenFile2); /* debug */
#endif
        buffer = (unsigned char *)XtMalloc((Cardinal)(lenFile1 + lenFile2 + 1));
        memset(buffer, 0, (lenFile1 + lenFile2 + 1));
        if (buffer) {
           /***************************************/
           /* Read file1 into buffer.             */
           /***************************************/
           if ((rlenFile1 = read(fd1, buffer, lenFile1)) != lenFile1) {
              /* didn't read whole file! */

	      /* INTERNATIONALIZE */
	      msgPtr = "Could not read the entire file:";
	      fmtPtr = "%s\n   %s";
	      errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
				 strlen(fname) + 1) * sizeof(char));
              sprintf(errPtr, fmtPtr, msgPtr, fname);
              display_error_message(XtParent(wid), errPtr);
	      XtFree(errPtr);
              if (mname) XtFree(mname);
              XtFree((char *) buffer);
              if (fd1 > -1) close(fd1);
              if (fd2 > -1) close(fd2);
              return;
           }
           if (lenFile2) {
#ifdef DEBUG
              printf("buffer = %p\n", buffer);
#endif
            /*ptr = (char *)&(buffer[lenFile1 + 1]);*/
              ptr = (char *)&(buffer[lenFile1]);
#ifdef DEBUG
              printf("ptr = %p\n", ptr);
#endif
              if ((rlenFile2 = read(fd2, ptr, lenFile2)) != lenFile2) {
                 /* didn't read whole file! */

		 /* INTERNATIONALIZE */
		 msgPtr = "Could not read the entire file:";
		 fmtPtr = "%s\n   %s";
		 errPtr = XtMalloc((strlen(msgPtr) + strlen(fmtPtr) +
				    strlen(fname) + 1) * sizeof(char));
		 sprintf(errPtr, fmtPtr, msgPtr, mname);
                 display_error_message(XtParent(wid), errPtr);
		 XtFree(errPtr);
                 XtFree((char *) buffer);
                 if (mname) XtFree(mname);
                 if (fd1 > -1) close(fd1);
                 if (fd2 > -1) close(fd2);
                 return;
              }
           }
           if (fd1 > -1) close(fd1);
	   fd1 = -1;
           if (fd2 > -1) close(fd2);
	   fd2 = -1;

#ifdef DEBUG
           printf("final buffer = '%s'\n", buffer); /* debug */
           printf("Buffer = '%s'\n", buffer); /* debug */
#endif
           tt_message_barg_add( m, TT_INOUT, "XPM", buffer, lenFile1 + lenFile2 + 1);
           if (mname) XtFree(mname);
           XtFree((char *) buffer);
        }
     }
  } else {
     tt_message_barg_add( m, TT_INOUT, "XPM", (const unsigned char *)NULL, 0);
  }
  tt_message_arg_add(m, TT_IN, "messageID", msgID);

  /******************************************************************/
  /* Create a pattern and add a callback to get notifications       */
  /* of periodic saves                                              */
  /******************************************************************/
  p = tt_pattern_create();
  tt_pattern_category_set(p, TT_OBSERVE);
  tt_pattern_scope_add(p, TT_SESSION);
  tt_pattern_session_add(p, tt_default_session());
  tt_pattern_address_add(p, TT_HANDLER);
  tt_pattern_op_add(p, "Saved");
  tt_pattern_callback_add(p, IconEdit_tt_handler);
  tt_pattern_register(p);

  /******************************************************************/
  /* Add callback to notify when change complete                    */
  /******************************************************************/
  tt_message_callback_add( m, IconEdit_tt_handler );

  /******************************************************************/
  /* Send message                                                   */
  /******************************************************************/
  TurnOnHourGlassAllWindows();
  ttRc = tt_message_send( m );
  DieFromToolTalkError( UxTopLevel, "tt_message_send", ttRc );

  if (fd1 > -1) close(fd1);
  if (fd2 > -1) close(fd2);
}
#endif  /* __TOOLTALK */

/*****************************************************************************/
/*                                                                           */
/*                                                                           */
/*    main                                                                   */
/*                                                                           */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/
int
main(int argc, char *argv[])
{
        /*-----------------------------------------------------------
         * Declarations.
         * The default identifier - mainIface will only be declared
         * if the interface function is global and of type swidget.
         * To change the identifier to a different name, modify the
         * string mainIface in the file "xtmain.dat". If "mainIface"
         * is declared, it will be used below where the return value
         * of  PJ_INTERFACE_FUNCTION_CALL will be assigned to it.
         *----------------------------------------------------------*/
#ifdef __TOOLTALK
        char * procId;
        int ttMark, ttFd;
	Tt_pattern *ttPatt;
        Tt_status ttRc;
        char * errfmt;
        char * sessionString;
        char * ttsession;
#endif

        Widget          mainIface;
        extern swidget  create_AddFiletype();
        extern swidget  create_FileCharacteristics();
        extern swidget  create_OpenFile();
        extern swidget  create_Confirmed();
        extern Widget   create_ErrorDialog();
        int             rc;
        Atom            xa_WM_SAVE_YOURSELF;
        char            *ptr;

        /*---------------------------------
         * Interface function declaration
         *--------------------------------*/
        Widget  create_applicationShell1(swidget);
        swidget UxParent = NULL;
        int i;

        /*---------------------
         * Initialize program
         *--------------------*/

        _DtEnvControl(DT_ENV_SET);
        XtSetLanguageProc(NULL, NULL, NULL);
        pszFileToEdit = (char *)NULL;
        memset(&sessiondata, 0, sizeof(SessionData));
        memset(IconDataList, 0, sizeof(IconDataList));

        /********************************************************************/
        /* Parse the command line arguments.                                */
        /********************************************************************/
        pszExecName = argv[0];

        if (argc > 1) {
          for (i=1; i<argc; i++) {
            if ((argv[i][0] == '-') && (argv[i][1] == '?')) {
	       setlocale(LC_ALL, "");
	       nlmsg_fd = CATOPEN("dtcreate", NL_CAT_LOCALE);
               printf("%s\n",
                      GETMESSAGE(5, 110, "Usage: dtcreate [<filename>] [-?]"));
               exit(0);
            } else {
               if (argv[i][0] == '-') {
                  if (!strcmp(argv[i], "-s")) {
                     i+=1;
                     sessiondata.pszSessionFile = (char *)XtMalloc(strlen(argv[i]) + 1);
                     strcpy(sessiondata.pszSessionFile, argv[i]);
                     sessiondata.useSession = True;
                  } else {
                     i+=1;
                  }
               } else {
                  pszFileToEdit = (char *)XtMalloc(strlen(argv[i]) + 1);
                  strcpy(pszFileToEdit, argv[i]);
               }
            }
          }
        }


        UxTopLevel = XtAppInitialize(&UxAppContext, CLASS_NAME,
                                     NULL, 0, &argc, argv, NULL, NULL, 0);

        nlmsg_fd = CATOPEN("dtcreate", NL_CAT_LOCALE);

        UxDisplay = XtDisplay(UxTopLevel);
        UxScreen = XDefaultScreen(UxDisplay);

        if (sessiondata.useSession) {
           GetSessionInfo();
        }

        /*---------------------
         * Determine resolution
         *--------------------*/
        if (_DtGetDisplayResolution(UxDisplay, UxScreen) == 1) {
           bLowRes = True;
        } else {
           bLowRes = False;
        }

#ifdef DEBUG_LOWRES
        bLowRes = True;
#endif

        /*-------------------------------------------------------
         * Insert initialization code for your application here
         *------------------------------------------------------*/
#ifdef __TOOLTALK
#ifdef DEBUG
        printf("display string = '%s'\n", DisplayString(UxDisplay));
#endif
        ttsession = getenv("TT_SESSION");
        if (!ttsession || strlen(ttsession)==0) {
	   char *ttxsession = tt_X_session(XDisplayString(UxDisplay));
           ttRc = tt_default_session_set(ttxsession);
        }

        ttMark = tt_mark( );

        procId = tt_open( );
	ttRc = tt_ptr_error(procId);
        errfmt =
          GETMESSAGE(13, 2, "Could not connect to ToolTalk:\n%s\nExiting ...");
        DieFromToolTalkError( UxTopLevel, errfmt, ttRc );

        ttFd = tt_fd( );
        DieFromToolTalkError( UxTopLevel, "tt_fd", tt_int_error( ttFd ) );

        ttRc = tt_ptype_declare( "dtcreate" );
        DieFromToolTalkError( UxTopLevel, "tt_ptype_declare", ttRc );

        ttRc = tt_session_join( tt_default_session( ));
        DieFromToolTalkError( UxTopLevel, "tt_session_join", ttRc );

        XtAppAddInput( UxAppContext, ttFd, (XtPointer)XtInputReadMask,
                            (XtInputCallbackProc)ProcessToolTalkMessage, 0 );
#endif

        if (!pszFileToEdit) {
           initAD(&AD);
        }


        /*----------------------------------------------------------------
         * Create and popup the first window of the interface.  The
         * return value can be used in the popdown or destroy functions.
         * The Widget return value of  PJ_INTERFACE_FUNCTION_CALL will
         * be assigned to "mainIface" from  PJ_INTERFACE_RETVAL_TYPE.
         *---------------------------------------------------------------*/

        mainIface = create_applicationShell1(UxParent);
        AddFiletype = create_AddFiletype(mainIface);
        FileCharacteristics = create_FileCharacteristics(AddFiletype);
        OpenFile = create_OpenFile();

        UxPopupInterface(mainIface, no_grab);
        if (pszFileToEdit) {
           if (!OpenDefinitionFile(pszFileToEdit, &AD)) {
              writeCAToGUI(&AD);
           }
        }
        XtVaGetValues (CA_WindowTypeArea, XmNheight, &wintypeheight, NULL);

        /*------------------------------------------------------------------*/
        /*   Register for save and restore.                                 */
        /*------------------------------------------------------------------*/
        xa_WM_SAVE_YOURSELF = XInternAtom(XtDisplay(CreateActionAppShell), "WM_SAVE_YOURSELF", False);
        XmAddWMProtocols(CreateActionAppShell, &xa_WM_SAVE_YOURSELF, 1);
        XmAddWMProtocolCallback(CreateActionAppShell, xa_WM_SAVE_YOURSELF,
                                SaveSessionCB, (XtPointer)CreateActionAppShell);

        /*------------------------------------------------------------------*/
        /* Make a copy of the AD data structure.  This will be used later   */
        /* when the user wants to exit to determine if the latest data has  */
        /* been saved or not.                                               */
        /*------------------------------------------------------------------*/
        pMyCopyAD = copyAD(&AD);

#ifdef __TOOLTALK
        DtDbLoad();
        ttMark = tt_mark( );

        procId = ttdt_open( &ttFd, "dtcreate", "CDE", "1.0", 1 );
	ttRc = tt_ptr_error(procId);
        errfmt =
          GETMESSAGE(13, 2, "Could not connect to ToolTalk:\n%s\nExiting ...");
        DieFromToolTalkError( UxTopLevel, errfmt, ttRc );

        ttFd = tt_fd( );
	ttRc = tt_int_error( ttFd );
        DieFromToolTalkError( UxTopLevel, "tt_fd", ttRc );

        sessionString = tt_default_session();
	ttRc = tt_ptr_error( sessionString );
        DieFromToolTalkError( UxTopLevel, "tt_default_session", ttRc );

	ttPatt = ttdt_session_join( sessionString, ProcessToolTalkMessage,
				    (Widget) 0, (void *) 0, 1 );
        ttRc = tt_ptr_error(ttPatt);
        DieFromToolTalkError( UxTopLevel, "ttdt_session_join", ttRc );

        XtAppAddInput( UxAppContext, ttFd, (XtPointer)XtInputReadMask,
                            tttk_Xt_input_handler, 0 );
#endif

        /*-----------------------
         * Enter the event loop
         *----------------------*/

        XtAppMainLoop (UxAppContext);

#ifdef __TOOLTALK
        ttdt_session_quit(0, 0, 1);
        tt_close( );
        tt_release( ttMark );
        RemoveTmpIconFiles();
#endif
}