rom/graphics/videocontrol.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Graphics function VideoControl()
   6     Lang: english
   7 */
   8 #include <aros/debug.h>
   9 #include <graphics/videocontrol.h>
  10 #include <graphics/view.h>
  11 #include <utility/tagitem.h>
  12 #include <proto/utility.h>
  13
  14 #include "graphics_intern.h"
  15
  16 /*****************************************************************************
  17
  18     NAME */
  19 #include <proto/graphics.h>
  20
  21         AROS_LH2(ULONG, VideoControl,
  22
  23 /*  SYNOPSIS */
  24         AROS_LHA(struct ColorMap *, cm, A0),
  25         AROS_LHA(struct TagItem *, tags, A1),
  26
  27 /*  LOCATION */
  28         struct GfxBase *, GfxBase, 118, Graphics)
  29
  30 /*  FUNCTION
  31
  32     INPUTS
  33         cm   - pointer to struct ColorMap obtained via GetColorMap()
  34         tags - pointer to a table of videocontrol tagitems
  35
  36     RESULT
  37         error - 0 if no error ocurred in the control operation
  38                 non-0 if bad colormap pointer, no tagitems or bad tag
  39     NOTES
  40         Not implemented
  41
  42     EXAMPLE
  43
  44     BUGS
  45
  46     SEE ALSO
  47
  48     INTERNALS
  49
  50     HISTORY
  51
  52
  53 ******************************************************************************/
  54 {
  55     AROS_LIBFUNC_INIT
  56
  57     const struct TagItem *tstate = tags;
  58     struct TagItem *tag;
  59     LONG *immediate = NULL;
  60     ULONG res = 0;
  61
  62     while ((tag = NextTagItem(&tstate))) {
  63         switch(tag->ti_Tag) {
  64
  65         case VTAG_ATTACH_CM_SET:
  66             cm->cm_vp = (struct ViewPort *)tag->ti_Data;
  67             break;
  68
  69         case VTAG_ATTACH_CM_GET:
  70             tag->ti_Tag = VTAG_ATTACH_CM_SET;
  71             tag->ti_Data = (STACKIPTR)cm->cm_vp;
  72             break;
  73
  74         case VTAG_VIEWPORTEXTRA_SET:
  75             cm->cm_vpe = (struct ViewPortExtra *)tag->ti_Data;
  76             GfxAssociate(cm->cm_vp, &cm->cm_vpe->n);
  77             break;
  78
  79         case VTAG_VIEWPORTEXTRA_GET:
  80             tag->ti_Tag = VTAG_VIEWPORTEXTRA_SET;
  81             tag->ti_Data = (STACKIPTR)cm->cm_vpe;
  82             break;
  83
  84         case VTAG_NORMAL_DISP_SET:
  85             cm->NormalDisplayInfo = (APTR)tag->ti_Data;
  86             break;
  87
  88         case VTAG_NORMAL_DISP_GET:
  89             tag->ti_Tag = VTAG_NORMAL_DISP_SET;
  90             tag->ti_Data = (STACKIPTR)cm->NormalDisplayInfo;
  91             break;
  92
  93         case VTAG_COERCE_DISP_SET:
  94             cm->CoerceDisplayInfo = (APTR)tag->ti_Data;
  95             break;
  96
  97         case VTAG_COERCE_DISP_GET:
  98             tag->ti_Tag = VTAG_COERCE_DISP_SET;
  99             tag->ti_Data = (STACKIPTR)cm->CoerceDisplayInfo;
 100             break;
 101
 102         case VTAG_PF1_BASE_SET:
 103             cm->Bp_0_base = tag->ti_Data;
 104             break;
 105
 106         case VTAG_PF1_BASE_GET:
 107             tag->ti_Tag = VTAG_PF1_BASE_SET;
 108             tag->ti_Data = cm->Bp_0_base;
 109             break;
 110
 111         case VTAG_PF2_BASE_SET:
 112             cm->Bp_1_base = tag->ti_Data;
 113             break;
 114
 115         case VTAG_PF2_BASE_GET:
 116             tag->ti_Tag = VTAG_PF2_BASE_SET;
 117             tag->ti_Data = cm->Bp_1_base;
 118             break;
 119
 120         case VTAG_SPODD_BASE_SET:
 121             cm->SpriteBase_Odd = tag->ti_Data;
 122             break;
 123
 124         case VTAG_SPODD_BASE_GET:
 125             tag->ti_Tag = VTAG_SPODD_BASE_SET;
 126             tag->ti_Data = cm->SpriteBase_Odd;
 127             break;
 128
 129         case VTAG_SPEVEN_BASE_SET:
 130             cm->SpriteBase_Even = tag->ti_Data;
 131             /* TODO: propagate this value to the display driver */
 132             break;
 133
 134         case VTAG_SPEVEN_BASE_GET:
 135             tag->ti_Tag = VTAG_SPEVEN_BASE_SET;
 136             tag->ti_Data = cm->SpriteBase_Even;
 137             break;
 138
 139         case VTAG_BORDERSPRITE_SET:
 140             cm->Flags |= BORDERSPRITES;
 141             break;
 142
 143         case VTAG_BORDERSPRITE_CLR:
 144             cm->Flags &= ~BORDERSPRITES;
 145             break;
 146
 147         case VTAG_BORDERSPRITE_GET:
 148             /* FIXME: Does AmigaOS do the same? */
 149             if (cm->Flags & BORDERSPRITES) {
 150                 tag->ti_Tag = VTAG_BORDERSPRITE_SET;
 151                 tag->ti_Data = TRUE;
 152             } else {
 153                 tag->ti_Tag = VTAG_BORDERSPRITE_CLR;
 154                 tag->ti_Data = FALSE;
 155             }
 156             break;
 157
 158         case VTAG_SPRITERESN_SET:
 159             cm->SpriteResolution = tag->ti_Data;
 160             break;
 161
 162         case VTAG_SPRITERESN_GET:
 163             tag->ti_Tag = VTAG_SPRITERESN_SET;
 164             tag->ti_Data = cm->SpriteResolution;
 165             break;
 166
 167 /* TODO: Implement these */
 168         case VTAG_PF1_TO_SPRITEPRI_SET:
 169             break;
 170
 171         case VTAG_PF1_TO_SPRITEPRI_GET:
 172             tag->ti_Tag = VTAG_PF1_TO_SPRITEPRI_SET;
 173             tag->ti_Data = 0;
 174             break;
 175
 176         case VTAG_PF2_TO_SPRITEPRI_SET:
 177             break;
 178
 179         case VTAG_PF2_TO_SPRITEPRI_GET:
 180             tag->ti_Tag = VTAG_PF2_TO_SPRITEPRI_SET;
 181             tag->ti_Data = 0;
 182             break;
 183
 184         case VTAG_BORDERBLANK_SET:
 185             cm->Flags |= BORDER_BLANKING;
 186             break;
 187
 188         case VTAG_BORDERBLANK_CLR:
 189             cm->Flags &= ~BORDER_BLANKING;
 190             break;
 191
 192         case VTAG_BORDERBLANK_GET:
 193             if (cm->Flags & BORDER_BLANKING) {
 194                 tag->ti_Tag = VTAG_BORDERBLANK_SET;
 195                 tag->ti_Data = TRUE;
 196             } else {
 197                 tag->ti_Tag = VTAG_BORDERBLANK_CLR;
 198                 tag->ti_Data = FALSE;
 199             }
 200             break;
 201
 202         case VTAG_BORDERNOTRANS_SET:
 203             cm->Flags |= BORDER_NOTRANSPARENCY;
 204             break;
 205
 206         case VTAG_BORDERNOTRANS_CLR:
 207             cm->Flags &= ~BORDER_NOTRANSPARENCY;
 208             break;
 209
 210         case VTAG_BORDERNOTRANS_GET:
 211             if (cm->Flags & BORDER_NOTRANSPARENCY) {
 212                 tag->ti_Tag = VTAG_BORDERNOTRANS_SET;
 213                 tag->ti_Data = TRUE;
 214             } else {
 215                 tag->ti_Tag = VTAG_BORDERNOTRANS_CLR;
 216                 tag->ti_Data = FALSE;
 217             }
 218             break;
 219
 220 /* TODO: implement these */
 221         case VTAG_CHROMAKEY_SET:
 222             break;
 223
 224         case VTAG_CHROMAKEY_CLR:
 225             break;
 226
 227         case VTAG_CHROMAKEY_GET:
 228             tag->ti_Tag = VTAG_CHROMAKEY_CLR;
 229             tag->ti_Data = 0;
 230             break;
 231
 232         case VTAG_BITPLANEKEY_SET:
 233             break;
 234
 235         case VTAG_BITPLANEKEY_CLR:
 236             break;
 237
 238         case VTAG_BITPLANEKEY_GET:
 239             tag->ti_Tag = VTAG_BITPLANEKEY_CLR;
 240             tag->ti_Data = 0;
 241             break;
 242
 243         case VTAG_CHROMA_PEN_SET:
 244             break;
 245
 246         case VTAG_CHROMA_PEN_CLR:
 247             break;
 248
 249         case VTAG_CHROMA_PEN_GET:
 250             tag->ti_Tag = VTAG_CHROMA_PEN_CLR;
 251             tag->ti_Data = 0;
 252             break;
 253
 254         case VTAG_CHROMA_PLANE_SET:
 255             break;
 256
 257         case VTAG_CHROMA_PLANE_GET:
 258             tag->ti_Tag = VTAG_CHROMA_PLANE_SET;
 259             tag->ti_Data = 0;
 260             break;
 261
 262         case VTAG_IMMEDIATE:
 263             immediate = (LONG *)tag->ti_Data;
 264             break;
 265
 266         case VTAG_FULLPALETTE_SET:
 267             cm->AuxFlags |= CMAF_FULLPALETTE;
 268             break;
 269
 270         case VTAG_FULLPALETTE_CLR:
 271             cm->AuxFlags &= ~CMAF_FULLPALETTE;
 272             break;
 273
 274         case VTAG_FULLPALETTE_GET:
 275             if (cm->AuxFlags & CMAF_FULLPALETTE) {
 276                 tag->ti_Tag = VTAG_FULLPALETTE_SET;
 277                 tag->ti_Data = TRUE;
 278             } else {
 279                 tag->ti_Tag = VTAG_FULLPALETTE_CLR;
 280                 tag->ti_Data = FALSE;
 281             }
 282             break;
 283
 284         case VC_IntermediateCLUpdate:
 285             if (tag->ti_Data)
 286                 cm->AuxFlags &= ~CMAF_NO_INTERMED_UPDATE;
 287             else
 288                 cm->AuxFlags |= CMAF_NO_INTERMED_UPDATE;
 289             break;
 290
 291         case VC_IntermediateCLUpdate_Query:
 292             *(ULONG *)tag->ti_Data = (cm->AuxFlags & CMAF_NO_INTERMED_UPDATE) ? FALSE : TRUE;
 293             break;
 294
 295         case VC_NoColorPaletteLoad:
 296             if (tag->ti_Data)
 297                 cm->AuxFlags |= CMAF_NO_COLOR_LOAD;
 298             else
 299                 cm->AuxFlags &= ~CMAF_NO_COLOR_LOAD;
 300             break;
 301
 302         case VC_NoColorPaletteLoad_Query:
 303             *(ULONG *)tag->ti_Data = (cm->AuxFlags & CMAF_NO_COLOR_LOAD) ? TRUE : FALSE;
 304             break;
 305
 306         case VC_DUALPF_Disable:
 307             if (tag->ti_Data)
 308                 cm->AuxFlags |= CMAF_DUALPF_DISABLE;
 309             else
 310                 cm->AuxFlags &= ~CMAF_DUALPF_DISABLE;
 311             break;
 312
 313         case VC_DUALPF_Disable_Query:
 314             *(ULONG *)tag->ti_Data = (cm->AuxFlags & CMAF_DUALPF_DISABLE) ? TRUE : FALSE;
 315             break;
 316
 317         case VTAG_USERCLIP_SET:
 318             cm->Flags |= USER_COPPER_CLIP;
 319             break;
 320
 321         case VTAG_USERCLIP_CLR:
 322             cm->Flags &= ~USER_COPPER_CLIP;
 323             break;
 324
 325         case VTAG_USERCLIP_GET:
 326             if (cm->Flags & USER_COPPER_CLIP) {
 327                 tag->ti_Tag = VTAG_USERCLIP_SET;
 328                 tag->ti_Data = TRUE;
 329             } else {
 330                 tag->ti_Tag = VTAG_USERCLIP_CLR;
 331                 tag->ti_Data = FALSE;
 332             }
 333             break;
 334
 335         case VTAG_NEXTBUF_CM:
 336             tstate = (const struct TagItem *)tag->ti_Data;
 337             break;
 338
 339         case VTAG_BATCH_CM_SET:
 340             cm->Flags |= VIDEOCONTROL_BATCH;
 341             break;
 342
 343         case VTAG_BATCH_CM_CLR:
 344             cm->Flags &= ~VIDEOCONTROL_BATCH;
 345             break;
 346
 347         case VTAG_BATCH_CM_GET:
 348             if (cm->Flags & VIDEOCONTROL_BATCH) {
 349                 tag->ti_Tag = VTAG_BATCH_CM_SET;
 350                 tag->ti_Data = TRUE;
 351             } else {
 352                 tag->ti_Tag = VTAG_BATCH_CM_CLR;
 353                 tag->ti_Data = FALSE;
 354             }
 355             break;
 356
 357         case VTAG_BATCH_ITEMS_SET:
 358             cm->cm_batch_items = (struct TagItem *)tag->ti_Data;
 359             break;
 360
 361 /* TODO: implement this */
 362         case VTAG_BATCH_ITEMS_ADD:
 363             break;
 364
 365         case VTAG_BATCH_ITEMS_GET:
 366             tag->ti_Tag = VTAG_BATCH_ITEMS_SET;
 367             tag->ti_Data = (STACKIPTR)cm->cm_batch_items;
 368             break;
 369
 370         case VTAG_VPMODEID_SET:
 371             cm->VPModeID = tag->ti_Data;
 372             break;
 373
 374         case VTAG_VPMODEID_CLR:
 375             cm->VPModeID = INVALID_ID;
 376             break;
 377
 378         case VTAG_VPMODEID_GET:
 379             tag->ti_Tag = (cm->VPModeID == INVALID_ID) ? VTAG_VPMODEID_CLR : VTAG_VPMODEID_SET;
 380             tag->ti_Data = cm->VPModeID;
 381             break;
 382
 383         default:
 384             res = 1;
 385         }
 386     }
 387
 388     if (immediate) {
 389
 390         /* TODO: update SpriteBase in the graphics driver here */
 391
 392         *immediate = 0;
 393     }
 394
 395     return res;
 396
 397     AROS_LIBFUNC_EXIT
 398 } /* VideoControl */