home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / flash078.zip / flashsource-r0_7_8.zip / FFont.cpp < prev    next >
C/C++ Source or Header  |  2001-07-24  |  11KB  |  519 lines
  1. #include "FFont.h"
  2. #include <strstream>
  3.  
  4.  
  5. std::ostream &operator << (std::ostream &out, FlashTagDefineFontInfo &data)
  6. {
  7.     out << FlashTagHeader(13, strlen(data.str)+2+2+data.codes.size()*((data.flags & 1) ? 2:1));
  8.     WRITE_UWORD(data.GetID());
  9.     out.put((char)strlen(data.str));
  10.     out << data.str;
  11.     out.put(data.flags);
  12.     if(data.flags & 1)
  13.     {
  14.         for(std::vector<UWORD>::iterator i = data.codes.begin(); i != data.codes.end(); i++)
  15.         {
  16.             WRITE_UWORD(*i);        
  17.         }
  18.     }
  19.     else
  20.     {
  21.         for(std::vector<UWORD>::iterator i = data.codes.begin(); i != data.codes.end(); i++)
  22.         {
  23.             out.put((char)*i);
  24.         }
  25.     }
  26.     return out;
  27. }
  28.  
  29. std::istream &operator >> (std::istream &in,  FlashTagDefineFontInfo &data)
  30. {
  31.     UWORD id;
  32.     READ_UWORD(id);
  33.     data.SetID(id);
  34.     int len = in.get();
  35.     //if(i == EOF) throw;
  36.     
  37.     data.str = (char *)malloc(len+1);
  38.     data.strings.push_back(data.str);
  39.     data.str[len] = 0;
  40.     
  41.     unsigned char * tmp = (unsigned char *)data.str;
  42.     
  43.     for(int i=0; (i < len); i++)
  44.     {
  45.         int c = in.get();
  46.         //if(c == EOF) throw;
  47.         tmp[i] = c;
  48.     }
  49.     int flags = in.get();
  50.     //if(flags == EOF) throw;
  51.     
  52.     data.flags = flags;
  53.     
  54.     UWORD size = data.importsize - (len+2+2);
  55.     
  56.     if(data.flags & 1)
  57.     {
  58.         for(UWORD i = 0; i < size; i+=2)
  59.         {
  60.             UWORD tmp;
  61.             READ_UWORD(tmp);
  62.             data.codes.push_back(tmp);        
  63.         }
  64.     }
  65.     else
  66.     {
  67.         for(UWORD i = 0; i < size; i++)
  68.         {
  69.             int c = in.get();
  70.             //if(c == EOF) throw;
  71.             data.codes.push_back(c);
  72.         }
  73.         
  74.     }
  75.     return in;
  76. }
  77.  
  78.  
  79. void FlashTagDefineFont::AddShape(FlashShape &shape)
  80. {
  81.     shapes.push_back(shape);
  82. }
  83.  
  84. std::ostream &operator << (std::ostream &out, FlashTagDefineFont &data)
  85. {
  86.     
  87.     std::ostrstream tmp;
  88.         
  89.     std::vector<UWORD> offsets;
  90.  
  91.     for(std::vector<FlashShape>::iterator i = data.shapes.begin(); i < data.shapes.end(); i++)
  92.     {
  93.         offsets.push_back(tmp.pcount());
  94.         tmp << *i;
  95.     }
  96.     
  97.     out << FlashTagHeader(10, 2+offsets.size()*2+tmp.pcount());
  98.     WRITE_UWORD(data.GetID());
  99.     
  100.     for(std::vector<UWORD>::iterator i2 = offsets.begin(); i2 < offsets.end(); i2++)
  101.     {
  102.         WRITE_UWORD(*i2+offsets.size()*2);
  103.     }
  104.     
  105.     out.write(tmp.rdbuf()->str(), tmp.pcount());
  106.  
  107.     return out;
  108. }
  109.  
  110. std::istream &operator >> (std::istream &in,  FlashTagDefineFont &data)
  111. {
  112.     return in;
  113. }
  114.  
  115. void FlashTextRecordStyle::Write(std::ostream &out, unsigned char bitsGlyph, unsigned char bitsAdvance)
  116. {
  117.     out.put((char)((char)(1 << 7)  | (char)(mhasFont << 3) | (char)(mhasFlashRGB << 2) | (char)(mhasOffsetx << 1) | (char)(mhasOffsety)));
  118.     if(mhasFont)
  119.     {
  120.         WRITE_UWORD(mFontID);
  121.     }
  122.     if(mhasFlashRGB)
  123.     {        
  124.         mcolor.SetAlphaWriteMode(GetTagVersion() > 1);
  125.         out << mcolor;
  126.     }
  127.     if(mhasOffsetx)
  128.     {
  129.         WRITE_SWORD(moffsetx);
  130.     }
  131.     if(mhasOffsety)
  132.     {
  133.         WRITE_SWORD(moffsety);
  134.     }
  135.     if(mhasFont)
  136.     {
  137.         WRITE_UWORD(mFontHeight);
  138.     }
  139. }
  140.  
  141. bool FlashTextRecordStyle::isGlyph(void)
  142. {
  143.     return false;
  144. }
  145.  
  146. void FlashTextRecordGlyph::Write(std::ostream &out, unsigned char bitsGlyph, unsigned char bitsAdvance)
  147. {
  148.     out.put((char)v.size());
  149.     BitStreamOut b(&out);
  150.     for(std::vector<FlashGlyphEntry>::iterator i=v.begin(); i != v.end(); i++)
  151.     {
  152.         b.Write((*i).first, bitsGlyph);
  153.         b.Write(PackBitsSigned((*i).second), bitsAdvance);
  154.     }
  155.     b.Align();
  156. }
  157.  
  158. int FlashTextRecordGlyph::returnGlyphBits(void)
  159. {
  160.     int ret=0;
  161.     for(std::vector<FlashGlyphEntry>::iterator i=v.begin(); i != v.end(); i++)
  162.     {
  163.         if(GetBitSize((*i).first) > ret) ret = GetBitSize((*i).first);
  164.     }
  165.     return ret;
  166. }
  167.  
  168. int FlashTextRecordGlyph::returnAdvBits(void)
  169. {
  170.         int ret=0;
  171.     for(std::vector<FlashGlyphEntry>::iterator i=v.begin(); i != v.end(); i++)
  172.     {
  173.         if(GetBitSizeSigned((*i).second) > ret) ret = GetBitSizeSigned((*i).second);
  174.     }
  175.     return ret;
  176. }
  177.  
  178.  
  179. void FlashTagDefineText::AddTextRecord(FlashTextRecord *r)
  180. {
  181.     records.push_back(r);
  182. }
  183.  
  184. std::ostream &operator << (std::ostream &out, FlashTagDefineText &data)
  185. {
  186.     std::ostrstream tmp;
  187.     int gbits=0;
  188.     int abits=0;
  189.     for(std::vector<FlashTextRecord *>::iterator i = data.records.begin(); i != data.records.end(); i++)
  190.     {
  191.         if((*i)->isGlyph())
  192.         {
  193.             if((*i)->returnGlyphBits() > gbits) { gbits=(*i)->returnGlyphBits(); }
  194.             if((*i)->returnAdvBits()   > abits) { abits=(*i)->returnAdvBits(); }
  195.         }
  196.     }
  197.     
  198.  
  199.     WRITE_UWORD2(data.GetID(), tmp);
  200.     tmp << data.rect;
  201.     tmp << data.matrix;
  202.     tmp << (char)gbits;
  203.     tmp << (char)abits;
  204.     
  205.     for(std::vector<FlashTextRecord *>::iterator i2 = data.records.begin(); i2 != data.records.end(); i2++)
  206.     {
  207.         (*i2)->SetTagVersion(1);
  208.         (*i2)->Write(tmp,gbits,abits);
  209.     }
  210.     
  211.     tmp << (char)0;
  212.  
  213.     out << FlashTagHeader(11, tmp.pcount());
  214.     out.write(tmp.rdbuf()->str(), tmp.pcount());
  215.  
  216.     return out;
  217. }
  218.  
  219. std::istream &operator >> (std::istream &in,  FlashTagDefineText &data)
  220. {
  221.     return in;
  222. }
  223.  
  224. void FlashTagDefineText2::AddTextRecord(FlashTextRecord *r)
  225. {
  226.     records.push_back(r);
  227. }
  228.  
  229. std::ostream &operator << (std::ostream &out, FlashTagDefineText2 &data)
  230. {
  231.     std::ostrstream tmp;
  232.     int gbits=0;
  233.     int abits=0;
  234.     for(std::vector<FlashTextRecord *>::iterator i = data.records.begin(); i != data.records.end(); i++)
  235.     {
  236.         if((*i)->isGlyph())
  237.         {
  238.             if((*i)->returnGlyphBits() > gbits) { gbits=(*i)->returnGlyphBits(); }
  239.             if((*i)->returnAdvBits()   > abits) { abits=(*i)->returnAdvBits(); }
  240.         }
  241.     }
  242.     
  243.  
  244.     WRITE_UWORD2(data.GetID(), tmp);
  245.     tmp << data.rect;
  246.     tmp << data.matrix;
  247.     tmp << (char)gbits;
  248.     tmp << (char)abits;
  249.     
  250.     for(std::vector<FlashTextRecord *>::iterator i2 = data.records.begin(); i2 != data.records.end(); i2++)
  251.     {
  252.         (*i2)->SetTagVersion(2);
  253.         (*i2)->Write(tmp,gbits,abits);
  254.     }
  255.     
  256.     tmp << (char)0;
  257.  
  258.     out << FlashTagHeader(33, tmp.pcount());
  259.     out.write(tmp.rdbuf()->str(), tmp.pcount());
  260.  
  261.     return out;
  262. }
  263.  
  264. std::istream &operator >> (std::istream &in,  FlashTagDefineText2 &data)
  265. {
  266.     return in;
  267. }
  268.  
  269. std::ostream &operator << (std::ostream &out, FlashKerningRecord &data)
  270. {
  271.     if(data.GetTagVersion() > 1)
  272.     {
  273.         WRITE_UWORD(data.code1);
  274.         WRITE_UWORD(data.code2);
  275.         WRITE_SWORD(data.adjustment);
  276.     }
  277.     else
  278.     {
  279.         out.put((char)data.code1);
  280.         out.put((char)data.code2);
  281.         WRITE_SWORD(data.adjustment);
  282.     }
  283.     return out;
  284. }
  285. std::istream &operator >> (std::istream &in,  FlashKerningRecord &data)
  286. {
  287.     return in;
  288. }
  289.  
  290.  
  291. // TODO: Error checking nGlyph?!
  292. void FlashTagDefineFont2::FlashFontLayout::Write(std::ostream &out)
  293. {
  294.     WRITE_SWORD(fontAscent);
  295.     WRITE_SWORD(fontDescent);
  296.     WRITE_SWORD(fontLeading);
  297.     for(std::vector<SWORD>::iterator i=fontAdvanceTable.begin(); i != fontAdvanceTable.end(); i++)
  298.     {
  299.         WRITE_SWORD(*i);
  300.     }
  301.     for(std::vector<FlashRect>::iterator i2=fontBoundsTable.begin(); i2 != fontBoundsTable.end(); i2++)
  302.     {
  303.         out << *i2;
  304.     }
  305.     WRITE_UWORD(fontKerningTable.size());
  306.     for(std::vector<FlashKerningRecord>::iterator i3=fontKerningTable.begin(); i3 != fontKerningTable.end(); i3++)
  307.     {
  308.         out << *i3;
  309.     }
  310. }
  311.  
  312. std::ostream &operator << (std::ostream &out, FlashTagDefineFont2 &data)
  313. {
  314.     
  315.     std::ostrstream tmp;
  316.     
  317.     tmp << (char)strlen(data.fontname);
  318.     tmp << data.fontname;
  319.     WRITE_UWORD2(data.shapes.size(),tmp);
  320.  
  321.     std::ostrstream tmp2;
  322.     
  323.     std::vector<UDWORD> offsets;
  324.  
  325.     for(std::vector<FlashShape>::iterator i = data.shapes.begin(); i < data.shapes.end(); i++)
  326.     {
  327.         offsets.push_back(tmp.pcount());
  328.         tmp << *i;
  329.     }    
  330.     bool longoffsets;
  331.     
  332.     if(offsets.size() > 0) longoffsets = offsets[offsets.size()-1] > (64*1024);
  333.     else longoffsets = false;
  334.  
  335.     for(std::vector<UDWORD>::iterator i2 = offsets.begin(); i2 < offsets.end(); i2++)
  336.     {
  337.         if(longoffsets)
  338.         {
  339.             WRITE_UDWORD2(*i2+offsets.size()*4,tmp);
  340.         }
  341.         else
  342.         {
  343.             WRITE_UWORD2(*i2+offsets.size()*2,tmp);
  344.         }        
  345.     }
  346.     
  347.     if(longoffsets)
  348.     {
  349.         WRITE_UDWORD2(tmp2.pcount(),tmp);
  350.     }
  351.     else
  352.     {
  353.         WRITE_UWORD2(tmp2.pcount(),tmp);    
  354.     }            
  355.     
  356.     tmp.write(tmp2.rdbuf()->str(), tmp2.pcount());
  357.     
  358.     bool longcodes = data.shapes.size() > (64*1024);
  359.     if(longcodes)
  360.     {
  361.         for(std::vector<UWORD>::iterator i = data.codes.begin(); i != data.codes.end(); i++)
  362.         {
  363.             WRITE_UWORD(*i);        
  364.         }
  365.     }
  366.     else
  367.     {
  368.         for(std::vector<UWORD>::iterator i = data.codes.begin(); i != data.codes.end(); i++)
  369.         {
  370.             out.put((char)*i);
  371.         }
  372.     }
  373.  
  374.     if(data.layout)
  375.     {
  376.         data.layout_data.Write(tmp);
  377.     }
  378.     
  379.     out << FlashTagHeader(48,tmp.pcount()+4);
  380.     
  381.     WRITE_UWORD(data.GetID());
  382.     
  383.     out.put((char)((data.layout << 7) | (longoffsets << 3) | (longcodes << 2) | (data.flags)));
  384.     out.put(0);
  385.     out.write(tmp.rdbuf()->str(), tmp.pcount());
  386.     
  387.     return out;
  388. }
  389.  
  390. std::istream &operator >> (std::istream &in,  FlashTagDefineFont2 &data)
  391. {
  392.     return in;
  393. }
  394.  
  395.  
  396. std::ostream &operator << (std::ostream &out, FlashTagDefineEditBox &data)
  397. {
  398.     std::ostrstream tmp;
  399.     WRITE_UWORD2(data.GetID(), tmp);
  400.     tmp << data.mr;
  401.     tmp.put((unsigned char)(data.mflags >> 8));
  402.     tmp.put((unsigned char)(data.mflags & 0xff));
  403.     if(data.mflags & FTDEB_HASFONT)
  404.     {
  405.         WRITE_UWORD2(data.mfontID,tmp); 
  406.         WRITE_UWORD2(data.mfontHeight,tmp);
  407.     }
  408.     if(data.mflags & FTDEB_HASTEXTCOLOR)
  409.     {
  410.         data.mcolor.SetAlphaWriteMode(true);
  411.         tmp << data.mcolor;
  412.     }
  413.     if(data.mflags & FTDEB_HASMAXLENGTH)
  414.     {
  415.         WRITE_UWORD2(data.mmaxLength, tmp); 
  416.     }
  417.     if(data.mflags & FTDEB_HASLAYOUT)
  418.     {
  419.         tmp.put(data.malign);
  420.         WRITE_UWORD2(data.mleftmargin, tmp); 
  421.         WRITE_UWORD2(data.mrightmargin, tmp); 
  422.         WRITE_UWORD2(data.mindent, tmp); 
  423.         WRITE_UWORD2(data.mleading, tmp);    
  424.     }
  425.     tmp << data.mvariable; 
  426.     tmp.put((char)0);
  427.     if(data.mflags & FTDEB_HASTEXT)
  428.     {
  429.         tmp << data.minitialtext;
  430.         tmp.put((char)0);
  431.     }
  432.     out << FlashTagHeader(37, tmp.pcount());
  433.     out.write(tmp.rdbuf()->str(),tmp.pcount());
  434.     return out;
  435. }
  436. std::istream &operator >> (std::istream &in,  FlashTagDefineEditBox &data)
  437. {
  438.     UWORD id;
  439.     READ_UWORD(id);
  440.     data.SetID(id);
  441.     
  442.     in >> data.mr;
  443.     
  444.     int c = in.get();
  445.     //if c == EOF throw
  446.     int c2 = in.get();
  447.     //if c2 == EOF throw
  448.  
  449.     data.mflags = ((unsigned char)c);
  450.     data.mflags = (data.mflags << 8) | (c2 & 0xff);
  451.  
  452.     
  453.     if(data.mflags & FTDEB_HASFONT)
  454.     {
  455.         READ_UWORD(data.mfontID); 
  456.         READ_UWORD(data.mfontHeight);
  457.     }
  458.     if(data.mflags & FTDEB_HASTEXTCOLOR)
  459.     {
  460.         data.mcolor.SetAlphaWriteMode(true);
  461.         in >> data.mcolor;
  462.     }
  463.     if(data.mflags & FTDEB_HASMAXLENGTH)
  464.     {
  465.         READ_UWORD(data.mmaxLength); 
  466.     }
  467.     if(data.mflags & FTDEB_HASLAYOUT)
  468.     {
  469.         data.malign = in.get();
  470.         // if(data.malign == EOF) throw
  471.         READ_UWORD(data.mleftmargin);
  472.         READ_UWORD(data.mrightmargin);
  473.         READ_UWORD(data.mindent);
  474.         READ_UWORD(data.mleading);
  475.     }
  476.     {
  477.         std::vector<int> text;
  478.         for(;;)
  479.         {
  480.             int i = in.get();
  481.             //if(i == EOF) throw;
  482.             text.push_back(i);
  483.             if(i==0) break;
  484.         }
  485.         data.mvariable = (char *)malloc(text.size());
  486.         data.gc.push_back(data.mvariable);
  487.         {
  488.             for(unsigned int i = 0; i < text.size(); i++)
  489.             {
  490.                 unsigned char *c = (unsigned char *)data.mvariable;
  491.                 c[i] = text[i];
  492.             }        
  493.         }
  494.     }
  495.  
  496.     if(data.mflags & FTDEB_HASTEXT)
  497.     {
  498.         std::vector<int> text;
  499.         for(;;)
  500.         {
  501.             int i = in.get();
  502.             //if(i == EOF) throw;
  503.             text.push_back(i);
  504.             if(i==0) break;
  505.         }
  506.         data.minitialtext = (char *)malloc(text.size());
  507.         data.gc.push_back(data.minitialtext);
  508.         {
  509.             for(unsigned int i = 0; i < text.size(); i++)
  510.             {
  511.                 unsigned char *c = (unsigned char *)data.minitialtext;
  512.                 c[i] = text[i];
  513.             }        
  514.         }    
  515.     }
  516.     return in;
  517. }
  518.  
  519.