workbench/c/RequestFile.c

   1 /*
   2     Copyright © 1995-2012, 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.2 (19.8.2012)\n";
  91
  92 extern struct Library *AslBase;
  93
  94 struct TagItem FileTags[] =
  95 {
  96     /* Note: The ordering of these is _important_! */
  97     { ASLFR_InitialDrawer , (IPTR) NULL  },
  98     { ASLFR_InitialFile   , (IPTR) NULL  },
  99     { ASLFR_InitialPattern, (IPTR) NULL  },
 100     { ASLFR_TitleText     , (IPTR) NULL  },
 101     { ASLFR_PositiveText  , (IPTR) NULL  },
 102     { ASLFR_NegativeText  , (IPTR) NULL  },
 103     { ASLFR_AcceptPattern , (IPTR) NULL  },
 104     { ASLFR_RejectPattern , (IPTR) NULL  },
 105     { ASLFR_DoSaveMode    ,        FALSE },
 106     { ASLFR_DoMultiSelect ,        FALSE },
 107     { ASLFR_DrawersOnly   ,        FALSE },
 108     { ASLFR_RejectIcons   ,        FALSE },
 109     { ASLFR_PubScreenName , (IPTR) NULL  },
 110     { ASLFR_DoPatterns    ,        FALSE },
 111     { ASLFR_InitialShowVolumes,     TRUE },
 112     { TAG_DONE            , (IPTR) NULL  }
 113 };
 114
 115 int __nocommandline;
 116
 117 static UBYTE *ParsePatternArg(IPTR **args, UWORD ArgNum);
 118
 119 int main(void)
 120 {
 121     struct RDArgs        *rda;
 122     struct FileRequester *FileReq;
 123     struct WBArg         *WBFiles;
 124     IPTR                 *args[TOTAL_ARGS] = { NULL, NULL, NULL, NULL,
 125                                                NULL, NULL, NULL, NULL,
 126                                                NULL, NULL, NULL, NULL,
 127                                                NULL, NULL };
 128     int                   Return_Value = RETURN_OK;
 129     IPTR                  DisplayArgs[1];
 130     char                 *Buffer;
 131     BOOL                  Success;
 132     int                   i;
 133
 134     Buffer = (char *)AllocVec(MAX_PATH_LEN, MEMF_ANY | MEMF_CLEAR);
 135     if (Buffer != NULL)
 136     {
 137         rda = ReadArgs(ARG_TEMPLATE, (IPTR *)args, NULL);
 138         if(rda != NULL)
 139         {
 140             FileTags[ARG_DRAWER].ti_Data        = (IPTR)args[ARG_DRAWER];
 141             FileTags[ARG_FILE].ti_Data          = (IPTR)args[ARG_FILE];
 142             FileTags[ARG_PATTERN].ti_Data       = (IPTR)args[ARG_PATTERN];
 143             FileTags[ARG_TITLE].ti_Data         = (IPTR)args[ARG_TITLE];
 144             FileTags[ARG_POSITIVE].ti_Data      = (IPTR)args[ARG_POSITIVE];
 145             FileTags[ARG_NEGATIVE].ti_Data      = (IPTR)args[ARG_NEGATIVE];
 146             ParsePatternArg(args, ARG_ACCEPTPAT);
 147             ParsePatternArg(args, ARG_REJECTPAT);
 148             FileTags[ARG_SAVEMODE].ti_Data      = (IPTR)args[ARG_SAVEMODE];
 149             FileTags[ARG_MULTISELECT].ti_Data   = (IPTR)args[ARG_MULTISELECT];
 150             FileTags[ARG_DRAWERSONLY].ti_Data   = (IPTR)args[ARG_DRAWERSONLY];
 151             FileTags[ARG_NOICONS].ti_Data       = (IPTR)args[ARG_NOICONS];
 152             FileTags[ARG_PUBSCREEN].ti_Data     = (IPTR)args[ARG_PUBSCREEN];
 153             FileTags[ARG_PUBSCREEN + 1].ti_Data = args[ARG_PATTERN] != NULL;
 154             if (!args[ARG_INITIALVOLUMES])
 155             {
 156                 FileTags[ARG_INITIALVOLUMES + 1].ti_Tag = TAG_IGNORE;
 157             }
 158
 159             FileReq = (struct FileRequester *)AllocAslRequest(ASL_FileRequest,
 160                 FileTags);
 161             if(FileReq != NULL)
 162             {
 163                 Success = AslRequest(FileReq, NULL);
 164
 165                 if(Success != FALSE)
 166                 {
 167                     if(!(IPTR)args[ARG_MULTISELECT])
 168                     {
 169                         strncpy(Buffer, FileReq->fr_Drawer, MAX_PATH_LEN);
 170
 171                         /* FileReq->fr_File is NULL when using DRAWERSONLY */
 172                         Success = AddPart(Buffer,
 173                                           FileReq->fr_File ? FileReq->fr_File : (STRPTR)"",
 174                                           MAX_PATH_LEN);
 175
 176                         if(Success != FALSE)
 177                         {
 178                             DisplayArgs[0] = (IPTR)Buffer;
 179                             VPrintf("\"%s\"\n", DisplayArgs);
 180                         }
 181                     }
 182                     else
 183                     {
 184                         WBFiles = FileReq->fr_ArgList;
 185
 186                         for (i = 0; i != FileReq->fr_NumArgs; i++)
 187                         {
 188                             strncpy(Buffer, FileReq->fr_Drawer, MAX_PATH_LEN);
 189
 190                             Success = AddPart(Buffer,
 191                                               WBFiles[i].wa_Name,
 192                                               MAX_PATH_LEN);
 193
 194                             if(Success != FALSE)
 195                             {
 196                                 DisplayArgs[0] = (IPTR)Buffer;
 197                                 VPrintf("\"%s\" ", DisplayArgs);
 198                             }
 199                         }
 200
 201                         PutStr("\n");
 202                     }
 203                 }
 204                 else
 205                 {
 206                     if (IoErr() == 0)
 207                     {
 208                         /* We cancelled it!!
 209                          */
 210                         Return_Value = RETURN_WARN;
 211
 212                         SetIoErr(ERROR_BREAK);
 213                     }
 214                     else
 215                     {
 216                         PrintFault(IoErr(), NULL);
 217                         Return_Value = RETURN_FAIL;
 218                     }
 219                 }
 220
 221                 FreeAslRequest((struct FileRequester *)FileReq);
 222             }
 223             else
 224             {
 225                 PrintFault(IoErr(), "RequestFile");
 226                 Return_Value = RETURN_ERROR;
 227             }
 228
 229             FreeArgs(rda);
 230         }
 231         else
 232         {
 233             PrintFault(IoErr(), "RequestFile");
 234             Return_Value = RETURN_ERROR;
 235         }
 236
 237         FreeVec((APTR)FileTags[ARG_ACCEPTPAT].ti_Data);
 238         FreeVec((APTR)FileTags[ARG_REJECTPAT].ti_Data);
 239         FreeVec(Buffer);
 240     }
 241     else
 242     {
 243         SetIoErr(ERROR_NO_FREE_STORE);
 244         PrintFault(IoErr(), NULL);
 245         Return_Value = RETURN_FAIL;
 246     }
 247
 248     return Return_Value;
 249
 250 } /* main */
 251
 252 static UBYTE *ParsePatternArg(IPTR **args, UWORD ArgNum)
 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 }