test/gfxtest.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Demo showing gfx hidd
   6 */
   7
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <exec/types.h>
  11 #include <graphics/rastport.h>
  12 #include <graphics/gfxmacros.h>
  13 #include <intuition/intuition.h>
  14 #include <proto/dos.h>
  15 #include <proto/exec.h>
  16 #include <proto/graphics.h>
  17 #include <proto/intuition.h>
  18
  19 #define SDEBUG 1
  20 #define DEBUG 1
  21
  22 #include <aros/debug.h>
  23
  24 #define USE_TWO_WINDOWS
  25
  26 struct IntuitionBase *IntuitionBase;
  27 struct GfxBase *GfxBase;
  28 struct Library *LayersBase;
  29 struct DosLibrary *DOSBase;
  30
  31 struct Screen * openscreen(void);
  32 struct Window *openwindow(struct Screen *screen, const char *title, LONG x, LONG y, LONG w, LONG h);
  33
  34 VOID test_blttemplate( struct Window *w);
  35 VOID test_bltpattern(struct Window *w);
  36 VOID test_bltmask(struct Window *w);
  37 VOID test_flood(struct Window *w);
  38 VOID test_readpixel(struct Window *w);
  39 VOID test_linedrawing(struct Window *w1, struct Window *w2);
  40
  41 ULONG handleevents(struct Window *win, ULONG idcmp);
  42
  43 #define W1_LEFT         100
  44 #define W1_TOP          100
  45 #define W1_WIDTH        200
  46 #define W1_HEIGHT       200
  47
  48 #define W2_LEFT         150
  49 #define W2_TOP          150
  50 #define W2_WIDTH        250
  51 #define W2_HEIGHT       250
  52
  53
  54 int main(int argc, char **argv)
  55 {
  56     /* Intialize debugging */
  57     SDInit();
  58
  59     if ((IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library", 0)))
  60     {
  61         if ((GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 0)))
  62         {
  63             if ((DOSBase = (struct DosLibrary *) OpenLibrary("dos.library",0)))
  64             {
  65               struct Screen *screen;
  66               struct Window *w1;
  67
  68
  69               if ((screen = openscreen()))
  70               {
  71                 w1 = openwindow(screen, "Window 1",  W1_LEFT, W1_TOP, W1_WIDTH, W1_HEIGHT);
  72                 if (w1)
  73                 {
  74
  75 #ifdef USE_TWO_WINDOWS
  76                     struct Window *w2;
  77
  78                     w2 = openwindow(screen, "Window 2", W2_LEFT, W2_TOP, W2_WIDTH, W2_HEIGHT);
  79                     if (w2)
  80                     {
  81
  82 #endif
  83                         /* Wait forever */
  84                         // test_readpixel(w1);
  85 /*                      SetAPen(w1->RPort, 3);
  86                         SetBPen(w1->RPort, 4);
  87                         test_blttemplate(w1);
  88 */
  89                         test_linedrawing(w1, w2);
  90                         handleevents(w1, 0);
  91
  92 #ifdef USE_TWO_WINDOWS
  93                         CloseWindow(w2);
  94                     }
  95 #endif
  96                     CloseWindow(w1);
  97                 }
  98                 CloseScreen(screen);
  99               }
 100               CloseLibrary((struct Library *)DOSBase);
 101           }
 102           CloseLibrary((struct Library *)GfxBase);
 103         }
 104         CloseLibrary((struct Library *) IntuitionBase);
 105     }
 106     return 0;
 107 } /* main */
 108
 109
 110
 111 struct Window *openwindow(struct Screen *screen, const char *title, LONG x, LONG y, LONG w, LONG h)
 112 {
 113
 114   struct Window *window;
 115   printf("Opening window, screen=%p\n", screen);
 116
 117   window = OpenWindowTags(NULL,
 118                           WA_IDCMP, IDCMP_RAWKEY | IDCMP_CLOSEWINDOW | IDCMP_CHANGEWINDOW,
 119                           WA_Left,      x,
 120                           WA_Top,       y,
 121                           WA_Width,     w,
 122                           WA_Height,    h,
 123                           WA_CustomScreen, screen,
 124                           WA_Activate,          TRUE,
 125                           WA_DepthGadget,       TRUE,
 126                           WA_CloseGadget,       TRUE,
 127                           WA_SmartRefresh,      TRUE,
 128                           WA_NotifyDepth,       TRUE,
 129                           WA_Title,             title,
 130
 131                           TAG_END);
 132
 133   printf("Window opened\n");
 134
 135   return window;
 136 }
 137
 138
 139 struct Screen * openscreen(void)
 140 {
 141   struct Screen * screen;
 142   UWORD pens[] = { ~0 };
 143 ULONG patterncoltab[] = {
 144     (16L << 16) + 0,    /* 16 colors, loaded at index 0 */
 145
 146     0xB3B3B3B3, 0xB3B3B3B3, 0xB3B3B3B3, /* Grey70       */
 147     0x00000000, 0x00000000, 0x00000000, /* Black        */
 148     0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, /* White        */
 149     0x66666666, 0x88888888, 0xBBBBBBBB, /* AMIGA Blue   */
 150
 151     0x00000000, 0x00000000, 0xFFFFFFFF, /* Blue         */
 152     0x00000000, 0xFFFFFFFF, 0x00000000, /* Green        */
 153     0xFFFFFFFF, 0x00000000, 0x00000000, /* Red          */
 154     0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, /* Cyan         */
 155
 156     0x33333333, 0x33333333, 0x33333333, /* Pattern Col 1 */
 157     0xcdcdcdcd, 0x6c6c6c6c, 0xc7c7c7c7, /* Pattern Col 2 */
 158     0x8e8e8e8e, 0x85858585, 0x93939393, /* Pattern Col 3 */
 159     0x22222222, 0x22222222, 0x22222222, /* Pattern Col 4 */
 160
 161     0x77777777, 0x77777777, 0x77777777, /* Pattern Col 5 */
 162     0x66666666, 0x66666666, 0x66666666, /* Pattern Col 6 */
 163     0x55555555, 0x55555555, 0x55555555, /* Pattern Col 7 */
 164     0x44444444, 0x44444444, 0x44444444, /* Pattern Col 8 */
 165
 166     0L          /* Termination */
 167 };
 168
 169   printf("Opening screen\n");
 170   if ((screen = OpenScreenTags(NULL,
 171                           SA_Width,     640,
 172                           SA_Height,    480,
 173                           SA_Depth,     24,
 174                           SA_Title,     "gfx hidd demo",
 175                           SA_Pens,      pens,
 176                           TAG_END))) {
 177   } else {
 178       screen = OpenScreenTags(NULL,
 179                           SA_Width,     640,
 180                           SA_Height,    480,
 181                           SA_Title,     "gfx hidd demo",
 182                           TAG_END);
 183   }
 184
 185   if (screen)
 186         LoadRGB32(&screen->ViewPort, patterncoltab);
 187
 188 /*  screen->RastPort.longreserved[0] = window->RPort->longreserved[0];
 189
 190   Draw(&screen->RastPort, 100, 100);
 191 */
 192   return screen;
 193 }
 194
 195
 196 VOID test_readpixel(struct Window *w)
 197 {
 198     ULONG i;
 199
 200     for (i = 0; i < 16; i ++) {
 201         UBYTE pen;
 202         SetAPen(w->RPort, i);
 203         WritePixel(w->RPort, 70, 70);
 204
 205         pen = ReadPixel(w->RPort, 70, 70);
 206
 207         printf("Wrote pen %ld, read pen %d\n", (long)i, pen);
 208
 209     }
 210 }
 211
 212 VOID test_flood(struct Window *w)
 213 {
 214
 215     struct TmpRas tmpras;
 216     BYTE *buffer;
 217
 218 D(bug("Window layer: %p\n", w->WLayer));
 219
 220     buffer = AllocRaster(w->WLayer->Width, w->WLayer->Height);
 221 D(bug("buffer: %p\n", buffer));
 222     if (!buffer)
 223         return;
 224
 225     InitTmpRas(&tmpras, buffer, RASSIZE(w->WLayer->Width, w->WLayer->Height));
 226     w->RPort->TmpRas = &tmpras;
 227
 228     SetOutlinePen(w->RPort, 1);
 229     SetAPen(w->RPort, 1);
 230
 231     SetDrPt(w->RPort, ~0L);
 232
 233     Move(w->RPort, 50, 50);
 234     Draw(w->RPort, 100, 100);
 235     Draw(w->RPort, 50,  100);
 236     Draw(w->RPort, 50, 50);
 237
 238 D(bug("Calling Flood()\n"));
 239     Flood(w->RPort, 0, 70, 80);   /* outline mode */
 240
 241     w->RPort->TmpRas = NULL;
 242
 243 }
 244
 245 #define MASK_WIDTH 32
 246 #define MASK_HEIGHT 6
 247
 248 #define SRC_X 50
 249 #define SRC_Y 50
 250
 251 #define DEST_X 100
 252 #define DEST_Y 50
 253
 254 VOID test_bltmask(struct Window *w)
 255 {
 256 /*    ULONG mask[] = {
 257         0xAAAAAAAA,
 258         0xAAAAAAAA,
 259         0xFFFFFFFF,
 260         0xFFFFFFFF,
 261         0xAAAAAAAA,
 262         0xAAAAAAAA
 263     };
 264 */
 265     /* Fill a area to blit from */
 266
 267     SetAPen(w->RPort, 1);
 268
 269     RectFill(w->RPort, SRC_X, SRC_Y, SRC_X + MASK_WIDTH - 1, SRC_Y + MASK_HEIGHT);
 270
 271     /* Blit from source area */
 272 /*    BltMaskBitMapRastPort(w->RPort
 273         , SRC_X, SRC_Y
 274         , DEST_X, DEST_Y
 275         , MASK_WIDTH, MASK_HEIGHT
 276         , 0x00C0
 277         , (PLANEPTR) mask
 278    );
 279 */
 280
 281     return;
 282 }
 283
 284 VOID test_blttemplate(struct Window *w)
 285 {
 286     UBYTE template[] = { 0xAA, 0xAA, 0xAA, 0xAA
 287                            , 0xAA, 0xAA, 0xAA, 0xAA };
 288
 289     BltTemplate((PLANEPTR)template
 290                 , 0 /* xsrc */
 291                 , 4 /* modulo */
 292                 , w->RPort
 293                 , 50, 50  /* xdest, ydest */
 294                 , 16 , 2  /* width, height */
 295     );
 296
 297     return;
 298 }
 299
 300 VOID test_bltpattern(struct Window *w)
 301 {
 302     UWORD afpt[] = { 0xAAAA , 0x5555 };
 303
 304
 305     SetDrMd(w->RPort, JAM2);
 306     SetAPen(w->RPort, 1);
 307     SetBPen(w->RPort, 2);
 308
 309
 310     SetAfPt(w->RPort, afpt, 1);
 311
 312     BltPattern(w->RPort, NULL, 50, 50, 100, 100, 0);
 313
 314     return;
 315
 316 }
 317
 318 VOID test_linedrawing(struct Window *w1, struct Window *w2)
 319 {
 320     struct RastPort *rp;
 321     struct Window *frontwin, *backwin, *tmp;
 322     LONG x;
 323     ULONG innerwidth;
 324
 325     rp = w1->RPort;
 326     frontwin = w2;
 327     backwin = w1;
 328
 329     SetAPen(rp, 3);
 330     SetDrMd(rp, COMPLEMENT);
 331
 332     innerwidth = W1_WIDTH - w1->BorderLeft - w1->BorderRight;
 333
 334     for (x = 0; x < innerwidth; x ++) {
 335         Move(rp, x + w1->BorderLeft, w1->BorderTop);
 336         Draw(rp, w1->BorderLeft + innerwidth - x  - 1, W1_HEIGHT - w1->BorderBottom - 1);
 337
 338
 339         Delay(25);
 340         WindowToFront(backwin);
 341         Delay(25);
 342         /* Wait for IDCMP_CHANGEWINDOW */
 343 kprintf("WAITING FOR TOFRONT ON %s\n", backwin->Title);
 344         handleevents(backwin, IDCMP_CHANGEWINDOW);
 345
 346         tmp = backwin;
 347         backwin = frontwin;
 348         frontwin = tmp;
 349
 350         Move(rp, x + w1->BorderLeft, w1->BorderTop);
 351         Draw(rp, w1->BorderLeft + innerwidth - x  - 1, W1_HEIGHT - w1->BorderBottom - 1);
 352
 353         Delay(25);
 354
 355
 356         WindowToFront(backwin);
 357         Delay(25);
 358         /* Wait for IDCMP_CHANGEWINDOW */
 359 kprintf("WAITING FOR TOFRONT ON %s\n", backwin->Title);
 360         handleevents(backwin, IDCMP_CHANGEWINDOW);
 361
 362         tmp = backwin;
 363         backwin = frontwin;
 364         frontwin = tmp;
 365     }
 366
 367
 368 }
 369
 370
 371 ULONG handleevents(struct Window *win, ULONG idcmp)
 372 {
 373     struct IntuiMessage *imsg;
 374     struct MsgPort *port = win->UserPort;
 375     BOOL terminated = FALSE;
 376     ULONG retidcmp = 0;
 377
 378     while (!terminated)
 379     {
 380         if ((imsg = (struct IntuiMessage *)GetMsg(port)) != NULL)
 381         {
 382
 383             switch (imsg->Class)
 384             {
 385             case IDCMP_REFRESHWINDOW:
 386                 BeginRefresh(win);
 387                 EndRefresh(win, TRUE);
 388                 break;
 389
 390             case IDCMP_CLOSEWINDOW:
 391                 terminated = TRUE;
 392                 break;
 393
 394             default:
 395                 if ((idcmp & imsg->Class) == imsg->Class) {
 396                     retidcmp = imsg->Class;
 397                     terminated = TRUE;
 398                 }
 399                 break;
 400
 401             } /* switch (imsg->Class) */
 402             ReplyMsg((struct Message *)imsg);
 403
 404
 405         } /* if ((imsg = GetMsg(port)) != NULL) */
 406         else
 407         {
 408             Wait(1L << port->mp_SigBit);
 409         }
 410     } /* while (!terminated) */
 411
 412     return retidcmp;
 413
 414 } /* HandleEvents() */
 415
 416
 417