bgui/screenreqclass.c

   1 /*
   2  * @(#) $Header$
   3  *
   4  * BGUI library
   5  * screenreqclass.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:02  stegerg
  18  * another hundreds of REG() macro replacements in func headers/protos.
  19  *
  20  * Revision 42.0  2000/05/09 22:10:08  mlemos
  21  * Bumped to revision 42.0 before handing BGUI to AROS team
  22  *
  23  * Revision 41.11  2000/05/09 19:55:03  mlemos
  24  * Merged with the branch Manuel_Lemos_fixes.
  25  *
  26  * Revision 41.10  1998/02/25 21:13:04  mlemos
  27  * Bumping to 41.10
  28  *
  29  * Revision 1.1  1998/02/25 17:09:42  mlemos
  30  * Ian sources
  31  *
  32  *
  33  */
  34
  35 #include "include/classdefs.h"
  36
  37 /// Class definitions.
  38 /*
  39  * Object instance data.
  40  */
  41 typedef struct {
  42    ULONG              sd_DisplayID;       /* Display mode ID                  */
  43    ULONG              sd_DisplayWidth;    /* Width of display in pixels       */
  44    ULONG              sd_DisplayHeight;   /* Height of display in pixels      */
  45    UWORD              sd_DisplayDepth;    /* Number of bit-planes of display  */
  46    UWORD              sd_OverscanType;    /* Type of overscan of display      */
  47    BOOL               sd_AutoScroll;      /* Display should auto-scroll?      */
  48
  49    BOOL               sd_InfoOpen;        /* Info window opened on exit?      */
  50    WORD               sd_InfoLeft;        /* Last coordinates of Info window  */
  51    WORD               sd_InfoTop;
  52    WORD               sd_InfoWidth;
  53    WORD               sd_InfoHeight;
  54 }  SD;
  55
  56 ///
  57
  58 /// OM_NEW
  59 /*
  60  * Create a shiny new object.
  61  */
  62 METHOD(ScreenReqClassNew, struct opSet *, ops)
  63 {
  64    IPTR            rc;
  65    struct TagItem *tags;
  66
  67    tags = DefTagList(BGUI_SCREENREQ_OBJECT, ops->ops_AttrList);
  68
  69    /*
  70     * First we let the superclass create the object.
  71     */
  72    if ((rc = NewSuperObject(cl, obj, tags)))
  73    {
  74       /*
  75        * Setup user attributes.
  76        */
  77       if (AsmCoerceMethod(cl, (Object *)rc, OM_SET, tags, NULL) != ASLREQ_OK)
  78       {
  79          /*
  80           * Failure.
  81           */
  82          AsmCoerceMethod(cl, (Object *)rc, OM_DISPOSE);
  83          rc = 0;
  84       };
  85    };
  86    FreeTagItems(tags);
  87
  88    return rc;
  89 }
  90 METHOD_END
  91 ///
  92 /// OM_DISPOSE
  93 /*
  94  * They want us gone.
  95  */
  96 METHOD(ScreenReqClassDispose, Msg, msg)
  97 {
  98    /*
  99     * The superclass does the rest.
 100     */
 101    return AsmDoSuperMethodA(cl, obj, msg);
 102 }
 103 METHOD_END
 104 ///
 105 /// OM_SET, OM_UPDATE
 106 /*
 107  * Change one or more of the object
 108  * it's attributes.
 109  */
 110 METHOD(ScreenReqClassSetUpdate, struct opSet *, ops)
 111 {
 112    SD             *sd = INST_DATA(cl, obj);
 113    ULONG           data, rc;
 114    struct TagItem *tstate = ops->ops_AttrList;
 115    struct TagItem *tag;
 116
 117    /*
 118     * First we let the superclass
 119     * have a go at it.
 120     */
 121    rc = AsmDoSuperMethodA(cl, obj, (Msg)ops);
 122
 123    while ((tag = NextTagItem(&tstate)))
 124    {
 125       data = tag->ti_Data;
 126       switch (tag->ti_Tag)
 127       {
 128       case ASLSM_InitialDisplayID:
 129       case SCREENREQ_DisplayID:
 130          sd->sd_DisplayID = data;
 131          break;
 132       case ASLSM_InitialDisplayWidth:
 133       case SCREENREQ_DisplayWidth:
 134          sd->sd_DisplayWidth = data;
 135          break;
 136       case ASLSM_InitialDisplayHeight:
 137       case SCREENREQ_DisplayHeight:
 138          sd->sd_DisplayHeight = data;
 139          break;
 140       case ASLSM_InitialDisplayDepth:
 141       case SCREENREQ_DisplayDepth:
 142          sd->sd_DisplayDepth = data;
 143          break;
 144       case ASLSM_InitialOverscanType:
 145       case SCREENREQ_OverscanType:
 146          sd->sd_OverscanType = data;
 147          break;
 148       case ASLSM_InitialAutoScroll:
 149       case SCREENREQ_AutoScroll:
 150          sd->sd_AutoScroll = data;
 151          break;
 152       };
 153    };
 154    return rc;
 155 }
 156 METHOD_END
 157 ///
 158 /// OM_GET
 159 /*
 160  * Give one of the attributes.
 161  */
 162 METHOD(ScreenReqClassGet, struct opGet *, opg)
 163 {
 164    SD          *sd = INST_DATA(cl, obj);
 165    ULONG        rc = 1;
 166    IPTR        *store = opg->opg_Storage;
 167    Tag          attr = opg->opg_AttrID;
 168
 169    switch (attr)
 170    {
 171    case ASLSM_InitialDisplayID:
 172    case SCREENREQ_DisplayID:
 173       STORE sd->sd_DisplayID;
 174       break;
 175    case ASLSM_InitialDisplayWidth:
 176    case SCREENREQ_DisplayWidth:
 177       STORE sd->sd_DisplayWidth;
 178       break;
 179    case ASLSM_InitialDisplayHeight:
 180    case SCREENREQ_DisplayHeight:
 181       STORE sd->sd_DisplayHeight;
 182       break;
 183    case ASLSM_InitialDisplayDepth:
 184    case SCREENREQ_DisplayDepth:
 185       STORE sd->sd_DisplayDepth;
 186       break;
 187    case ASLSM_InitialOverscanType:
 188    case SCREENREQ_OverscanType:
 189       STORE sd->sd_OverscanType;
 190       break;
 191    case ASLSM_InitialAutoScroll:
 192    case SCREENREQ_AutoScroll:
 193       STORE sd->sd_AutoScroll;
 194       break;
 195   default:
 196       rc = AsmDoSuperMethodA(cl, obj, (Msg)opg);
 197       break;
 198    }
 199    return rc;
 200 }
 201 METHOD_END
 202 ///
 203 /// ASLM_DOREQUEST
 204 /*
 205  * Pop up the ScreenRequester.
 206  */
 207 METHOD(ScreenReqClassDoRequest, Msg, msg)
 208 {
 209    SD                         *sd = INST_DATA(cl, obj);
 210    struct ScreenModeRequester *sm;
 211    ULONG                       rc = FRQ_OK;
 212
 213    DoSetMethodNG(obj, ASLSM_InitialDisplayWidth,  sd->sd_DisplayWidth,
 214                       ASLSM_InitialDisplayHeight, sd->sd_DisplayHeight,
 215                       ASLSM_InitialDisplayDepth,  sd->sd_DisplayDepth,
 216                       ASLSM_InitialDisplayID,     sd->sd_DisplayID,
 217                       ASLSM_InitialOverscanType,  sd->sd_OverscanType,
 218                       ASLSM_InitialAutoScroll,    sd->sd_AutoScroll,
 219                       TAG_DONE);
 220
 221    if (sd->sd_InfoWidth)
 222    {
 223       DoSetMethodNG(obj, ASLSM_InitialInfoLeftEdge, sd->sd_InfoLeft,
 224                          ASLSM_InitialInfoTopEdge,  sd->sd_InfoTop,
 225                          ASLSM_InitialInfoOpened,   sd->sd_InfoOpen,
 226                          TAG_DONE);
 227    };
 228
 229    /*
 230     * Allocate ScreenRequester structure.
 231     */
 232    if ((sm = (struct ScreenModeRequester *)AsmDoSuperMethod(cl, obj, ASLM_ALLOCREQUEST)))
 233    {
 234       /*
 235        * Put up the requester.
 236        */
 237       if (AsmDoSuperMethod(cl, obj, ASLM_REQUEST))
 238       {
 239          /*
 240           * Copy relevant info into our structure.
 241           */
 242          DoSetMethodNG(obj, SCREENREQ_DisplayWidth,   sm->sm_DisplayWidth,
 243                             SCREENREQ_DisplayHeight,  sm->sm_DisplayHeight,
 244                             SCREENREQ_DisplayDepth,   sm->sm_DisplayDepth,
 245                             SCREENREQ_DisplayID,      sm->sm_DisplayID,
 246                             SCREENREQ_OverscanType,   sm->sm_OverscanType,
 247                             SCREENREQ_AutoScroll,     sm->sm_AutoScroll,
 248                             TAG_DONE);
 249       } else
 250          rc = FRQ_CANCEL;
 251
 252       /*
 253        * Remember these even if the requester was cancelled.
 254        */
 255       DoSuperSetMethodNG(cl, obj, ASLREQ_Bounds, &sm->sm_LeftEdge, TAG_DONE);
 256
 257       sd->sd_InfoOpen   = sm->sm_InfoOpened;
 258       sd->sd_InfoLeft   = sm->sm_InfoLeftEdge;
 259       sd->sd_InfoTop    = sm->sm_InfoTopEdge;
 260       sd->sd_InfoWidth  = sm->sm_InfoWidth;
 261       sd->sd_InfoHeight = sm->sm_InfoHeight;
 262
 263       /*
 264        * Free the requester structure.
 265        */
 266       AsmDoSuperMethod(cl, obj, ASLM_FREEREQUEST);
 267    } else
 268       rc = ASLREQ_ERROR_NO_REQ;
 269
 270    return rc;
 271 }
 272 METHOD_END
 273 ///
 274
 275 /// Class initialization.
 276 /*
 277  * Function table.
 278  */
 279 STATIC DPFUNC ClassFunc[] = {
 280    { OM_NEW,                 ScreenReqClassNew, },
 281    { OM_SET,                 ScreenReqClassSetUpdate, },
 282    { OM_UPDATE,              ScreenReqClassSetUpdate, },
 283    { OM_GET,                 ScreenReqClassGet, },
 284    { OM_DISPOSE,             ScreenReqClassDispose, },
 285    { ASLM_DOREQUEST,         ScreenReqClassDoRequest, },
 286    { DF_END,                 NULL },
 287 };
 288
 289 /*
 290  * Simple class initialization.
 291  */
 292 makeproto Class *InitScreenReqClass(void)
 293 {
 294    return BGUI_MakeClass(CLASS_SuperClassBGUI, BGUI_ASLREQ_OBJECT,
 295                          CLASS_ObjectSize,     sizeof(SD),
 296                          CLASS_DFTable,        ClassFunc,
 297                          TAG_DONE);
 298 }
 299 ///