home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / GFX / Painting / HF-XIP40.LZX / XiPaint4.0 / Developer / OutputLib / libraries / retina.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-12  |  21.8 KB  |  523 lines

  1.  
  2. /*
  3. **  This C include file was generated automatically
  4. **  from an assembly include file
  5. **  using I2H written by Henning Friedl.
  6. */
  7.  
  8. /* --------------------------------------------------------------------------- */
  9. /*    IFND UTILITY_TAGITEM_I */
  10. /*                 include   utility/tagitem.i */
  11. /*    ENDC */
  12. /* --------------------------------------------------------------------------- */
  13. #define RETINA_LIB_VERSION    (11)    /* the current version of retina.library */
  14. /* --------------------------------------------------------------------------- */
  15. #define SEGMENTSIZE    (64*1024)    /* Retina-Z2 only */
  16. /* --------------------------------------------------------------------------- */
  17. /*  New in v11.7: */
  18. /* --------------------------------------------------------------------------- */
  19. /*  Tags for Retina_AllocBrush(): */
  20.  
  21. #define BT_SrcScreen    (TAG_USER+401)    /* struct RetinaScreen * */
  22. #define BT_DestScreen    (TAG_USER+402)    /* struct RetinaScreen * */
  23. #define BT_LeftEdge    (TAG_USER+403)    /* Default: 0 */
  24. #define BT_TopEdge    (TAG_USER+404)    /* Default: 0 */
  25. #define BT_Width    (TAG_USER+405)    /* Default: 16 */
  26. #define BT_Height    (TAG_USER+406)    /* Default: 16 */
  27. #define BT_Flags    (TAG_USER+407)    /* see below */
  28.  
  29. /*  values for BT_Flags */
  30.  
  31. #define BHB_COPYSOURCE    0
  32. #define BHF_COPYSOURCE    0x00000001    /* copy source brush */
  33. #define BHB_RESTOREBG    1
  34. #define BHF_RESTOREBG    0x00000002    /* restore background */
  35. /* --------------------------------------------------------------------------- */
  36. /*  Tags for Retina_DisplayControl() (v10): */
  37. #define DCT_DPMS    (TAG_USER+300)    /* Display Power Management System */
  38.  
  39. /*  values for DCT_DPMS: */
  40. #define DPMS_ON    (0)    /* display on, monitor on */
  41. #define DPMS_BLANK    (1)    /* display off, monitor on */
  42. #define DPMS_STANDBY    (2)    /* display off, monitor standby */
  43. #define DPMS_OFF    (3)    /* display off, monitor off */
  44. /* --------------------------------------------------------------------------- */
  45. /*  Tags for Retina_FilterMonitor() (v8): */
  46.  
  47. #define FMT_Flags    (TAG_USER+200)
  48. #define FMT_MinWidth    (TAG_USER+201)
  49. #define FMT_MaxWidth    (TAG_USER+202)
  50. #define FMT_MinHeight    (TAG_USER+203)
  51. #define FMT_MaxHeight    (TAG_USER+204)
  52. #define FMT_MinHFrequency    (TAG_USER+205)
  53. #define FMT_MaxHFrequency    (TAG_USER+206)
  54. #define FMT_MinVFrequency    (TAG_USER+207)
  55. #define FMT_MaxVFrequency    (TAG_USER+208)
  56.  
  57. /* Flags for FMT_Flags */
  58. #define FMTB_DEPTH08    1
  59. #define FMTF_DEPTH08    0x00000002
  60. #define FMTB_DEPTH16    2
  61. #define FMTF_DEPTH16    0x00000004
  62. #define FMTB_DEPTH24    3
  63. #define FMTF_DEPTH24    0x00000008
  64. #define FMTB_GROUPS    4
  65. #define FMTF_GROUPS    0x00000010
  66. #define FMTB_NONGROUPS    5
  67. #define FMTF_NONGROUPS    0x00000020
  68. /* --------------------------------------------------------------------------- */
  69. /*  ALL entries in struct RetinaScreenMode are READ ONLY! */
  70. /*  The entries in this structure are only valid after a successful call */
  71. /*  to Retina_Request()! The window dimensions _rsm_Reqxxx are valid even if */
  72. /*  the call failed. */
  73.  
  74. struct RetinaScreenMode {
  75.     ULONG    rsm_UserData;    /* the value provided by RSM_UserData */
  76.  
  77.     ULONG    rsm_DisplayID;    /* the selected display id */
  78.     UWORD    rsm_Depth;    /* the selected depth (8, 16 or 24) */
  79.     UWORD    rsm_Width;    /* the selected width */
  80.     UWORD    rsm_Height;    /* the selected height */
  81.     UBYTE    rsm_Virtual;    /* BOOL, set if virtual screen enabled */
  82.     UBYTE    rsm_pad;
  83.     UWORD    rsm_VisibleWidth;    /* the selected visible size, only valid */
  84.     UWORD    rsm_VisibleHeight;    /*   if _rsm_Virtual is true */
  85.  
  86.     WORD    rsm_ReqLeftEdge;    /* left edge of requesting window */
  87.     WORD    rsm_ReqTopEdge;    /* top edge of requesting window */
  88.     WORD    rsm_ReqWidth;    /* width of requesting window */
  89.     WORD    rsm_ReqHeight;    /* height of requesting window */
  90.  
  91. };
  92.  
  93. /*  Do NOT refer to _rsm_PUBSIZE, this structure may grow in the future! */
  94. /* --------------------------------------------------------------------------- */
  95. /*  Tagitems for Retina_AllocRequest() or Retina_Request(): */
  96.  
  97. #define RSMR_Window    (TAG_USER+100)    /* open on this windows screen */
  98. #define RSMR_PubScreenName    (TAG_USER+101)    /* open on this public screen */
  99. #define RSMR_Screen    (TAG_USER+102)    /* open on this screen */
  100. #define RSMR_UserData    (TAG_USER+103)
  101. #define RSMR_Flags    (TAG_USER+104)    /* see below */
  102. #define RSMR_ReqLeftEdge    (TAG_USER+105)    /* the hor. position to open the requester */
  103. #define RSMR_ReqTopEdge    (TAG_USER+106)    /* the vert. position to open the requester */
  104. #define RSMR_DisplayID    (TAG_USER+107)    /* (v10) the initial display ID */
  105. #define RSMR_Depth    (TAG_USER+108)    /* (v10) the initial depth */
  106. #define RSMR_Width    (TAG_USER+109)    /* (v10) the initial width */
  107. #define RSMR_Height    (TAG_USER+110)    /* (v10) the initial height */
  108. #define RSMR_VisibleWidth    (TAG_USER+111)    /* (v10) the initial visible width */
  109. #define RSMR_VisibleHeight    (TAG_USER+112)    /* (v10) the initial visible height */
  110. /* --------------------------------------------------------------------------- */
  111. #define RSMB_DEPTH08    0
  112. #define RSMF_DEPTH08    0x00000001    /*  enable 8 bit modes */
  113. #define RSMB_DEPTH16    1
  114. #define RSMF_DEPTH16    0x00000002    /*  enable 16 bit modes */
  115. #define RSMB_DEPTH24    2
  116. #define RSMF_DEPTH24    0x00000004    /*  enable 24 bit modes */
  117.  
  118. #define RSMB_SIZE    3
  119. #define RSMF_SIZE    0x00000008    /*  enable the Width and Height gadget */
  120. #define RSMB_VIRTUAL    4
  121. #define RSMF_VIRTUAL    0x00000010    /*  enable the Virtual gadget */
  122. #define RSMB_VIRTUALON    5
  123. #define RSMF_VIRTUALON    0x00000020    /*  select the Virtual gadget */
  124.  
  125. #define RSMB_GROUPS    6
  126. #define RSMF_GROUPS    0x00000040    /*  display groups */
  127. #define RSMB_NONGROUPS    7
  128. #define RSMF_NONGROUPS    0x00000080    /*  display single display modes */
  129. /* --------------------------------------------------------------------------- */
  130. /* --------------------------------------------------------------------------- */
  131. /* ---- Alerts: */
  132.  
  133. /*  an alert number like 35xx01xx identifies an alert caused by retina.library */
  134.  
  135. #define ALERT_NOHARD    (0x0100)    /* no Retina hardware present */
  136.  
  137. #define ALERT_NOMEM    (0x0110|AG_NoMemory)    /* Retina does not have any memory at all */
  138. #define ALERT_NOMEMTOFREE    (0x0111)    /* tried to free memory although no memory is in use */
  139. #define ALERT_MEMTOFREENOTFOUND    (0x0112)    /* tried to free memory which has not been allocated */
  140. #define ALERT_NOMEMNODEMEM    (0x0113|AG_NoMemory)    /* no Amiga memory for memory listnode */
  141. #define ALERT_MEMNOTFREED    (0x0114)    /* still some memory in use at library expunge */
  142. #define ALERT_MUNGWALLLOW    (0x0115)    /* internal */
  143. #define ALERT_MUNGWALLHIGH    (0x0116)    /* internal */
  144. #define ALERT_MEMCLK    (0x0117)    /* internal */
  145.  
  146. #define ALERT_CLOSE_LIB_MONITOR    (0x0121)    /* tried to remove a library internal monitor */
  147. #define ALERT_MONITOR_NOT_CLOSED    (0x0122)    /* LIB_Expunge and not all monitors removed */
  148. #define ALERT_MONITOR_ID_INUSE    (0x0123)    /* internal */
  149. /* --------------------------------------------------------------------------- */
  150. /*  modes for Retina_SetDrMd() */
  151.  
  152. #define RDM_JAM1    (0)
  153. #define RDM_COMPLEMENT    (2)
  154. #define RDMB_PENCLR    4
  155. #define RDMF_PENCLR    0x00000010    /*  (v11) PRIVATE */
  156. #define RDMB_PENSET    5
  157. #define RDMF_PENSET    0x00000020    /*  (v11) PRIVATE */
  158. #define RDMB_PENINVERT    6
  159. #define RDMF_PENINVERT    0x00000040    /*  (v11) PRIVATE */
  160. /* --------------------------------------------------------------------------- */
  161. /*  modes for Retina_WriteBitMap() */
  162.  
  163. #define WBMMODE_STD    (0)    /* normal 2 to 256 color images and EHB to 8 bit */
  164. #define WBMMODE_HAM    (1)    /* 4096 color HAM to 16 or 24 bit (16 Bit: (v4)) */
  165. #define WBMMODE_HAM8    (2)    /* 256k color AA HAM to 24 bit */
  166.  
  167. #define WBMMODEB_EXTENDED    16
  168. #define WBMMODEF_EXTENDED    0x00010000    /* see retina.doc/Retina_WriteBitMap() (v3) */
  169. /* --------------------------------------------------------------------------- */
  170. /*  modes for Retina_WriteRect(), ... */
  171.  
  172. #define RECTMODE_RGB    (0)    /* one byte each for red, green, blue */
  173. #define RECTMODE_RGBA    (1)    /* one byte each for red, green, blue and alpha */
  174. #define RECTMODE_BGR    (2)    /* same as RGB, but reverse pixel order */
  175. #define RECTMODE_GB_R    (3)    /* PRIVATE, do not use */
  176. #define RECTMODE_256    (4)    /* one byte for each pixel */
  177. #define RECTMODE_GB_R0    (5)    /* PRIVATE, do not use */
  178. #define RECTMODE_RAW    (6)    /* raw data, either 8, 16 or 24 bit (v4) */
  179. #define RECTMODE_RGBA_0    (7)    /* PRIVATE, do not use (v5) */
  180. #define RECTMODE_CLUT    (8)    /* Palette: RGBA --- PRIVATE, do not use (v6) */
  181.  
  182. /*  you may OR the following flags to Mode when calling Retina_WriteRect(), ... */
  183.  
  184. #define RECTMODEB_BYTEMEMWIDTH    16
  185. #define RECTMODEF_BYTEMEMWIDTH    0x00010000    /* if set, MemWidth counts in bytes */
  186. /*   instead of pixels (v7) */
  187. /* --------------------------------------------------------------------------- */
  188. /*  Flags for Retina_CopyRect(): */
  189.  
  190. #define CRB_SRCDBUF    0
  191. #define CRF_SRCDBUF    0x00000001    /* use the double buffer bitmap as source */
  192. #define CRB_DESTDBUF    1
  193. #define CRF_DESTDBUF    0x00000002    /* use the double buffer bitmap as destination */
  194. #define CRB_XOR    2
  195. #define CRF_XOR    0x00000004    /* XOR Source with Destination (v11) PRIVATE */
  196. #define CRB_NOCLIP    3
  197. #define CRF_NOCLIP    0x00000008    /* avoid clipping (v11) PRIVATE */
  198. /* --------------------------------------------------------------------------- */
  199. /*  Tagitems for Retina_SetSprite() or Retina_SpriteFunction(): */
  200.  
  201. #define RSP_On    (TAG_USER+1)
  202. #define RSP_Color0    (TAG_USER+2)
  203. #define RSP_Color1    (TAG_USER+3)
  204. #define RSP_ZoomX    (TAG_USER+4)
  205. #define RSP_ZoomY    (TAG_USER+5)    /* ignored by Retina_SpriteFunction() */
  206. /* --------------------------------------------------------------------------- */
  207. #define MONID_LIB    (0x00000000)    /*  IDs used by retina.library. Do NOT use! */
  208. #define MONID_WBEMU    (0x10000000)    /*  IDs used by RetinaEmu. Do NOT use! */
  209. #define MONID_CUSTOM    (0x20000000)    /*  Software which adds custom monitor */
  210. /*  definitions must set the highest */
  211. /*  nibble of the monitor ID to 2! */
  212. #define MONID_AUTO    (0x70000000)    /*  Auto-IDs created by Retina_AddMonitor(). */
  213. /*  Do NOT use! */
  214. #define MONID_ADDAUTO    (0xffffffff)    /*  Used by Retina_AddMonitor() to create */
  215. /*  auto IDs. */
  216.  
  217. /*  flag definitions for _nrm_Flags and _rm_Flags: */
  218.  
  219. #define MDB_DBL    0
  220. #define MDF_DBL    0x00000001    /* 1 = Double-Scan */
  221. #define MDB_LACE    1
  222. #define MDF_LACE    0x00000002    /* 1 = Interlace */
  223. #define MDB_CLKDIV2    2
  224. #define MDF_CLKDIV2    0x00000004    /* 1 = use 1/2 pixel clock */
  225. #define MDB_PLANAR    3
  226. #define MDF_PLANAR    0x00000008    /* 1 = screen has 16 colors on 4 planes          (v2) */
  227. #define MDB_HIDE    4
  228. #define MDF_HIDE    0x00000010    /* 1 = entry should not appear in public lists   (v2) */
  229. #define MDB_GROUP    5
  230. #define MDF_GROUP    0x00000020    /* 1 = this definition is a group-header         (v2) */
  231. #define MDB_POSHSYNC    6
  232. #define MDF_POSHSYNC    0x00000040    /* 1 = HSync wird positiv                        (v4) */
  233. #define MDB_POSVSYNC    7
  234. #define MDF_POSVSYNC    0x00000080    /* 1 = VSync wird positiv                        (v4) */
  235.  
  236. #define ATNT_MODE_8    (0)    /*  8 bit with color lookup */
  237. #define ATNT_MODE_15    (1)    /* 15 bit true color (not supported) */
  238. #define ATNT_MODE_24    (2)    /* 24 bit true color */
  239. #define ATNT_MODE_16    (3)    /* 16 bit true color */
  240.  
  241. struct NewRetinaMonitor {
  242.     LONG    nrm_MonitorID;    /* a unique ID to describe this monitor */
  243. /*  0 is NOT a valid ID */
  244. /* -1 forces Retina_Addmonitor() to */
  245. /*    generate a unique ID */
  246.     LONG    nrm_PixelClock;    /* the desired pixelclock, must be one */
  247. /* out of: */
  248. /* 25175000,28322000,36000000,44900000 */
  249. /* 50000000,56644000,63000000,65000000 */
  250. /* 72000000,75000000,80000000,90000000 */
  251.     BYTE    nrm_AtntMode;    /* see definitions above */
  252.     BYTE    nrm_Flags;    /* see definitions above */
  253.  
  254.  /* LABEL _nrm_NewGroupIDs */    /* PRIVATE (v5) */
  255.  
  256.     WORD    nrm_StdWidth;    /* standard width of the monitor */
  257.     WORD    nrm_StdHeight;    /* standard height of the monitor */
  258.     WORD    nrm_MaxWidth;    /* maximum (overscen) width of the monitor */
  259.     WORD    nrm_MaxHeight;    /* maximum (overscen) height of the monitor */
  260.  
  261.  /* LABEL _nrm_GroupIDs */    /* a ULONG *, pointing to a NULL terminated */
  262. /*   array of monitor IDs. (v2) */
  263.     WORD    nrm_HBStart;
  264.     WORD    nrm_HSStart;
  265.     WORD    nrm_HSEnd;
  266.     WORD    nrm_HBEnd;
  267.     WORD    nrm_HTotal;
  268.  
  269.     WORD    nrm_VBStart;
  270.     WORD    nrm_VSStart;
  271.     WORD    nrm_VSEnd;
  272.     WORD    nrm_VBEnd;
  273.     WORD    nrm_VTotal;
  274.  
  275. };
  276.  
  277. /*  Do NOT refer to _nrm_SIZEOF, this structure may grow in the future! */
  278. /* --------------------------------------------------------------------------- */
  279. struct RetinaMonitor {
  280.     struct    Node _rm_Node;    /* LN_NAME points to a human readable string */
  281. /* which identifies the monitor definition. */
  282.     LONG    rm_MonitorID;
  283.  
  284.     LONG    rm_HFrequency;
  285.     LONG    rm_VFrequency;
  286.  
  287.     WORD    rm_BytesPerPixel;
  288.  
  289.     WORD    rm_StdWidth;
  290.     WORD    rm_StdHeight;
  291.     WORD    rm_MaxWidth;
  292.     WORD    rm_MaxHeight;
  293.  
  294.     BYTE    rm_PrivateFlags;    /* PRIVATE, do not use! */
  295.     BYTE    rm_Reserved1;    /* PRIVATE, do not use! */
  296.     BYTE    rm_AtntMode;    /* a copy of _nrm_AtntMode */
  297.     BYTE    rm_Flags;    /* a copy of _nrm_Flags */
  298.  
  299.     APTR    rm_GroupIDs;    /* points to a null terminated array of IDs */
  300. /* if this is a group, otherwise NULL (v5) */
  301.     LONG    rm_PixelClock;    /* (v5) */
  302.  
  303. };
  304. /* --------------------------------------------------------------------------- */
  305. /* definitions for _dsi_Flags */
  306. #define DSIB_USEWIDTH    0
  307. #define DSIF_USEWIDTH    0x00000001    /* If set, use the value in _dsi_Width. If not set, */
  308. /*   pass the original value to Retina_OpenScreen(). */
  309. #define DSIB_USEHEIGHT    1
  310. #define DSIF_USEHEIGHT    0x00000002    /* If set, use the value in _dsi_Height. If not set, */
  311. /*   pass the original value to Retina_OpenScreen(). */
  312.  
  313. struct DefaultScreenInfo {
  314.     LONG    dsi_ID;    /* the current ScreenMode-ID */
  315.     WORD    dsi_Width;    /* the current width */
  316. /* (only valid if DSIB_USEWIDTH is set) */
  317.     WORD    dsi_Height;    /* the current height */
  318. /* (only valid if DSIB_USEHEIGHT is set) */
  319.     BYTE    dsi_Flags;    /* flag definitions see above */
  320.     UBYTE    _dsi_Reserved[7];    /* reserved, do not use */
  321. };
  322. /* --------------------------------------------------------------------------- */
  323. /*  special values vor Retina_OpenScreen() Width and Height */
  324.  
  325. #define RSCR_MINWIDTH    (13)    /* minimum width of a Retina screen */
  326. #define RSCR_MINHEIGHT    (1)    /* minimum height of a Retina screen */
  327.  
  328. #define RSCR_STDWIDTH    (-1)    /* open the screen at its standard width */
  329. #define RSCR_STDHEIGHT    (-1)    /* open the screen at its standard height */
  330. #define RSCR_MAXWIDTH    (-2)    /* open the screen at its maximum width */
  331. #define RSCR_MAXHEIGHT    (-2)    /* open the screen at its maximum height */
  332.  
  333. /*  TagItems for Retina_OpenScreen(): */
  334.  
  335. #define RSA_BitMap    (TAG_USER+1)    /* use this BitMap */
  336. #define RSA_DBufBitMap    (TAG_USER+2)    /* not supported yet */
  337. #define RSA_ErrorCode    (TAG_USER+3)    /* return an error code */
  338. #define RSA_Name    (TAG_USER+4)    /* the screens name (v3) */
  339. #define RSA_Palette    (TAG_USER+5)    /* the screens initial palette (v3) */
  340. #define RSA_PaletteRange    (TAG_USER+6)    /* to select less then 256 colors (v3) */
  341. /* high word of ti_Data: First */
  342. /* low word of ti_Data: Count */
  343. /* see: retina.doc/Retina_LoadPalette() */
  344. #define RSA_FreeID    (TAG_USER+7)    /* optional ID for 'free screens' (v4) */
  345. #define RSA_TopEdge    (TAG_USER+8)    /* initial top edge of the screen (v5) */
  346. #define RSA_Parent    (TAG_USER+9)    /* parent screen used by the panel screen (v5) */
  347. #define RSA_Depth    (TAG_USER+10)    /* PRIVATE, do not use! */
  348. #define RSA_LeftEdge    (TAG_USER+11)    /* initial left edge of the screen (v7) */
  349. #define RSA_VisibleWidth    (TAG_USER+12)    /* visible width of the screen (v7) */
  350. #define RSA_VisibleHeight    (TAG_USER+13)    /* visible height of the screen (v7) */
  351.  
  352. /*  values for RSA_ErrorCode: */
  353.  
  354. #define ROSERR_NONE    (0)    /*  everything ok if Retina_OpenScreen() returned NON-NULL */
  355. /*    or unknown error if it returned NULL */
  356. #define ROSERR_ID    (1)    /*  unknown monitor-ID */
  357. #define ROSERR_DEFAULTID    (2)    /*  unknown default monitor-ID */
  358. #define ROSERR_TOOBIG    (3)    /*  screen size is too big */
  359. #define ROSERR_NOMEM    (4)    /*  couldn't get normal memory */
  360. #define ROSERR_NORETINAMEM    (5)    /*  couldn't get Retina graphics memory */
  361. #define ROSERR_TOOSMALL    (6)    /*  screen size is too small (< 13*1) (v5) */
  362. #define ROSERR_CLOCK    (7)    /*  pixelclock is too high (v5) */
  363.  
  364. /*  Flags for _rs_Flags: */
  365.  
  366. #define RSFB_DONTCLEARONOPEN    0
  367. #define RSFF_DONTCLEARONOPEN    0x00000001    /* don't clear the screens memory when opened */
  368. #define RSFB_DONTCLEARONCLOSE    1
  369. #define RSFF_DONTCLEARONCLOSE    0x00000002    /* don't turn off display after closing screen */
  370. #define RSFB_DOUBLEBUFFER    2
  371. #define RSFF_DOUBLEBUFFER    0x00000004    /* prepare screen for double buffering */
  372. #define RSFB_CUSTOMBITMAP    3
  373. #define RSFF_CUSTOMBITMAP    0x00000008    /* PRIVATE, do not use */
  374. #define RSFB_CUSTOMDBUFBITMAP    4
  375. #define RSFF_CUSTOMDBUFBITMAP    0x00000010    /* PRIVATE, do not use */
  376. #define RSFB_AUTOADJUST    5
  377. #define RSFF_AUTOADJUST    0x00000020    /* adjust the screens size if too big, ... */
  378. #define RSFB_OPENBEHIND    6
  379. #define RSFF_OPENBEHIND    0x00000040    /* open the screen behind all others */
  380. #define RSFB_DBUFPALETTE    7
  381. #define RSFF_DBUFPALETTE    0x00000080    /* use special palette handling (v3) */
  382. #define RSFB_OVERSIZED    8
  383. #define RSFF_OVERSIZED    0x00000100    /* PRIVATE, do not use (v3) */
  384. #define RSFB_SYSTEM    9
  385. #define RSFF_SYSTEM    0x00000200    /* PRIVATE, do not use (v3) */
  386. #define RSFB_DONTCLOSEONCLOSE    10
  387. #define RSFF_DONTCLOSEONCLOSE    0x00000400    /* don't close the screen on Retina_CloseScreen() (v4) */
  388. #define RSFB_FREE    11
  389. #define RSFF_FREE    0x00000800    /* PRIVATE, do not use (v4) */
  390. #define RSFB_ZEROBITMAP    12
  391. #define RSFF_ZEROBITMAP    0x00001000    /* PRIVATE, do not use (v5) */
  392. #define RSFB_PANEL    13
  393. #define RSFF_PANEL    0x00002000    /* screen is a panel screen (v5) */
  394. #define RSFB_LOCKPANEL    14
  395. #define RSFF_LOCKPANEL    0x00004000    /* panel screen is locked to its parent (v5) */
  396. #define RSFB_FAKE    15
  397. #define RSFF_FAKE    0x00008000    /* this is a fake screen allocated */
  398. /*   by Retina_AllocScreen() (v6) */
  399. #define RSFB_HCENTER    16
  400. #define RSFF_HCENTER    0x00010000    /* center the screen horizontally (v7) */
  401. #define RSFB_VCENTER    17
  402. #define RSFF_VCENTER    0x00020000    /* center the screen vertically (v7) */
  403. #define RSFB_DEEP    18
  404. #define RSFF_DEEP    0x00040000    /* PRIVATE, do not use (v7) */
  405.  
  406. struct RetinaScreen {
  407.     struct    Node Node;    /* ListNode for internal use only */
  408. /* LN_NAME MAY point to the screens name */
  409. /*   it also may be NULL! (v3) */
  410.     WORD    rs_Width;    /* number of pixels in one horizontal line */
  411.     WORD    rs_Height;    /* number of lines */
  412. /* --- */
  413.     APTR    rs_BitMap;    /* the screen's address in Retina memory */
  414.     APTR    rs_DBufBitMap;    /* used for double buffered screens */
  415.  
  416.     LONG    rs_Flags;    /* flags see above */
  417.  
  418.  /* LABEL _rs_APen */
  419.     BYTE    rs_APen_reserved;    /* reserved */
  420.     BYTE    rs_APenR;    /* the red component (true color only) */
  421.     BYTE    rs_APenG;    /* the green component (true color only) */
  422.  /* LABEL _rs_APen256 */    /* the number of the palette register */
  423. /*   on a 256 color screen */
  424.     BYTE    rs_APenB;    /*   or the blue component (true color) */
  425. /* --- */
  426.     BYTE    rs_DrawMode;    /* RDM_JAM1, ... */
  427.     BYTE    rs_Reserved;    /* (v3) */
  428. /* --- */
  429.     WORD    rs_BytesPerPixel;    /* number of bytes per pixel (1..3) */
  430.     WORD    rs_Modulo;    /* number of bytes in one line */
  431.     APTR    rs_Monitor;    /* struct RetinaMonitor * */
  432.  
  433.     APTR    rs_Palette;    /* points to an array of 256 RGB values */
  434. /*   read only! */
  435.  
  436.     WORD    rs_BitsPerPixel;    /* number of bits per pixel (4,8,16,24) (v3) */
  437.  
  438.     WORD    rs_LeftEdge;    /* the position of centered */
  439.     WORD    rs_TopEdge;    /*   or oversized screens (v7) */
  440.  
  441.     WORD    rs_VisibleWidth;    /* the visible size */
  442.     WORD    rs_VisibleHeight;    /*   of oversized screens (v7) */
  443.  
  444.     APTR    rs_BitMapA;    /* PRIVATE, do not use (v11) */
  445.     APTR    rs_DBufBitMapA;    /* PRIVATE, do not use (v11) */
  446.  
  447.     ULONG    rs_UserData;    /* for your use - _rs_UserData is */
  448. /*   set to 0 by Retina_OpenScreen() */
  449. /*   or Retina_AllocScreen(). (v11) */
  450.  
  451. };
  452. /* --------------------------------------------------------------------------- */
  453. /*  These are the currently available Mode-ID's you need for Retina_OpenScreen() */
  454.  
  455. #define MID_DEFAULT_08    (-1)    /* ask for the default 8 bit screen */
  456. #define MID_DEFAULT_16    (-2)    /* ask for the default 16 bit screen */
  457. #define MID_DEFAULT_24    (-3)    /* ask for the default 24 bit screen */
  458.  
  459. #define MID_UNKNOWN    (0)
  460. /* --------------------------------------------------------------------------- */
  461. /*  the public-part of retina.library */
  462.  
  463. struct RetinaBase {
  464.     struct    Library Library;
  465.     APTR    rb_FirstScreen;    /* A pointer to the first screen. This */
  466. /* is the visible screen. If no screen */
  467. /* is open, _rb_FirstScreen is NULL. */
  468.     ULONG    rb_FrameCount;    /* This is incremented each Retina */
  469. /* vertical blank interrupt. You may use */
  470. /* it to check wether your animation got */
  471. /* every frame, but NEVER use it at a */
  472. /* clock! */
  473.     APTR    rb_HardInfo;    /* NULL, if there is no Retina hardware */
  474. /* Non-NULL if there is a hardware. (v2) */
  475. /* Starting with (v5) _rb_HardInfo is a  */
  476. /* pointer to struct HardInfo (PRIVATE)  */
  477. /* or NULL. */
  478. /* Do NOT use _rb_HardInfo as a pointer */
  479. /* in earlier versions! */
  480.     APTR    rb_BoardAddress;    /* the address of the Retina board (v3) */
  481.     APTR    rb_SegmentAddress;    /* the address of the Retina memory */
  482. /* window (v3) */
  483.     UBYTE    _rb_private1[12];    /* PRIVATE, do not use */
  484.  
  485.     struct    List _rb_ScreenList;    /* all open Retina screens (v3) */
  486.  
  487.     APTR    rb_SpriteMem;    /* PRIVATE, do not use */
  488.     struct    List _rb_MemList;    /* PRIVATE, do not use */
  489.  
  490. };
  491.  
  492. /*  subsequent fields in the library base are RETINA PRIVATE */
  493. /* --------------------------------------------------------------------------- */
  494. struct MemNode {
  495.     struct    MinNode MinNode;    /* PRIVATE, do not use */
  496.     APTR    mn_Memory;    /* PRIVATE, do not use */
  497.     LONG    mn_Size;    /* PRIVATE, do not use */
  498. };
  499. /* --------------------------------------------------------------------------- */
  500. /*  flags for _hi_Flags: */
  501. #define HIB_FREEPIXCLK    0
  502. #define HIF_FREEPIXCLK    0x00000001    /* PRIVATE, do not use */
  503. #define HIB_DPMS    1
  504. #define HIF_DPMS    0x00000002    /* PRIVATE, do not use */
  505. #define HIB_LINEAR    2
  506. #define HIF_LINEAR    0x00000004    /* PRIVATE, do not use */
  507.  
  508. /*  values for _hi_Board: */
  509. #define HIB_RETINA    (0)    /* PRIVATE, do not use */
  510. #define HIB_RETINABLTZ3    (1)    /* PRIVATE, do not use */
  511.  
  512. struct HardInfo {    /* PRIVATE, do not use */
  513.     ULONG    hi_Flags;    /* PRIVATE, do not use */
  514.     ULONG    hi_MaxPixClk;    /* PRIVATE, do not use */
  515.     UBYTE    hi_Board;    /* PRIVATE, do not use */
  516.     UBYTE    _hi_Reserved[3];    /* PRIVATE, do not use */
  517. };
  518. /* --------------------------------------------------------------------------- */
  519. /*  You may use this macro to call the functions in retina.library. To avoid */
  520. /*  conflicts with existing functions, they have a slightly unusual name. */
  521.  
  522. /* --------------------------------------------------------------------------- */
  523.