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