Subversion Repositories Kolibri OS

Rev

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