home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 1 / ARM_CLUB_CD.iso / contents / apps / clib / progs / haswinlib / c / vdu < prev    next >
Encoding:
Text File  |  1991-02-04  |  10.2 KB  |  237 lines
  1. /* > $.CLIB.C.vdu
  2.  *
  3.  *      HASWIN Graphics Library
  4.  *     =========================
  5.  *
  6.  *      Copyright (C) H.A.Shaw 1990.
  7.  *              Howard A. Shaw.
  8.  *              The Unit for Space Sciences,
  9.  *              Room 165,
  10.  *              Physics Building,
  11.  *              University of Kent at Canterbury.
  12.  *              Canterbury.
  13.  *              Kent.  CT2 7NJ
  14.  *      You may use and distribute this code freely, however please leave
  15.  *      it alone.  If you find bugs (and there will be many) please contact
  16.  *      me and the master source can be modified.  If you keep me informed
  17.  *      of who you give copies of this to then I can get release upgrades
  18.  *      to them.
  19.  *
  20.  *      Routines to handle VDU variables.
  21.  */
  22. #include "includes.h"
  23. /*
  24.  *       this table contains the data for the VDU variables system
  25.  *       Each VDU variable has a record containing
  26.  *       vduconvert[VDUVAR_<name>][0]
  27.  *               - code to give "OS_ReadVduVariables" to get value.
  28.  *       vduconvert[VDUVAR_<name>][1]
  29.  *               - flags -
  30.  *                       VDU_MODE    - value set only on mode change.
  31.  *                                     if not present the variable can
  32.  *                                     change at any time, and must be
  33.  *                                     got from RISCOS when needed.
  34.  *        Note that some of the variables are HASWIN addins.  ModeNumber
  35.  *        is not a true VDU variable but this seems like the right place
  36.  *        to keep it.  There has to be special traps in the code to do
  37.  *        ModeNumber right but I think it's worth it.  Especially since
  38.  *        The sprite stuff needs to create sprites from the screen and
  39.  *        needs the mode number.  
  40.  */
  41. #define VDU_MODE               0x01
  42.  
  43. #define Vduvar_ModeFlags         0
  44. #define Vduvar_ScrRCol           1
  45. #define Vduvar_ScrBRow           2
  46. #define Vduvar_NColour           3
  47. #define Vduvar_XEigFactor        4
  48. #define Vduvar_YEigFactor        5
  49. #define Vduvar_LineLength        6
  50. #define Vduvar_ScreenSize        7
  51. #define Vduvar_YShftFactor       8
  52. #define Vduvar_Log2BPP           9
  53. #define Vduvar_Log2BPC          10
  54. #define Vduvar_XWindLimit       11
  55. #define Vduvar_YWindLimit       12
  56. #define Vduvar_GWLCol          128
  57. #define Vduvar_GWBRow          129
  58. #define Vduvar_GWRCol          130
  59. #define Vduvar_GWTRow          131
  60. #define Vduvar_TWLCol          132
  61. #define Vduvar_TWBRow          133
  62. #define Vduvar_TWRCol          134
  63. #define Vduvar_TWTRow          135
  64. #define Vduvar_OrgX            136
  65. #define Vduvar_OrgY            137
  66. #define Vduvar_GCsX            138
  67. #define Vduvar_GCsY            139
  68. #define Vduvar_OlderGCsX       140
  69. #define Vduvar_OlderGCsY       141
  70. #define Vduvar_OldGCsX         142
  71. #define Vduvar_OldGCsY         143
  72. #define Vduvar_GCsIX           144
  73. #define Vduvar_GCsIY           145
  74. #define Vduvar_NewPtX          146
  75. #define Vduvar_NewPtY          147
  76. #define Vduvar_ScreenStart     148
  77. #define Vduvar_DisplayStart    149
  78. #define Vduvar_TotalScreenSize 150
  79. #define Vduvar_GPLFMD          151
  80. #define Vduvar_GPLBMD          152
  81. #define Vduvar_GFCOL           153
  82. #define Vduvar_GBCOL           154
  83. #define Vduvar_TForeCol        155
  84. #define Vduvar_TBackCol        156
  85. #define Vduvar_GFTint          157
  86. #define Vduvar_GBTint          158
  87. #define Vduvar_TFTint          159
  88. #define Vduvar_TBTint          160
  89. #define Vduvar_MaxMode         161
  90. #define Vduvar_GCharSizeX      162
  91. #define Vduvar_GCharSizeY      163
  92. #define Vduvar_GCharSpaceX     164
  93. #define Vduvar_GCharSpaceY     165
  94. #define Vduvar_HLineAddr       166
  95. #define Vduvar_TCharSizeX      167
  96. #define Vduvar_TCharSizeY      168
  97. #define Vduvar_TCharSpaceX     169
  98. #define Vduvar_TCharSpaceY     170
  99. #define Vduvar_GcolOraEorAddr  171
  100. #define Vduvar_WindowWidth     256
  101. #define Vduvar_WindowHeight    257
  102.  
  103. static  int     haswin_vduvarconv[VDUVAR_MAXVARS][2] = {
  104.     {Vduvar_ModeFlags,       VDU_MODE}, {Vduvar_ScrRCol,         VDU_MODE},
  105.     {Vduvar_ScrBRow,         VDU_MODE}, {Vduvar_NColour,         VDU_MODE},
  106.     {Vduvar_XEigFactor,      VDU_MODE}, {Vduvar_YEigFactor,      VDU_MODE},
  107.     {Vduvar_LineLength,      VDU_MODE}, {Vduvar_ScreenSize,      VDU_MODE},
  108.     {Vduvar_YShftFactor,     VDU_MODE}, {Vduvar_Log2BPP,         VDU_MODE},
  109.     {Vduvar_Log2BPC,         VDU_MODE}, {     Vduvar_XWindLimit, VDU_MODE},
  110.     {Vduvar_YWindLimit,      VDU_MODE}, {         Vduvar_GWLCol,        0},
  111.     {Vduvar_GWBRow,                 0}, {         Vduvar_GWRCol,        0},
  112.     {Vduvar_GWTRow,                 0}, {         Vduvar_TWLCol,        0},
  113.     {Vduvar_TWBRow,                 0}, {         Vduvar_TWRCol,        0},
  114.     {Vduvar_TWTRow,                 0}, {           Vduvar_OrgX,        0},
  115.     {Vduvar_OrgY,                   0}, {           Vduvar_GCsX,        0},
  116.     {Vduvar_GCsY,                   0}, {      Vduvar_OlderGCsX,        0},
  117.     {Vduvar_OlderGCsY,              0}, {        Vduvar_OldGCsX,        0},
  118.     {Vduvar_OldGCsY,                0}, {          Vduvar_GCsIX,        0},
  119.     {Vduvar_GCsIY,                  0}, {         Vduvar_NewPtX,        0},
  120.     {Vduvar_NewPtY,                 0}, {    Vduvar_ScreenStart,        0},
  121.     {Vduvar_DisplayStart,           0}, {Vduvar_TotalScreenSize,        0},
  122.     {Vduvar_GPLFMD,                 0}, {         Vduvar_GPLBMD,        0},
  123.     {Vduvar_GFCOL,                  0}, {          Vduvar_GBCOL,        0},
  124.     {Vduvar_TForeCol,               0}, {       Vduvar_TBackCol,        0},
  125.     {Vduvar_GFTint,                 0}, {         Vduvar_GBTint,        0},
  126.     {Vduvar_TFTint,                 0}, {         Vduvar_TBTint,        0},
  127.     {Vduvar_MaxMode,         VDU_MODE}, {     Vduvar_GCharSizeX, VDU_MODE},
  128.     {Vduvar_GCharSizeY,      VDU_MODE}, {    Vduvar_GCharSpaceX, VDU_MODE},
  129.     {Vduvar_GCharSpaceY,     VDU_MODE}, {      Vduvar_HLineAddr, VDU_MODE},
  130.     {Vduvar_TCharSizeX,      VDU_MODE}, {     Vduvar_TCharSizeY, VDU_MODE},
  131.     {Vduvar_TCharSpaceX,     VDU_MODE}, {    Vduvar_TCharSpaceY, VDU_MODE},
  132.     {Vduvar_GcolOraEorAddr,         0}, {    Vduvar_WindowWidth,        0},
  133.     {Vduvar_WindowHeight,           0}, { /*    Modenumber */ 0, VDU_MODE},
  134.     { /* CharXsize     */ 0, VDU_MODE}, { /*     CharYsize */ 0, VDU_MODE},
  135.     { /* ScreenXsize   */ 0, VDU_MODE}, { /*   ScreenYsize */ 0, VDU_MODE}
  136. };
  137. static int     haswin_vdustore[VDUVAR_MAXVARS+1];
  138.  
  139. /*
  140.  *      this is a list of all the RISCOS codes for the VDU variables.
  141.  *      If stored in a buffer in this order then the HASWIN codes starting
  142.  *      "VDUVAR_" will access the right element of the buffer.  It is used
  143.  *      as the buffer to give OS_ReadVduVariables for a full update.
  144.  */
  145. static int     haswin_vdulist[VDUVAR_MAXVARS+1] = {
  146.         Vduvar_ModeFlags,     Vduvar_ScrRCol,       Vduvar_ScrBRow,
  147.         Vduvar_NColour,       Vduvar_XEigFactor,    Vduvar_YEigFactor,
  148.         Vduvar_LineLength,    Vduvar_ScreenSize,    Vduvar_YShftFactor,
  149.         Vduvar_Log2BPP,       Vduvar_Log2BPC,       Vduvar_XWindLimit,
  150.         Vduvar_YWindLimit,    Vduvar_GWLCol,        Vduvar_GWBRow,
  151.         Vduvar_GWRCol,        Vduvar_GWTRow,        Vduvar_TWLCol,
  152.         Vduvar_TWBRow,        Vduvar_TWRCol,        Vduvar_TWTRow,
  153.         Vduvar_OrgX,          Vduvar_OrgY,          Vduvar_GCsX,
  154.         Vduvar_GCsY,          Vduvar_OlderGCsX,     Vduvar_OlderGCsY,
  155.         Vduvar_OldGCsX,       Vduvar_OldGCsY,       Vduvar_GCsIX,
  156.         Vduvar_GCsIY,         Vduvar_NewPtX,        Vduvar_NewPtY,
  157.         Vduvar_ScreenStart,   Vduvar_DisplayStart,  Vduvar_TotalScreenSize,
  158.         Vduvar_GPLFMD,        Vduvar_GPLBMD,        Vduvar_GFCOL,
  159.         Vduvar_GBCOL,         Vduvar_TForeCol,      Vduvar_TBackCol,
  160.         Vduvar_GFTint,        Vduvar_GBTint,        Vduvar_TFTint,
  161.         Vduvar_TBTint,        Vduvar_MaxMode,       Vduvar_GCharSizeX,
  162.         Vduvar_GCharSizeY,    Vduvar_GCharSpaceX,   Vduvar_GCharSpaceY,
  163.         Vduvar_HLineAddr,     Vduvar_TCharSizeX,    Vduvar_TCharSizeY,
  164.         Vduvar_TCharSpaceX,   Vduvar_TCharSpaceY,   Vduvar_GcolOraEorAddr,
  165.         Vduvar_WindowWidth,   Vduvar_WindowHeight,  -1
  166. };
  167.  
  168. int haswin_updatevduvariable(int code) {
  169.  
  170.         int                     inbuff[2], outbuff[1];
  171.         _kernel_swi_regs        regs;
  172.  
  173.         if ((code < 0) || (code > VDUVAR_MAXVARS))
  174.                 return(HASWIN_FALSE);
  175.         if (haswin_vduvarconv[code][1] & VDU_MODE)
  176.                 return(HASWIN_TRUE);
  177.         switch (code) {
  178.         case VDUVAR_ModeNumber:
  179.         case VDUVAR_CharXsize:
  180.         case VDUVAR_CharYsize:
  181.         case VDUVAR_ScreenXsize:
  182.         case VDUVAR_ScreenYsize:
  183.                 return(HASWIN_TRUE);
  184.         default:
  185.                 inbuff[0] = haswin_vduvarconv[code][0];
  186.                 inbuff[1] = -1;
  187.                 regs.r[0] = (int)&inbuff;
  188.                 regs.r[1] = (int)&outbuff;
  189.                 haswin_swi(OS_ReadVduVariables, ®s);
  190.                 haswin_vdustore[code] = outbuff[0];
  191.                 return(HASWIN_TRUE);
  192.         }
  193.         return(HASWIN_TRUE);
  194. }
  195.  
  196. int haswin_readvduvariable(int code) {
  197.  
  198.         if ((code < 0) || (code > VDUVAR_MAXVARS))
  199.                 return(HASWIN_UNKNOWN);
  200.         if (!(haswin_vduvarconv[code][1] & VDU_MODE))
  201.                 haswin_updatevduvariable(code);
  202.         return(haswin_vdustore[code]);
  203. }
  204.  
  205. /*
  206.  *      read all the vdu variables and place them in the buffer given.  The
  207.  *      buffer must be at least VDUVAR_MAXVARS integers long, but this is
  208.  *      not checked for.  If no buffer is given then use the system one.
  209.  */
  210. int haswin_updateallvduvariables(int *buff) {
  211.         _kernel_swi_regs        regs;
  212.         int                     res;
  213.  
  214.         if (!buff)
  215.                 buff = haswin_vdustore;
  216.         regs.r[0] = (int)haswin_vdulist;
  217.         regs.r[1] = (int)buff;
  218.         res = haswin_swi(OS_ReadVduVariables, ®s);
  219.         /*
  220.          *       now we have done the RISCOS VDU Variables we do the HASWIN
  221.          *       extensions.
  222.          */
  223.         regs.r[0] = 135;
  224.         haswin_swi(OS_Byte, ®s);
  225.         buff[VDUVAR_ModeNumber] = regs.r[2];
  226.         buff[VDUVAR_CharXsize] =
  227.                 buff[VDUVAR_GCharSpaceX] << buff[VDUVAR_XEigFactor];
  228.         buff[VDUVAR_CharYsize] =
  229.                 buff[VDUVAR_GCharSpaceY] << buff[VDUVAR_YEigFactor];
  230.         buff[VDUVAR_ScreenXsize] =
  231.                 buff[VDUVAR_XWindLimit] << buff[VDUVAR_XEigFactor];
  232.         buff[VDUVAR_ScreenYsize] =
  233.                 buff[VDUVAR_YWindLimit] << buff[VDUVAR_YEigFactor];
  234.         return(res);
  235. }
  236.  
  237.