workbench/c/iprefs/wbpatternprefs.c

   1 /*
   2     Copyright © 2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 /*********************************************************************************************/
  10
  11 #include "global.h"
  12
  13 #include <prefs/prefhdr.h>
  14 #include <prefs/wbpattern.h>
  15 #include <datatypes/pictureclass.h>
  16
  17 #define DEBUG 0
  18 #include <aros/debug.h>
  19
  20 /*********************************************************************************************/
  21
  22 struct FileWBPatternPrefs
  23 {
  24     UBYTE   wbp_Reserved[4 * 4];
  25     UBYTE   wbp_Which[2];
  26     UBYTE   wbp_Flags[2];
  27     UBYTE   wbp_Revision;
  28     UBYTE   wbp_Depth;
  29     UBYTE   wbp_DataLength[2];
  30 };
  31
  32 struct LayerHookMsg
  33 {
  34     struct Layer        *lay;           /* not valid for layerinfo backfill hook!!! */
  35     struct Rectangle    bounds;
  36     LONG                offsetx;
  37     LONG                offsety;
  38 };
  39
  40 struct LayerHookData
  41 {
  42     struct BitMap *pat_bm;
  43     ULONG pat_width;
  44     ULONG pat_height;
  45 };
  46
  47 /*********************************************************************************************/
  48
  49 static LONG stopchunks[] =
  50 {
  51     ID_PREF, ID_PTRN
  52 };
  53
  54 /*********************************************************************************************/
  55
  56 static void RootPatternSetup(STRPTR filename);
  57
  58 /*********************************************************************************************/
  59
  60 void WBPatternPrefs_Handler(STRPTR filename)
  61 {
  62     struct IFFHandle *iff;
  63
  64     D(bug("In IPrefs:WBPatternPrefs_Handler\n"));
  65
  66     if ((iff = CreateIFF(filename, stopchunks, 1)))
  67     {
  68         while(ParseIFF(iff, IFFPARSE_SCAN) == 0)
  69         {
  70             struct ContextNode   *cn;
  71             struct FileWBPatternPrefs wbpatternprefs;
  72
  73             cn = CurrentChunk(iff);
  74
  75             D(bug("WBPatternPrefs_Handler: ParseIFF okay. Chunk Type = %c%c%c%c  ChunkID = %c%c%c%c\n",
  76                   cn->cn_Type >> 24,
  77                   cn->cn_Type >> 16,
  78                   cn->cn_Type >> 8,
  79                   cn->cn_Type,
  80                   cn->cn_ID >> 24,
  81                   cn->cn_ID >> 16,
  82                   cn->cn_ID >> 8,
  83                   cn->cn_ID));
  84
  85             if ((cn->cn_ID == ID_PTRN) && (cn->cn_Size > sizeof(wbpatternprefs)))
  86             {
  87                 D(bug("WBPatternPrefs_Handler: ID_FONT chunk with correct size found.\n"));
  88
  89                 if (ReadChunkBytes(iff, &wbpatternprefs, sizeof(wbpatternprefs)) == sizeof(wbpatternprefs))
  90                 {
  91                     UWORD           type;
  92                     UWORD           len;
  93                     STRPTR          filename;
  94
  95                     D(bug("WBPatternPrefs_Handler: Reading of ID_PTRN chunk okay.\n"));
  96
  97                     type = (wbpatternprefs.wbp_Which[0] << 8) + wbpatternprefs.wbp_Which[1];
  98                     len = (wbpatternprefs.wbp_DataLength[0] << 8) + wbpatternprefs.wbp_DataLength[1];
  99
 100                     D(bug("Type = %d  Len = %d\n", type, len));
 101
 102                     if (sizeof(wbpatternprefs) + len == cn->cn_Size)
 103                     {
 104                         filename = (STRPTR)AllocVec(len + 1, MEMF_ANY);
 105                         if (filename != NULL)
 106                         {
 107                             if (ReadChunkBytes(iff, filename, len) == len)
 108                             {
 109                                 filename[len] = 0;
 110                                 D(bug("Filename = %s\n", filename));
 111                                 switch(type)
 112                                 {
 113                                     case WBP_ROOT:
 114                                         RootPatternCleanup();
 115                                         RootPatternSetup(filename);
 116                                         break;
 117                                     case WBP_DRAWER:
 118                                         break;
 119                                     case WBP_SCREEN:
 120                                         break;
 121                                 } /* switch(type) */
 122                             } /*  if (ReadChunkBytes(iff, filename, len + 1) == len + 1) */
 123                             FreeVec(filename);
 124                         } /*  if (filename != NULL) */
 125                     } /*  if (sizeof(wbpatternprefs) + len + 1 == cn->cn_Size) */
 126                 } /* if (ReadChunkBytes(iff, &wbpatternprefs, sizeof(wbpatternprefs)) == sizeof(wbpatternprefs)) */
 127
 128             } /* if ((cn->cn_ID == ID_FONT) && (cn->cn_Size == sizeof(wbpatternprefs))) */
 129
 130         } /* while(ParseIFF(iff, IFFPARSE_SCAN) == 0) */
 131
 132         KillIFF(iff);
 133
 134     } /* if ((iff = CreateIFF(filename))) */
 135
 136
 137     D(bug("In IPrefs:WBPatternPrefs_Handler. Done.\n", filename));
 138 }
 139
 140 /****************************************************************************************/
 141
 142 static void mybackfillfunc(struct Hook *hook,struct RastPort *rp, struct LayerHookMsg *msg)
 143 {
 144     struct LayerHookData *data = (struct LayerHookData *)hook->h_Data;
 145     WORD            x1,y1,x2,y2,px,py,pw,ph;
 146
 147     x1 = msg->bounds.MinX;
 148     y1 = msg->bounds.MinY;
 149     x2 = msg->bounds.MaxX;
 150     y2 = msg->bounds.MaxY;
 151
 152     px = x1 % data->pat_width;
 153
 154     pw = data->pat_width - px;
 155
 156     do
 157     {
 158         y1 = msg->bounds.MinY;
 159         py = y1  % data->pat_height;
 160
 161         ph = data->pat_height - py;
 162
 163         if (pw > (x2 - x1 + 1)) pw = x2 - x1 + 1;
 164
 165         do
 166         {
 167             if (ph > (y2 - y1 + 1)) ph = y2 - y1 + 1;
 168
 169             BltBitMap(data->pat_bm,
 170                       px,
 171                       py,
 172                       rp->BitMap,
 173                       x1,
 174                       y1,
 175                       pw,
 176                       ph,
 177                       192,
 178                       255,
 179                       0);
 180
 181             y1 += ph;
 182
 183             py = 0;
 184             ph = data->pat_height;
 185
 186         } while (y1 <= y2); /* while(y1 < y2) */
 187
 188         x1 += pw;
 189
 190         px = 0;
 191         pw = data->pat_width;
 192
 193     } while (x1 <= x2); /* while (x1 < x2) */
 194
 195 }
 196
 197
 198 /****************************************************************************************/
 199
 200 static struct Hook *installbackfillhook(struct Screen *scr, struct Hook *backfillhook,
 201                                         struct LayerHookData *data)
 202 {
 203     struct Window *tempwin;
 204     struct Hook *oldhook;
 205
 206     struct TagItem wintags[] =
 207     {
 208         {WA_PubScreen   ,(IPTR)scr                      },
 209         {WA_Left        ,0                              },
 210         {WA_Top         ,0                              },
 211         {WA_Width       ,scr->Width                     },
 212         {WA_Height      ,scr->Height                    },
 213         {WA_Borderless  ,TRUE                           },
 214         {WA_Backdrop    ,TRUE                           },
 215         {WA_BackFill    ,(IPTR)LAYERS_NOBACKFILL        },
 216         {TAG_DONE                                       }
 217     };
 218
 219     backfillhook->h_Entry    = HookEntry;
 220     backfillhook->h_SubEntry = (HOOKFUNC)mybackfillfunc;
 221     backfillhook->h_Data     = data;
 222
 223     oldhook = InstallLayerInfoHook(&scr->LayerInfo, backfillhook);
 224     tempwin = OpenWindowTagList(NULL, wintags);
 225     if (tempwin) CloseWindow(tempwin);
 226     return oldhook;
 227 }
 228
 229 /****************************************************************************************/
 230
 231 static void removebackfillhook(struct Screen *scr, struct Hook *oldhook)
 232 {
 233     struct TagItem wintags[] =
 234     {
 235         { WA_PubScreen , (IPTR)scr               },
 236         { WA_Left      , 0                       },
 237         { WA_Top       , 0                       },
 238         { WA_Width     , scr->Width              },
 239         { WA_Height    , scr->Height             },
 240         { WA_Borderless, TRUE                    },
 241         { WA_Backdrop  , TRUE                    },
 242         { WA_BackFill  , (IPTR)LAYERS_NOBACKFILL },
 243         { TAG_DONE                               }
 244     };
 245     struct Window *tempwin;
 246
 247     InstallLayerInfoHook(&scr->LayerInfo, oldhook);
 248     tempwin = OpenWindowTagList(NULL, wintags);
 249     if (tempwin) CloseWindow(tempwin);
 250 }
 251
 252 /*********************************************************************************************/
 253
 254 static struct BitMap *LoadDTBitmap (CONST_STRPTR filename, struct Screen *scr,
 255                                     Object **obj, ULONG *width, ULONG *height)
 256 {
 257     struct BitMapHeader *bmhd;
 258     struct BitMap *bitmap = NULL;
 259     Object *o;
 260     struct Process *myproc = (struct Process *)FindTask(NULL);
 261     APTR oldwindowptr = myproc->pr_WindowPtr;
 262
 263     myproc->pr_WindowPtr = (APTR)-1;
 264
 265     o = NewDTObject((APTR)filename,
 266                     DTA_GroupID          , GID_PICTURE,
 267                     OBP_Precision        , PRECISION_EXACT,
 268                     PDTA_Screen          , (IPTR)scr,
 269                     PDTA_FreeSourceBitMap, TRUE,
 270                     PDTA_DestMode        , PMODE_V43,
 271                     PDTA_UseFriendBitMap , TRUE,
 272                     TAG_DONE);
 273
 274     myproc->pr_WindowPtr = oldwindowptr;
 275
 276     if (o)
 277     {
 278         struct FrameInfo fri = {0};
 279         DoMethod(o, DTM_FRAMEBOX, (IPTR) NULL, (IPTR) &fri, (IPTR) &fri,
 280                  sizeof(struct FrameInfo), 0);
 281
 282         if (fri.fri_Dimensions.Depth > 0)
 283         {
 284             if (DoMethod(o, DTM_PROCLAYOUT, (IPTR) NULL, 1))
 285             {
 286                 *obj = o;
 287                 GetDTAttrs(o, PDTA_BitMapHeader, (IPTR)&bmhd, TAG_DONE);
 288                 if (bmhd)
 289                 {
 290                     *width = bmhd->bmh_Width;
 291                     *height = bmhd->bmh_Height;
 292                     GetDTAttrs(o, PDTA_DestBitMap, (IPTR)&bitmap, TAG_DONE);
 293                     if (NULL == bitmap)
 294                         GetDTAttrs(o, PDTA_BitMap, (IPTR)&bitmap, TAG_DONE);
 295                     if (bitmap)
 296                         return bitmap;
 297                 }
 298             }
 299
 300         }
 301         DisposeDTObject(o);
 302     }
 303     return NULL;
 304 }
 305
 306 /*********************************************************************************************/
 307
 308 static Object        *myDTObject = NULL;
 309 static struct Hook   *myOldHook = (APTR)-1; // NULL is a valid value
 310 static struct Screen *myScreen = NULL;
 311 static struct LayerHookData myData;
 312 static struct Hook    myBackFillHook;
 313
 314 /*********************************************************************************************/
 315
 316 static void RootPatternSetup(STRPTR filename)
 317 {
 318     struct BitMap *patternbm = NULL;
 319     ULONG w;
 320     ULONG h;
 321
 322     if ((myScreen = LockPubScreen(NULL)) != NULL)
 323     {
 324         D(bug("loading '%s'\n", filename));
 325         patternbm = LoadDTBitmap(filename, myScreen, &myDTObject, &w, &h);
 326
 327         if (patternbm)
 328         {
 329             myData.pat_bm = patternbm;
 330             myData.pat_width = w;
 331             myData.pat_height = h;
 332
 333             myOldHook = installbackfillhook(myScreen, &myBackFillHook, &myData);
 334             D(bug("oldhook=%p\n", myOldHook));
 335         }
 336     }
 337 }
 338
 339 /*********************************************************************************************/
 340
 341 void RootPatternCleanup (void)
 342 {
 343     if (myOldHook != (APTR)-1)
 344     {
 345         D(bug("Reinstalling old backfillhook\n"));
 346         removebackfillhook(myScreen, myOldHook);
 347         myOldHook = (APTR)-1;
 348     }
 349     if (myDTObject)
 350     {
 351         D(bug("Disposing DT obj\n"));
 352         DisposeDTObject(myDTObject);
 353         myDTObject = NULL;
 354     }
 355     if (myScreen)
 356     {
 357         D(bug("Unlock PubScreen\n"));
 358         UnlockPubScreen(NULL, myScreen);
 359         myScreen = NULL;
 360     }
 361 }
 362