workbench/c/RequestFile.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     RequestFile CLI command.
   6 */
   7
   8 /*****************************************************************************
   9
  10     NAME
  11
  12         RequestFile
  13
  14     SYNOPSIS
  15
  16         DRAWER,FILE/K,PATTERN/K,TITLE/K,POSITIVE/K,NEGATIVE/K,
  17         ACCEPTPATTERN/K,REJECTPATTERN/K,SAVEMODE/S,MULTISELECT/S,
  18         DRAWERSONLY/S,NOICONS/S,PUBSCREEN/K,INITIALVOLUMES/S
  19
  20     LOCATION
  21
  22         C:
  23
  24     FUNCTION
  25
  26         Creates file requester. The selected files will be displayed separated
  27         by spaces. If no file is selected the return code is 5 (warn).
  28
  29     INPUTS
  30         DRAWER          -- initial content of drawer field
  31         FILE            -- initial content of file field
  32         PATTERN         -- content of pattern field (e.g. #?.c)
  33         TITLE           -- title of the dialog box
  34         POSITIVE        -- string for the left button
  35         NEGATIVE        -- string for the right button
  36         ACCEPTPATTERN   -- only files which match the pattern are displayed
  37         REJECTPATTERN   -- files which match the pattern aren't displayed
  38         SAVEMODE        -- requester is displayed as save requester
  39         MULTISELECT     -- more than one file can be selected
  40         DRAWERSONLY     -- only drawers are displayed
  41         NOICONS         -- no icon files (#?.info) are displayed
  42         PUBSCREEN       -- requester is opened on the given public screen
  43         INITIALVOLUMES  -- shows the volumes
  44
  45     RESULT
  46
  47         Standard DOS error codes.
  48
  49     NOTES
  50
  51     EXAMPLE
  52
  53     BUGS
  54
  55     SEE ALSO
  56
  57     INTERNALS
  58
  59 ******************************************************************************/
  60
  61 #include <proto/asl.h>
  62 #include <proto/dos.h>
  63 #include <proto/exec.h>
  64
  65 #include <dos/dos.h>
  66 #include <dos/rdargs.h>
  67 #include <dos/var.h>
  68 #include <dos/dosasl.h>
  69 #include <exec/types.h>
  70 #include <exec/memory.h>
  71 #include <libraries/asl.h>
  72 #include <utility/tagitem.h>
  73 #include <workbench/startup.h>
  74
  75 #include <string.h>
  76
  77 #define ARG_TEMPLATE    "DRAWER,FILE/K,PATTERN/K,TITLE/K,POSITIVE/K," \
  78                         "NEGATIVE/K,ACCEPTPATTERN/K,REJECTPATTERN/K," \
  79                         "SAVEMODE/S,MULTISELECT/S,DRAWERSONLY/S," \
  80                         "NOICONS/S,PUBSCREEN/K,INITIALVOLUMES/S"
  81
  82 #define MAX_PATH_LEN    512
  83
  84
  85 enum { ARG_DRAWER = 0, ARG_FILE, ARG_PATTERN, ARG_TITLE, ARG_POSITIVE,
  86        ARG_NEGATIVE, ARG_ACCEPTPAT, ARG_REJECTPAT, ARG_SAVEMODE,
  87        ARG_MULTISELECT, ARG_DRAWERSONLY, ARG_NOICONS, ARG_PUBSCREEN,
  88        ARG_INITIALVOLUMES, TOTAL_ARGS };
  89
  90 const TEXT version[] = "$VER: RequestFile 42.4 (3.4.2014)\n";
  91
  92 struct TagItem FileTags[] =
  93 {
  94     /* Note: The ordering of these is _important_! */
  95     { ASLFR_InitialDrawer , (IPTR) NULL  },
  96     { ASLFR_InitialFile   , (IPTR) NULL  },
  97     { ASLFR_InitialPattern, (IPTR) NULL  },
  98     { ASLFR_TitleText     , (IPTR) NULL  },
  99     { ASLFR_PositiveText  , (IPTR) NULL  },
 100     { ASLFR_NegativeText  , (IPTR) NULL  },
 101     { ASLFR_AcceptPattern , (IPTR) NULL  },
 102     { ASLFR_RejectPattern , (IPTR) NULL  },
 103     { ASLFR_DoSaveMode    ,        FALSE },
 104     { ASLFR_DoMultiSelect ,        FALSE },
 105     { ASLFR_DrawersOnly   ,        FALSE },
 106     { ASLFR_RejectIcons   ,        FALSE },
 107     { ASLFR_PubScreenName , (IPTR) NULL  },
 108     { ASLFR_DoPatterns    ,        FALSE },
 109     { ASLFR_InitialShowVolumes,     TRUE },
 110     { TAG_DONE            , (IPTR) NULL  }
 111 };
 112
 113 int __nocommandline;
 114
 115 static UBYTE *ParsePatternArg(IPTR **args, UWORD ArgNum);
 116
 117 int main(void)
 118 {
 119     struct RDArgs        *rda;
 120     struct FileRequester *FileReq;
 121     struct WBArg         *WBFiles;
 122     IPTR                 *args[TOTAL_ARGS] = { NULL, NULL, NULL, NULL,
 123                                                NULL, NULL, NULL, NULL,
 124                                                NULL, NULL, NULL, NULL,
 125                                                NULL, NULL };
 126     int                   Return_Value = RETURN_OK;
 127     char                 *Buffer;
 128     BOOL                  Success;
 129     int                   i;
 130
 131     Buffer = (char *)AllocVec(MAX_PATH_LEN, MEMF_ANY | MEMF_CLEAR);
 132     if (Buffer != NULL)
 133     {
 134         rda = ReadArgs(ARG_TEMPLATE, (IPTR *)args, NULL);
 135         if(rda != NULL)
 136         {
 137             FileTags[ARG_DRAWER].ti_Data        = (IPTR)args[ARG_DRAWER];
 138             FileTags[ARG_FILE].ti_Data          = (IPTR)args[ARG_FILE];
 139             FileTags[ARG_PATTERN].ti_Data       = (IPTR)args[ARG_PATTERN];
 140             FileTags[ARG_TITLE].ti_Data         = (IPTR)args[ARG_TITLE];
 141             FileTags[ARG_POSITIVE].ti_Data      = (IPTR)args[ARG_POSITIVE];
 142             FileTags[ARG_NEGATIVE].ti_Data      = (IPTR)args[ARG_NEGATIVE];
 143             ParsePatternArg(args, ARG_ACCEPTPAT);
 144             ParsePatternArg(args, ARG_REJECTPAT);
 145             FileTags[ARG_SAVEMODE].ti_Data      = (IPTR)args[ARG_SAVEMODE];
 146             FileTags[ARG_MULTISELECT].ti_Data   = (IPTR)args[ARG_MULTISELECT];
 147             FileTags[ARG_DRAWERSONLY].ti_Data   = (IPTR)args[ARG_DRAWERSONLY];
 148             FileTags[ARG_NOICONS].ti_Data       = (IPTR)args[ARG_NOICONS];
 149             FileTags[ARG_PUBSCREEN].ti_Data     = (IPTR)args[ARG_PUBSCREEN];
 150             FileTags[ARG_PUBSCREEN + 1].ti_Data = args[ARG_PATTERN] != NULL;
 151             if (!args[ARG_INITIALVOLUMES])
 152             {
 153                 FileTags[ARG_INITIALVOLUMES + 1].ti_Tag = TAG_IGNORE;
 154             }
 155
 156             FileReq = (struct FileRequester *)AllocAslRequest(ASL_FileRequest,
 157                 FileTags);
 158             if(FileReq != NULL)
 159             {
 160                 Success = AslRequest(FileReq, NULL);
 161
 162                 if(Success != FALSE)
 163                 {
 164                     if(!(IPTR)args[ARG_MULTISELECT])
 165                     {
 166                         strncpy(Buffer, FileReq->fr_Drawer, MAX_PATH_LEN);
 167
 168                         /* FileReq->fr_File is NULL when using DRAWERSONLY */
 169                         Success = AddPart(Buffer,
 170                                           FileReq->fr_File ? FileReq->fr_File : (STRPTR)"",
 171                                           MAX_PATH_LEN);
 172
 173                         if(Success != FALSE)
 174                         {
 175                             Printf("\"%s\"\n", Buffer);
 176                         }
 177                     }
 178                     else
 179                     {
 180                         WBFiles = FileReq->fr_ArgList;
 181
 182                         for (i = 0; i != FileReq->fr_NumArgs; i++)
 183                         {
 184                             strncpy(Buffer, FileReq->fr_Drawer, MAX_PATH_LEN);
 185
 186                             Success = AddPart(Buffer,
 187                                               WBFiles[i].wa_Name,
 188                                               MAX_PATH_LEN);
 189
 190                             if(Success != FALSE)
 191                             {
 192                                 Printf("\"%s\" ", Buffer);
 193                             }
 194                         }
 195
 196                         PutStr("\n");
 197                     }
 198                 }
 199                 else
 200                 {
 201                     if (IoErr() == 0)
 202                     {
 203                         /* We cancelled it!!
 204                          */
 205                         Return_Value = RETURN_WARN;
 206
 207                         SetIoErr(ERROR_BREAK);
 208                     }
 209                     else
 210                     {
 211                         PrintFault(IoErr(), NULL);
 212                         Return_Value = RETURN_FAIL;
 213                     }
 214                 }
 215
 216                 FreeAslRequest((struct FileRequester *)FileReq);
 217             }
 218             else
 219             {
 220                 PrintFault(IoErr(), "RequestFile");
 221                 Return_Value = RETURN_ERROR;
 222             }
 223
 224             FreeArgs(rda);
 225         }
 226         else
 227         {
 228             PrintFault(IoErr(), "RequestFile");
 229             Return_Value = RETURN_ERROR;
 230         }
 231
 232         FreeVec((APTR)FileTags[ARG_ACCEPTPAT].ti_Data);
 233         FreeVec((APTR)FileTags[ARG_REJECTPAT].ti_Data);
 234         FreeVec(Buffer);
 235     }
 236     else
 237     {
 238         PrintFault(IoErr(), NULL);
 239         Return_Value = RETURN_FAIL;
 240     }
 241
 242     return Return_Value;
 243
 244 } /* main */
 245
 246 static UBYTE *ParsePatternArg(IPTR **args, UWORD ArgNum)
 247 {
 248     if (!args[ArgNum]) /* AROS crashes on strlen(NULL) */
 249     {
 250         FileTags[ArgNum].ti_Tag = TAG_IGNORE;
 251         return NULL;
 252     }
 253
 254     UBYTE *PatternBuffer = NULL;
 255     LONG PatternBufferSize;
 256     STRPTR pattern = (STRPTR)args[ArgNum];
 257
 258     PatternBufferSize = 2 * strlen((char *)pattern);
 259     PatternBuffer = AllocVec(PatternBufferSize, MEMF_PUBLIC);
 260     if (PatternBuffer != NULL)
 261     {
 262         if (ParsePatternNoCase((STRPTR)pattern,
 263             PatternBuffer, PatternBufferSize) >= 0)
 264         {
 265             FileTags[ArgNum].ti_Data = (IPTR)PatternBuffer;
 266         }
 267         else
 268         {
 269             FreeVec(PatternBuffer);
 270             PatternBuffer = NULL;
 271             FileTags[ArgNum].ti_Tag = TAG_IGNORE;
 272         }
 273     }
 274
 275     return PatternBuffer;
 276 }