cde/programs/dtfile/FileDialog.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these libraries and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $XConsortium: FileDialog.c /main/7 1996/10/23 16:25:18 mustafa $ */
  24 /************************************<+>*************************************
  25  ****************************************************************************
  26  *
  27  *   FILE:           FileDialog.c
  28  *
  29  *   COMPONENT_NAME: Desktop File Manager (dtfile)
  30  *
  31  *   Description:    Simple Dialogs for file manipulation commands.
  32  *
  33  *   FUNCTIONS: ApplyFileDone
  34  *              DialogCancel
  35  *              FileTypePreview
  36  *              FileTypePreviewCB
  37  *              GetToPath
  38  *              MakeFileApply
  39  *              MakeFileDone
  40  *              MakeFileOk
  41  *              RenameDone
  42  *              RenameOk
  43  *              ShowCopyFileDialog
  44  *              ShowLinkFileDialog
  45  *              ShowMakeFileDialog
  46  *              ShowMoveFileDialog
  47  *              ShowRenameFileDialog
  48  *
  49  *   (c) Copyright 1993, 1994, 1995 Hewlett-Packard Company
  50  *   (c) Copyright 1993, 1994, 1995 International Business Machines Corp.
  51  *   (c) Copyright 1993, 1994, 1995 Sun Microsystems, Inc.
  52  *   (c) Copyright 1993, 1994, 1995 Novell, Inc.
  53  *
  54  ****************************************************************************
  55  ************************************<+>*************************************/
  56
  57
  58 #include <sys/types.h>
  59 #include <sys/stat.h>
  60 #include <errno.h>
  61
  62 #if defined(_AIX) || defined(hpux)
  63 #include <sys/dir.h>
  64 #else
  65 #ifndef MAXNAMLEN
  66 #define MAXNAMLEN 255
  67 #endif
  68 #endif
  69
  70 #include <Xm/DialogS.h>
  71 #include <Xm/Frame.h>
  72 #include <Xm/Form.h>
  73 #include <Xm/SeparatoG.h>
  74 #include <Xm/TextF.h>
  75 #include <Xm/LabelG.h>
  76 #include <Xm/PushBG.h>
  77 #include <Xm/RowColumn.h>
  78 #include <Xm/MwmUtil.h>
  79 #include <Xm/Protocols.h>
  80
  81 #include <X11/Shell.h>
  82 #include <X11/Xatom.h>
  83
  84 #include <Dt/TitleBox.h>
  85 #include <Dt/Icon.h>
  86 #include <Dt/IconP.h>
  87 #include <Dt/IconFile.h>
  88 #include <Dt/Connect.h>
  89 #include <Dt/DtNlUtils.h>
  90 #include <Dt/FileM.h>
  91 #include <Dt/HourGlass.h>
  92 #include <Dt/Dts.h>
  93 #include <Dt/SharedProcs.h>
  94
  95 #include <Tt/tttk.h>
  96
  97 #include "Encaps.h"
  98 #include "SharedProcs.h"
  99 #include "sharedFuncs.h"
 100 #include "FileMgr.h"
 101 #include "Desktop.h"
 102 #include "Main.h"
 103 #include "Help.h"
 104 #include "SharedMsgs.h"
 105
 106
 107 #define FM_TYPE_LABEL  "TYPE_LABEL"
 108
 109
 110 /********    Static Function Declarations    ********/
 111
 112 static void RenameOk(
 113                         Widget w,
 114                         XtPointer client_data,
 115                         XtPointer call_data) ;
 116 void RenameDone(
 117                         XtPointer client_data,
 118                         int rc) ;
 119 static Boolean GetToPath(
 120                         char *to,
 121                         char *new_name,
 122                         char *host_in,
 123                         char *dir_in) ;
 124 static void FileTypePreview(
 125                         Widget w,
 126                         String new_name,
 127                         XtPointer client_data,
 128                         XtPointer call_data) ;
 129 static void FileTypePreviewCB(
 130                         Widget w,
 131                         XtPointer client_data,
 132                         XtPointer call_data) ;
 133 static void MakeFileOk(
 134                         Widget w,
 135                         XtPointer client_data,
 136                         XtPointer call_data) ;
 137 static void MakeFileApply(
 138                         Widget w,
 139                         XtPointer client_data,
 140                         XtPointer call_data) ;
 141 static void MakeFileDone(
 142                         XtPointer client_data,
 143                         char *to,
 144                         int rc) ;
 145 static void ApplyFileDone(
 146                         XtPointer client_data,
 147                         char *to,
 148                         int rc) ;
 149 static void DialogCancel(
 150                         Widget w,
 151                         XtPointer client_data,
 152                         XtPointer call_data) ;
 153
 154 /********    End Static Function Declarations    ********/
 155
 156
 157
 158 /************************************************************************
 159  *
 160  *  ShowRenameFileDialog
 161  *      Callback function invoked from the File Manager menu.  This
 162  *      function creates and displays a dialog prompting for a new
 163  *      name for the selected file.
 164  *
 165  *  NOTE:  The Rename File... menu item can currently be reactivated
 166  *         by single select on another item.  Is this behavior correct?
 167  *
 168  ************************************************************************/
 169
 170 void
 171 ShowRenameFileDialog(
 172         Widget w,
 173         XtPointer client_data,
 174         XtPointer call_data )
 175 {
 176   FileMgrRec * file_mgr_rec;
 177   DialogData * dialog_data;
 178   FileViewData * file_view_data;
 179   Arg args[20];
 180   Widget mbar;
 181   FileMgrData * file_mgr_data;
 182   char * directory_name;
 183   int n;
 184
 185    /*  Set the menu item to insensitive to prevent multiple  */
 186    /*  dialogs from being posted and get the area under the  */
 187    /*  menu pane redrawn.                                    */
 188
 189   XmUpdateDisplay (w);
 190
 191   if(client_data != 0)
 192   {
 193     file_view_data = (FileViewData *)client_data;
 194     mbar = XtParent(w);
 195   }
 196   else
 197   {
 198     file_view_data = NULL;
 199     mbar = XmGetPostedFromWidget(XtParent(w));
 200   }
 201
 202
 203   XtSetArg(args[0], XmNuserData, &file_mgr_rec);
 204   XtGetValues(mbar, args, 1);
 205
 206   dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
 207   file_mgr_data = (FileMgrData *) dialog_data->data;
 208
 209
 210   /*  Get the selected file.  */
 211
 212   if( file_view_data == NULL )
 213     file_view_data = file_mgr_data->selection_list[0];
 214
 215   directory_name = ((DirectorySet *) file_view_data->directory_set)->name;
 216
 217   /*  Create the widget hierarchy for the dialog  */
 218
 219   n = 0;
 220   XtSetArg (args[n], XmNallowShellResize, True);  n++;
 221
 222   /* Ignore accelerators when we're insensitive */
 223   if(client_data == 0)
 224   {
 225     if ((file_mgr_rec->menuStates & RENAME) == 0)
 226       return;
 227     file_mgr_rec->menuStates &= ~RENAME;
 228   }
 229   else
 230   {
 231     if(file_mgr_data->selected_file_count != 0)
 232       file_mgr_rec->menuStates |= RENAME;
 233   }
 234
 235   UnpostTextField (file_mgr_data);
 236
 237   CreateNameChangeDialog(file_view_data->widget, file_view_data,
 238                          (XtPointer)file_mgr_data, 0);
 239 }
 240
 241
 242 /************************************************************************
 243  *
 244  *  ShowCopyFileDialog
 245  *      Callback function invoked from the File Manager menu.  This
 246  *      function creates and displays a dialog prompting for a new
 247  *      name for the selected file.
 248  *
 249  *  NOTE:  The Rename File... menu item can currently be reactivated
 250  *         by single select on another item.  Is this behavior correct?
 251  *
 252  ************************************************************************/
 253
 254 void
 255 ShowCopyFileDialog(
 256         Widget w,
 257         XtPointer client_data,
 258         XtPointer call_data )
 259 {
 260    FileMgrRec * file_mgr_rec;
 261    DialogData * dialog_data;
 262    FileMgrData * file_mgr_data;
 263    static FileViewData * file_view_data;    /* static because it is passed to RenameOk callback */
 264
 265    char name_string[18+MAX_PATH];
 266    char * directory_name;
 267    char * tmpStr, *tempStr;
 268
 269    XtArgVal width;
 270    Dimension f_width, d_width;
 271
 272    Widget shell;
 273    Widget form, dir_form, file_form;
 274    Widget current_name;
 275    Widget dir_label, dir_text;
 276    Widget file_label, file_text;
 277    Widget file_type_box;
 278    Widget file_type;
 279    Widget separator;
 280    Widget ok;
 281    Widget cancel;
 282    Widget preview;
 283    Widget help;
 284    int flag = FLAG_RESET;
 285
 286    DialogCallbackStruct * call_struct;
 287    XmString label_string;
 288
 289    Arg args[20];
 290    int n;
 291    Widget mbar;
 292    XtTranslations trans_table;
 293    Atom delete_window_atom;
 294
 295    /*  Set the menu item to insensitive to prevent multiple  */
 296    /*  dialogs from being posted and get the area under the  */
 297    /*  menu pane redrawn.                                    */
 298
 299    XmUpdateDisplay (w);
 300
 301    if(client_data != 0)
 302    {
 303       file_view_data = (FileViewData *)client_data;
 304       mbar = XtParent(w);
 305    }
 306    else
 307    {
 308       file_view_data = NULL;
 309       mbar = XmGetPostedFromWidget(XtParent(w));
 310    }
 311
 312
 313    XtSetArg(args[0], XmNuserData, &file_mgr_rec);
 314    XtGetValues(mbar, args, 1);
 315
 316    /* Ignore accelerators when we're insensitive */
 317
 318    if ((file_mgr_rec->menuStates & DUPLICATE) == 0)
 319      return;
 320
 321    dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
 322    file_mgr_data = (FileMgrData *) dialog_data->data;
 323
 324
 325    /*  Get the selected file.  */
 326
 327    if(file_view_data == NULL)
 328       file_view_data = file_mgr_data->selection_list[0];
 329    directory_name = ((DirectorySet *) file_view_data->directory_set)->name;
 330
 331
 332    /*  Create the widget hierarchy for the dialog  */
 333
 334    n = 0;
 335    XtSetArg (args[n], XmNallowShellResize, True);  n++;
 336
 337    /*  Adjust the decorations for the dialog shell of the dialog  */
 338
 339    XtSetArg (args[n], XmNmwmFunctions, MWM_FUNC_MOVE | MWM_FUNC_CLOSE); ++n;
 340    XtSetArg (args[n], XmNmwmDecorations, MWM_DECOR_BORDER | MWM_DECOR_TITLE);                       ++n;
 341
 342    file_mgr_rec->menuStates &= ~DUPLICATE;
 343    if(file_mgr_data->title != NULL &&
 344       strcmp(file_mgr_data->helpVol, DTFILE_HELP_NAME) != 0)
 345    {
 346      tmpStr = GETMESSAGE(10, 44, "Copy Object");
 347      tempStr = (char *)XtMalloc(strlen(tmpStr) +
 348                                 strlen(file_mgr_data->title) + 5);
 349      sprintf(tempStr, "%s - %s", file_mgr_data->title, tmpStr);
 350    }
 351    else
 352    {
 353      tmpStr = (GETMESSAGE(10,45, "File Manager - Copy Object"));
 354      tempStr = XtNewString(tmpStr);
 355    }
 356
 357    XtSetArg (args[n], XmNtitle, tempStr);      n++;
 358    shell = XmCreateDialogShell (file_mgr_rec->shell, "copy_file", args, n);
 359    XtFree(tempStr);
 360
 361    /* Set the useAsyncGeo on the shell */
 362    XtSetArg (args[0], XmNuseAsyncGeometry, True);
 363    XtSetValues (XtParent(shell), args, 1);
 364
 365
 366    trans_table = XtParseTranslationTable(translations_space);
 367
 368    n = 0;
 369    XtSetArg (args[n], XmNmarginWidth, 1);                n++;
 370    XtSetArg (args[n], XmNmarginHeight, 1);               n++;
 371    XtSetArg (args[n], XmNshadowThickness, 1);            n++;
 372    XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT);      n++;
 373    XtSetArg (args[n], XmNautoUnmanage, False);           n++;
 374 #ifdef _CHECK_FOR_SPACES
 375    XtSetArg (args[n], XmNtextTranslations, trans_table); n++;
 376 #endif
 377    XtSetArg (args[n], XmNuserData, file_mgr_rec);        n++;
 378    form = XmCreateForm (shell, "form", args, n);
 379    XtAddCallback(form, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 380                  HELP_COPY_DIALOG_STR);
 381
 382
 383    sprintf (name_string, "%s ", ((char *)GETMESSAGE(10, 37, "Selected object:")));
 384    strcat (name_string, file_view_data->file_data->file_name);
 385    label_string = XmStringCreateLocalized (name_string);
 386
 387    n = 0;
 388    XtSetArg (args[n], XmNlabelString, label_string);        n++;
 389    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);    n++;
 390    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);     n++;
 391    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);   n++;
 392    XtSetArg (args[n], XmNtopOffset, 5);                     n++;
 393    XtSetArg (args[n], XmNtraversalOn, False);               n++;
 394    current_name = XmCreateLabelGadget (form, "current_name", args, n);
 395    XtManageChild (current_name);
 396    XtAddCallback(current_name, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 397                  HELP_COPY_DIALOG_STR);
 398
 399    XmStringFree (label_string);
 400
 401    /* Create the field displaying the file type info */
 402
 403    n = 0;
 404    XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET);            n++;
 405    XtSetArg(args[n], XmNtopWidget, current_name);                   n++;
 406    XtSetArg(args[n], XmNtopOffset, 3);                              n++;
 407    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);            n++;
 408    XtSetArg(args[n], XmNrightOffset, 5);                            n++;
 409    XtSetArg(args[n], XmNmarginHeight, 5);                           n++;
 410    XtSetArg(args[n], XmNmarginWidth, 5);                            n++;
 411    file_type_box = XmCreateFrame (form, "file_type_box", args, n);
 412    XtManageChild (file_type_box);
 413    XtAddCallback(file_type_box, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 414                  HELP_COPY_DIALOG_STR);
 415
 416
 417    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 8, "File Type")));
 418
 419    n = 0;
 420    XtSetArg (args[n], XmNlabelString, label_string);          n++;
 421    XtSetArg (args[n], XmNshadowThickness, 0);                 n++;
 422    XtSetArg (args[n], XmNshadowType, XmSHADOW_ETCHED_OUT);    n++;
 423    XtSetArg (args[n], XmNpixmapPosition, XmPIXMAP_TOP);       n++;
 424    XtSetArg (args[n], XmNtraversalOn, False);                 n++;
 425    file_type = _DtCreateIcon (file_type_box, "file_type", args, n);
 426    XtManageChild (file_type);
 427    XtAddCallback(file_type, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 428                  HELP_COPY_DIALOG_STR);
 429
 430    XmStringFree (label_string);
 431
 432
 433    /* Adjust the colors of the icon */
 434    SetToNormalColors (file_type, form, file_mgr_rec->main, 0);
 435
 436
 437    /* ------------------------------------------------------------ */
 438    /*  Create a form to hold the destination label and TextField.  */
 439    /*  The form makes sure they will always be aligned together.   */
 440    /* ------------------------------------------------------------ */
 441
 442    n = 0;
 443    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);     n++;
 444    XtSetArg (args[n], XmNleftOffset, 5);                     n++;
 445    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);    n++;
 446    XtSetArg (args[n], XmNtopWidget, current_name);           n++;
 447    XtSetArg (args[n], XmNtopOffset, 10);                     n++;
 448    XtSetArg (args[n], XmNrightAttachment, XmATTACH_WIDGET);  n++;
 449    XtSetArg (args[n], XmNrightWidget, file_type_box);        n++;
 450    XtSetArg (args[n], XmNrightOffset, 5);                    n++;
 451
 452    dir_form = XmCreateForm (form, "dir_form", args, n);
 453    XtManageChild (dir_form);
 454
 455    /* Create the Destination Label */
 456    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 34, "Destination Folder: ")));
 457
 458    n = 0;
 459    XtSetArg (args[n], XmNlabelString, label_string);         n++;
 460    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);     n++;
 461    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);      n++;
 462    XtSetArg (args[n], XmNalignment, XmALIGNMENT_END);        n++;
 463    XtSetArg (args[n], XmNtraversalOn, False);                n++;
 464    dir_label = XmCreateLabelGadget (dir_form, "new_name", args, n);
 465    XtManageChild (dir_label);
 466    XtAddCallback(dir_label, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 467                  HELP_COPY_DIALOG_STR);
 468
 469    XmStringFree (label_string);
 470
 471    /* Create the Destination TextField */
 472    n = 0;
 473    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);  n++;
 474    XtSetArg (args[n], XmNleftOffset, 5);                    n++;
 475    XtSetArg (args[n], XmNleftWidget, dir_label);            n++;
 476    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);     n++;
 477    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);   n++;
 478    XtSetArg (args[n], XmNtraversalOn, True);                n++;
 479    XtSetArg (args[n], XmNcursorPosition,
 480                strlen(file_view_data->file_data->file_name));  n++;
 481    dir_text = XmCreateTextField (dir_form, "new_text", args, n);
 482    XtManageChild (dir_text);
 483    XtAddCallback(dir_text, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 484                  HELP_COPY_DIALOG_STR);
 485    XmTextFieldInsert(dir_text, 0, directory_name);
 486
 487    /* -------------------------------------------------------------- */
 488    /*  Create a form to hold the Name for Copy label and TextField.  */
 489    /*  The form makes sure they will always be aligned together.     */
 490    /* -------------------------------------------------------------- */
 491
 492    n = 0;
 493    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);     n++;
 494    XtSetArg (args[n], XmNleftOffset, 5);                     n++;
 495    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);    n++;
 496    XtSetArg (args[n], XmNtopWidget, dir_form);               n++;
 497    XtSetArg (args[n], XmNtopOffset, 5);                      n++;
 498    XtSetArg (args[n], XmNrightAttachment, XmATTACH_WIDGET);  n++;
 499    XtSetArg (args[n], XmNrightWidget, file_type_box);        n++;
 500    XtSetArg (args[n], XmNrightOffset, 5);                    n++;
 501
 502    file_form = XmCreateForm (form, "file_form", args, n);
 503    XtManageChild (file_form);
 504
 505    /* Create the Name for Copy Label */
 506    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 38, "Name for copy : ")));
 507
 508    n = 0;
 509    XtSetArg (args[n], XmNlabelString, label_string);         n++;
 510    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);     n++;
 511    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);      n++;
 512    XtSetArg (args[n], XmNalignment, XmALIGNMENT_END);        n++;
 513    XtSetArg (args[n], XmNtraversalOn, False);                n++;
 514    file_label = XmCreateLabelGadget (file_form, "new_name", args, n);
 515    XtManageChild (file_label);
 516    XtAddCallback(file_label, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 517                  HELP_COPY_DIALOG_STR);
 518
 519    XmStringFree (label_string);
 520
 521    /* Create the Name for Copy TextField */
 522    n = 0;
 523    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);    n++;
 524    XtSetArg (args[n], XmNleftWidget, file_label);             n++;
 525    XtSetArg (args[n], XmNleftOffset, 5);                      n++;
 526    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);       n++;
 527    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);     n++;
 528    XtSetArg (args[n], XmNtraversalOn, True);                  n++;
 529    XtSetArg (args[n], XmNcursorPosition,
 530                strlen(file_view_data->file_data->file_name)); n++;
 531    file_text = XmCreateTextField (file_form, "new_text", args, n);
 532    XtManageChild (file_text);
 533    XtAddCallback(file_text, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 534                  HELP_COPY_DIALOG_STR);
 535    XmTextFieldInsert(file_text, 0, file_view_data->file_data->file_name);
 536
 537
 538    /* ------------------------------------------------ */
 539    /*  Make the two labels the same length - maximum.  */
 540    /* ------------------------------------------------ */
 541
 542    XtVaGetValues(dir_label, XmNwidth, &width, NULL);
 543    d_width = (Dimension)width;
 544    XtVaGetValues(file_label, XmNwidth, &width, NULL);
 545    f_width = (Dimension)width;
 546
 547    if (d_width > f_width)
 548        XtVaSetValues(file_label, XmNwidth, d_width, NULL);
 549    else
 550        XtVaSetValues(dir_label, XmNwidth, f_width, NULL);
 551
 552    XtVaGetValues(dir_text, XmNwidth, &width, NULL);
 553    d_width = (Dimension)width;
 554    XtVaGetValues(file_text, XmNwidth, &width, NULL);
 555    f_width = (Dimension)width;
 556
 557    if (d_width > f_width)
 558        XtVaSetValues(file_text, XmNwidth, d_width, NULL);
 559    else
 560        XtVaSetValues(dir_text, XmNwidth, f_width, NULL);
 561
 562
 563    /*  The data sent to the Text, Ok and Cancel callbacks  */
 564
 565    call_struct =
 566       (DialogCallbackStruct *) XtMalloc (sizeof (DialogCallbackStruct));
 567
 568    call_struct->dialog_widget = form;
 569    call_struct->menu_widget = w;
 570    call_struct->dir_text_widget = dir_text;
 571    call_struct->file_text_widget = file_text;
 572    call_struct->file_type_widget = file_type;
 573    call_struct->original_physical_type =
 574       file_view_data->file_data->physical_type;
 575    call_struct->file_mgr_rec = file_mgr_rec;
 576    call_struct->host_name = XtNewString (file_mgr_data->host);
 577    call_struct->directory_name = XtNewString (directory_name);
 578    call_struct->mode = COPY_FILE;
 579    call_struct->file_name = XtNewString (file_view_data->file_data->file_name);
 580    call_struct->original_logical_type =file_view_data->file_data->logical_type;
 581    call_struct->previous_file_type = NULL;
 582    call_struct->file_mgr_data = file_mgr_data;
 583
 584
 585    /*  Create a separator between the buttons  */
 586
 587    n = 0;
 588    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 589    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);       n++;
 590    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 591    XtSetArg (args[n], XmNtopWidget, file_type_box);             n++;
 592    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 593    separator =  XmCreateSeparatorGadget (form, "separator", args, n);
 594    XtManageChild (separator);
 595
 596
 597
 598    /*  Create the ok, cancel, preview and help buttons  */
 599
 600    n = 0;
 601    XtSetArg (args[n], XmNlabelString, okXmString);               n++;
 602    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);     n++;
 603    XtSetArg (args[n], XmNleftPosition, 1);                       n++;
 604    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);    n++;
 605    XtSetArg (args[n], XmNrightPosition, 21);                     n++;
 606    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);        n++;
 607    XtSetArg (args[n], XmNtopWidget, separator);                  n++;
 608    XtSetArg (args[n], XmNtopOffset, 5);                          n++;
 609    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);       n++;
 610    XtSetArg (args[n], XmNbottomOffset, 5);                       n++;
 611    XtSetArg (args[n], XmNmarginWidth, 4);                        n++;
 612    XtSetArg (args[n], XmNmarginHeight, 4);                       n++;
 613    XtSetArg (args[n], XmNshowAsDefault, True);                   n++;
 614    XtSetArg (args[n], XmNuserData, flag);                        n++;
 615    ok = XmCreatePushButtonGadget (form, "ok", args, n);
 616    XtManageChild (ok);
 617
 618    XtAddCallback (ok, XmNactivateCallback, RenameOk, (XtPointer) call_struct);
 619    XtAddCallback(ok, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 620                  HELP_COPY_DIALOG_STR);
 621
 622
 623    /*  Set the ok button to the default for the bulletin board.  */
 624    /*  This causes the return key from the text widget to be     */
 625    /*  properly processed.                                       */
 626
 627    XtSetArg (args[0], XmNdefaultButton, ok);
 628    XtSetValues (form, args, 1);
 629
 630
 631    n = 0;
 632    XtSetArg (args[n], XmNlabelString, cancelXmString);          n++;
 633    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
 634    XtSetArg (args[n], XmNleftPosition, 22);                     n++;
 635    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
 636    XtSetArg (args[n], XmNrightPosition, 42);                    n++;
 637    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 638    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
 639    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 640    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
 641    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
 642    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
 643    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
 644    XtSetArg (args[n], XmNuserData, flag);                       n++;
 645    cancel = XmCreatePushButtonGadget (form, "cancel", args, n);
 646    XtManageChild (cancel);
 647
 648    XtAddCallback (cancel, XmNactivateCallback, DialogCancel,
 649                                                    (XtPointer) call_struct);
 650    XtAddCallback(cancel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 651                  HELP_COPY_DIALOG_STR);
 652
 653
 654    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 36, "Show Icon")));
 655
 656    n = 0;
 657    XtSetArg (args[n], XmNlabelString, label_string);              n++;
 658    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);      n++;
 659    XtSetArg (args[n], XmNleftPosition, 43);                       n++;
 660    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);     n++;
 661    XtSetArg (args[n], XmNrightPosition, 78);                      n++;
 662    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);         n++;
 663    XtSetArg (args[n], XmNtopWidget, separator);                   n++;
 664    XtSetArg (args[n], XmNtopOffset, 5);                           n++;
 665    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);        n++;
 666    XtSetArg (args[n], XmNbottomOffset, 5);                        n++;
 667    XtSetArg (args[n], XmNmarginWidth, 4);                         n++;
 668    XtSetArg (args[n], XmNmarginHeight, 4);                        n++;
 669    preview = XmCreatePushButtonGadget (form, "show_file_type", args, n);
 670    XtManageChild (preview);
 671
 672    XmStringFree (label_string);
 673    XtAddCallback (preview, XmNactivateCallback, FileTypePreviewCB,
 674                                                    (XtPointer) call_struct);
 675    XtAddCallback(preview, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 676                  HELP_COPY_DIALOG_STR);
 677    tmpStr = XtNewString(file_view_data->file_data->file_name);
 678    FileTypePreview (preview, tmpStr, (XtPointer) call_struct, NULL);
 679
 680    n = 0;
 681    XtSetArg (args[n], XmNlabelString, helpXmString);              n++;
 682    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);      n++;
 683    XtSetArg (args[n], XmNleftPosition, 79);                       n++;
 684    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);     n++;
 685    XtSetArg (args[n], XmNrightPosition, 99);                      n++;
 686    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);         n++;
 687    XtSetArg (args[n], XmNtopWidget, separator);                   n++;
 688    XtSetArg (args[n], XmNtopOffset, 5);                           n++;
 689    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);        n++;
 690    XtSetArg (args[n], XmNbottomOffset, 5);                        n++;
 691    XtSetArg (args[n], XmNmarginWidth, 4);                         n++;
 692    XtSetArg (args[n], XmNmarginHeight, 4);                        n++;
 693    help = XmCreatePushButtonGadget (form, "help", args, n);
 694    XtManageChild (help);
 695
 696    XtAddCallback(help, XmNactivateCallback, (XtCallbackProc)HelpRequestCB,
 697                  HELP_COPY_DIALOG_STR);
 698    XtAddCallback(help, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 699                  HELP_COPY_DIALOG_STR);
 700
 701
 702
 703    XtSetArg (args[0], XmNcancelButton, cancel);
 704    XtSetValues (form, args, 1);
 705
 706    XtAddCallback (shell, XmNpopupCallback, (XtCallbackProc)_DtmapCB,
 707                                              (XtPointer) XtParent(shell));
 708
 709    delete_window_atom = XmInternAtom (XtDisplay(shell), "WM_DELETE_WINDOW", True);
 710    XmRemoveWMProtocols( shell, &delete_window_atom, 1 );
 711    XmAddWMProtocolCallback( shell, delete_window_atom, DialogCancel,
 712                             (XtPointer) call_struct );
 713
 714    call_struct->Ok               = ok;
 715    call_struct->Cancel           = cancel;
 716
 717    XtManageChild (form);
 718
 719    /* Force the focus to the text field */
 720    XmProcessTraversal(dir_text, XmTRAVERSE_CURRENT);
 721 }
 722
 723 /************************************************************************
 724  *
 725  *  ShowMoveFileDialog
 726  *      Callback function invoked from the File Manager menu.  This
 727  *      function creates and displays a dialog prompting for a new
 728  *      name for the selected file.
 729  *
 730  *  NOTE:  The Rename File... menu item can currently be reactivated
 731  *         by single select on another item.  Is this behavior correct?
 732  *
 733  ************************************************************************/
 734
 735 void
 736 ShowMoveFileDialog(
 737         Widget w,
 738         XtPointer client_data,
 739         XtPointer call_data )
 740 {
 741    FileMgrRec * file_mgr_rec;
 742    DialogData * dialog_data;
 743    static FileMgrData * file_mgr_data;   /* static because it is passed to RenameOk callback */
 744    FileViewData * file_view_data;
 745
 746    char name_string[18+MAX_PATH];
 747    char * directory_name;
 748    char * tmpStr, *tempStr;
 749
 750    Widget shell;
 751    Widget form;
 752    Widget current_name;
 753    Widget new_name;
 754    Widget new_text;
 755    Widget separator;
 756    Widget ok;
 757    Widget cancel;
 758    Widget help;
 759    int flag=FLAG_RESET;
 760
 761    DialogCallbackStruct * call_struct;
 762    XmString label_string;
 763
 764    Arg args[20];
 765    int n;
 766    Widget mbar;
 767    XtTranslations trans_table;
 768    Atom delete_window_atom;
 769
 770    /*  Set the menu item to insensitive to prevent multiple  */
 771    /*  dialogs from being posted and get the area under the  */
 772    /*  menu pane redrawn.                                    */
 773
 774    XmUpdateDisplay (w);
 775
 776    if(client_data != 0)
 777    {
 778       file_view_data = (FileViewData *)client_data;
 779       mbar = XtParent(w);
 780    }
 781    else
 782    {
 783       file_view_data = NULL;
 784       mbar = XmGetPostedFromWidget(XtParent(w));
 785    }
 786
 787
 788    XtSetArg(args[0], XmNuserData, &file_mgr_rec);
 789    XtGetValues(mbar, args, 1);
 790
 791    /* Ignore accelerators when we're insensitive */
 792
 793    if ((file_mgr_rec->menuStates & MOVE) == 0)
 794      return;
 795
 796    dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
 797    file_mgr_data = (FileMgrData *) dialog_data->data;
 798
 799    /*  Get the selected file.  */
 800
 801    if(file_view_data == NULL)
 802       file_view_data = file_mgr_data->selection_list[0];
 803    directory_name = ((DirectorySet *) file_view_data->directory_set)->name;
 804
 805
 806    /*  Create the widget hierarchy for the dialog  */
 807
 808    n = 0;
 809    XtSetArg (args[n], XmNallowShellResize, True);  n++;
 810
 811    /*  Adjust the decorations for the dialog shell of the dialog  */
 812    XtSetArg (args[n], XmNmwmFunctions, MWM_FUNC_MOVE | MWM_FUNC_CLOSE); ++n;
 813    XtSetArg (args[n], XmNmwmDecorations, MWM_DECOR_BORDER | MWM_DECOR_TITLE);                       ++n;
 814
 815    file_mgr_rec->menuStates &= ~MOVE;
 816    if(file_mgr_data->title != NULL &&
 817       strcmp(file_mgr_data->helpVol, DTFILE_HELP_NAME) != 0)
 818    {
 819      tmpStr = GETMESSAGE(10, 42, "Move Object");
 820      tempStr = (char *)XtMalloc(strlen(tmpStr) +
 821                                 strlen(file_mgr_data->title) + 5);
 822      sprintf(tempStr, "%s - %s", file_mgr_data->title, tmpStr);
 823    }
 824    else
 825    {
 826      tmpStr = (GETMESSAGE(10,43, "File Manager - Move Object"));
 827      tempStr = XtNewString(tmpStr);
 828    }
 829    XtSetArg (args[n], XmNtitle, tempStr);      n++;
 830    shell = XmCreateDialogShell (file_mgr_rec->shell, "move_file", args, n);
 831    XtFree(tempStr);
 832
 833    /* Set the useAsyncGeo on the shell */
 834    XtSetArg (args[0], XmNuseAsyncGeometry, True);
 835    XtSetValues (XtParent(shell), args, 1);
 836
 837
 838    trans_table = XtParseTranslationTable(translations_space);
 839
 840    n = 0;
 841    XtSetArg (args[n], XmNmarginWidth, 1);                n++;
 842    XtSetArg (args[n], XmNmarginHeight, 1);               n++;
 843    XtSetArg (args[n], XmNshadowThickness, 1);            n++;
 844    XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT);      n++;
 845    XtSetArg (args[n], XmNautoUnmanage, False);           n++;
 846 #ifdef _CHECK_FOR_SPACES
 847    XtSetArg (args[n], XmNtextTranslations, trans_table);n++;
 848 #endif
 849    XtSetArg (args[n], XmNuserData, file_mgr_rec);        n++;
 850    form = XmCreateForm (shell, "form", args, n);
 851    XtAddCallback(form, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 852                  HELP_MOVE_DIALOG_STR);
 853
 854
 855    sprintf (name_string, "%s ", ((char *)GETMESSAGE(10, 37, "Selected object:")));
 856    strcat (name_string, file_view_data->file_data->file_name);
 857    label_string = XmStringCreateLocalized (name_string);
 858
 859    n = 0;
 860    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 861    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 862    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 863    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
 864    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
 865    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 866    current_name = XmCreateLabelGadget (form, "current_name", args, n);
 867    XtManageChild (current_name);
 868    XtAddCallback(current_name, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 869                  HELP_MOVE_DIALOG_STR);
 870
 871    XmStringFree (label_string);
 872
 873
 874    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 34, "Destination Folder: ")));
 875
 876    n = 0;
 877    XtSetArg (args[n], XmNlabelString, label_string);            n++;
 878    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
 879    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
 880    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
 881    XtSetArg (args[n], XmNtopWidget, current_name);              n++;
 882    XtSetArg (args[n], XmNtopOffset, 12);                        n++;
 883    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
 884    new_name = XmCreateLabelGadget (form, "new_name", args, n);
 885    XtManageChild (new_name);
 886    XtAddCallback(new_name, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 887                  HELP_MOVE_DIALOG_STR);
 888
 889    XmStringFree (label_string);
 890
 891
 892    n = 0;
 893    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);   n++;
 894    XtSetArg (args[n], XmNleftWidget, new_name);              n++;
 895    XtSetArg (args[n], XmNleftOffset, 0);                     n++;
 896    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);    n++;
 897    XtSetArg (args[n], XmNtopWidget, current_name);           n++;
 898    XtSetArg (args[n], XmNtopOffset, 5);                      n++;
 899    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);    n++;
 900    XtSetArg (args[n], XmNrightOffset, 5);                    n++;
 901    XtSetArg (args[n], XmNtraversalOn, True);                 n++;
 902    XtSetArg (args[n], XmNcursorPosition,
 903                strlen(file_view_data->file_data->file_name));   n++;
 904    new_text = XmCreateTextField (form, "new_text", args, n);
 905    XtManageChild (new_text);
 906    XtAddCallback(new_text, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 907                  HELP_MOVE_DIALOG_STR);
 908
 909    /*  The data sent to the Text, Ok and Cancel callbacks  */
 910
 911    call_struct =
 912       (DialogCallbackStruct *) XtMalloc (sizeof (DialogCallbackStruct));
 913
 914    call_struct->dialog_widget = form;
 915    call_struct->menu_widget = w;
 916    call_struct->dir_text_widget = new_text;
 917    call_struct->file_text_widget = NULL;
 918    call_struct->file_type_widget = NULL;
 919    call_struct->original_physical_type =
 920       file_view_data->file_data->physical_type;
 921    call_struct->file_mgr_rec = file_mgr_rec;
 922    call_struct->host_name = XtNewString (file_mgr_data->host);
 923    call_struct->directory_name = XtNewString (directory_name);
 924    call_struct->file_name = XtNewString (file_view_data->file_data->file_name);
 925    call_struct->mode = MOVE_FILE;
 926    call_struct->original_logical_type =file_view_data->file_data->logical_type;
 927    call_struct->previous_file_type = NULL;
 928    call_struct->file_mgr_data = file_mgr_data;
 929
 930
 931    /*  Create a separator between the buttons  */
 932
 933    n = 0;
 934    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);    n++;
 935    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);   n++;
 936    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);   n++;
 937    XtSetArg (args[n], XmNtopWidget, new_name);              n++;
 938    XtSetArg (args[n], XmNtopOffset, 10);                    n++;
 939    separator =  XmCreateSeparatorGadget (form, "separator", args, n);
 940    XtManageChild (separator);
 941
 942
 943
 944    /*  Create the ok, cancel, preview and help buttons  */
 945
 946
 947    n = 0;
 948    XtSetArg (args[n], XmNlabelString, okXmString);               n++;
 949    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);     n++;
 950    XtSetArg (args[n], XmNleftPosition, 2);                       n++;
 951    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);    n++;
 952    XtSetArg (args[n], XmNrightPosition, 32);                     n++;
 953    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);        n++;
 954    XtSetArg (args[n], XmNtopWidget, separator);                  n++;
 955    XtSetArg (args[n], XmNtopOffset, 5);                          n++;
 956    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);       n++;
 957    XtSetArg (args[n], XmNbottomOffset, 5);                       n++;
 958    XtSetArg (args[n], XmNmarginWidth, 4);                        n++;
 959    XtSetArg (args[n], XmNmarginHeight, 4);                       n++;
 960    XtSetArg (args[n], XmNshowAsDefault, True);                   n++;
 961    XtSetArg (args[n], XmNuserData, flag);                        n++;
 962    ok = XmCreatePushButtonGadget (form, "ok", args, n);
 963    XtManageChild (ok);
 964
 965    XtAddCallback (ok, XmNactivateCallback, RenameOk, (XtPointer) call_struct);
 966    XtAddCallback(ok, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 967                  HELP_MOVE_DIALOG_STR);
 968
 969
 970    /*  Set the ok button to the default for the bulletin board.  */
 971    /*  This causes the return key from the text widget to be     */
 972    /*  properly processed.                                       */
 973
 974    XtSetArg (args[0], XmNdefaultButton, ok);
 975    XtSetValues (form, args, 1);
 976
 977
 978    n = 0;
 979    XtSetArg (args[n], XmNlabelString, cancelXmString);           n++;
 980    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);     n++;
 981    XtSetArg (args[n], XmNleftPosition, 35);                      n++;
 982    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);    n++;
 983    XtSetArg (args[n], XmNrightPosition, 65);                     n++;
 984    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);        n++;
 985    XtSetArg (args[n], XmNtopWidget, separator);                  n++;
 986    XtSetArg (args[n], XmNtopOffset, 5);                          n++;
 987    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);       n++;
 988    XtSetArg (args[n], XmNbottomOffset, 5);                       n++;
 989    XtSetArg (args[n], XmNmarginWidth, 4);                        n++;
 990    XtSetArg (args[n], XmNmarginHeight, 4);                       n++;
 991    XtSetArg (args[n], XmNuserData, flag);                        n++;
 992    cancel = XmCreatePushButtonGadget (form, "cancel", args, n);
 993    XtManageChild (cancel);
 994
 995    XtAddCallback (cancel, XmNactivateCallback, DialogCancel,
 996                                                    (XtPointer) call_struct);
 997    XtAddCallback(cancel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
 998                  HELP_MOVE_DIALOG_STR);
 999
1000
1001    n = 0;
1002    XtSetArg (args[n], XmNlabelString, helpXmString);             n++;
1003    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);     n++;
1004    XtSetArg (args[n], XmNleftPosition, 68);                      n++;
1005    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);    n++;
1006    XtSetArg (args[n], XmNrightPosition, 98);                     n++;
1007    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);        n++;
1008    XtSetArg (args[n], XmNtopWidget, separator);                  n++;
1009    XtSetArg (args[n], XmNtopOffset, 5);                          n++;
1010    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);       n++;
1011    XtSetArg (args[n], XmNbottomOffset, 5);                       n++;
1012    XtSetArg (args[n], XmNmarginWidth, 4);                        n++;
1013    XtSetArg (args[n], XmNmarginHeight, 4);                       n++;
1014    help = XmCreatePushButtonGadget (form, "help", args, n);
1015    XtManageChild (help);
1016
1017    XtAddCallback(help, XmNactivateCallback, (XtCallbackProc)HelpRequestCB,
1018                  HELP_MOVE_DIALOG_STR);
1019    XtAddCallback(help, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1020                  HELP_MOVE_DIALOG_STR);
1021
1022
1023
1024    XtSetArg (args[0], XmNcancelButton, cancel);
1025    XtSetValues (form, args, 1);
1026
1027    XtAddCallback (shell, XmNpopupCallback, (XtCallbackProc)_DtmapCB,
1028                                              (XtPointer) XtParent(shell));
1029
1030    delete_window_atom = XmInternAtom (XtDisplay(shell), "WM_DELETE_WINDOW", True);
1031    XmRemoveWMProtocols( shell, &delete_window_atom, 1 );
1032    XmAddWMProtocolCallback( shell, delete_window_atom, DialogCancel,
1033                             (XtPointer) call_struct );
1034
1035    call_struct->Ok               = ok;
1036    call_struct->Cancel           = cancel;
1037
1038    XtManageChild (form);
1039
1040    /* Force the focus to the text field */
1041    XmProcessTraversal(new_text, XmTRAVERSE_CURRENT);
1042
1043 }
1044
1045 /************************************************************************
1046  *
1047  *  ShowLinkFileDialog
1048  *      Callback function invoked from the File Manager menu.  This
1049  *      function creates and displays a dialog prompting for a new
1050  *      name for the selected file.
1051  *
1052  *  NOTE:  The Rename File... menu item can currently be reactivated
1053  *         by single select on another item.  Is this behavior correct?
1054  *
1055  ************************************************************************/
1056
1057 void
1058 ShowLinkFileDialog(
1059         Widget w,
1060         XtPointer client_data,
1061         XtPointer call_data )
1062 {
1063    FileMgrRec * file_mgr_rec;
1064    DialogData * dialog_data;
1065    static FileMgrData * file_mgr_data;   /* static because it is passed to RenameOk callback */
1066    FileViewData * file_view_data;
1067
1068    char name_string[18+MAX_PATH];
1069    char * directory_name;
1070    char * tmpStr, *tempStr;
1071
1072    Widget shell;
1073    Widget form;
1074    Widget current_name;
1075    Widget dir_label, dir_text;
1076    Widget file_label, file_text;
1077    Widget file_type_box;
1078    Widget file_type;
1079    Widget separator;
1080    Widget ok;
1081    Widget cancel;
1082    Widget preview;
1083    Widget help;
1084    int flag=FLAG_RESET;
1085
1086    DialogCallbackStruct * call_struct;
1087    XmString label_string;
1088
1089    Arg args[20];
1090    int n;
1091    Widget mbar;
1092    XtTranslations trans_table;
1093    Atom delete_window_atom;
1094
1095    /*  Set the menu item to insensitive to prevent multiple  */
1096    /*  dialogs from being posted and get the area under the  */
1097    /*  menu pane redrawn.                                    */
1098
1099    XmUpdateDisplay (w);
1100
1101    if(client_data != 0)
1102    {
1103       file_view_data = (FileViewData *)client_data;
1104       mbar = XtParent(w);
1105    }
1106    else
1107    {
1108       file_view_data = NULL;
1109       mbar = XmGetPostedFromWidget(XtParent(w));
1110    }
1111
1112
1113    XtSetArg(args[0], XmNuserData, &file_mgr_rec);
1114    XtGetValues(mbar, args, 1);
1115
1116    /* Ignore accelerators when we're insensitive */
1117
1118    if ((file_mgr_rec->menuStates & LINK) == 0)
1119      return;
1120
1121    dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
1122    file_mgr_data = (FileMgrData *) dialog_data->data;
1123
1124
1125    /*  Get the selected file.  */
1126
1127    if(file_view_data == NULL)
1128       file_view_data = file_mgr_data->selection_list[0];
1129    directory_name = ((DirectorySet *) file_view_data->directory_set)->name;
1130
1131
1132    /*  Create the widget hierarchy for the dialog  */
1133
1134    n = 0;
1135    XtSetArg (args[n], XmNallowShellResize, True);  n++;
1136
1137    file_mgr_rec->menuStates &= ~LINK;
1138    if(file_mgr_data->title != NULL &&
1139       strcmp(file_mgr_data->helpVol, DTFILE_HELP_NAME) != 0)
1140    {
1141      tmpStr = GETMESSAGE(10, 46, "Link Object");
1142      tempStr = (char *)XtMalloc(strlen(tmpStr) +
1143                                 strlen(file_mgr_data->title) + 5);
1144      sprintf(tempStr, "%s - %s", file_mgr_data->title, tmpStr);
1145    }
1146    else
1147    {
1148      tmpStr = (GETMESSAGE(10,47, "File Manager - Link Object"));
1149      tempStr = XtNewString(tmpStr);
1150    }
1151    XtSetArg (args[n], XmNtitle, tempStr);      n++;
1152    shell = XmCreateDialogShell (file_mgr_rec->shell, "link_file", args, n);
1153    XtFree(tempStr);
1154
1155    /* Set the useAsyncGeo on the shell */
1156    XtSetArg (args[0], XmNuseAsyncGeometry, True);
1157    XtSetValues (XtParent(shell), args, 1);
1158
1159
1160    trans_table = XtParseTranslationTable(translations_space);
1161
1162    n = 0;
1163    XtSetArg (args[n], XmNmarginWidth, 1);                n++;
1164    XtSetArg (args[n], XmNmarginHeight, 1);               n++;
1165    XtSetArg (args[n], XmNshadowThickness, 1);            n++;
1166    XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT);      n++;
1167    XtSetArg (args[n], XmNautoUnmanage, False);           n++;
1168 #ifdef _CHECK_FOR_SPACES
1169    XtSetArg (args[n], XmNtextTranslations, trans_table); n++;
1170 #endif
1171    XtSetArg (args[n], XmNuserData, file_mgr_rec);        n++;
1172    form = XmCreateForm (shell, "form", args, n);
1173    XtAddCallback(form, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1174                  HELP_LINK_DIALOG_STR);
1175
1176
1177    sprintf (name_string, "%s ", ((char *)GETMESSAGE(10, 37, "Selected object:")));
1178    strcat (name_string, file_view_data->file_data->file_name);
1179    label_string = XmStringCreateLocalized (name_string);
1180
1181    n = 0;
1182    XtSetArg (args[n], XmNlabelString, label_string);        n++;
1183    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);     n++;
1184    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);    n++;
1185
1186    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);     n++;
1187    XtSetArg (args[n], XmNtopOffset, 5);                     n++;
1188    XtSetArg (args[n], XmNtraversalOn, False);               n++;
1189    current_name = XmCreateLabelGadget (form, "current_name", args, n);
1190    XtManageChild (current_name);
1191    XtAddCallback(current_name, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1192                  HELP_LINK_DIALOG_STR);
1193
1194    XmStringFree (label_string);
1195
1196    /* Create the field displaying the file type info */
1197
1198    n = 0;
1199    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);              n++;
1200    XtSetArg(args[n], XmNtopOffset, 15);                             n++;
1201    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);            n++;
1202    XtSetArg(args[n], XmNrightOffset, 5);                            n++;
1203    XtSetArg(args[n], XmNmarginHeight, 5);                           n++;
1204    XtSetArg(args[n], XmNmarginWidth, 5);                            n++;
1205    file_type_box = XmCreateFrame (form, "file_type_box", args, n);
1206    XtManageChild (file_type_box);
1207    XtAddCallback(file_type_box, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1208                  HELP_LINK_DIALOG_STR);
1209
1210
1211    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 8, "File Type")));
1212
1213    n = 0;
1214    XtSetArg (args[n], XmNlabelString, label_string);          n++;
1215    XtSetArg (args[n], XmNshadowThickness, 0);                 n++;
1216    XtSetArg (args[n], XmNshadowType, XmSHADOW_ETCHED_OUT);    n++;
1217    XtSetArg (args[n], XmNpixmapPosition, XmPIXMAP_TOP);       n++;
1218    XtSetArg (args[n], XmNtraversalOn, False);                 n++;
1219    file_type = _DtCreateIcon (file_type_box, "file_type", args, n);
1220    XtManageChild (file_type);
1221    XtAddCallback(file_type, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1222                  HELP_LINK_DIALOG_STR);
1223
1224    XmStringFree (label_string);
1225
1226
1227    /* Adjust the colors of the icon */
1228    SetToNormalColors (file_type, form, file_mgr_rec->main, 0);
1229
1230    n = 0;
1231    XtSetArg (args[n], XmNrightAttachment, XmATTACH_WIDGET);    n++;
1232    XtSetArg (args[n], XmNrightWidget, file_type_box);          n++;
1233    XtSetArg (args[n], XmNrightOffset, 5);                      n++;
1234    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);      n++;
1235    XtSetArg (args[n], XmNtopWidget, current_name);             n++;
1236    XtSetArg (args[n], XmNtopOffset, 5);                        n++;
1237    XtSetArg (args[n], XmNtraversalOn, True);                   n++;
1238    XtSetArg (args[n], XmNcursorPosition,
1239                strlen(file_view_data->file_data->file_name));  n++;
1240    dir_text = XmCreateTextField (form, "new_text", args, n);
1241    XtManageChild (dir_text);
1242    XtAddCallback(dir_text, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1243                  HELP_LINK_DIALOG_STR);
1244    XmTextFieldInsert(dir_text, 0, directory_name);
1245
1246
1247    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 34, "Destination Folder: ")));
1248
1249    n = 0;
1250    XtSetArg (args[n], XmNlabelString, label_string);         n++;
1251    XtSetArg (args[n], XmNrightWidget, dir_text);             n++;
1252    XtSetArg (args[n], XmNrightAttachment, XmATTACH_WIDGET);  n++;
1253    XtSetArg (args[n], XmNrightOffset, 5);                    n++;
1254    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);    n++;
1255    XtSetArg (args[n], XmNtopWidget, current_name);           n++;
1256    XtSetArg (args[n], XmNtopOffset, 12);                     n++;
1257    XtSetArg (args[n], XmNtraversalOn, False);                n++;
1258    dir_label = XmCreateLabelGadget (form, "new_name", args, n);
1259    XtManageChild (dir_label);
1260    XtAddCallback(dir_label, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1261                  HELP_LINK_DIALOG_STR);
1262
1263    XmStringFree (label_string);
1264
1265    n = 0;
1266    XtSetArg (args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET);    n++;
1267    XtSetArg (args[n], XmNleftWidget, dir_text);                        n++;
1268    XtSetArg (args[n], XmNleftOffset, 0);                               n++;
1269    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);              n++;
1270    XtSetArg (args[n], XmNtopWidget, dir_label);                        n++;
1271    XtSetArg (args[n], XmNtopOffset, 5);                                n++;
1272    XtSetArg (args[n], XmNtraversalOn, True);                           n++;
1273    XtSetArg (args[n], XmNcursorPosition,
1274                strlen(file_view_data->file_data->file_name));          n++;
1275    file_text = XmCreateTextField (form, "new_text", args, n);
1276    XtManageChild (file_text);
1277    XtAddCallback(file_text, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1278                  HELP_LINK_DIALOG_STR);
1279    XmTextFieldInsert(file_text, 0, file_view_data->file_data->file_name);
1280
1281    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 38, "Name for copy : ")));
1282
1283    n = 0;
1284    XtSetArg (args[n], XmNlabelString, label_string);            n++;
1285    XtSetArg (args[n], XmNrightWidget, file_text);               n++;
1286    XtSetArg (args[n], XmNrightAttachment, XmATTACH_WIDGET);     n++;
1287    XtSetArg (args[n], XmNrightOffset, 5);                       n++;
1288    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
1289    XtSetArg (args[n], XmNtopWidget, dir_label);                 n++;
1290    XtSetArg (args[n], XmNtopOffset, 12);                        n++;
1291    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
1292    file_label = XmCreateLabelGadget (form, "new_name", args, n);
1293    XtManageChild (file_label);
1294    XtAddCallback(file_label, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1295                  HELP_LINK_DIALOG_STR);
1296
1297    XmStringFree (label_string);
1298
1299
1300    /*  The data sent to the Text, Ok and Cancel callbacks  */
1301
1302    call_struct =
1303       (DialogCallbackStruct *) XtMalloc (sizeof (DialogCallbackStruct));
1304
1305    call_struct->dialog_widget = form;
1306    call_struct->menu_widget = w;
1307    call_struct->dir_text_widget = dir_text;
1308    call_struct->file_text_widget = file_text;
1309    call_struct->file_type_widget = file_type;
1310    call_struct->original_physical_type =
1311       file_view_data->file_data->physical_type;
1312    call_struct->file_mgr_rec = file_mgr_rec;
1313    call_struct->host_name = XtNewString (file_mgr_data->host);
1314    call_struct->directory_name = XtNewString (directory_name);
1315    call_struct->mode = LINK_FILE;
1316    call_struct->file_name = XtNewString (file_view_data->file_data->file_name);
1317    call_struct->original_logical_type =file_view_data->file_data->logical_type;
1318    call_struct->previous_file_type = NULL;
1319    call_struct->file_mgr_data = file_mgr_data;
1320
1321
1322    /*  Create a separator between the buttons  */
1323
1324    n = 0;
1325    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
1326    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);       n++;
1327    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
1328    XtSetArg (args[n], XmNtopWidget, file_label);                        n++;
1329    XtSetArg (args[n], XmNtopOffset, 10);                        n++;
1330    separator =  XmCreateSeparatorGadget (form, "separator", args, n);
1331    XtManageChild (separator);
1332
1333
1334
1335    /*  Create the ok, cancel, preview and help buttons  */
1336
1337
1338    n = 0;
1339    XtSetArg (args[n], XmNlabelString, okXmString);               n++;
1340    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);     n++;
1341    XtSetArg (args[n], XmNleftPosition, 1);                       n++;
1342    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);    n++;
1343    XtSetArg (args[n], XmNrightPosition, 21);                     n++;
1344    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);        n++;
1345    XtSetArg (args[n], XmNtopWidget, separator);                  n++;
1346    XtSetArg (args[n], XmNtopOffset, 5);                          n++;
1347    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);       n++;
1348    XtSetArg (args[n], XmNbottomOffset, 5);                       n++;
1349    XtSetArg (args[n], XmNmarginWidth, 4);                        n++;
1350    XtSetArg (args[n], XmNmarginHeight, 4);                       n++;
1351    XtSetArg (args[n], XmNshowAsDefault, True);                   n++;
1352    XtSetArg (args[n], XmNuserData, flag);                        n++;
1353    ok = XmCreatePushButtonGadget (form, "ok", args, n);
1354    XtManageChild (ok);
1355
1356    XtAddCallback (ok, XmNactivateCallback, RenameOk, (XtPointer) call_struct);
1357    XtAddCallback(ok, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1358                  HELP_LINK_DIALOG_STR);
1359
1360
1361    /*  Set the ok button to the default for the bulletin board.  */
1362    /*  This causes the return key from the text widget to be     */
1363    /*  properly processed.                                       */
1364
1365    XtSetArg (args[0], XmNdefaultButton, ok);
1366    XtSetValues (form, args, 1);
1367
1368
1369    n = 0;
1370    XtSetArg (args[n], XmNlabelString, cancelXmString);          n++;
1371    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
1372    XtSetArg (args[n], XmNleftPosition, 22);                     n++;
1373    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
1374    XtSetArg (args[n], XmNrightPosition, 42);                    n++;
1375    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
1376    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
1377    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
1378    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
1379    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
1380    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
1381    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
1382    XtSetArg (args[n], XmNuserData, flag);                        n++;
1383    cancel = XmCreatePushButtonGadget (form, "cancel", args, n);
1384    XtManageChild (cancel);
1385
1386    XtAddCallback (cancel, XmNactivateCallback, DialogCancel,
1387                                                    (XtPointer) call_struct);
1388    XtAddCallback(cancel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1389                  HELP_LINK_DIALOG_STR);
1390
1391
1392    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 36, "Show Icon")));
1393
1394    n = 0;
1395    XtSetArg (args[n], XmNlabelString, label_string);              n++;
1396    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);      n++;
1397    XtSetArg (args[n], XmNleftPosition, 43);                       n++;
1398    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);     n++;
1399    XtSetArg (args[n], XmNrightPosition, 78);                      n++;
1400    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);         n++;
1401    XtSetArg (args[n], XmNtopWidget, separator);                   n++;
1402    XtSetArg (args[n], XmNtopOffset, 5);                           n++;
1403    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);        n++;
1404    XtSetArg (args[n], XmNbottomOffset, 5);                        n++;
1405    XtSetArg (args[n], XmNmarginWidth, 4);                         n++;
1406    XtSetArg (args[n], XmNmarginHeight, 4);                        n++;
1407    preview = XmCreatePushButtonGadget (form, "show_file_type", args, n);
1408    XtManageChild (preview);
1409
1410    XmStringFree (label_string);
1411    XtAddCallback (preview, XmNactivateCallback, FileTypePreviewCB,
1412                                                    (XtPointer) call_struct);
1413    XtAddCallback(preview, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1414                  HELP_LINK_DIALOG_STR);
1415    tmpStr = XtNewString(file_view_data->file_data->file_name);
1416    FileTypePreview (preview, tmpStr, (XtPointer) call_struct, NULL);
1417
1418    n = 0;
1419    XtSetArg (args[n], XmNlabelString, helpXmString);              n++;
1420    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);      n++;
1421    XtSetArg (args[n], XmNleftPosition, 79);                       n++;
1422    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);     n++;
1423    XtSetArg (args[n], XmNrightPosition, 99);                      n++;
1424    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);         n++;
1425    XtSetArg (args[n], XmNtopWidget, separator);                   n++;
1426    XtSetArg (args[n], XmNtopOffset, 5);                           n++;
1427    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);        n++;
1428    XtSetArg (args[n], XmNbottomOffset, 5);                        n++;
1429    XtSetArg (args[n], XmNmarginWidth, 4);                         n++;
1430    XtSetArg (args[n], XmNmarginHeight, 4);                        n++;
1431    help = XmCreatePushButtonGadget (form, "help", args, n);
1432    XtManageChild (help);
1433
1434    XtAddCallback(help, XmNactivateCallback, (XtCallbackProc)HelpRequestCB,
1435                  HELP_LINK_DIALOG_STR);
1436    XtAddCallback(help, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
1437                  HELP_LINK_DIALOG_STR);
1438
1439
1440
1441    XtSetArg (args[0], XmNcancelButton, cancel);
1442    XtSetValues (form, args, 1);
1443
1444    XtAddCallback (shell, XmNpopupCallback, (XtCallbackProc)_DtmapCB,
1445                                              (XtPointer) XtParent(shell));
1446
1447    delete_window_atom = XmInternAtom (XtDisplay(shell), "WM_DELETE_WINDOW", True);
1448    XmRemoveWMProtocols( shell, &delete_window_atom, 1 );
1449    XmAddWMProtocolCallback( shell, delete_window_atom, DialogCancel,
1450                             (XtPointer) call_struct );
1451
1452    call_struct->Ok     = ok;
1453    call_struct->Cancel = cancel;
1454
1455    XtManageChild (form);
1456
1457    /* Force the focus to the text field */
1458    XmProcessTraversal(dir_text, XmTRAVERSE_CURRENT);
1459 }
1460
1461
1462
1463 /************************************************************************
1464  *
1465  *  RenameOk
1466  *      Get the new file name and rename the file.
1467  *
1468  ************************************************************************/
1469
1470 static void
1471 RenameOk(
1472         Widget w,
1473         XtPointer client_data,
1474         XtPointer call_data )
1475 {
1476    DialogCallbackStruct * call_struct = (DialogCallbackStruct *)client_data;
1477    char *title = NULL;
1478    char *msg = NULL;
1479    char *new_name = NULL, *new_dir = NULL, new[MAX_PATH];
1480    unsigned int btnMask = 0;
1481    RenameDoneData *data;
1482    char to_host[256];
1483    char to_dir[MAX_PATH];
1484    char to_file[256];
1485    unsigned int modifiers;
1486    char *host_set[1], *file_set[1];
1487    int  file_count = 1;
1488
1489    if(RecheckFlag(call_struct->dialog_widget,w))   /* OK button */
1490      return;
1491    else if(RecheckFlag(NULL,call_struct->Cancel))
1492      return;
1493
1494    /* currently, only one file can be moved/copied/linked using the menu */
1495    /* the following arrays can be expanded if this restriction is lifted */
1496
1497    new_dir = XmTextFieldGetString (call_struct->dir_text_widget);
1498    new_dir = (char *) _DtStripSpaces (new_dir);
1499
1500    if (new_dir[0] == '~')
1501       new_dir = _DtChangeTildeToHome (new_dir);
1502
1503    switch (call_struct->mode)
1504    {
1505      case MOVE_FILE:
1506        title = XtNewString(GetSharedMessage(FILE_MOVE_ERROR_TITLE));
1507        btnMask = MOVE;
1508        break;
1509      case COPY_FILE:
1510        title = XtNewString(GetSharedMessage(FILE_COPY_ERROR_TITLE));
1511        btnMask = DUPLICATE;
1512        break;
1513      case LINK_FILE:
1514        title = XtNewString(GetSharedMessage(FILE_LINK_ERROR_TITLE));
1515        btnMask = LINK;
1516        break;
1517    }
1518
1519    if (strlen (new_dir) == 0)
1520      msg = XtNewString(GETMESSAGE(10, 11,
1521                                   "A file or folder cannot have a blank name."));
1522 #ifdef _CHECK_FOR_SPACES
1523    else if (DtStrchr (new_dir, ' ') != NULL ||
1524             DtStrchr (new_dir, '\t') != NULL)
1525      msg = XtNewString(GetSharedMessage(NO_SPACES_ALLOWED_ERROR));
1526 #endif
1527
1528    switch (call_struct->mode)
1529    {
1530      case COPY_FILE:
1531      case LINK_FILE:
1532        new_name = XmTextFieldGetString (call_struct->file_text_widget);
1533        new_name = (char *) _DtStripSpaces (new_name);
1534        if (strlen (new_name) == 0)
1535          msg = XtNewString(GETMESSAGE(10, 11,
1536                                       "A file or folder cannot have a blank name."));
1537 #ifdef _CHECK_FOR_SPACES
1538        else if (DtStrchr (new_name, ' ') != NULL ||
1539                 DtStrchr (new_name, '\t') != NULL)
1540          msg = XtNewString(GetSharedMessage(NO_SPACES_ALLOWED_ERROR));
1541 #endif
1542        sprintf(new, "%s/%s", new_dir, new_name );
1543        break;
1544      case MOVE_FILE:
1545        sprintf(new, "%s/%s", new_dir, call_struct->file_name);
1546        break;
1547    }
1548
1549    if (msg != NULL)
1550    {
1551       _DtMessage(XtParent (w), title, msg, NULL, HelpRequestCB);
1552       XtFree(title);
1553       XtFree(msg);
1554       if(new_name) XtFree(new_name);
1555       if(new_dir) XtFree(new_dir);
1556       ResetFlag(call_struct->dialog_widget,w);
1557       ResetFlag(call_struct->dialog_widget,call_struct->Cancel);
1558       return;
1559    }
1560
1561    XtFree(title);
1562    XtFree(msg);
1563    if(new_name) XtFree(new_name);
1564    if(new_dir) XtFree(new_dir);
1565
1566    /* set up data for RenameDone callback */
1567    data = (RenameDoneData *)XtMalloc(sizeof(RenameDoneData));
1568    data->w = w;
1569    data->call_struct = call_struct;
1570    data->mode = call_struct->mode;
1571    data->btnMask = btnMask;
1572
1573    /*
1574     * Do the rename/copy/...
1575     * This operation is performed in a background process; when the
1576     * background process finishes, the RenameDone callback will be
1577     * called with a return code indicating success or failure.
1578     */
1579
1580    /* get host & path of the target file */
1581    GetTarget(call_struct->host_name, call_struct->directory_name, new,
1582              to_host, to_dir, to_file);
1583    /* get host & path of source file */
1584    host_set[0] = call_struct->host_name;
1585    file_set[0] = build_path(call_struct->directory_name, call_struct->file_name);
1586    /* set up modifiers depending on operation */
1587    switch (call_struct->mode)
1588    {
1589      case MOVE_FILE:
1590        modifiers = 0;
1591        break;
1592      case COPY_FILE:
1593        modifiers = ControlMask;
1594        break;
1595      case LINK_FILE:
1596        modifiers = ShiftMask;
1597        break;
1598    }
1599
1600    FileMoveCopy(call_struct->file_mgr_data,
1601                 to_file, to_dir, to_host,
1602                 host_set, file_set, file_count,
1603                 modifiers, RenameDone, (XtPointer)data);
1604
1605    XtFree(file_set[0]);
1606    file_set[0] = NULL;
1607 }
1608
1609
1610 /************************************************************************
1611  *
1612  *  RenameDone
1613  *      This routine is called when the file move/copy/link is finished.
1614  *
1615  ************************************************************************/
1616
1617 void
1618 RenameDone(
1619         XtPointer client_data,
1620         int rc)
1621 {
1622    RenameDoneData *data = (RenameDoneData *)client_data;
1623    DialogCallbackStruct *call_struct = data->call_struct;
1624
1625    if (rc == 0)
1626    {
1627       XtUnmanageChild(call_struct->dialog_widget);
1628       XmUpdateDisplay(call_struct->dialog_widget);
1629       XtDestroyWidget(XtParent(call_struct->dialog_widget));
1630       call_struct->file_mgr_rec->menuStates |= data->btnMask;
1631
1632       XtFree(call_struct->host_name);
1633       XtFree(call_struct->directory_name);
1634       XtFree(call_struct->file_name);
1635       if(call_struct->previous_file_type)
1636         XtFree(call_struct->previous_file_type);
1637
1638       XtFree((char *) call_struct);
1639    }
1640
1641    XtFree((char *)data);
1642 }
1643
1644
1645 /************************************************************************
1646  *
1647  *  GetToPath
1648  *      Build a directory,filename path to be used as the destination
1649  *      of a create, copy or move operation.
1650  *
1651  ************************************************************************/
1652
1653 static Boolean
1654 GetToPath (
1655         char *to,
1656         char *new_name,
1657         char *host_in,
1658         char *dir_in)
1659 {
1660    char *ptr;
1661    char *host_name;
1662    char *directory_name;
1663    char *path;
1664    Tt_status tt_status;
1665
1666    if (strncmp (new_name, "/", 1) == 0)
1667    {
1668       if ((path = (char *) ResolveLocalPathName (host_in,
1669                                                  new_name,
1670                                                  NULL,
1671                                                  home_host_name,
1672                                                  &tt_status )) == NULL)
1673          return (False);
1674    }
1675    else
1676    {
1677       if (strcmp(dir_in, "/") == 0)
1678          sprintf(to, "%s%s", dir_in, new_name);
1679       else
1680          sprintf(to, "%s/%s", dir_in, new_name);
1681
1682       if ((path = (char *) ResolveLocalPathName (host_in,
1683                                                  to,
1684                                                  NULL,
1685                                                  home_host_name,
1686                                                  &tt_status )) == NULL)
1687          return (False);
1688    }
1689
1690    strcpy (to, path);
1691
1692    XtFree(path);
1693    return (True);
1694 }
1695
1696
1697
1698 /************************************************************************
1699  *
1700  *  FileTypePreviewCB
1701  *      Get the text field file name, find out what the file type is
1702  *      for the file name and display the name and icon for the
1703  *      file type.
1704  *
1705  ************************************************************************/
1706
1707 static void
1708 FileTypePreviewCB(
1709         Widget w,
1710         XtPointer client_data,
1711         XtPointer call_data )
1712 {
1713    DialogCallbackStruct * call_struct;
1714    char * new_name;
1715
1716    call_struct = (DialogCallbackStruct *) client_data;
1717
1718    new_name = XmTextFieldGetString (call_struct->file_text_widget);
1719    FileTypePreview(w, new_name, client_data, call_data);
1720 }
1721
1722
1723 /************************************************************************
1724  *
1725  *  FileTypePreview
1726  *      Find out what the file type is for the specified file name and
1727  *      display the name and icon for the file type.
1728  *
1729  ************************************************************************/
1730
1731 static void
1732 FileTypePreview(
1733         Widget w,
1734         String new_name,
1735         XtPointer client_data,
1736         XtPointer call_data )
1737 {
1738    DialogCallbackStruct * call_struct;
1739    char * file_type;
1740    XmString string;
1741    Arg args[2];
1742    int n;
1743    char whole_name[MAX_PATH];
1744    char * orig_name;
1745    char * link_path;
1746    char * new_link_path;
1747    PixmapData *pixmapData;
1748    Tt_status tt_status;
1749    Boolean Flag =  ((Boolean)(XtArgVal)call_data == True)?True:False;
1750
1751    call_struct = (DialogCallbackStruct *) client_data;
1752    new_name = (char *) _DtStripSpaces (new_name);
1753
1754    if (new_name[0] == '~')
1755       new_name = _DtChangeTildeToHome (new_name);
1756
1757    if (GetToPath (whole_name, new_name, call_struct->host_name,
1758                                  call_struct->directory_name) == False)
1759       strcpy(whole_name, " ");
1760
1761    orig_name = ResolveLocalPathName( call_struct->host_name,
1762                                      call_struct->directory_name,
1763                                      call_struct->file_name,
1764                                      home_host_name, &tt_status);
1765
1766    /* Check for broken links so we get the proper file_type */
1767    if (call_struct->original_logical_type != NULL &&
1768        strcmp(call_struct->original_logical_type, LT_BROKEN_LINK) == 0)
1769       file_type = XtNewString(call_struct->original_logical_type);
1770    else if (call_struct->original_physical_type == DtDIRECTORY)
1771       file_type = XtNewString(LT_DIRECTORY);
1772    else if ( *new_name == 0x0 &&
1773              call_struct->original_physical_type == DtDATA )
1774       file_type = XtNewString(LT_DATA);
1775    else if (link_path = _DtFollowLink(whole_name))
1776    {
1777       if (strcmp(orig_name, whole_name) == 0)
1778         file_type = (char *) DtDtsDataToDataType(orig_name, NULL, 0, NULL,
1779                                                  NULL, NULL, NULL);
1780       else
1781       {
1782          if (call_struct->menu_widget == *renameBtn)
1783          {
1784             new_link_path = XtNewString(link_path);
1785
1786             if ((link_path = _DtFollowLink(orig_name)) &&
1787                 (strcmp(link_path, orig_name) == 0))
1788             {
1789                file_type = (char *) DtDtsDataToDataType(new_link_path, NULL, 0,
1790                                                    NULL, NULL, NULL, NULL);
1791             }
1792             else
1793             {
1794                /* Links are typed according to what they are linked to */
1795                file_type = call_struct->original_logical_type;
1796             }
1797
1798             XtFree(new_link_path);
1799          }
1800          else
1801          {
1802            /* We want to find out the possible filetype of a file that has
1803               such name (stored in link_path). However, the file does not even
1804               existed yet. In order for the file typing code to work correctly,
1805               we have to pass in a dummy stat structure indicates that if the
1806               file is created, this is its mode.
1807            */
1808            struct stat fileStat;
1809            unsigned int creationMask = umask( DtFILE_DATA_CREATION_MASK );
1810
1811            memset( &fileStat, 0, sizeof( struct stat ) );
1812            fileStat.st_mode = creationMask | S_IFREG;
1813
1814            file_type = (char *) DtDtsDataToDataType( link_path, NULL, 0,
1815                                                      &fileStat,
1816                                                      NULL, NULL, NULL);
1817            umask( creationMask );
1818          }
1819       }
1820    }
1821    else
1822       file_type = XtNewString(LT_RECURSIVE_LINK);
1823
1824
1825    n = 0;
1826    string = NULL;
1827
1828    if (file_type)
1829    {
1830       if( call_struct->previous_file_type
1831           && strcmp( call_struct->previous_file_type, file_type ) == 0 )
1832       {
1833         char *tmpStr, *title, *msg;
1834
1835         if(Flag == False)
1836         {
1837           tmpStr = GETMESSAGE(10, 36, "Show Icon");
1838           title = XtNewString(tmpStr);
1839           tmpStr = GETMESSAGE(10, 41, "The correct icon for this datatype is already shown.");
1840           msg = XtNewString(tmpStr);
1841
1842           _DtMessage(XtParent(w), title, msg, NULL, HelpRequestCB);
1843           XtFree(title);
1844           XtFree(msg);
1845
1846           XtFree ((char *) file_type);
1847           XtFree ((char *) new_name);
1848           XtFree ((char *) orig_name);
1849         }
1850         return;
1851       }
1852
1853       call_struct->previous_file_type = file_type;
1854
1855       if (DtActionExists(file_type))
1856       {
1857          char *str = (char *)DtActionLabel(file_type);
1858          if(str != NULL)
1859              string = XmStringCreateLocalized(str);
1860          else
1861              string = XmStringCreateLocalized(file_type);
1862          XtFree(str);
1863       }
1864       else
1865       {
1866          char *str = (char *)DtDtsDataTypeToAttributeValue(file_type,
1867                                                            FM_TYPE_LABEL,
1868                                                            NULL);
1869          if (str)
1870          {
1871             string = XmStringCreateLocalized(str);
1872             DtDtsFreeAttributeValue(str);
1873          }
1874          else
1875          {
1876             string = XmStringCreateLocalized(file_type);
1877          }
1878       }
1879
1880       XtSetArg (args[n], XmNstring, string);            n++;
1881
1882       pixmapData = _DtRetrievePixmapData(file_type,
1883                                          call_struct->file_name,
1884                                          call_struct->directory_name,
1885                                          toplevel,
1886                                          LARGE);
1887       if (pixmapData)
1888         XtSetArg (args[n], XmNimageName, pixmapData->iconFileName);
1889       else
1890         XtSetArg (args[n], XmNimageName, NULL);                 n++;
1891       XtSetValues (call_struct->file_type_widget, args, n);
1892
1893       _DtCheckAndFreePixmapData(file_type,
1894                                 toplevel,
1895                                 (DtIconGadget) (call_struct->file_type_widget),
1896                                 pixmapData);
1897    }
1898    else
1899    {
1900       XtSetArg (args[n], XmNimageName, NULL);           n++;
1901       XtSetValues (call_struct->file_type_widget, args, n);
1902       if (call_struct->previous_file_type)
1903       {
1904         XtFree((char *)call_struct->previous_file_type );
1905         call_struct->previous_file_type = NULL;
1906       }
1907    }
1908
1909    if (string != NULL)
1910       XmStringFree (string);
1911
1912    XtFree ((char *) new_name);
1913    XtFree ((char *) orig_name);
1914 }
1915
1916
1917 /************************************************************************
1918  *
1919  *  MakeFileDialog
1920  *      Callback function invoked from the File Manager menu.  This
1921  *      function creates and displays a dialog prompting for a file name
1922  *      to be used to create a directory, executable, or normal file.
1923  *
1924  ************************************************************************/
1925
1926 void
1927 ShowMakeFileDialog(
1928         Widget w,
1929         XtPointer client_data,
1930         XtPointer call_data )
1931 {
1932    FileMgrRec * file_mgr_rec;
1933    DialogData * dialog_data;
1934    FileMgrData * file_mgr_data;
1935
1936    Widget shell = NULL;
1937    Widget form;
1938    Widget new_name;
1939    Widget new_text;
1940    Widget file_type_box;
1941    Widget file_type;
1942    Widget separator;
1943    Widget ok;
1944    Widget apply;
1945    Widget cancel;
1946    Widget preview;
1947    Widget help;
1948    int flag=FLAG_RESET;
1949
1950    DialogCallbackStruct * call_struct;
1951    char * tmpStr = NULL, *tempStr = NULL;
1952    XmString label_string = NULL;
1953
1954    Arg args[20];
1955    int n;
1956    Widget mbar = XmGetPostedFromWidget(XtParent(w));
1957    Atom delete_window_atom;
1958
1959
1960
1961    /*  Set the menu item to insensitive to prevent multiple  */
1962    /*  dialogs from being posted and get the area under the  */
1963    /*  menu pane redrawn.                                    */
1964
1965    XmUpdateDisplay (w);
1966
1967    XtSetArg(args[0], XmNuserData, &file_mgr_rec);
1968    XtGetValues(mbar, args, 1);
1969
1970    dialog_data = _DtGetInstanceData ((XtPointer)file_mgr_rec);
1971    file_mgr_data = (FileMgrData *) dialog_data->data;
1972
1973
1974    n = 0;
1975    XtSetArg (args[n], XmNallowShellResize, True);  n++;
1976    /*  Adjust the decorations for the dialog shell of the dialog  */
1977    XtSetArg (args[n], XmNmwmFunctions, MWM_FUNC_MOVE | MWM_FUNC_CLOSE);         ++n;
1978    XtSetArg (args[n], XmNmwmDecorations, MWM_DECOR_BORDER | MWM_DECOR_TITLE);   ++n;
1979
1980    if (w == *create_directoryBtn)
1981    {
1982       /* Ignore accelerators when we're insensitive */
1983       if (file_mgr_rec->create_directoryBtn_child)
1984       {
1985          XSetInputFocus(XtDisplay(w),
1986                         XtWindow(file_mgr_rec->create_directoryBtn_child),
1987                         RevertToParent, CurrentTime);
1988          return;
1989       }
1990
1991       file_mgr_rec->menuStates &= ~CREATE_DIR;
1992
1993       if(file_mgr_data->title != NULL &&
1994                strcmp(file_mgr_data->helpVol, DTFILE_HELP_NAME) != 0)
1995       {
1996          tmpStr = GETMESSAGE(10, 14, "New Folder");
1997          tempStr = (char *)XtMalloc(strlen(tmpStr) +
1998                                  strlen(file_mgr_data->title) + 5);
1999          sprintf(tempStr, "%s - %s", file_mgr_data->title, tmpStr);
2000       }
2001       else
2002       {
2003          tmpStr = (GETMESSAGE(10,28, "File Manager - New Folder"));
2004          tempStr = XtNewString(tmpStr);
2005       }
2006
2007       XtSetArg (args[n], XmNtitle, tempStr);      n++;
2008       shell =XmCreateDialogShell(file_mgr_rec->shell, "new_folder", args, n);
2009       label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 16, "New Folder Name: ")));
2010    }
2011    else if (w == *create_dataBtn)
2012    {
2013       /* Ignore accelerators when we're insensitive */
2014       if ( file_mgr_rec->create_dataBtn_child )
2015       {
2016          XSetInputFocus(XtDisplay(w),
2017                         XtWindow(file_mgr_rec->create_dataBtn_child),
2018                         RevertToParent, CurrentTime);
2019          return;
2020       }
2021
2022       file_mgr_rec->menuStates &= ~CREATE_FILE;
2023
2024       if(file_mgr_data->title != NULL &&
2025                strcmp(file_mgr_data->helpVol, DTFILE_HELP_NAME) != 0)
2026       {
2027          tmpStr = (GETMESSAGE(10,26, "New File"));
2028          tempStr = (char *)XtMalloc(strlen(tmpStr) +
2029                                  strlen(file_mgr_data->title) + 5);
2030          sprintf(tempStr, "%s - %s", file_mgr_data->title, tmpStr);
2031       }
2032       else
2033       {
2034          tmpStr = (GETMESSAGE(10,29, "File Manager - New File"));
2035          tempStr = XtNewString(tmpStr);
2036       }
2037       XtSetArg (args[n], XmNtitle, tempStr);      n++;
2038       shell =XmCreateDialogShell(file_mgr_rec->shell, "new_data_file", args, n);
2039       label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 7, "New File Name: ")));
2040    }
2041    XtFree(tempStr);
2042
2043    if (!shell)
2044    {
2045        /* shouldn't happen, but... */
2046        if (label_string)
2047            XmStringFree(label_string);
2048        return;
2049    }
2050
2051    /* Set the useAsyncGeo on the shell */
2052    XtSetArg (args[0], XmNuseAsyncGeometry, True);
2053    XtSetValues (XtParent(shell), args, 1);
2054
2055    /*  Create the widget hierarchy for the dialog  */
2056
2057    n = 0;
2058    XtSetArg (args[n], XmNmarginWidth, 1);               n++;
2059    XtSetArg (args[n], XmNmarginHeight, 1);              n++;
2060    XtSetArg (args[n], XmNshadowThickness, 1);           n++;
2061    XtSetArg (args[n], XmNshadowType, XmSHADOW_OUT);     n++;
2062    XtSetArg (args[n], XmNautoUnmanage, False);          n++;
2063    XtSetArg (args[n], XmNuserData, file_mgr_rec);       n++;
2064    form = XmCreateForm (shell, "form", args, n);
2065
2066
2067    n = 0;
2068    XtSetArg (args[n], XmNlabelString, label_string);            n++;
2069    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
2070    XtSetArg (args[n], XmNleftPosition, 15);                     n++;
2071 /*
2072    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
2073    XtSetArg (args[n], XmNleftOffset, 5);                        n++;
2074 */
2075    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
2076    XtSetArg (args[n], XmNtopOffset, 30);                        n++;
2077    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
2078    new_name = XmCreateLabelGadget (form, "new_name", args, n);
2079    XtManageChild (new_name);
2080
2081    XmStringFree (label_string);
2082
2083
2084    n = 0;
2085    XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);      n++;
2086    XtSetArg (args[n], XmNleftWidget, new_name);                 n++;
2087    XtSetArg (args[n], XmNleftOffset, 0);                        n++;
2088    XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);         n++;
2089    XtSetArg (args[n], XmNtopOffset, 30);                        n++;
2090    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
2091    XtSetArg (args[n], XmNrightPosition, 70);                    n++;
2092    XtSetArg (args[n], XmNtraversalOn, True);                    n++;
2093    new_text = XmCreateTextField (form, "new_text", args, n);
2094
2095    XtManageChild (new_text);
2096
2097    /* Create the field displaying the file type info */
2098
2099    n = 0;
2100    XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM);          n++;
2101    XtSetArg(args[n], XmNtopOffset, 5);                          n++;
2102 /*
2103    XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET);       n++;
2104    XtSetArg(args[n], XmNleftWidget, new_text);                  n++;
2105    XtSetArg(args[n], XmNleftOffset, 20);                        n++;
2106 */
2107    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
2108    XtSetArg (args[n], XmNleftPosition, 75);                     n++;
2109 /*
2110    XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM);        n++;
2111    XtSetArg(args[n], XmNrightOffset, 5);                        n++;
2112 */
2113    XtSetArg(args[n], XmNmarginHeight, 5);                       n++;
2114    XtSetArg(args[n], XmNmarginWidth, 5);                        n++;
2115    file_type_box = XmCreateFrame (form, "file_type_box", args, n);
2116    XtManageChild (file_type_box);
2117
2118    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 8, "File Type")));
2119
2120    n = 0;
2121    XtSetArg (args[n], XmNlabelString, label_string);            n++;
2122    XtSetArg(args[n], XmNshadowThickness, 0);                    n++;
2123    XtSetArg(args[n], XmNshadowType, XmSHADOW_ETCHED_OUT);       n++;
2124    XtSetArg(args[n], XmNpixmapPosition, XmPIXMAP_TOP);          n++;
2125    XtSetArg (args[n], XmNtraversalOn, False);                   n++;
2126    file_type = _DtCreateIcon (file_type_box, "file_type", args, n);
2127    XtManageChild (file_type);
2128
2129    XmStringFree (label_string);
2130
2131
2132    /* Adjust the colors of the icon */
2133    SetToNormalColors (file_type, form, file_mgr_rec->main, 0);
2134
2135    /*  The data sent to the Text, Ok and Cancel callbacks  */
2136
2137    call_struct =
2138       (DialogCallbackStruct *) XtMalloc (sizeof (DialogCallbackStruct));
2139
2140    if(w == *create_directoryBtn)
2141    {
2142      file_mgr_rec->create_directoryBtn_child = form;
2143      call_struct->original_physical_type = DtDIRECTORY;
2144    }
2145    if(w == *create_dataBtn)
2146    {
2147      file_mgr_rec->create_dataBtn_child = form;
2148      call_struct->original_physical_type = DtDATA;
2149    }
2150
2151    call_struct->dialog_widget = form;
2152    call_struct->menu_widget = w;
2153    call_struct->dir_text_widget = NULL;
2154    call_struct->file_text_widget = new_text;
2155    call_struct->file_type_widget = file_type;
2156    call_struct->file_mgr_rec = file_mgr_rec;
2157    call_struct->host_name = XtNewString (file_mgr_data->host);
2158    call_struct->directory_name =  XtNewString(file_mgr_data->current_directory);
2159    call_struct->file_name = NULL;
2160    call_struct->original_logical_type = NULL;
2161    call_struct->previous_file_type = NULL;
2162    call_struct->file_mgr_data = file_mgr_data;
2163
2164
2165    /*  Create a separator between the buttons  */
2166
2167    n = 0;
2168    XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);        n++;
2169    XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);       n++;
2170    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
2171    XtSetArg (args[n], XmNtopWidget, file_type_box);             n++;
2172    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
2173    separator =  XmCreateSeparatorGadget (form, "separator", args, n);
2174    XtManageChild (separator);
2175
2176
2177
2178    /*  Create the ok, apply, cancel, and help buttons  */
2179
2180    n = 0;
2181    XtSetArg (args[n], XmNlabelString, okXmString);              n++;
2182    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
2183    XtSetArg (args[n], XmNleftPosition, 1);                      n++;
2184    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
2185    XtSetArg (args[n], XmNrightPosition, 19);                    n++;
2186    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
2187    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
2188    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
2189    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
2190    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
2191    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
2192    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
2193    XtSetArg (args[n], XmNshowAsDefault, True);                  n++;
2194    XtSetArg (args[n], XmNuserData, flag);                        n++;
2195    ok = XmCreatePushButtonGadget (form, "ok", args, n);
2196    XtManageChild (ok);
2197
2198    XtAddCallback (ok, XmNactivateCallback, MakeFileOk, (XtPointer) call_struct);
2199
2200    /*  Set the ok button to the default for the bulletin board.  */
2201    /*  This causes the return key from the text widget to be     */
2202    /*  properly processed.                                       */
2203
2204    XtSetArg (args[0], XmNdefaultButton, ok);
2205    XtSetValues (form, args, 1);
2206
2207    n = 0;
2208    XtSetArg (args[n], XmNlabelString, applyXmString);           n++;
2209    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
2210    XtSetArg (args[n], XmNleftPosition, 20);                      n++;
2211    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
2212    XtSetArg (args[n], XmNrightPosition, 39);                    n++;
2213    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
2214    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
2215    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
2216    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
2217    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
2218    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
2219    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
2220    apply = XmCreatePushButtonGadget (form, "apply", args, n);
2221    XtManageChild (apply);
2222
2223    XtAddCallback (apply, XmNactivateCallback, MakeFileApply, (XtPointer) call_struct);
2224
2225    n = 0;
2226    XtSetArg (args[n], XmNlabelString, cancelXmString);          n++;
2227    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
2228    XtSetArg (args[n], XmNleftPosition, 40);                     n++;
2229    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
2230    XtSetArg (args[n], XmNrightPosition, 59);                    n++;
2231    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
2232    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
2233    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
2234    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
2235    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
2236    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
2237    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
2238    XtSetArg (args[n], XmNuserData, flag);                       n++;
2239    cancel = XmCreatePushButtonGadget (form, "cancel", args, n);
2240    XtManageChild (cancel);
2241
2242    XtAddCallback (cancel, XmNactivateCallback, DialogCancel,
2243                   (XtPointer) call_struct);
2244
2245
2246    label_string = XmStringCreateLocalized (((char *)GETMESSAGE(10, 36, "Show Icon")));
2247
2248    n = 0;
2249    XtSetArg (args[n], XmNlabelString, label_string);            n++;
2250    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
2251    XtSetArg (args[n], XmNleftPosition, 60);                     n++;
2252    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
2253    XtSetArg (args[n], XmNrightPosition, 79);                    n++;
2254    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
2255    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
2256    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
2257    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
2258    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
2259    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
2260    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
2261    preview = XmCreatePushButtonGadget (form, "show_file_type", args, n);
2262    XtManageChild (preview);
2263
2264    XmStringFree (label_string);
2265    XtAddCallback (preview, XmNactivateCallback, FileTypePreviewCB,
2266                   (XtPointer) call_struct);
2267
2268    FileTypePreviewCB (preview, (XtPointer) call_struct, NULL);
2269
2270    n = 0;
2271    XtSetArg (args[n], XmNlabelString, helpXmString);            n++;
2272    XtSetArg (args[n], XmNleftAttachment, XmATTACH_POSITION);    n++;
2273    XtSetArg (args[n], XmNleftPosition, 80);                     n++;
2274    XtSetArg (args[n], XmNrightAttachment, XmATTACH_POSITION);   n++;
2275    XtSetArg (args[n], XmNrightPosition, 99);                    n++;
2276    XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);       n++;
2277    XtSetArg (args[n], XmNtopWidget, separator);                 n++;
2278    XtSetArg (args[n], XmNtopOffset, 5);                         n++;
2279    XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);      n++;
2280    XtSetArg (args[n], XmNbottomOffset, 5);                      n++;
2281    XtSetArg (args[n], XmNmarginWidth, 4);                       n++;
2282    XtSetArg (args[n], XmNmarginHeight, 4);                      n++;
2283    help = XmCreatePushButtonGadget (form, "help", args, n);
2284    XtManageChild (help);
2285
2286    if (w == *create_directoryBtn)
2287    {
2288       XtAddCallback(form, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2289                     HELP_CREATE_DIR_DIALOG_STR);
2290       XtAddCallback(new_name, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2291                     HELP_CREATE_DIR_DIALOG_STR);
2292       XtAddCallback(new_text, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2293                     HELP_CREATE_DIR_DIALOG_STR);
2294       XtAddCallback(help, XmNactivateCallback, (XtCallbackProc)HelpRequestCB,
2295                     HELP_CREATE_DIR_DIALOG_STR);
2296       XtAddCallback(file_type_box,XmNhelpCallback,(XtCallbackProc)HelpRequestCB,
2297                     HELP_CREATE_DIR_DIALOG_STR);
2298       XtAddCallback(file_type, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2299                     HELP_CREATE_DIR_DIALOG_STR);
2300       XtAddCallback(ok, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2301                     HELP_CREATE_DIR_DIALOG_STR);
2302       XtAddCallback(apply, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2303                     HELP_CREATE_DIR_DIALOG_STR);
2304       XtAddCallback(cancel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2305                     HELP_CREATE_DIR_DIALOG_STR);
2306       XtAddCallback(preview, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2307                     HELP_CREATE_DIR_DIALOG_STR);
2308       XtAddCallback(help, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2309                     HELP_CREATE_DIR_DIALOG_STR);
2310    }
2311    else
2312    {
2313       XtAddCallback(form, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2314                     HELP_CREATE_FILE_DIALOG_STR);
2315       XtAddCallback(new_name, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2316                     HELP_CREATE_FILE_DIALOG_STR);
2317       XtAddCallback(new_text, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2318                     HELP_CREATE_FILE_DIALOG_STR);
2319       XtAddCallback(help, XmNactivateCallback, (XtCallbackProc)HelpRequestCB,
2320                     HELP_CREATE_FILE_DIALOG_STR);
2321       XtAddCallback(file_type_box,XmNhelpCallback,(XtCallbackProc)HelpRequestCB,
2322                     HELP_CREATE_FILE_DIALOG_STR);
2323       XtAddCallback(file_type, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2324                     HELP_CREATE_FILE_DIALOG_STR);
2325       XtAddCallback(ok, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2326                     HELP_CREATE_FILE_DIALOG_STR);
2327       XtAddCallback(apply, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2328                     HELP_CREATE_FILE_DIALOG_STR);
2329       XtAddCallback(cancel, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2330                     HELP_CREATE_FILE_DIALOG_STR);
2331       XtAddCallback(preview, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2332                     HELP_CREATE_FILE_DIALOG_STR);
2333       XtAddCallback(help, XmNhelpCallback, (XtCallbackProc)HelpRequestCB,
2334                     HELP_CREATE_FILE_DIALOG_STR);
2335    }
2336
2337
2338    XtSetArg (args[0], XmNcancelButton, cancel);
2339    XtSetValues (form, args, 1);
2340
2341    XtAddCallback (shell, XmNpopupCallback, (XtCallbackProc)_DtmapCB,
2342                   (XtPointer) XtParent(shell));
2343
2344    delete_window_atom = XmInternAtom (XtDisplay(shell), "WM_DELETE_WINDOW", True);
2345    XmRemoveWMProtocols( shell, &delete_window_atom, 1 );
2346    XmAddWMProtocolCallback( shell, delete_window_atom, DialogCancel,
2347                             (XtPointer) call_struct );
2348
2349    call_struct->Ok     = ok;
2350    call_struct->Cancel = cancel;
2351
2352    XtManageChild (form);
2353
2354    /* Force the focus to the text field */
2355    XmProcessTraversal(new_text, XmTRAVERSE_CURRENT);
2356
2357 }
2358
2359
2360 /************************************************************************
2361  *
2362  *  MakeFileOk
2363  *      Get the new file name and create the file.
2364  *
2365  ************************************************************************/
2366
2367 static void
2368 MakeFileOk(
2369         Widget w,
2370         XtPointer client_data,
2371         XtPointer call_data )
2372 {
2373    DialogCallbackStruct * call_struct = (DialogCallbackStruct *) client_data;
2374    char * new_name;
2375    unsigned char type;
2376    char * title;
2377    char * msg;
2378    int length;
2379    int dirNameLength = strlen (call_struct->directory_name);
2380    int maxFileNameLength = pathconf (call_struct->directory_name, _PC_NAME_MAX);
2381    unsigned int btnMask;
2382    MakeFileDoneData *data;
2383
2384    if(RecheckFlag(call_struct->dialog_widget,w))
2385      return;
2386    else if(RecheckFlag(NULL,call_struct->Cancel))
2387      return;
2388
2389    /* see if this is a create file or directory */
2390    if (call_struct->menu_widget == *create_directoryBtn)
2391    {
2392       call_struct->file_mgr_rec->create_directoryBtn_child = NULL;
2393       type = DtDIRECTORY;
2394       btnMask = CREATE_DIR;
2395    }
2396    else
2397    {
2398       call_struct->file_mgr_rec->create_dataBtn_child = NULL;
2399       type = DtDATA;
2400       btnMask = CREATE_FILE;
2401    }
2402
2403    /* get the new name */
2404    new_name = XmTextFieldGetString (call_struct->file_text_widget);
2405    new_name = (char *) _DtStripSpaces (new_name);
2406
2407
2408    if (new_name[0] == '~')
2409       new_name = _DtChangeTildeToHome (new_name);
2410
2411    length = strlen (new_name);
2412    msg = NULL;
2413    if (length == 0)
2414    {
2415       msg = XtNewString(GETMESSAGE(10, 22,
2416                       "Cannot create a file or folder with a blank name."));
2417    }
2418    /* Ensure the new name has length less than or equal to the maximum
2419       length that the system allows.
2420       If maxFileNameLength == -1 the file system is not supporting POSIX, use MAXNAMLEN
2421    */
2422    else if( maxFileNameLength < -1  || ( maxFileNameLength == -1 && ( length > MAXNAMLEN  || length + dirNameLength > MAX_PATH ) ) || ( maxFileNameLength > 0 && length > maxFileNameLength ) )
2423    {
2424      if (type == DtDIRECTORY)
2425      {
2426        title = XtNewString(GETMESSAGE(10, 20, "Create Folder Error"));
2427        msg = XtNewString(GETMESSAGE(10, 23, "Invalid folder name."));
2428      }
2429      else
2430      {
2431        title = XtNewString(GETMESSAGE(10, 21, "Create File Error"));
2432        msg = XtNewString(GETMESSAGE(10, 24, "Invalid file name."));
2433      }
2434    }
2435 #ifdef _CHECK_FOR_SPACES
2436    else if (DtStrchr (new_name, ' ') != NULL ||
2437             DtStrchr (new_name, '\t') != NULL)
2438    {
2439       msg = XtNewString(GetSharedMessage(NO_SPACES_ALLOWED_ERROR));
2440    }
2441 #endif
2442
2443    if (msg != NULL)
2444    {
2445       if (type == DtDIRECTORY)
2446          title = XtNewString(GETMESSAGE(10, 20, "Create Folder Error"));
2447       else
2448          title = XtNewString(GETMESSAGE(10, 21, "Create File Error"));
2449       _DtMessage (XtParent (w), title, msg, NULL, HelpRequestCB);
2450       XtFree(title);
2451       XtFree(msg);
2452       XtFree(new_name);
2453       ResetFlag(call_struct->dialog_widget,w);
2454       ResetFlag(call_struct->dialog_widget,call_struct->Cancel);
2455       return;
2456    }
2457
2458    /* set up data for MakeFileDone callback */
2459    data = (MakeFileDoneData *)XtMalloc(sizeof(MakeFileDoneData));
2460    data->w = w;
2461    data->call_struct = call_struct;
2462    data->type = type;
2463    data->btnMask = btnMask;
2464    data->new_name = new_name;
2465
2466    /*
2467     * Create the file/directory.
2468     * This operation is performed in a background process; when the
2469     * background process finishes, the MakeFileDone callback will be
2470     * called with a return code indicating success or failure.
2471     */
2472
2473    MakeFile (w, call_struct->host_name, call_struct->directory_name,
2474              new_name, type, MakeFileDone, (XtPointer)data);
2475 }
2476
2477
2478 /************************************************************************
2479  *
2480  *  MakeFileDone
2481  *      This routine is called when the file creation is finished.
2482  *
2483  ************************************************************************/
2484
2485 static void
2486 MakeFileDone(
2487         XtPointer client_data,
2488         char *to,
2489         int rc)
2490 {
2491    MakeFileDoneData *data = (MakeFileDoneData *)client_data;
2492    DialogCallbackStruct *call_struct = data->call_struct;
2493    FileMgrRec *file_mgr_rec = (FileMgrRec *) call_struct->file_mgr_rec;
2494
2495    char *title;
2496    char *msg;
2497    FileViewData *file_view_data;
2498    FileMgrData *file_mgr_data;
2499    DialogData *dialog_data;
2500    DirectorySet *directory_set;
2501    int i;
2502
2503    /*
2504     * If the file/directory create was successful, unmanage the dialog
2505     * and free up any allocated data space.  Otherwise, just return
2506     * to allow the user to try a different name or cancel the dialog.
2507     */
2508
2509    if (rc == EINVAL)
2510    {
2511       /* invalid name */
2512       if (data->type == DtDIRECTORY)
2513       {
2514          title = XtNewString(GETMESSAGE(10, 20, "Create Folder Error"));
2515          msg = XtNewString(GETMESSAGE(10, 23, "Invalid folder name."));
2516       }
2517       else
2518       {
2519          title = XtNewString(GETMESSAGE(10, 21, "Create File Error"));
2520          msg = XtNewString(GETMESSAGE(10, 24, "Invalid file name."));
2521       }
2522       _DtMessage (XtParent(data->w), title, msg, NULL, HelpRequestCB);
2523       ResetFlag(call_struct->dialog_widget,call_struct->Ok);
2524       ResetFlag(call_struct->dialog_widget,call_struct->Cancel);
2525       XtFree(title);
2526       XtFree(msg);
2527    }
2528    else if (rc != 0)
2529    {
2530       /* some other error */
2531       if (rc == EEXIST)
2532          msg = XtNewString(GetSharedMessage(CANT_OVERWRITE_ERROR));
2533       else
2534          msg = XtNewString(GetSharedMessage(CANT_CREATE_ERROR));
2535       FileOperationError (XtParent(data->w), msg, to);
2536       ResetFlag(call_struct->dialog_widget,call_struct->Ok);
2537       ResetFlag(call_struct->dialog_widget,call_struct->Cancel);
2538       XtFree(msg);
2539    }
2540    else
2541    {
2542       /* create was successful: close the dialog */
2543       XtUnmanageChild (call_struct->dialog_widget);
2544       XtDestroyWidget (XtParent (call_struct->dialog_widget));
2545       file_mgr_rec->menuStates |= data->btnMask;
2546    }
2547
2548    if (rc == 0)
2549    {
2550       /* free the call data */
2551       XtFree(call_struct->host_name);
2552       XtFree(call_struct->directory_name);
2553       if (call_struct->previous_file_type)
2554         XtFree((char *) call_struct->previous_file_type);
2555       XtFree((char *) call_struct);
2556
2557 #ifdef FOO
2558       /* @@@
2559        * The code below wants to make the file that was just created
2560        * be selected and scroll the view so the new file is visible.
2561        * But: since we made directory updates asynchronous, this code
2562        * won't work anymore, because at this point, we won't yet be able
2563        * to find the new file in the cached directory.
2564        *
2565        * Possible solutions:
2566        * Somewhere (e.g., in the file_mgr_data structure) log our
2567        * intention to select the new file; when it finally shows up,
2568        * select it them.
2569        */
2570       dialog_data = _DtGetInstanceData (file_mgr_rec);
2571       file_mgr_data = (FileMgrData *) dialog_data->data;
2572       for (i = 0; i < file_mgr_data->directory_count; i++)
2573       {
2574          directory_set = (DirectorySet *)file_mgr_data->directory_set[i];
2575          if (strcmp(directory_set->name, call_struct->directory_name) == 0)
2576             break;
2577       }
2578
2579       file_view_data = NULL;
2580       for (i = 0; i < directory_set->file_count; i++)
2581       {
2582          if (strcmp(directory_set->order_list[i]->file_data->file_name,
2583                                                           data->new_name) == 0)
2584          {
2585             file_view_data = directory_set->order_list[i];
2586             break;
2587          }
2588       }
2589
2590       if (file_view_data != NULL)
2591       {
2592          if (file_view_data->widget != NULL)
2593          {
2594             DeselectAllFiles(file_mgr_data);
2595             SelectFile (file_mgr_data, file_view_data);
2596             PositionFileView(file_view_data, file_mgr_data);
2597             ActivateSingleSelect ((FileMgrRec *) file_mgr_data->file_mgr_rec,
2598                     file_mgr_data->selection_list[0]->file_data->logical_type);
2599          }
2600       }
2601 #endif /* FOO */
2602    }
2603
2604    XtFree(data->new_name);
2605    XtFree((char *)data);
2606 }
2607
2608
2609
2610 /************************************************************************
2611  *
2612  *  MakeFileApply
2613  *      Get the new file name and create the file.
2614  *
2615  ************************************************************************/
2616
2617 static void
2618 MakeFileApply(
2619         Widget w,
2620         XtPointer client_data,
2621         XtPointer call_data )
2622 {
2623    DialogCallbackStruct * call_struct = (DialogCallbackStruct *) client_data;
2624    char * new_name;
2625    unsigned char type;
2626    char * title;
2627    char * msg;
2628    int length;
2629    int dirNameLength = strlen (call_struct->directory_name);
2630    int maxFileNameLength = pathconf (call_struct->directory_name, _PC_NAME_MAX);
2631    unsigned int btnMask;
2632    MakeFileDoneData *data;
2633
2634    /* see if this is a create file or directory */
2635    if (call_struct->menu_widget == *create_directoryBtn)
2636    {
2637       call_struct->file_mgr_rec->create_directoryBtn_child = NULL;
2638       type = DtDIRECTORY;
2639       btnMask = CREATE_DIR;
2640    }
2641    else
2642    {
2643       call_struct->file_mgr_rec->create_dataBtn_child = NULL;
2644       type = DtDATA;
2645       btnMask = CREATE_FILE;
2646    }
2647
2648    /* get the new name */
2649    new_name = XmTextFieldGetString (call_struct->file_text_widget);
2650    new_name = (char *) _DtStripSpaces (new_name);
2651
2652
2653    if (new_name[0] == '~')
2654       new_name = _DtChangeTildeToHome (new_name);
2655
2656    length = strlen (new_name);
2657    msg = NULL;
2658    if (length == 0)
2659    {
2660       msg = XtNewString(GETMESSAGE(10, 22,
2661                       "Cannot create a file or folder with a blank name."));
2662    }
2663    /* Ensure the new name has length less than or equal to the maximum
2664       length that the system allows.
2665       If maxFileNameLength == -1 the file system is not supporting POSIX, use MAXNAMLEN
2666    */
2667    else if( maxFileNameLength < -1  || ( maxFileNameLength == -1 && ( length > MAXNAMLEN  || length + dirNameLength > MAX_PATH ) ) || ( maxFileNameLength > 0 && length > maxFileNameLength ) )
2668    {
2669      if (type == DtDIRECTORY)
2670      {
2671        title = XtNewString(GETMESSAGE(10, 20, "Create Folder Error"));
2672        msg = XtNewString(GETMESSAGE(10, 23, "Invalid folder name."));
2673      }
2674      else
2675      {
2676        title = XtNewString(GETMESSAGE(10, 21, "Create File Error"));
2677        msg = XtNewString(GETMESSAGE(10, 24, "Invalid file name."));
2678      }
2679    }
2680 #ifdef _CHECK_FOR_SPACES
2681    else if (DtStrchr (new_name, ' ') != NULL ||
2682             DtStrchr (new_name, '\t') != NULL)
2683    {
2684       msg = XtNewString(GetSharedMessage(NO_SPACES_ALLOWED_ERROR));
2685    }
2686 #endif
2687
2688    if (msg != NULL)
2689    {
2690       if (type == DtDIRECTORY)
2691          title = XtNewString(GETMESSAGE(10, 20, "Create Folder Error"));
2692       else
2693          title = XtNewString(GETMESSAGE(10, 21, "Create File Error"));
2694       _DtMessage (XtParent (w), title, msg, NULL, HelpRequestCB);
2695       XtFree(title);
2696       XtFree(msg);
2697       XtFree(new_name);
2698       return;
2699    }
2700
2701    /* set up data for MakeFileDone callback */
2702    data = (MakeFileDoneData *)XtMalloc(sizeof(MakeFileDoneData));
2703    data->w = w;
2704    data->call_struct = call_struct;
2705    data->type = type;
2706    data->btnMask = btnMask;
2707    data->new_name = new_name;
2708
2709    /*
2710     * Create the file/directory.
2711     * This operation is performed in a background process; when the
2712     * background process finishes, the MakeFileDone callback will be
2713     * called with a return code indicating success or failure.
2714     */
2715
2716    MakeFile (w, call_struct->host_name, call_struct->directory_name,
2717              new_name, type, ApplyFileDone, (XtPointer)data);
2718    FileTypePreviewCB (w, client_data, (XtPointer) True);
2719 }
2720
2721
2722 /************************************************************************
2723  *
2724  *  MakeFileDone
2725  *      This routine is called when the file creation is finished.
2726  *
2727  ************************************************************************/
2728
2729 static void
2730 ApplyFileDone(
2731         XtPointer client_data,
2732         char *to,
2733         int rc)
2734 {
2735    MakeFileDoneData *data = (MakeFileDoneData *)client_data;
2736    DialogCallbackStruct *call_struct = data->call_struct;
2737    FileMgrRec *file_mgr_rec = (FileMgrRec *) call_struct->file_mgr_rec;
2738
2739    char *title;
2740    char *msg;
2741    FileViewData *file_view_data;
2742    FileMgrData *file_mgr_data;
2743    DialogData *dialog_data;
2744    DirectorySet *directory_set;
2745    int i;
2746
2747    /*
2748     * If the file/directory create was successful, unmanage the dialog
2749     * and free up any allocated data space.  Otherwise, just return
2750     * to allow the user to try a different name or cancel the dialog.
2751     */
2752
2753    if (rc == EINVAL)
2754    {
2755       /* invalid name */
2756       if (data->type == DtDIRECTORY)
2757       {
2758          title = XtNewString(GETMESSAGE(10, 20, "Create Folder Error"));
2759          msg = XtNewString(GETMESSAGE(10, 23, "Invalid folder name."));
2760       }
2761       else
2762       {
2763          title = XtNewString(GETMESSAGE(10, 21, "Create File Error"));
2764          msg = XtNewString(GETMESSAGE(10, 24, "Invalid file name."));
2765       }
2766       _DtMessage (XtParent(data->w), title, msg, NULL, HelpRequestCB);
2767       XtFree(title);
2768       XtFree(msg);
2769    }
2770    else if (rc != 0)
2771    {
2772       /* some other error */
2773       if (rc == EEXIST)
2774          msg = XtNewString(GetSharedMessage(CANT_OVERWRITE_ERROR));
2775       else
2776          msg = XtNewString(GetSharedMessage(CANT_CREATE_ERROR));
2777       FileOperationError (XtParent(data->w), msg, to);
2778       XtFree(msg);
2779    }
2780 }
2781
2782
2783
2784 /************************************************************************
2785  *
2786  *  DialogCancel
2787  *      Unmanage and destroy the dialog
2788  *
2789  ************************************************************************/
2790
2791 static void
2792 DialogCancel(
2793         Widget w,
2794         XtPointer client_data,
2795         XtPointer call_data )
2796 {
2797    DialogCallbackStruct * call_struct = (DialogCallbackStruct *) client_data;
2798    DialogData *dialog_data;
2799    FileMgrData *file_mgr_data;
2800    unsigned int btnMask = 0;
2801
2802    if(RecheckFlag(NULL,w))
2803      return;
2804
2805    dialog_data = _DtGetInstanceData ((XtPointer)call_struct->file_mgr_rec);
2806    file_mgr_data = (FileMgrData *) dialog_data->data;
2807
2808    XtUnmanageChild (call_struct->dialog_widget);
2809    XtDestroyWidget (XtParent (call_struct->dialog_widget));
2810
2811    if (file_mgr_data->selected_file_count == 1 )
2812    {
2813      /* If the selection count is 1 then
2814         resensitize the appropriate menu button.
2815         Otherwise, ignore it.
2816      */
2817      if (call_struct->menu_widget == *renameBtn)
2818        btnMask = RENAME;
2819      else if (call_struct->menu_widget == *moveBtn)
2820        btnMask = MOVE;
2821      else if (call_struct->menu_widget == *duplicateBtn)
2822        btnMask = DUPLICATE;
2823      else if (call_struct->menu_widget == *linkBtn)
2824        btnMask = LINK;
2825    }
2826
2827    if (call_struct->menu_widget == *create_directoryBtn)
2828    {
2829      btnMask = CREATE_DIR;
2830      call_struct->file_mgr_rec->create_directoryBtn_child = NULL;
2831    }
2832    else if (call_struct->menu_widget == *create_dataBtn)
2833    {
2834      btnMask = CREATE_FILE;
2835      call_struct->file_mgr_rec->create_dataBtn_child = NULL;
2836    }
2837
2838    call_struct->file_mgr_rec->menuStates |= btnMask;
2839
2840    /* Clean up
2841    */
2842    if (call_struct->host_name != NULL)
2843       XtFree ((char *) call_struct->host_name);
2844
2845    if (call_struct->directory_name != NULL)
2846       XtFree ((char *) call_struct->directory_name);
2847
2848    if (call_struct->file_name != NULL)
2849       XtFree ((char *) call_struct->file_name);
2850
2851    if (call_struct->previous_file_type)
2852       XtFree ((char *) call_struct->previous_file_type);
2853
2854    XtFree ((char *) call_struct);
2855 }
2856
2857 int
2858 RecheckFlag(
2859   Widget parent,
2860   Widget w)
2861 {
2862    Arg args[2];
2863    XtArgVal flag;
2864
2865    XtSetArg (args[0], XmNuserData, &flag);
2866    XtGetValues(w,args,1);
2867    if(flag == FLAG_SET)
2868       return True;
2869    else if(flag != FLAG_RESET)
2870       return False;
2871    flag = FLAG_SET;
2872    XtSetArg (args[0], XmNuserData, flag);
2873    XtSetValues(w,args,1);
2874    if(parent != NULL)
2875     _DtTurnOnHourGlass(parent);
2876    return False;
2877 }
2878
2879 void
2880 ResetFlag(
2881    Widget parent,
2882    Widget w)
2883 {
2884    Arg args[2];
2885    XtArgVal flag0;
2886    int flag;
2887    XtSetArg (args[0], XmNuserData, &flag0);
2888    XtGetValues(w,args,1);
2889    flag = (int)flag0;
2890    if(flag != FLAG_SET)
2891       return;
2892    flag = FLAG_RESET;
2893    XtSetArg (args[0], XmNuserData, flag);
2894    XtSetValues(w,args,1);
2895    if(parent != NULL)
2896     _DtTurnOffHourGlass(parent);
2897 }