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    ULONG           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    struct TagItem *tag, *tstate = ops->ops_AttrList;
 109    ULONG           data, rc;
 110    BOOL            path_update = FALSE;
 111
 112    /*
 113     * First we let the superclass have a go at it.
 114     */
 115    rc = AsmDoSuperMethodA(cl, obj, (Msg)ops);
 116
 117    while (tag = NextTagItem(&tstate))
 118    {
 119       data = tag->ti_Data;
 120       switch (tag->ti_Tag)
 121       {
 122       case FILEREQ_MultiHook:
 123          fd->fd_MultiHook = (struct Hook *)data;
 124          break;
 125       case ASLFR_InitialFile:
 126       case FILEREQ_File:
 127          strncpy(fd->fd_File, (UBYTE *)data, MAX_FILE);
 128          path_update = TRUE;
 129          break;
 130       case ASLFR_InitialDrawer:
 131       case FILEREQ_Drawer:
 132          strncpy(fd->fd_Drawer, (UBYTE *)data, MAX_DRAWER);
 133          path_update = TRUE;
 134          break;
 135       case ASLFR_InitialPattern:
 136       case FILEREQ_Pattern:
 137          strncpy(fd->fd_Pattern, (UBYTE *)data, MAX_PATTERN);
 138          break;
 139       };
 140       if (path_update)
 141       {
 142          strncpy(fd->fd_Path, fd->fd_Drawer, MAX_PATH);
 143          AddPart(fd->fd_Path, fd->fd_File,   MAX_PATH);
 144       };
 145    };
 146    return rc;
 147 }
 148 METHOD_END
 149 ///
 150 /// OM_GET
 151 /*
 152  * Give one of the attributes.
 153  */
 154 METHOD(FileReqClassGet, struct opGet *, opg)
 155 {
 156    FD          *fd = INST_DATA(cl, obj);
 157    ULONG        rc = 1, *store = opg->opg_Storage, attr = opg->opg_AttrID;
 158
 159    switch (attr)
 160    {
 161    case ASLFR_InitialDrawer:
 162    case FILEREQ_Drawer:
 163       STORE fd->fd_Drawer;
 164       break;
 165    case ASLFR_InitialFile:
 166    case FILEREQ_File:
 167       STORE fd->fd_File;
 168       break;
 169    case ASLFR_InitialPattern:
 170    case FILEREQ_Pattern:
 171       STORE fd->fd_Pattern;
 172       break;
 173    case FILEREQ_Path:
 174       STORE fd->fd_Path;
 175       break;
 176    case FILEREQ_MultiHook:
 177       STORE fd->fd_MultiHook;
 178       break;
 179    default:
 180       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 181       break;
 182    }
 183    return rc;
 184 }
 185 METHOD_END
 186 ///
 187 /// ASLM_DOREQUEST
 188 /*
 189  * Pop up the filerequester.
 190  */
 191 METHOD(FileReqClassDoRequest, Msg, msg)
 192 {
 193    FD                   *fd = INST_DATA(cl, obj);
 194    struct FileRequester *fr;
 195    ULONG                 rc = ASLREQ_OK;
 196
 197    DoSuperSetMethodNG(cl, obj, ASLFR_InitialFile,     fd->fd_File,
 198                                ASLFR_InitialDrawer,   fd->fd_Drawer,
 199                                ASLFR_InitialPattern,  fd->fd_Pattern, TAG_DONE);
 200
 201    /*
 202     * Allocate filerequester structure.
 203     */
 204    if (fr = (struct FileRequester *)AsmDoSuperMethod(cl, obj, ASLM_ALLOCREQUEST))
 205    {
 206       /*
 207        * Put up the requester.
 208        */
 209       if (AsmDoSuperMethod(cl, obj, ASLM_REQUEST))
 210       {
 211          /*
 212           * Copy drawer, file and pattern strings.
 213           */
 214          DoSetMethodNG(obj, FILEREQ_File,     fr->fr_File,
 215                             FILEREQ_Drawer,   fr->fr_Drawer,
 216                             FILEREQ_Pattern,  fr->fr_Pattern, TAG_DONE);
 217
 218          /*
 219           * Do we have a multi-select hook?
 220           */
 221          if (fd->fd_MultiHook)
 222          {
 223             /*
 224              * Any multi-selections made?
 225              */
 226             if (fr->fr_NumArgs)
 227                BGUI_CallHookPkt(fd->fd_MultiHook, (VOID *)obj, (VOID *)fr);
 228          };
 229
 230       } else
 231          rc = ASLREQ_CANCEL;
 232
 233       /*
 234        * Remember these even if the requester was cancelled.
 235        */
 236       DoSuperSetMethodNG(cl, obj, ASLREQ_Bounds, &fr->fr_LeftEdge, TAG_DONE);
 237
 238       /*
 239        * Free the requester structure.
 240        */
 241       AsmDoSuperMethod(cl, obj, ASLM_FREEREQUEST);
 242    } else
 243       rc = ASLREQ_ERROR_NO_REQ;
 244
 245    return rc;
 246 }
 247 METHOD_END
 248 ///
 249
 250 /// Class initialization.
 251 /*
 252  * Function table.
 253  */
 254 STATIC DPFUNC ClassFunc[] = {
 255    OM_NEW,                 (FUNCPTR)FileReqClassNew,
 256    OM_SET,                 (FUNCPTR)FileReqClassSetUpdate,
 257    OM_UPDATE,              (FUNCPTR)FileReqClassSetUpdate,
 258    OM_GET,                 (FUNCPTR)FileReqClassGet,
 259    OM_DISPOSE,             (FUNCPTR)FileReqClassDispose,
 260    ASLM_DOREQUEST,         (FUNCPTR)FileReqClassDoRequest,
 261    DF_END,                 NULL
 262 };
 263
 264 /*
 265  * Simple class initialization.
 266  */
 267 makeproto Class *InitFileReqClass(void)
 268 {
 269    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_ASLREQ_OBJECT,
 270                          CLASS_ObjectSize,     sizeof(FD),
 271                          CLASS_DFTable,        ClassFunc,
 272                          TAG_DONE);
 273 }
 274 ///