Subversion Repositories Kolibri OS

Rev

Rev 5741 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. #ifndef INCLUDE_FONT_H
  2. #define INCLUDE_FONT_H
  3.  
  4. #ifndef INCLUDE_MATH_H
  5. #include "../lib/math.h"
  6. #endif
  7.  
  8. #ifndef INCLUDE_IO_H
  9. #include "../lib/io.h"
  10. #endif
  11.  
  12. :struct FONT
  13. {
  14.         byte width,height,offsetLine,r,g,b;
  15.         word width_buffer;
  16.         dword file_size;
  17.         dword buffer;
  18.         dword buffer_size;
  19.         word block;
  20.         dword data;
  21.         dword begin;
  22.         dword size_file;
  23.         byte load(...);
  24.         byte symbol(word x;byte s;dword c);
  25.         byte symbol_size(byte s);
  26.         dword text(word x,y;dword text,c;byte size);
  27.         dword text_width(dword text1;byte size);
  28.         dword textarea(word x,y;dword text,c;byte size);
  29.         byte changeSIZE(byte size);
  30.         void PixelRGB(word x,y);
  31.         dword tmp_y,tmp_height,tmp_x;
  32. };
  33. FONT font = 0;
  34.  
  35. :void FONT::PixelRGB(dword x,y)
  36. {
  37.         dword tmp;
  38.         tmp = y*width_buffer*3;
  39.         tmp += x*3;
  40.         tmp += buffer;
  41.  
  42.         DSBYTE[tmp] = r;
  43.         tmp++;
  44.         DSBYTE[tmp] = g;
  45.         tmp++;
  46.         DSBYTE[tmp] = b;
  47. }
  48. :byte FONT::changeSIZE(byte size)
  49. {
  50.         dword TMP_DATA;
  51.         dword ofs;
  52.         byte s;
  53.         IF(size<9) size = 8;
  54.         IF(size>45)size = 45;
  55.                 s = size-8;
  56.                 data = begin;
  57.                 TMP_DATA = data;
  58.                 TMP_DATA +=s*4;
  59.                 ofs = DSDWORD[TMP_DATA];
  60.                 IF(ofs==-1)return false;
  61.                 data += ofs;
  62.                 data += 156;
  63.                 TMP_DATA = data;
  64.                 file_size = DSDWORD[TMP_DATA];
  65.                 TMP_DATA += file_size;
  66.                 TMP_DATA--;
  67.                 height = DSBYTE[TMP_DATA];
  68.                 TMP_DATA--;
  69.                 width =  DSBYTE[TMP_DATA];
  70.                 block = math.ceil(height*width/32);
  71.                 return true;
  72. }
  73. :proc_info Form_SELF_FONTS;
  74.  
  75. :dword FONT::text_width(dword text1;byte size)
  76. {
  77.         dword len=0;
  78.         IF(size)IF(!changeSIZE(size))return 0;
  79.         WHILE(DSBYTE[text1])
  80.         {
  81.                 len += symbol_size(DSBYTE[text1]);
  82.                 text1++;
  83.         }
  84.         return len;
  85. }
  86. :byte FONT::symbol_size(byte s)
  87. {
  88.         dword xi,yi;
  89.         dword tmp,_;
  90.         dword iii;
  91.         byte rw=0;
  92.         IF(s==32)return width/4;
  93.                 IF(s==9)return width;
  94.         yi = 0;
  95.         iii = 0;
  96.         tmp = 4*block*s;
  97.         tmp +=data;
  98.         WHILE(yi<height)
  99.         {
  100.                 xi = 0;
  101.                 WHILE(xi<width)
  102.                 {
  103.                         IF(iii%32) _ >>= 1;
  104.                                                 ELSE
  105.                                                 {
  106.                                 tmp += 4;
  107.                                 _ = DSDWORD[tmp];
  108.                         }
  109.                         IF(_&1) IF(xi>rw)rw=xi;
  110.                         xi++;
  111.                         iii++;
  112.                 }
  113.                 yi++;
  114.         }
  115.         return rw;
  116. }
  117. :dword FONT::text(word x,y;dword text1,c;byte size)
  118. {
  119.         signed len=0;
  120.         IF(size)IF(!changeSIZE(size))return 0;
  121.         GetProcessInfo(#Form_SELF_FONTS, SelfInfo);
  122.         IF(y>Form_SELF_FONTS.cheight) return 0;
  123.         IF(x>Form_SELF_FONTS.cwidth) return 0;
  124.         tmp_y = y;
  125.         AX = c;
  126.         r = AL;
  127.         g = AH;
  128.         c>>=16;
  129.         AX = c;
  130.         b = AL;
  131.         width_buffer = width;
  132.         width_buffer *= strlen(text1);
  133.         IF(!buffer_size)buffer = malloc(width_buffer*height*3);
  134.         ELSE IF(buffer_size<width_buffer*height)buffer = realloc(width_buffer*height*3);
  135.         CopyScreen(buffer,x+Form_SELF_FONTS.left+5,y+Form_SELF_FONTS.top+GetSkinHeight(),width_buffer,height);
  136.        
  137.         WHILE(DSBYTE[text1])
  138.         {
  139.                 symbol(len,DSBYTE[text1],c);
  140.                 len+=EAX;
  141.                 text1++;
  142.         }
  143.         _PutImage(x,y,width_buffer,height,buffer);
  144.         return len;
  145. }
  146. :dword FONT::textarea(word x,y;dword text1,c;byte size)
  147. {
  148.        
  149. }
  150.  
  151. :byte FONT::symbol(signed x;byte s;dword c)
  152. {
  153.         dword xi,yi;
  154.         dword tmp,_;
  155.         dword iii;
  156.                 dword ___x;
  157.         byte rw=0;
  158.                 x -= 2;
  159.         IF(s==32)return width/4;
  160.                 IF(s==9)return width;
  161.         yi = 0;
  162.         iii = 0;
  163.         tmp = 4*block*s;
  164.         tmp +=data;
  165.         while(yi<height)
  166.         {
  167.                 xi = 0;
  168.                 WHILE(xi<width)
  169.                 {
  170.                         IF(iii%32) _ >>= 1;
  171.                                                 ELSE
  172.                                                 {
  173.                                 tmp += 4;
  174.                                 _ = DSDWORD[tmp];
  175.                         }
  176.                         IF(_&1)
  177.                         {
  178.                                 IF(xi>rw)rw=xi;
  179.                                                                 ___x = x+xi;
  180.                                                                 IF(___x<Form_SELF_FONTS.cwidth)&&(tmp_y+yi<Form_SELF_FONTS.cheight)PixelRGB(___x,yi);
  181.                         }
  182.                         xi++;
  183.                         iii++;
  184.                 }
  185.                 yi++;
  186.         }
  187.         return rw;
  188. }
  189. :byte FONT::load(dword path)
  190. {
  191.         dword tmp;
  192.         IF(data)free(data);
  193.         tmp = io.read(path);
  194.         data = tmp;
  195.         begin = data;
  196.         size_file = io.FILES_SIZE;
  197.         tmp +=size_file;
  198.         tmp--;
  199.         height = DSBYTE[tmp];
  200.         tmp--;
  201.         width = DSBYTE[tmp];
  202.         block = math.ceil(height*width/32);
  203. }
  204.  
  205. #endif