test/HiddGraphics/obsolete/GCReadWritePixelDirect.c

   1 /*
   2     Copyright © 1998, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Test for graphics.hidd
   6     Lang: english
   7 */
   8
   9 /*****************************************************************************
  10
  11     NAME
  12
  13         GCReadWritePixelDirect
  14
  15     SYNOPSIS
  16
  17         GCReadWritePixelDirect HIDD/K,WIDTH/N/K,HEIGHT/N/K,DEPTH/N/K,CHUNKY/S,DISPLAYABLE=DP/S
  18
  19     LOCATION
  20
  21         test/HiddGraphics
  22
  23     FUNCTION
  24
  25         Creates a gc, writes and reads some pixels and disposes
  26         the gc.
  27
  28     INPUTS
  29         HIDD   - name of the hidd to use e.g. "graphics-X11.hidd"
  30                  (default: graphics.hidd)
  31         WIDTH  - width of bitmap (default: 320)
  32         HEIGHT - height of bitmap (default: 200)
  33         DEPTH  - depth of bitmap (default: 8)
  34         CHUNKY - create bitmap in chunky-mode (default: planar)
  35         DISPLAYABLE - show bitmap (default: FALSE)
  36
  37     RESULT
  38         RETURN_OK    - hidd works
  39         RETURN_ERROR - hidd produce errors
  40         RETURN_FAIL  - could not test hidd i.e. OpenLibrary() fails
  41
  42     NOTES
  43
  44     EXAMPLE
  45
  46     BUGS
  47
  48     SEE ALSO
  49
  50     INTERNALS
  51
  52     HISTORY
  53
  54 ******************************************************************************/
  55
  56 #define AROS_USE_OOP
  57
  58 #include <stdlib.h>
  59 #include <stdio.h>
  60
  61 #include <aros/config.h>
  62
  63 #include <exec/types.h>
  64
  65 #include <proto/exec.h>
  66 #include <proto/dos.h>
  67 #include <proto/oop.h>
  68 #include <proto/utility.h>
  69
  70 #include <utility/tagitem.h>
  71
  72 #include <oop/oop.h>
  73 #include <hidd/graphics.h>
  74 #include <hidd/graphics-amiga-intuition.h>
  75
  76 #include "gfxhiddtool.h"
  77
  78 #undef  SDEBUG
  79 #define SDEBUG 0
  80 #undef  DEBUG
  81 #define DEBUG 0
  82 #include <aros/debug.h>
  83
  84 struct DosLibrary    *DOSBase;
  85 struct Library       *OOPBase;
  86 struct Library       *HIDDGraphicsBase;
  87
  88 struct ght_OpenLibs LibsArray[] =
  89 {
  90     GHT_LIB("dos.library"      , 37, &DOSBase),
  91     GHT_LIB(AROSOOP_NAME       ,  0, &OOPBase),
  92     GHT_LIB(NULL               ,  0, NULL)
  93 };
  94 /***************************************************************/
  95
  96 int main(int argc, char **argv)
  97 {
  98     ULONG ret = RETURN_FAIL;
  99
 100     OOP_AttrBase HiddGCAttrBase;
 101     OOP_AttrBase HiddGfxAttrBase;
 102     OOP_AttrBase HiddBitMapAttrBase;
 103
 104     struct pHidd_BitMap_GetPixel  msg_ReadPixel;
 105     struct pHidd_BitMap_PutPixel  msg_WritePixel;
 106
 107     OOP_Object   *gfxHidd;
 108     OOP_Object   *bitMap;
 109     OOP_Object   *gc;
 110
 111     STRPTR hiddName = "graphics.hidd";
 112     ULONG  width    = 320;
 113     ULONG  height   = 200;
 114     ULONG  depth    = 8;
 115     ULONG  format   = vHidd_BitMap_Format_Planar;
 116
 117     WORD  x, y;
 118     ULONG val;
 119     char  wait;
 120
 121     struct Args
 122     {
 123         STRPTR hiddName;
 124         IPTR   *width;
 125         IPTR   *height;
 126         IPTR   *depth;
 127         IPTR   *chunky;
 128         ULONG  displayable;
 129     };
 130
 131     struct Args args = {hiddName, &width, &height, &depth, 0, 0};
 132     struct RDArgs *rda;
 133
 134
 135     if(ght_OpenLibs(LibsArray))
 136     {
 137         rda = ReadArgs("HIDD/K,WIDTH/N/K,HEIGHT/N/K,DEPTH/N/K,CHUNKY/S,DISPLAYABLE=DP/S", (IPTR *)&args, NULL);
 138         if (rda != NULL)
 139         {
 140             if(args.chunky      != 0) format           = vHidd_BitMap_Format_Chunky;
 141             if(args.displayable != 0) args.displayable = (ULONG) TRUE;
 142
 143             HIDDGraphicsBase = OpenLibrary(args.hiddName, 0);
 144             if(HIDDGraphicsBase)
 145             {
 146                 ret = RETURN_ERROR;
 147
 148                 HiddGfxAttrBase    = OOP_ObtainAttrBase(IID_Hidd_Gfx);
 149                 HiddBitMapAttrBase = OOP_ObtainAttrBase(IID_Hidd_BitMap);
 150                 HiddGCAttrBase     = OOP_ObtainAttrBase(IID_Hidd_GC);
 151
 152                 if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase)
 153                 {
 154                     gfxHidd = OOP_NewObject(NULL, args.hiddName, NULL);
 155                     if(gfxHidd)
 156                     {
 157                         struct TagItem bm_tags[] =
 158                         {
 159                             {aHidd_BitMap_Width,       (IPTR) *args.width},
 160                             {aHidd_BitMap_Height,      (IPTR) *args.height},
 161                             {aHidd_BitMap_Depth,       (IPTR) *args.depth},
 162                             {aHidd_BitMap_Format,      (IPTR) format},
 163                             {aHidd_BitMap_Displayable, (IPTR) args.displayable},
 164                             {TAG_DONE, 0UL}
 165                         };
 166
 167                         bitMap = HIDD_Gfx_NewBitMap(gfxHidd, bm_tags);
 168                         if(bitMap)
 169                         {
 170                             struct TagItem gc_tags[] =
 171                             {
 172                                 {aHidd_GC_BitMap,     (IPTR) bitMap},
 173                                 {TAG_DONE, 0UL}
 174                             };
 175
 176                             gc = HIDD_Gfx_NewGC(gfxHidd, gc_tags);
 177                             if(gc)
 178                             {
 179                                 msg_WritePixel.val = 0;
 180                                 msg_WritePixel.mID = GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PutPixel);
 181                                 msg_ReadPixel.mID  = GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_GetPixel);
 182
 183                                 for(x = 0; x < 30; x++)
 184                                 {
 185                                     msg_WritePixel.x = x;
 186                                     msg_WritePixel.y = 1;
 187                                     OOP_DoMethod(gc, (OOP_Msg) &msg_WritePixel);
 188                                 }
 189
 190                                 for(y = 1; y < 11; y++)
 191                                 {
 192                                     for(x = 0; x < 10; x++)
 193                                     {
 194                                         printf("  x: %i y: %i val: %li ", x, y, msg_WritePixel.val);
 195                                         msg_WritePixel.x = x;
 196                                         msg_WritePixel.y = y;
 197                                         DoMethod(gc, (Msg) &msg_WritePixel);
 198
 199                                         msg_ReadPixel.x = x;
 200                                         msg_ReadPixel.y = y;
 201                                         printf("ret: %li: ", (val = OOP_DoMethod(gc, (OOP_Msg) &msg_ReadPixel)));
 202                                         if(msg_WritePixel.val == OOP_DoMethod(gc, (OOP_Msg) &msg_ReadPixel))
 203                                         {
 204                                             printf("OK\n");
 205                                         }
 206                                         else
 207                                         {
 208                                             printf("ERROR\n");
 209                                             ret = RETURN_ERROR;
 210                                         }
 211
 212                                         msg_WritePixel.val++;
 213                                     }
 214                                 }
 215
 216                                 printf("Press enter to continue");
 217                                 scanf("%c", &wait);
 218
 219                                 HIDD_Gfx_DisposeGC(gfxHidd, gc);
 220
 221                                 ret = RETURN_OK;
 222                             }
 223
 224                             HIDD_Gfx_DisposeBitMap(gfxHidd, bitMap);
 225                         }
 226
 227                         if(gfxHidd) OOP_DisposeObject(gfxHidd);
 228                     }
 229                 }  /* if(HiddGfxAttrBase && HiddBitMapAttrBase && HiddGCAttrBase) */
 230
 231                 if(HiddGfxAttrBase)    OOP_ReleaseAttrBase(IID_Hidd_Gfx);
 232                 if(HiddBitMapAttrBase) OOP_ReleaseAttrBase(IID_Hidd_BitMap);
 233                 if(HiddGCAttrBase)     OOP_ReleaseAttrBase(IID_Hidd_GC);
 234
 235                 CloseLibrary(HIDDGraphicsBase);
 236             } /* if(HIDDGraphicsBase) */
 237             FreeArgs(rda);
 238         }
 239         else
 240         {
 241            PrintFault(IoErr(), "");
 242         }  /* if (rda != NULL) */
 243     } /* if OpenLibs() */
 244
 245     ght_CloseLibs(LibsArray);
 246
 247     return(ret);
 248 }