Subversion Repositories Kolibri OS

Rev

Rev 5742 | 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 text1,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.         byte no_bg_copy;
  33.         dword bg_color;
  34. };
  35. FONT font = 0;
  36.  
  37. :void FONT::PixelRGB(dword x,y)
  38. {
  39.         dword tmp;
  40.         tmp = y*width_buffer*3;
  41.         tmp += x*3;
  42.         tmp += buffer;
  43.  
  44.         DSBYTE[tmp] = r;
  45.         tmp++;
  46.         DSBYTE[tmp] = g;
  47.         tmp++;
  48.         DSBYTE[tmp] = b;
  49. }
  50. :byte FONT::changeSIZE(byte size)
  51. {
  52.         dword TMP_DATA;
  53.         dword ofs;
  54.         byte s;
  55.         IF(size<9) size = 8;
  56.         IF(size>45)size = 45;
  57.                 s = size-8;
  58.                 data = begin;
  59.                 TMP_DATA = data;
  60.                 TMP_DATA +=s*4;
  61.                 ofs = DSDWORD[TMP_DATA];
  62.                 IF(ofs==-1)return false;
  63.                 data += ofs;
  64.                 data += 156;
  65.                 TMP_DATA = data;
  66.                 file_size = DSDWORD[TMP_DATA];
  67.                 TMP_DATA += file_size;
  68.                 TMP_DATA--;
  69.                 height = DSBYTE[TMP_DATA];
  70.                 TMP_DATA--;
  71.                 width =  DSBYTE[TMP_DATA];
  72.                 block = math.ceil(height*width/32);
  73.                 return true;
  74. }
  75. :proc_info Form_SELF_FONTS;
  76.  
  77. :dword FONT::text_width(dword text1;byte size)
  78. {
  79.         dword len=0;
  80.         IF(size)IF(!changeSIZE(size))return 0;
  81.         WHILE(DSBYTE[text1])
  82.         {
  83.                 len += symbol_size(DSBYTE[text1]);
  84.                 text1++;
  85.         }
  86.         return len;
  87. }
  88. :byte FONT::symbol_size(byte s)
  89. {
  90.         dword xi,yi;
  91.         dword tmp,_;
  92.         dword iii;
  93.         byte rw=0;
  94.         IF(s==32)return width/4;
  95.                 IF(s==9)return width;
  96.         yi = 0;
  97.         iii = 0;
  98.         tmp = 4*block*s;
  99.         tmp +=data;
  100.         WHILE(yi<height)
  101.         {
  102.                 xi = 0;
  103.                 WHILE(xi<width)
  104.                 {
  105.                         IF(iii%32) _ >>= 1;
  106.                                                 ELSE
  107.                                                 {
  108.                                 tmp += 4;
  109.                                 _ = DSDWORD[tmp];
  110.                         }
  111.                         IF(_&1) IF(xi>rw)rw=xi;
  112.                         xi++;
  113.                         iii++;
  114.                 }
  115.                 yi++;
  116.         }
  117.         return rw;
  118. }
  119. :dword FONT::text(word x,y;dword text1,c;byte size)
  120. {
  121.         signed len=0;
  122.         IF(size)IF(!changeSIZE(size))return 0;
  123.         GetProcessInfo(#Form_SELF_FONTS, SelfInfo);
  124.         IF(y>Form_SELF_FONTS.cheight) return 0;
  125.         IF(x>Form_SELF_FONTS.cwidth) return 0;
  126.         tmp_y = y;
  127.         AX = c;
  128.         r = AL;
  129.         g = AH;
  130.         c>>=16;
  131.         AX = c;
  132.         b = AL;
  133.         width_buffer = text_width(text1,size);
  134.         //width_buffer *= strlen(text1);
  135.         IF(!buffer_size)
  136.         {
  137.                 buffer_size = width_buffer*height*3;
  138.                 buffer = malloc(buffer_size);
  139.         }
  140.         ELSE IF(buffer_size<width_buffer*height*3)
  141.         {
  142.                 buffer_size = width_buffer*height*3;
  143.                 buffer = realloc(buffer,buffer_size);
  144.         }
  145.         IF (no_bg_copy)
  146.         {
  147.                 EBX = bg_color;
  148.                 EAX = buffer_size+buffer;
  149.                 EDI = buffer;
  150.                 WHILE (EDI<EAX)
  151.                 {
  152.                         ESDWORD[EDI] = EBX;
  153.                         $add edi,3
  154.                 }
  155.         }
  156.         ELSE CopyScreen(buffer,x+Form_SELF_FONTS.left+5,y+Form_SELF_FONTS.top+GetSkinHeight(),width_buffer,height);
  157.         //width_buffer = text_width(text1);
  158.         WHILE(DSBYTE[text1])
  159.         {
  160.                 symbol(len,DSBYTE[text1],c);
  161.                 len+=EAX;
  162.                 text1++;
  163.         }
  164.         _PutImage(x,y,width_buffer,height,buffer);
  165.         return len;
  166. }
  167. :dword FONT::textarea(word x,y;dword text1,c;byte size)
  168. {
  169.        
  170. }
  171.  
  172. :byte FONT::symbol(signed x;byte s;dword c)
  173. {
  174.         dword xi,yi;
  175.         dword tmp,_;
  176.         dword iii;
  177.                 dword ___x;
  178.         byte rw=0;
  179.                 x -= 2;
  180.         IF(s==32)return width/4;
  181.                 IF(s==9)return width;
  182.         yi = 0;
  183.         iii = 0;
  184.         tmp = 4*block*s;
  185.         tmp +=data;
  186.         while(yi<height)
  187.         {
  188.                 xi = 0;
  189.                 WHILE(xi<width)
  190.                 {
  191.                         IF(iii%32) _ >>= 1;
  192.                                                 ELSE
  193.                                                 {
  194.                                 tmp += 4;
  195.                                 _ = DSDWORD[tmp];
  196.                         }
  197.                         IF(_&1)
  198.                         {
  199.                                 IF(xi>rw)rw=xi;
  200.                                                                 ___x = x+xi;
  201.                                                                 IF(___x<Form_SELF_FONTS.cwidth)&&(tmp_y+yi<Form_SELF_FONTS.cheight)PixelRGB(___x,yi);
  202.                         }
  203.                         xi++;
  204.                         iii++;
  205.                 }
  206.                 yi++;
  207.         }
  208.         return rw;
  209. }
  210. :byte FONT::load(dword path)
  211. {
  212.         dword tmp;
  213.         buffer_size = 0;
  214.         IF(data)free(data);
  215.         if (io.read(path)!=0)
  216.         {
  217.                 debug("Error while loading font: ");
  218.                 debugln(path);
  219.                 return 0;
  220.         }
  221.         tmp = io.buffer_data;
  222.         data = tmp;
  223.         begin = data;
  224.         size_file = io.FILES_SIZE;
  225.         tmp +=size_file;
  226.         tmp--;
  227.         height = DSBYTE[tmp];
  228.         tmp--;
  229.         width = DSBYTE[tmp];
  230.         block = math.ceil(height*width/32);
  231. }
  232.  
  233. #endif