Subversion Repositories Kolibri OS

Rev

Rev 5753 | 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 __SIZE
  13. {
  14.         word width,height;
  15.         signed offset_x,offset_y;
  16.         byte text;
  17.         byte TMP_WEIGHT;
  18. };
  19. :struct FONT
  20. {
  21.         __SIZE size;
  22.         byte width,height,offsetLine,r,g,b,weight;
  23.         dword color;
  24.         dword file_size;
  25.         dword buffer;
  26.         dword buffer_size;
  27.         word block;
  28.         dword data;
  29.         dword begin;
  30.         dword size_file;
  31.         byte load(...);
  32.         byte symbol(word x;byte s;dword c);
  33.         byte symbol_size(byte s);
  34.         dword text(word x,y;dword text1);
  35.         dword getsize(dword text1);
  36.         dword textarea(word x,y;dword text,c);
  37.         byte changeSIZE();
  38.         void PixelRGB(word x,y);
  39.         dword tmp_y,tmp_height,tmp_x;
  40.         byte no_bg_copy;
  41.         dword bg_color;
  42. };
  43. FONT font = 0;
  44.  
  45. :void FONT::PixelRGB(dword x,y)
  46. {
  47.         dword tmp;
  48.         tmp = y*size.width*3;
  49.         tmp += x*3;
  50.         tmp += buffer;
  51.  
  52.         DSBYTE[tmp] = r;
  53.         tmp++;
  54.         DSBYTE[tmp] = g;
  55.         tmp++;
  56.         DSBYTE[tmp] = b;
  57. }
  58. :byte FONT::changeSIZE()
  59. {
  60.         dword TMP_DATA;
  61.         dword ofs;
  62.         byte s;
  63.         IF(size.text<9) size.text = 8;
  64.         s = size.text-8;
  65.         data = begin;
  66.         TMP_DATA = data;
  67.         TMP_DATA +=s*4;
  68.         ofs = DSDWORD[TMP_DATA];
  69.         IF(ofs==-1)return false;
  70.         data += ofs;
  71.         data += 156;
  72.         TMP_DATA = data;
  73.         file_size = DSDWORD[TMP_DATA];
  74.         TMP_DATA += file_size;
  75.         TMP_DATA--;
  76.         height = DSBYTE[TMP_DATA];
  77.         TMP_DATA--;
  78.         width =  DSBYTE[TMP_DATA];
  79.         block = math.ceil(height*width/32);
  80.         return true;
  81. }
  82. :proc_info Form_SELF_FONTS;
  83.  
  84. :dword FONT::getsize(dword text1)
  85. {
  86.         size.height = size.width = 0;
  87.         size.offset_x = size.offset_y = -1;
  88.         IF(size.text)IF(!changeSIZE())return 0;
  89.         WHILE(DSBYTE[text1])
  90.         {
  91.                 symbol_size(DSBYTE[text1]);
  92.                 text1++;
  93.         }
  94.         $neg size.offset_y
  95.         $neg size.offset_x
  96.         size.height++;
  97.         size.height += size.offset_y;
  98.         size.width += size.offset_x;
  99.         size.width++;
  100.         return size.width;
  101. }
  102. :byte FONT::symbol_size(byte s)
  103. {
  104.         dword xi,yi;
  105.         dword tmp,_;
  106.         dword iii;
  107.         byte rw=0;
  108.                 byte X;
  109.                 size.TMP_WEIGHT = math.ceil(size.text/17);
  110.         IF(s==32)
  111.                 {
  112.                         size.width += width/4;
  113.                         IF(weight) size.width+=size.TMP_WEIGHT;
  114.                         return;
  115.                 }
  116.                 IF(s==9)
  117.                 {
  118.                         size.width += width;
  119.                         IF(weight) size.width+=size.TMP_WEIGHT;
  120.                         return;
  121.                 }
  122.         yi = 0;
  123.         iii = 0;
  124.         tmp = 4*block*s;
  125.         tmp +=data;
  126.         while(yi<height)
  127.         {
  128.                 xi = 0;
  129.                 WHILE(xi<width)
  130.                 {
  131.                         IF(iii%32) _ >>= 1;
  132.                                                 ELSE
  133.                                                 {
  134.                                 tmp += 4;
  135.                                 _ = DSDWORD[tmp];
  136.                         }
  137.                         IF(_&1)
  138.                                                 {
  139.                                                         IF(xi>rw)rw=xi;
  140.                                                         IF(size.height<yi)size.height = yi;
  141.                                                         IF(size.offset_y<0)size.offset_y = yi;
  142.                                                         ELSE IF(yi<size.offset_y)size.offset_y = yi;
  143.                                                         IF(!X) X = xi;
  144.                                                         ELSE IF(X>xi)X = xi;
  145.                                                 }
  146.                         xi++;
  147.                         iii++;
  148.                 }
  149.                 yi++;
  150.         }
  151.                 size.width += rw;
  152.                 IF(weight) size.width+=size.TMP_WEIGHT;
  153.                 IF(s=='_') size.width--;
  154.                 IF(size.offset_x<0)size.offset_x = X;
  155. }
  156. :dword FONT::text(word x,y;dword text1)
  157. {
  158.         signed len=0;
  159.         dword c;
  160.         word _tmp_h;
  161.         c = color;
  162.         IF(!text1)return false;
  163.         IF(size.text)IF(!changeSIZE())return false;
  164.         GetProcessInfo(#Form_SELF_FONTS, SelfInfo);
  165.         IF(y>Form_SELF_FONTS.cheight) return false;
  166.         IF(x>Form_SELF_FONTS.cwidth) return false;
  167.         AX = c;
  168.         r = AL;
  169.         g = AH;
  170.         c>>=16;
  171.         AX = c;
  172.         b = AL;
  173.         getsize(text1);
  174.         y -= size.offset_y;
  175.         tmp_y = y;
  176.        
  177.         EDX = size.width*size.height*3;
  178.         IF(!buffer_size)
  179.         {
  180.                 buffer_size = EDX;
  181.                 buffer = malloc(buffer_size);
  182.         }
  183.         ELSE IF(buffer_size<EDX)
  184.         {
  185.                 buffer_size = EDX;
  186.                 buffer = realloc(buffer,buffer_size);
  187.         }
  188.         IF (no_bg_copy)
  189.         {
  190.                 EBX = bg_color;
  191.                 EDI = buffer;
  192.                 EAX = buffer_size+EDI;
  193.                 WHILE (EDI<EAX)
  194.                 {
  195.                         ESDWORD[EDI] = EBX;
  196.                         $add edi,3
  197.                 }
  198.         }
  199.         ELSE CopyScreen(buffer,x+Form_SELF_FONTS.left+5,y+Form_SELF_FONTS.top+GetSkinHeight(),size.width,size.height);
  200.  
  201.         WHILE(DSBYTE[text1])
  202.         {
  203.                 IF(DSBYTE[text1]=='_') len--;
  204.                 len+=symbol(len,DSBYTE[text1]);
  205.                 IF(weight)len+=math.ceil(size.text/17);
  206.                 text1++;
  207.         }
  208.         _PutImage(x,y,size.width,size.height,buffer);
  209.         return len;
  210. }
  211. :dword FONT::textarea(word x,y;dword text1,c;byte size)
  212. {
  213.        
  214. }
  215.  
  216. :byte FONT::symbol(signed x;byte s)
  217. {
  218.         dword xi,yi;
  219.         dword tmp,_;
  220.         dword iii;
  221.                 dword ___x;
  222.                 word TMP;
  223.                 byte _TMP_WEIGHT;
  224.         byte rw=0;
  225.                 x += size.offset_x;
  226.         IF(s==32)return width/4;
  227.                 IF(s==9)return width;
  228.         yi = 0;
  229.         iii = 0;
  230.         tmp = 4*block*s;
  231.         tmp +=data;
  232.         while(yi<height)
  233.         {
  234.                 xi = 0;
  235.                                 TMP = size.offset_y+yi;
  236.                 while(xi<width)
  237.                 {
  238.                         IF(iii%32) _ >>= 1;
  239.                                                 ELSE
  240.                                                 {
  241.                                 tmp += 4;
  242.                                 _ = DSDWORD[tmp];
  243.                         }
  244.                         if(_&1)
  245.                         {
  246.                                 IF(xi>rw)rw=xi;
  247.                                                                 ___x = x+xi;
  248.                                                                 IF(___x<Form_SELF_FONTS.cwidth)&&(tmp_y+yi<Form_SELF_FONTS.cheight)
  249.                                                                 {
  250.                                                                         PixelRGB(___x,TMP);
  251.                                                                         _TMP_WEIGHT = size.TMP_WEIGHT;
  252.                                                                         WHILE(_TMP_WEIGHT)
  253.                                                                         {
  254.                                                                                 IF(weight) PixelRGB(___x+_TMP_WEIGHT,TMP);
  255.                                                                                 _TMP_WEIGHT--;
  256.                                                                         }
  257.                                                                 }
  258.                         }
  259.                         xi++;
  260.                         iii++;
  261.                 }
  262.                 yi++;
  263.         }
  264.         return rw;
  265. }
  266. :byte FONT::load(dword path)
  267. {
  268.         dword tmp;
  269.         buffer_size = 0;
  270.         IF(data)free(data);
  271.         if (!io.readKPACK(path))
  272.         {
  273.                 debug("Error while loading font: ");
  274.                 debugln(path);
  275.                 return false;
  276.         }
  277.         data = io.buffer_data;
  278.         tmp = data;
  279.         begin = data;
  280.         size_file = io.FILES_SIZE;
  281.         tmp +=size_file;
  282.         tmp--;
  283.         height = DSBYTE[tmp];
  284.         tmp--;
  285.         width = DSBYTE[tmp];
  286.         block = math.ceil(height*width/32);
  287.         return true;
  288. }
  289.  
  290. #endif