rom/intuition/setiprefs.c

   1 /*
   2     Copyright © 1995-2015, The AROS Development Team. All rights reserved.
   3     Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7 #include <proto/exec.h>
   8 #include <intuition/iprefs.h>
   9 #include <intuition/pointerclass.h>
  10 #include <prefs/pointer.h>
  11 #include <prefs/palette.h>
  12
  13 #include <proto/intuition.h>
  14 #include <proto/graphics.h>
  15
  16 #include "intuition_intern.h"
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21         AROS_LH3(ULONG, SetIPrefs,
  22
  23 /*  SYNOPSIS */
  24         AROS_LHA(APTR , data, A0),
  25         AROS_LHA(ULONG, length, D0),
  26         AROS_LHA(ULONG, type, D1),
  27
  28 /*  LOCATION */
  29         struct IntuitionBase *, IntuitionBase, 96, Intuition)
  30
  31 /*  FUNCTION
  32
  33     INPUTS
  34
  35     RESULT
  36         Depending on the operation.
  37
  38     NOTES
  39         This function is currently considered private.
  40
  41     EXAMPLE
  42
  43     BUGS
  44
  45     SEE ALSO
  46
  47     INTERNALS
  48
  49 *****************************************************************************/
  50 {
  51     AROS_LIBFUNC_INIT
  52
  53     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
  54     ULONG Result = TRUE;
  55     ULONG lock = LockIBase(0);
  56
  57     DEBUG_SETIPREFS(bug("SetIPrefs: data %p length %lu type %lu\n", data, length, type));
  58
  59     switch (type)
  60     {
  61         case IPREFS_TYPE_ICONTROL_V37:
  62             DEBUG_SETIPREFS(bug("SetIPrefs: IP_ICONTROL_V37\n"));
  63             if (length > sizeof(struct IIControlPrefs))
  64                 length = sizeof(struct IIControlPrefs);
  65             CopyMem(data, &GetPrivIBase(IntuitionBase)->IControlPrefs, length);
  66
  67             DEBUG_SETIPREFS(bug("SetIPrefs: Drag modes: 0x%04lX\n", GetPrivIBase(IntuitionBase)->IControlPrefs.ic_VDragModes[0]));
  68
  69             break;
  70
  71         case IPREFS_TYPE_SCREENMODE_V37:
  72         {
  73             BOOL reopen = FALSE, closed = (GetPrivIBase(IntuitionBase)->WorkBench) ? FALSE : TRUE;
  74
  75             DEBUG_SETIPREFS(bug("SetIPrefs: IP_SCREENMODE_V37\n"));
  76             if (length > sizeof(struct IScreenModePrefs))
  77                 length = sizeof(struct IScreenModePrefs);
  78
  79             if (!GetPrivIBase(IntuitionBase)->ScreenModePrefs)
  80                 GetPrivIBase(IntuitionBase)->ScreenModePrefs = AllocMem(sizeof(struct IScreenModePrefs), MEMF_ANY);
  81
  82             if (memcmp(GetPrivIBase(IntuitionBase)->ScreenModePrefs, data,
  83                        sizeof(struct IScreenModePrefs)) == 0)
  84                 break;
  85
  86             if (!closed)
  87             {
  88                 BOOL try = TRUE;
  89
  90                 reopen = TRUE;
  91
  92                 UnlockIBase(lock);
  93
  94                 while (try && !(closed = CloseWorkBench()))
  95                 {
  96                     struct EasyStruct es =
  97                     {
  98                         sizeof(struct EasyStruct),
  99                         0,
 100                         "System Request",
 101                         "Intuition is attempting to reset the screen,\n"
 102                         "please close all windows except Wanderer's ones.",
 103                         "Retry|Cancel"
 104                     };
 105
 106                     try = EasyRequestArgs(NULL, &es, NULL, NULL) == 1;
 107                 }
 108             }
 109
 110             if (closed)
 111                 CopyMem(data, GetPrivIBase(IntuitionBase)->ScreenModePrefs, sizeof(struct IScreenModePrefs));
 112
 113             if (reopen)
 114             {
 115                 if (closed)
 116                 {
 117                     if (!OpenWorkBench())
 118                     {
 119                         /* FIXME: handle the error condition if OpenWorkBench() fails */
 120                         /* What to do if OpenWorkBench() fails? Try until it succeeds?
 121                            Try for a finite amount of times? Don't try and do nothing
 122                            at all? */
 123                     }
 124                 }
 125                 else
 126                     Result = FALSE;
 127                 return Result;
 128             }
 129
 130             break;
 131         }
 132
 133         case IPREFS_TYPE_POINTER_V39:
 134         DEBUG_SETIPREFS(bug("SetIPrefs: IP_POINTER_V39\n"));
 135         {
 136             struct IPointerPrefs *fp = data;
 137             struct TagItem pointertags[] = {
 138                 {POINTERA_BitMap , (IPTR)fp->BitMap},
 139                 {POINTERA_XOffset, fp->XOffset     },
 140                 {POINTERA_YOffset, fp->YOffset     },
 141                 {TAG_DONE        , 0               }
 142             };
 143
 144             Object *pointer = NewObjectA(
 145                           GetPrivIBase(IntuitionBase)->pointerclass,
 146                           NULL,
 147                           pointertags);
 148
 149             Object **oldptr = fp->Which ?
 150                       &GetPrivIBase(IntuitionBase)->BusyPointer :
 151                       &GetPrivIBase(IntuitionBase)->DefaultPointer;
 152
 153             InstallPointer(IntuitionBase, fp->Which, oldptr, pointer);
 154             /* return -1 so that WB3.x C:IPrefs is happy */
 155             Result = -1;
 156         }
 157         break;
 158
 159         case IPREFS_TYPE_POINTER_V37:
 160         DEBUG_SETIPREFS(bug("SetIPrefs: IP_POINTER_V37\n"));
 161         {
 162             struct Preferences *ActivePrefs = &GetPrivIBase(IntuitionBase)->ActivePreferences;
 163             struct IPointerPrefsV37 *fp = data;
 164             UWORD size = fp->YSize * 2;
 165             Object *pointer;
 166
 167             if (size > POINTERSIZE)
 168                 size = POINTERSIZE;
 169             memset(ActivePrefs->PointerMatrix, 0, POINTERSIZE * sizeof (UWORD));
 170             CopyMem(fp->data, ActivePrefs->PointerMatrix, size * sizeof (UWORD));
 171             ActivePrefs->XOffset = fp->XOffset;
 172             ActivePrefs->YOffset = fp->YOffset;
 173
 174             pointer = MakePointerFromPrefs(IntuitionBase, ActivePrefs);
 175             if (pointer)
 176                  InstallPointer(IntuitionBase, WBP_NORMAL, &GetPrivIBase(IntuitionBase)->DefaultPointer, pointer);
 177             /* return -1 so that WB2.x C:IPrefs is happy */
 178             Result = -1;
 179         }
 180         break;
 181
 182         case IPREFS_TYPE_PALETTE_V39:
 183         case IPREFS_TYPE_PALETTE_V37:
 184         DEBUG_SETIPREFS(bug("SetIPrefs: IP_PALETTE_V%d %p %d\n", type == IPREFS_TYPE_PALETTE_V39 ? 39 : 37, data, length));
 185         {
 186             struct ColorSpec *pp = data;
 187             struct Color32 *p = GetPrivIBase(IntuitionBase)->Colors;
 188             BOOL update_pointer = FALSE;
 189             struct Preferences *ActivePrefs = &GetPrivIBase(IntuitionBase)->ActivePreferences;
 190
 191             DEBUG_SETIPREFS(bug("SetIPrefs: Intuition Color32 Table 0x%p\n", p));
 192
 193             while (pp->ColorIndex != -1)
 194             {
 195                 WORD idx;
 196
 197                 idx = pp->ColorIndex;
 198                 DEBUG_SETIPREFS(bug("SetIPrefs: Index %ld R 0x%04lX G 0x%04lX B 0x%04lX\n",
 199                                     idx, pp->Red, pp->Green, pp->Blue));
 200                 if (type == IPREFS_TYPE_PALETTE_V37) {
 201                     /* v37 cursor colors are 17 to 19 */
 202                     if (idx >= 17)
 203                         idx = idx - 17 + 8;
 204                     else if (idx >= 8)
 205                         idx = -1;
 206                 }
 207                 if (idx >= 0 && idx < COLORTABLEENTRIES)
 208                 {
 209                     UWORD red, green, blue;
 210                     if (type == IPREFS_TYPE_PALETTE_V37) {
 211                         /* 4-bit color components */
 212                         red = (pp->Red << 4) | pp->Red;
 213                         green = (pp->Green << 4) | pp->Green;
 214                         blue = (pp->Blue << 4) | pp->Blue;
 215                         red = (red << 8) | red;
 216                         green = (green << 8) | green;
 217                         blue = (blue << 8) | blue;
 218                     } else {
 219                         /* 8-bit color components */
 220                         red = pp->Red;
 221                         green = pp->Green;
 222                         blue = pp->Blue;
 223                     }
 224
 225                     p[idx].red   = (red << 16) | red;
 226                     p[idx].green = (green << 16) | green;
 227                     p[idx].blue  = (blue << 16) | blue;
 228
 229                     /* Update oldstyle preferences */
 230                     if (ActivePrefs)
 231                     {
 232                         UWORD *cols = NULL;
 233                         UWORD baseindex;
 234
 235                         if (idx < 4) {
 236                             baseindex = 0;
 237                             cols = &ActivePrefs->color0;
 238                         } else if (idx >= 8 && idx <= 10) {
 239                             baseindex = 8;
 240                             cols=&ActivePrefs->color17;
 241                             update_pointer = TRUE;
 242                         }
 243
 244                         if (cols)
 245                             cols[idx - baseindex] = ((red >> 4) & 0xf00) | ((green >> 8) & 0x0f0) | ((blue >> 12));
 246                     }
 247                     DEBUG_SETIPREFS(bug("SetIPrefs: Set Color32 %ld R 0x%08lx G 0x%08lx B 0x%08lx\n",
 248                                 (LONG) idx,
 249                                 p[idx].red,
 250                                 p[idx].green,
 251                                 p[idx].blue));
 252                 }
 253                 pp++;
 254             }
 255
 256             if (update_pointer) {
 257                 DEBUG_SETIPREFS(bug("[SetIPrefs] Updating pointer colors\n"));
 258                 SetPointerColors(IntuitionBase);
 259             }
 260         }
 261         break;
 262
 263         case IPREFS_TYPE_PENS_V39:
 264         DEBUG_SETIPREFS(bug("SetIPrefs: IP_PENS_V39\n"));
 265         {
 266             struct IOldPenPrefs *fp = data;
 267             UWORD *dataptr;
 268             int i;
 269             DEBUG_SETIPREFS(bug("SetIPrefs: Count %ld Type %ld\n",
 270                         (LONG) fp->Count,
 271                         (LONG) fp->Type));
 272
 273             if (fp->Type==0)
 274             {
 275                 dataptr = &GetPrivIBase(IntuitionBase)->DriPens4[0];
 276                 DEBUG_SETIPREFS(bug("SetIPrefs: Pens4[]\n"));
 277             }
 278             else
 279             {
 280                 dataptr = &GetPrivIBase(IntuitionBase)->DriPens8[0];
 281                 DEBUG_SETIPREFS(bug("SetIPrefs: Pens8[]\n"));
 282             }
 283             for (i=0;i<NUMDRIPENS;i++)
 284             {
 285                 if (fp->PenTable[i]==(UWORD)~0UL)
 286                 {
 287                     /*
 288                      * end of the array
 289                      */
 290                     DEBUG_SETIPREFS(bug("SetIPrefs: PenTable end at entry %ld\n", (LONG) i));
 291                     break;
 292                 }
 293                 else
 294                 {
 295                     DEBUG_SETIPREFS(bug("SetIPrefs: Pens[%ld] %ld\n",
 296                                 (LONG) i,
 297                                 (LONG) fp->PenTable[i]));
 298                     dataptr[i] = fp->PenTable[i];
 299                 }
 300             }
 301         }
 302         break;
 303
 304
 305         case IPREFS_TYPE_POINTER_ALPHA:
 306             DEBUG_SETIPREFS(bug("[SetIPrefs]: IP_POINTER_ALPHA\n"));
 307             GetPrivIBase(IntuitionBase)->PointerAlpha = *(UWORD *)data;
 308         break;
 309
 310         case IPREFS_TYPE_OVERSCAN_V37:
 311             DEBUG_SETIPREFS(bug("[SetIPrefs]: IP_OVERSCAN_V37\n"));
 312         break;
 313
 314         case IPREFS_TYPE_FONT_V37:
 315         DEBUG_SETIPREFS(bug("SetIPrefs: IP_FONT_V37\n"));
 316         {
 317             struct IFontPrefs *fp = data;
 318             struct TextFont *font = OpenFont(&fp->fp_TextAttr);
 319             struct TextFont **fontptr;
 320
 321             DEBUG_SETIPREFS(bug("SetIPrefs: Type %d Name <%s> Size %d Font %p\n", fp->fp_ScrFont, fp->fp_Name, fp->fp_TextAttr.ta_YSize, font));
 322
 323             if (font)
 324             {
 325                 if (fp->fp_ScrFont==0)
 326                 {
 327                     /*
 328                      * We can't free graphics defaultfont..it`s shared
 329                      */
 330                     fontptr = &GfxBase->DefaultFont;
 331                 }
 332                 else
 333                 {
 334                     fontptr = &GetPrivIBase(IntuitionBase)->ScreenFont;
 335                     CloseFont(*fontptr);
 336                 }
 337                 *fontptr = font;
 338             }
 339         }
 340         break;
 341
 342         default:
 343             DEBUG_SETIPREFS(bug("SetIPrefs: Unknown Prefs Type\n"));
 344             Result = FALSE;
 345             break;
 346     }
 347
 348     UnlockIBase(lock);
 349
 350     DEBUG_SETIPREFS(bug("SetIPrefs: Result 0x%lx\n",Result));
 351
 352     return(Result);
 353
 354     AROS_LIBFUNC_EXIT
 355 } /* private1 */