bgui/filereqclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * filereqclass.c
   6  *
   7  * (C) Copyright 1998 Manuel Lemos.
   8  * (C) Copyright 1996-1997 Ian J. Einman.
   9  * (C) Copyright 1993-1996 Jaba Development.
  10  * (C) Copyright 1993-1996 Jan van den Baard.
  11  * All Rights Reserved.
  12  *
  13  * $Log$
  14  * Revision 42.2  2004/06/16 20:16:48  verhaegs
  15  * Use METHODPROTO, METHOD_END and REGFUNCPROTOn where needed.
  16  *
  17  * Revision 42.1  2000/05/15 19:27:01  stegerg
  18  * another hundreds of REG() macro replacements in func headers/protos.
  19  *
  20  * Revision 42.0  2000/05/09 22:08:53  mlemos
  21  * Bumped to revision 42.0 before handing BGUI to AROS team
  22  *
  23  * Revision 41.11  2000/05/09 19:54:14  mlemos
  24  * Merged with the branch Manuel_Lemos_fixes.
  25  *
  26  * Revision 41.10.2.1  1999/07/03 15:17:35  mlemos
  27  * Replaced the calls to CallHookPkt to BGUI_CallHookPkt.
  28  *
  29  * Revision 41.10  1998/02/25 21:12:00  mlemos
  30  * Bumping to 41.10
  31  *
  32  * Revision 1.1  1998/02/25 17:08:12  mlemos
  33  * Ian sources
  34  *
  35  *
  36  */
  37
  38 #include "include/classdefs.h"
  39
  40 /// Class definitions.
  41 /*
  42  * Object instance data.
  43  */
  44 typedef struct {
  45    struct Hook       *fd_MultiHook;                   /* Multi-select hook */
  46    UBYTE              fd_Drawer [MAX_DRAWER  + 2];    /* Drawer buffer     */
  47    UBYTE              fd_File   [MAX_FILE    + 2];    /* Filename buffer   */
  48    UBYTE              fd_Path   [MAX_PATH    + 2];    /* Full path buffer  */
  49    UBYTE              fd_Pattern[MAX_PATTERN + 2];    /* Pattern buffer    */
  50 }  FD;
  51 ///
  52
  53 /// OM_NEW
  54 /*
  55  * Create a shiny new object.
  56  */
  57 METHOD(FileReqClassNew, struct opSet *, ops)
  58 {
  59    IPTR            rc;
  60    struct TagItem *tags;
  61
  62    tags = DefTagList(BGUI_FILEREQ_OBJECT, ops->ops_AttrList);
  63
  64    /*
  65     * First we let the superclass create the object.
  66     */
  67    if ((rc = NewSuperObject(cl, obj, tags)))
  68    {
  69       /*
  70        * Setup user attributes.
  71        */
  72       if (AsmCoerceMethod(cl, (Object *)rc, OM_SET, tags, NULL) != ASLREQ_OK)
  73       {
  74          /*
  75           * Failure.
  76           */
  77          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
  78          rc = 0;
  79       };
  80    };
  81    FreeTagItems(tags);
  82
  83    return rc;
  84 }
  85 METHOD_END
  86 ///
  87 /// OM_DISPOSE
  88 /*
  89  * They want us gone.
  90  */
  91 METHOD(FileReqClassDispose, Msg, msg)
  92 {
  93    /*
  94     * The superclass does the rest.
  95     */
  96    return AsmDoSuperMethodA(cl, obj, msg);
  97 }
  98 METHOD_END
  99 ///
 100 /// OM_SET, OM_UPDATE
 101 /*
 102  * Change one or more of the object
 103  * it's attributes.
 104  */
 105 METHOD(FileReqClassSetUpdate, struct opSet *, ops)
 106 {
 107    FD             *fd = INST_DATA(cl, obj);
 108    IPTR            data, rc;
 109    struct TagItem *tag;
 110    struct TagItem *tstate = ops->ops_AttrList;
 111    BOOL            path_update = FALSE;
 112
 113    /*
 114     * First we let the superclass have a go at it.
 115     */
 116    rc = AsmDoSuperMethodA(cl, obj, (Msg)ops);
 117
 118    while ((tag = NextTagItem(&tstate)))
 119    {
 120       data = tag->ti_Data;
 121       switch (tag->ti_Tag)
 122       {
 123       case FILEREQ_MultiHook:
 124          fd->fd_MultiHook = (struct Hook *)data;
 125          break;
 126       case ASLFR_InitialFile:
 127       case FILEREQ_File:
 128          strncpy(fd->fd_File, (UBYTE *)data, MAX_FILE);
 129          path_update = TRUE;
 130          break;
 131       case ASLFR_InitialDrawer:
 132       case FILEREQ_Drawer:
 133          strncpy(fd->fd_Drawer, (UBYTE *)data, MAX_DRAWER);
 134          path_update = TRUE;
 135          break;
 136       case ASLFR_InitialPattern:
 137       case FILEREQ_Pattern:
 138          strncpy(fd->fd_Pattern, (UBYTE *)data, MAX_PATTERN);
 139          break;
 140       };
 141       if (path_update)
 142       {
 143          strncpy(fd->fd_Path, fd->fd_Drawer, MAX_PATH);
 144          AddPart(fd->fd_Path, fd->fd_File,   MAX_PATH);
 145       };
 146    };
 147    return rc;
 148 }
 149 METHOD_END
 150 ///
 151 /// OM_GET
 152 /*
 153  * Give one of the attributes.
 154  */
 155 METHOD(FileReqClassGet, struct opGet *, opg)
 156 {
 157    FD          *fd = INST_DATA(cl, obj);
 158    ULONG        rc = 1;
 159    IPTR        *store = opg->opg_Storage;
 160    Tag          attr = opg->opg_AttrID;
 161
 162    switch (attr)
 163    {
 164    case ASLFR_InitialDrawer:
 165    case FILEREQ_Drawer:
 166       STORE fd->fd_Drawer;
 167       break;
 168    case ASLFR_InitialFile:
 169    case FILEREQ_File:
 170       STORE fd->fd_File;
 171       break;
 172    case ASLFR_InitialPattern:
 173    case FILEREQ_Pattern:
 174       STORE fd->fd_Pattern;
 175       break;
 176    case FILEREQ_Path:
 177       STORE fd->fd_Path;
 178       break;
 179    case FILEREQ_MultiHook:
 180       STORE fd->fd_MultiHook;
 181       break;
 182    default:
 183       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 184       break;
 185    }
 186    return rc;
 187 }
 188 METHOD_END
 189 ///
 190 /// ASLM_DOREQUEST
 191 /*
 192  * Pop up the filerequester.
 193  */
 194 METHOD(FileReqClassDoRequest, Msg, msg)
 195 {
 196    FD                   *fd = INST_DATA(cl, obj);
 197    struct FileRequester *fr;
 198    ULONG                 rc = ASLREQ_OK;
 199
 200    DoSuperSetMethodNG(cl, obj, ASLFR_InitialFile,     fd->fd_File,
 201                                ASLFR_InitialDrawer,   fd->fd_Drawer,
 202                                ASLFR_InitialPattern,  fd->fd_Pattern, TAG_DONE);
 203
 204    /*
 205     * Allocate filerequester structure.
 206     */
 207    if ((fr = (struct FileRequester *)AsmDoSuperMethod(cl, obj, ASLM_ALLOCREQUEST)))
 208    {
 209       /*
 210        * Put up the requester.
 211        */
 212       if (AsmDoSuperMethod(cl, obj, ASLM_REQUEST))
 213       {
 214          /*
 215           * Copy drawer, file and pattern strings.
 216           */
 217          DoSetMethodNG(obj, FILEREQ_File,     fr->fr_File,
 218                             FILEREQ_Drawer,   fr->fr_Drawer,
 219                             FILEREQ_Pattern,  fr->fr_Pattern, TAG_DONE);
 220
 221          /*
 222           * Do we have a multi-select hook?
 223           */
 224          if (fd->fd_MultiHook)
 225          {
 226             /*
 227              * Any multi-selections made?
 228              */
 229             if (fr->fr_NumArgs)
 230                BGUI_CallHookPkt(fd->fd_MultiHook, (VOID *)obj, (VOID *)fr);
 231          };
 232
 233       } else
 234          rc = ASLREQ_CANCEL;
 235
 236       /*
 237        * Remember these even if the requester was cancelled.
 238        */
 239       DoSuperSetMethodNG(cl, obj, ASLREQ_Bounds, &fr->fr_LeftEdge, TAG_DONE);
 240
 241       /*
 242        * Free the requester structure.
 243        */
 244       AsmDoSuperMethod(cl, obj, ASLM_FREEREQUEST);
 245    } else
 246       rc = ASLREQ_ERROR_NO_REQ;
 247
 248    return rc;
 249 }
 250 METHOD_END
 251 ///
 252
 253 /// Class initialization.
 254 /*
 255  * Function table.
 256  */
 257 STATIC DPFUNC ClassFunc[] = {
 258    { OM_NEW,                 FileReqClassNew, },
 259    { OM_SET,                 FileReqClassSetUpdate, },
 260    { OM_UPDATE,              FileReqClassSetUpdate, },
 261    { OM_GET,                 FileReqClassGet, },
 262    { OM_DISPOSE,             FileReqClassDispose, },
 263    { ASLM_DOREQUEST,         FileReqClassDoRequest, },
 264    { DF_END,                 NULL },
 265 };
 266
 267 /*
 268  * Simple class initialization.
 269  */
 270 makeproto Class *InitFileReqClass(void)
 271 {
 272    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_ASLREQ_OBJECT,
 273                          CLASS_ObjectSize,     sizeof(FD),
 274                          CLASS_DFTable,        ClassFunc,
 275                          TAG_DONE);
 276 }
 277 ///