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