home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / DClap / DIconLib.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  14.7 KB  |  634 lines  |  [TEXT/R*ch]
  1. // DIconLib.cp
  2.  
  3.  
  4.  
  5. #include "Dvibrant.h"
  6. #include "DIconLib.h"
  7. #include "DApplication.h"
  8. #include "DList.h"
  9. #include "DFile.h"
  10. #include <stdio.h>
  11.  
  12. typedef    unsigned char    byte;
  13. enum  BitFormat            { macbits, msbits, xbits };
  14. enum  BitmapFormat     { unknown, xbitmapfile, maciconrezfile};
  15.  
  16. DIconList* gIconList = NULL;
  17.  
  18. class DIconGlobals {
  19. public:
  20.    DIconGlobals() { gIconList = new DIconList(); }
  21. };
  22.  
  23. static DIconGlobals    globals; // initializes globals here
  24.  
  25. // Unix CC and gcc have problems linking DIcon.o w/ only data
  26. #ifdef OS_UNIX
  27. #include "DIcons.cc"
  28. #endif
  29.  
  30.  
  31. #if 0
  32. static unsigned short testicons[] = {
  33.     22213, 0, 13, 13, 12,
  34.  0xff00, 0x8180, 0x81c0, 0x9040, 0xa840, 0xa840, 0x9240, 0x8240,
  35.  0x8240, 0x8240, 0x8040, 0xffc0 
  36. ,
  37.   1215, 0, 32, 32, 64,
  38.  0x1fff, 0xfc00, 0x1000,  0x600, 0x13a0,  0x500, 0x13a0,  0x480,
  39.  0x13a8, 0x2440, 0x13a0,  0x420, 0x13a0, 0xe7f0, 0x13a1, 0x1010,
  40.  0x13a2,  0x810, 0x13a2,  0x810, 0x13aa,  0x890, 0x13a1, 0x1010,
  41.  0x13e0, 0xe010, 0x1220,   0x10, 0x1220,   0x10, 0x1220,   0x10,
  42.  0x122b, 0xfe90, 0x1222,  0x210, 0x11c2,  0x210, 0x1322, 0x1fd0,
  43.  0x1322, 0x1050, 0x1212, 0x1050, 0x121b, 0xf250, 0x1210, 0x1050,
  44.  0x1230, 0x1050, 0x1120, 0x1fd0, 0x11a0,   0x10, 0x10e0,   0x10,
  45.  0x1230, 0x2090, 0x1000,   0x10, 0x1000,   0x10, 0x1fff, 0xfff0
  46. ,
  47.   0,0,0,0,0,0 
  48. };
  49. #endif
  50.  
  51. static Boolean gByteFlipMade = false;
  52.  
  53. #ifdef NOTNOW_WIN_MOTIF
  54.  
  55. static byte    XByteFlip [256];
  56.  
  57. void MakeXByteFlip()
  58. {
  59.     short i, j;
  60.   byte val, inv;
  61.  
  62.   for (i = 0; i < 256; i++) {
  63.     inv = 0;
  64.     val = (byte) i;
  65.     for (j = 0; j < 8; j++) {
  66.       inv = (inv << 1);
  67.       inv += (val % 2);
  68.       val = (val >> 1);
  69.     }
  70.     XByteFlip[i] = inv;
  71.   }
  72.   gByteFlipMade= true;
  73. }
  74.  
  75. #else
  76.  
  77. void  MakeXByteFlip()
  78. {
  79.   gByteFlipMade= true;
  80. }
  81. #endif
  82.  
  83.  
  84. void DIconList::WriteAsCode( char* filename) 
  85. {
  86.     if (!filename) 
  87.         filename= (char*) gFileManager->GetOutputFileName("icons.c");
  88.     if (filename) {
  89.         long i, n= this->GetSize();
  90.         char *sbreak= ",\n";
  91.         DFile  iconf( filename, "w", "TEXT", "MMCC");
  92.         iconf.Open();
  93.         char buf[128];
  94.         sprintf(buf, "static unsigned short iconlist[] = { /* %d icons */ {\n", n);
  95.         iconf.WriteLine(buf);
  96.         for (i=0; i<n; i++) {
  97.             DIcon* ic= (DIcon*)IconAt(i);
  98.             ic->WriteCode( &iconf);
  99.             if (i == n-1) sbreak= ",\n 0, 0, 0, 0, 0, 0\n};\n";
  100.             iconf.WriteLine( sbreak );
  101.             }
  102.         iconf.Close();
  103.         }
  104. }
  105.  
  106. void DIcon::WriteCode( DFile* iconf)
  107. {
  108.     short i, nwords= 1 + ((fBitmapSize-1) / sizeof(short) );
  109.     char buf[512];
  110.     
  111.     sprintf( buf, " %d, %d, %d, %d, %d,\n", 
  112.                         fId, fSmall, fWidth, fHeight, nwords );
  113.     iconf->WriteLine( buf);
  114.     unsigned short *w = (unsigned short*) fBitmap;
  115.     char comma= ',';
  116.     for (i=0; i<nwords; i++) {
  117.         Boolean last= (i == nwords-1);
  118.         Boolean newline= (i % 8 == 7) || last;
  119.         if (last) comma= ' ';
  120.         sprintf( buf, " %#6x%c", *w, comma);
  121.         iconf->WriteLine( buf, newline);
  122.         w++;
  123.         }
  124.      
  125. }
  126.  
  127.  
  128. //class DIcon : public DObject
  129.  
  130. DIcon::DIcon() :
  131.     DObject(),
  132.     fId(0), fWidth(0), fHeight(0), fSmall(false),
  133.     fBitmapSize(0), fBitmap(NULL)
  134. { 
  135. }
  136.     
  137. DIcon::DIcon( long id, short width, short height, const char* bitmap, long bitmapsize) : 
  138.     DObject(),
  139.     fId(id), fWidth(width), fHeight(height),fSmall(false),
  140.     fBitmapSize(bitmapsize), fBitmap(NULL)
  141. {
  142.     Install( width, height, bitmap, bitmapsize);
  143. }
  144.  
  145. DIcon::DIcon( IconStore* store) :
  146.     DObject(), fBitmapSize(0), fBitmap(NULL)
  147. {
  148.     Install( -(store->width), store->height, (char*) &(store->bitmap), 
  149.                      store->bitmapsize * sizeof(short));
  150.     fId= store->id;
  151.     fSmall= store->smalli;
  152.     if (gIconList) gIconList->InsertLast( this);
  153. }
  154.  
  155.     
  156. DIcon::~DIcon() 
  157. { 
  158.     fBitmap= (char*)Nlm_MemFree(fBitmap); 
  159. }
  160.  
  161.  
  162. void DIcon::Draw(Nlm_RecT area)
  163. {
  164.     area.right  = Min( area.right, area.left + fWidth);
  165.     area.bottom = Min( area.bottom, area.top + fHeight);
  166.     Nlm_CopyBits( &area, fBitmap);
  167. }
  168.         
  169. void DIcon::Install( short width, short height, const char* bitmap, long bitmapsize) 
  170. {
  171.   Boolean flipbyte= (width<0);
  172.   if (flipbyte) width = -width;
  173.  
  174.     fWidth = width;
  175.     fHeight= height;
  176.     if (fBitmap) fBitmap= (char*)Nlm_MemFree(fBitmap);
  177.     fBitmapSize= 0;
  178.  
  179.     if (bitmap) {        
  180.         fBitmapSize = bitmapsize;
  181.         if ((fBitmap = (char*) Nlm_MemGet(fBitmapSize+2, FALSE)) != NULL) {
  182.  
  183. #ifdef IS_LITTLE_ENDIAN
  184. // damn, really I should just revise the compiled data form to use bytes instead of words
  185. // this is just a word little/big endian problem....
  186. //#if defined(WIN_MOTIF) || defined(WIN_MSWIN)
  187.        if (flipbyte) {
  188.          byte *storebyte, *bp, *bpend;
  189.          //if (!gByteFlipMade) MakeXByteFlip();  
  190.          storebyte= (byte*) fBitmap;
  191.          bp = (byte*) bitmap;
  192.          bpend= bp + bitmapsize;
  193.          while (bp < bpend) { 
  194.                  *storebyte++= bp[1];
  195.                  *storebyte++= bp[0];
  196.                  bp += 2;
  197.                     }
  198.          }
  199.        else
  200. #endif
  201.                 Nlm_MemCpy (fBitmap, bitmap, fBitmapSize); // +1 bad for mswin?
  202.                 fBitmap[fBitmapSize]= 0;
  203.             }
  204.         }
  205. } 
  206.  
  207.  
  208.  
  209.  
  210. //class DIconList : public DList
  211.  
  212. DIconList::DIconList()
  213. {
  214. }
  215.  
  216.  
  217. DIcon* DIconList::IconById(long id) 
  218. {
  219.     if (id) {
  220.         long i, n= this->GetSize();
  221.         for (i= 0; i<n; i++) {
  222.             if (IconAt(i)->fId == id) return IconAt(i);
  223.             }
  224.     }
  225.     return NULL;
  226. }
  227.  
  228. void DIconList::StoreFromCode( unsigned short* ilist, short nlist) 
  229. {
  230.     Boolean notdone;
  231.     IconStore* store;
  232.     unsigned short* next;
  233.     short i= 0;
  234.     
  235.     store= (IconStore*) ilist;    
  236.     notdone= (store->bitmapsize) && (nlist==0 || (i<nlist));
  237.     while (notdone) {
  238.         next= ilist + sizeof(IconStore) + (store->bitmapsize - 1) * sizeof(short);
  239.         DIcon* ic= new DIcon( store);
  240.         this->InsertLast( ic);
  241.         i++;
  242.         ilist= next;
  243.         store= (IconStore*) ilist;
  244.         notdone= (store->bitmapsize) && (nlist==0 || (i<nlist));
  245.         }
  246. }
  247.  
  248.  
  249. void DIconList::ReadAppIcons() 
  250. {
  251. #ifdef OS_DOS
  252.   char *suffix = ".icn"; // ?? or ".ico", which is also MSWin own format
  253. #else
  254.   char *suffix = ".icons";
  255. #endif
  256.     char *iconfile = NULL;
  257.  
  258.   //MakeXByteFlip();
  259.     long len= StrLen(  (char*)gApplication->Shortname()) + StrLen(suffix);
  260.     iconfile= (char*) MemNew(len+2);
  261.     StrCpy(iconfile, (char*)gApplication->Shortname());
  262.     StrCat(iconfile, suffix);
  263.     this->Read(iconfile);
  264.     Nlm_MemFree(iconfile);
  265. }
  266.     
  267.     
  268.  
  269.  
  270. Boolean DIconList::Read(char* filename) 
  271. {
  272.     BitmapFormat    fileformat= unknown;
  273.     FILE *f= FileOpen( filename, "r");
  274.     if (f) {
  275.         char line[512];
  276.         Boolean more= true;
  277.         short    atline = 0;
  278.         while (more && FileGets( line, 512, f)) {
  279.             unsigned long index = 0;
  280.             atline++;
  281.  
  282.             if (Nlm_StrngPos(line, "char ", 0, true, &index)  
  283.             || Nlm_StrngPos(line, "static ", 0, true, &index)) {
  284.                 fileformat= xbitmapfile;    
  285.                 more= false;
  286.                 }
  287.                 
  288.             else if (Nlm_StrngPos(line, "resource ", 0, true, &index))  {
  289.                 fileformat= maciconrezfile;    
  290.                 more= false;
  291.                 }
  292.             
  293.             if (atline > 50) more= false;        
  294.             }
  295.         }
  296.     FileClose( f);
  297.     
  298.     switch (fileformat) {
  299.         case xbitmapfile        : return this->ReadXbitmapFormat( filename);
  300.         case maciconrezfile    : return this->ReadMacRezFormat( filename);
  301.         default                            : return false;
  302.         }
  303.         
  304. }
  305.  
  306.  
  307.  
  308. Boolean DIconList::ReadMacRezFormat(char* filename) 
  309. {
  310. /******
  311. mac rez file format:
  312. resource 'ICN#' (128, "Calc Family", purgeable) {
  313. {    $"..."
  314.     $"...",
  315.     // icon mask 
  316.     $"..."
  317.     $"..."
  318.   }
  319. };
  320.  
  321. resource 'ics#' (128, "Calc Family", purgeable) {
  322. };
  323.  
  324. resource 'ICON' (kSeedIconId, purgeable) {
  325.     $"0001 0000 0002 8000 0004 4000 0008 2000 0010 1000 0020 0800 0040 0400 0080 0200"
  326.     $"0100 0100 0200 0080 0400 0040 0800 0020 1000 0010 2000 0008 4000 3F04 8000 4082"
  327.     $"4000 8041 2001 3022 1001 C814 080E 7F8F 0402 3007 0201 0007 0100 8007 0080 6007"
  328.     $"0040 1FE7 0020 021F 0010 0407 0008 0800 0004 1000 0002 2000 0001 4000 0000 8000"
  329. };
  330. ******/
  331.  
  332.     const    short    bufsize = 512;
  333.     char  line[512];
  334.     byte    buf[bufsize];
  335.     byte *bitsp= NULL, *bitmap = NULL;
  336.     Boolean inbits= false, instring= false;
  337.     short    width = 0, height = 0;
  338.     long     id = 0;
  339.     char* linep= line;
  340.     long     bytesize= 0;
  341.     long     atsize= 0;
  342.     Boolean gotdata= false;
  343.     unsigned long index;
  344.  
  345.     FILE *f= FileOpen( filename, "r");
  346.     if (f) 
  347.      while (FileGets( line, 512, f)) {
  348.         // assume may be multiple bitmaps / file
  349.         linep= line;
  350.         
  351.         if (inbits) {
  352.     suckbits:            
  353.     
  354.                 // here we must watch for 
  355.                 //    "$" == flag for hex data following
  356.                 //    '"' == start/end of string data
  357.                 //    ',' == end of one icon, another follows ?? we only get 1st & ingore mask?
  358.                 //    '}' ';' == end of resource
  359.                 
  360.             char ec, *ep;
  361.             char *cp= linep;
  362.             unsigned short card;
  363.             short rslt;
  364.             
  365.             if (!atsize || !bitsp) {
  366.                 bitsp= buf;
  367.                 atsize= 0;
  368.                 }
  369.                 
  370.             while (*cp) {
  371.             
  372.                 if (instring) {
  373.                     short ic;
  374.                     while (*cp && !isalnum(*cp)) cp++;
  375.                     for (ic= 0, ep= cp; 
  376.                         ic<2 && (*ep) && isalnum(*ep); 
  377.                         ep++, ic++) ;
  378.                     ec= *ep; *ep= 0; card= 0;
  379.                     rslt= sscanf( cp, "%hx", &card);
  380.                     *ep= ec;
  381.                     if ( atsize<bufsize && rslt>0 ) { 
  382.                         *bitsp++ = (byte) card;
  383.                         atsize++;
  384.                         }
  385.                     cp = ep;
  386.                     }    
  387.                 else
  388.                     cp++;
  389.                     
  390.                 if (*cp == '"') instring= !instring;
  391.                 else if (*cp == '}' || *cp == ';') inbits= instring = false;
  392.                 else if (*cp == ',') { 
  393.                         // skip rest of data in this rez.. ??
  394.                     while (*cp && !(*cp == '}' || *cp == ';')) cp++; 
  395.                     inbits= instring= false;
  396.                     } 
  397.                 
  398.                 if (atsize >= bufsize || !inbits) {
  399.                     //move buf[] data to bitmap store...
  400.                     long offset= bytesize;
  401.                     bytesize += atsize;
  402.                     if (!bitmap) 
  403.                         bitmap= (byte*) Nlm_MemGet( bytesize, false);
  404.                     else 
  405.                         bitmap= (byte*) Nlm_MemMore( bitmap, bytesize);
  406.                     Nlm_MemCopy( bitmap+offset, buf, atsize);
  407.                     bitsp= buf;
  408.                     atsize= 0;
  409.                     }
  410.                     
  411.                 if (!inbits) {                    
  412.                         // guess at width/height
  413. #if 1
  414.                     width= height= short( sqrt(bytesize * 8));
  415. #else            
  416.                         // ?? do a simple int square root -- bad for non-base-2 values
  417.                     long w= bytesize * 8;
  418.                     long h= 1;
  419.                     while (w>h) {  
  420.                         w >>= 1;
  421.                         h <<= 1;
  422.                         }
  423.                     width = w;
  424.                     height= h;
  425. #endif                    
  426.                     DIcon* ic= new DIcon( id, width, height, (const char*)bitmap, bytesize);
  427.                     this->InsertLast( ic);
  428.                     width= height= id= 0;
  429.                     bitmap= (byte*) Nlm_MemFree(bitmap);
  430.                     bitsp= NULL;
  431.                     bytesize= atsize= 0;
  432.                     inbits= instring= false;
  433.                     gotdata= true;
  434.                     *cp= 0; // done
  435.                     }
  436.                     
  437.                 }
  438.             } // end suckbits
  439.             
  440.                         
  441.         else if ( (linep= strchr(line,'{')) != NULL  && 
  442.              ( Nlm_StrngPos(line, "resource 'ICN#'", 0, true, &index)
  443.             || Nlm_StrngPos(line, "resource 'ics#'", 0, true, &index)
  444.             || Nlm_StrngPos(line, "resource 'ICON'", 0, true, &index) ) )
  445.             {
  446.             // !! get id value == first # after "("
  447.             char *nump= strchr(line,'(');
  448.             if (nump) {
  449.                 char *ep, ec;
  450.                 nump++;
  451.                 for (ep= nump; isdigit(*ep); ep++) ;
  452.                 ec= *ep; *ep= 0;
  453.                 id= atol(nump);
  454.                 *ep= ec;
  455.                 }
  456.             linep++;
  457.             inbits= true;
  458.             goto suckbits; 
  459.             }
  460.  
  461.         
  462.         }
  463.         
  464.     FileClose(f);
  465.     return gotdata;
  466. }
  467.  
  468.  
  469.  
  470. Boolean DIconList::ReadXbitmapFormat(char* filename) 
  471. {
  472. /******
  473. Xbitmap file format:
  474. #define  somename_width  16
  475. #define  somename_height 32
  476. #define  somename_bittype  x    #< optional addition to specify BitFormat
  477. static char somename [] = {            #< data starts after "{", ends after "}"
  478.    0x0f, 0xc0, 0x12, 0xff };    #< bitmap data as hex or decimal string of chars
  479. ******/
  480.     Boolean gotdata= false;
  481.     char line[512];
  482.     byte *bitsp= NULL, *bitmap = NULL;
  483.     Boolean inbits= false;
  484.     short    width = 0, height = 0;
  485.     long id = 0;
  486.     char* linep= line;
  487.     long     bytesize= 0;
  488.     long     atsize= 0;
  489.     short    bswap = 0;
  490.     BitFormat bitstype = macbits;
  491.  
  492.                 // set win system defaults -- override if file says to.
  493. #ifdef  WIN_MAC
  494.     bitstype = macbits;
  495. #endif
  496. #ifdef WIN_MSWIN
  497.     bitstype = msbits;
  498. #endif
  499. #ifdef WIN_MOTIF
  500.     bitstype = xbits;
  501. #endif
  502.  
  503.     FILE *f= FileOpen( filename, "r");
  504.     if (f) 
  505.      while (FileGets( line, 512, f)) {
  506.         // assume may be multiple bitmaps / file
  507.         linep= line;
  508.         
  509.         if (inbits) {
  510.     suckbits:            
  511.                   // data looks like: 0x80, 0x01, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00};
  512.             char* cp= linep;
  513.             if (!bitmap) {
  514.                 bytesize= height * ((width+7) / 8); // bytes/row + rowcount
  515.                 bitmap= (byte*) Nlm_MemGet( bytesize+1, false);
  516.                 bitsp= bitmap;
  517.                 }
  518.                 
  519.             while (*cp) {
  520.             
  521.                 if (*cp == '}' || *cp == ';') {
  522.                     // install data into new icon...
  523.                     *bitsp= 0; // 0 terminate? -- this isn't really useful, since bitmap can have nulls
  524.                     DIcon* ic= new DIcon( id, width, height, (const char*)bitmap, atsize);
  525.                     this->InsertLast( ic);
  526.                     width= height= id= 0;
  527.                     bitmap= (byte*) Nlm_MemFree(bitmap);
  528.                     bitsp= NULL;
  529.                     bswap= bytesize= atsize= 0;
  530.                     inbits= false;
  531.                     gotdata= true;
  532.                     *cp= 0; // done
  533.                     }
  534.                     
  535.                 else if (isdigit(*cp)) {
  536.                     short rslt= 0;
  537.                     unsigned short card= 0;
  538.                     char *fmt = "%hu";
  539.                     char ec, *ep = cp;
  540.                     Boolean okay= true;
  541.                     
  542.                     while (okay) {
  543.                         ep++;
  544.                         if (*ep == 'x' || *ep == 'X') fmt= "%hx";  
  545.                         else if (!*ep || !isalnum(*ep)) okay= false;
  546.                         }
  547.                     ec= *ep; *ep= 0;
  548.                     rslt= sscanf( cp, fmt, &card);
  549.                     *ep= ec;
  550.                     if ( atsize<bytesize && rslt>0 ) { 
  551.                         switch (bitstype) {
  552.                             case xbits: {
  553.                                 // X bitmaps have WEIRD storage format !! see Nlm_CopyBits
  554.                                 byte drac, i;
  555.                                 for (i=0, drac= 0; i<8; i++) { drac <<= 1; drac += card & 1; card >>= 1; }
  556.                                 *bitsp++ = (byte) drac;
  557.                                 }break;
  558.                             case msbits: {
  559.                                 *bitsp++ = ~(byte) card; // mswin is NOT
  560.                                 }break;
  561.                             case macbits: {
  562.                                 *bitsp++ = (byte) card;
  563.                                 }break;
  564.                             }
  565.                         atsize++;
  566.                         }
  567.                     cp = ep;
  568.                     }
  569.                     
  570.                 //else if (*cp == ',') cp++;
  571.                 else cp++; // spaces, all else...
  572.                 }
  573.             }
  574.             
  575.         else if (width && height && (linep= strchr(line,'{')) != NULL) {
  576.             linep++;
  577.             inbits= true;
  578.             goto suckbits; 
  579.             }
  580.             
  581.         else {
  582.             //look for string w/ "#define somename_width 16" << "width" is key
  583.             //or "#define somename_height 16" << "height" is key
  584.             unsigned long index = 0;
  585.             char* cp;
  586.             if (Nlm_StrngPos(line, "width", 0, false, &index)) { //false==case-insensitive
  587.                 cp= line + index + 5; //length(width)
  588.                 while (*cp && !isdigit(*cp)) cp++;
  589.                 width= atol(cp); //?? what is better than atol()    
  590.                 }                 
  591.             else if (Nlm_StrngPos(line, "height", 0, false, &index)) {
  592.                 cp= line + index + 5;  
  593.                 while (*cp && !isdigit(*cp)) cp++;
  594.                 height= atol(cp); //?? what is better than atol()    
  595.                 }                 
  596.             else if (Nlm_StrngPos(line, "ident", 0, false, &index)) { 
  597.                 cp= line + index + 5; 
  598.                 while (*cp & !isdigit(*cp)) cp++;
  599.                 id= atol(cp);
  600.                 }                 
  601.             else if (Nlm_StrngPos(line, "bitstype", 0, false, &index)) { 
  602.                 cp= line + index + 8; 
  603.                 index= 0;
  604.                 if (Nlm_StrngPos(cp, "mac", 0, false, &index)) bitstype= macbits; 
  605.                 else if (Nlm_StrngPos(cp, "x", 0, false, &index)) bitstype= xbits; 
  606.                 else if (Nlm_StrngPos(cp, "ms", 0, false, &index)) bitstype= msbits; 
  607.                 }                 
  608.             }
  609.         
  610.         }
  611.         
  612.     FileClose(f);
  613.     return gotdata;
  614. }
  615.         
  616.  
  617.  
  618. #if 0
  619.  
  620.  
  621. // Xlibrary standard bitmap form:
  622. // (width+7) div 8 = # bytes/row
  623. #define left_ptr_width 16
  624. #define left_ptr_height 16
  625. #define left_ptr_x_hot 3
  626. #define left_ptr_y_hot 1
  627. static char left_ptr_bits[] = {
  628.    0x00, 0x00, 0x08, 0x00, 0x18, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf8, 0x00,
  629.    0xf8, 0x01, 0xf8, 0x03, 0xf8, 0x07, 0xf8, 0x00, 0xd8, 0x00, 0x88, 0x01,
  630.    0x80, 0x01, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00};
  631.  
  632.   
  633. #endif
  634.