API tools faq
paste
Advertisement
KIKIJIKI

Untitled

KIKIJIKI
Oct 6th, 2014
91
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 17.67 KB | None | 0 0
raw download clone embed print report
  1. import java.lang.ref.WeakReference;
  2. import java.util.Random;
  3. import java.util.Stack;
  4. import org.xml.sax.Attributes;
  5. import org.xml.sax.SAXException;
  6. import org.xml.sax.helpers.DefaultHandler;
  7.  
  8. import com.kikijiki.ryukisenga.Uti;
  9. import com.kikijiki.ryukisenga.content.SVGUti.SvgTag;
  10. import com.kikijiki.ryukisenga.drawing.Sen;
  11. import com.kikijiki.ryukisenga.drawing.Sequence.Settings;
  12. import com.kikijiki.ryukisenga.drawing.vec;
  13.  
  14. import android.annotation.SuppressLint;
  15. import android.graphics.Matrix;
  16.  
  17. public class SvgContentHandler extends DefaultHandler
  18. {
  19.     private final int CIRCLE_ELLIPSE_SEGMENTS_MIN = 4;
  20.     private final static float PI2 = (float) (Math.PI * 2);
  21.    
  22.     private WeakReference<ParserInterface> _thread;
  23.  
  24.     private Stack<Matrix> _transform = new Stack<Matrix>();
  25.     private boolean _abort = false;
  26.     private Random _rnd = new Random();
  27.     private Settings _settings;
  28.    
  29.     private CubicBezierFlattener _flattener;
  30.     private ParserData _data = new ParserData();
  31.    
  32.     private class ParserData
  33.     {
  34.         String s;
  35.         int cur = 0;
  36.         int len = 0;
  37.        
  38.         float prev_x = .0f;
  39.         float prev_y = .0f;
  40.        
  41.         float prev_cx = .0f;
  42.         float prev_cy = .0f;
  43.        
  44.         float start_x = .0f;
  45.         float start_y = .0f;
  46.        
  47.         char prev_curve;
  48.         char next_curve = 0;
  49.        
  50.         public void setData(String data)
  51.         {
  52.             s = data;
  53.             len = s.length();
  54.            
  55.             cur = 0;
  56.             prev_x = 0;
  57.             prev_y = 0;
  58.            
  59.             prev_cx = .0f;
  60.             prev_cy = .0f;
  61.            
  62.             start_x = .0f;
  63.             start_y = .0f;
  64.            
  65.             prev_curve = 0;
  66.             next_curve = 0;        
  67.         }
  68.        
  69.         public boolean hasNext()
  70.         {
  71.             return cur < len;
  72.         }
  73.        
  74.         public char getNext()
  75.         {
  76.             return s.charAt(cur++);
  77.         }
  78.        
  79.         public char peekNext()
  80.         {
  81.             return s.charAt(cur);
  82.         }
  83.        
  84.         public void skipSpaces()
  85.         {
  86.             while(hasNext())
  87.             {
  88.                 char c = s.charAt(cur);
  89.                
  90.                 switch(c)
  91.                 {
  92.                 case ' ':
  93.                 case ',':
  94.                 case '\n':
  95.                 case '\t':
  96.                 case '\r':
  97.                     break;
  98.                    
  99.                 default:
  100.                     return;
  101.                 }
  102.                
  103.                 cur++;
  104.             }
  105.         }
  106.  
  107.         private float parseFloat()
  108.         {
  109.             boolean exp = false;
  110.  
  111.             skipSpaces();
  112.  
  113.             int j = cur;
  114.  
  115.             if(s.charAt(j) == '-')
  116.             {
  117.                 getNext();
  118.             }
  119.  
  120.             while(hasNext())
  121.             {
  122.                 char c = getNext();
  123.  
  124.                 switch(c)
  125.                 {
  126.                     case '0':
  127.                     case '1':
  128.                     case '2':
  129.                     case '3':
  130.                     case '4':
  131.                     case '5':
  132.                     case '6':
  133.                     case '7':
  134.                     case '8':
  135.                     case '9':
  136.                     case '+':
  137.                     case '.':
  138.                         exp = false;
  139.                         break;
  140.  
  141.                     case '-':
  142.                         if(exp)
  143.                         {
  144.                             exp = false;
  145.                         }
  146.                         else
  147.                         {
  148.                             cur--;
  149.                             return Uti.safeParseFloat(s.substring(j, cur));
  150.                         }
  151.                         break;
  152.  
  153.                     case 'e':
  154.                     case 'E':
  155.                         exp = true;
  156.                         break;
  157.  
  158.                     default:
  159.                         cur--;
  160.                         return Uti.safeParseFloat(s.substring(j, cur));
  161.                 }
  162.             }
  163.  
  164.             return Uti.safeParseFloat(s.substring(j, cur));
  165.         }
  166.     }
  167.    
  168.     public SvgContentHandler(ParserInterface thread, Settings settings)
  169.     {
  170.         _thread = new WeakReference<ParserInterface>(thread);
  171.        
  172.         Matrix root = new Matrix();
  173.         if(!(settings.viewbox.x < 0 || settings.viewbox.y < 0))
  174.         {
  175.             root.setTranslate(-settings.viewbox.x, -settings.viewbox.y);
  176.         }
  177.        
  178.         _transform.push(root);
  179.         _settings = settings;
  180.         _flattener = new CubicBezierConverterFloat(_settings.invScale);
  181.     }
  182.    
  183.     private Matrix getCurrentTransform(Attributes attributes, boolean push)
  184.     {
  185.         String mat = SVGUti.getTransform(attributes);
  186.        
  187.         if(mat == null)
  188.         {
  189.             if(push)
  190.             {
  191.                 _transform.push(_transform.peek());
  192.             }
  193.            
  194.             return _transform.peek();
  195.         }
  196.         else
  197.         {
  198.             Matrix cur = parseTransform(mat);
  199.             cur.preConcat(_transform.peek());
  200.            
  201.             if(push)
  202.             {
  203.                 _transform.push(cur);
  204.             }
  205.            
  206.             return cur;
  207.         }
  208.     }
  209.  
  210.     @SuppressLint("DefaultLocale")
  211.     @Override
  212.     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException
  213.     {
  214.         checkAbort();
  215.        
  216.         SvgTag tag = SvgTag.ignore;
  217.  
  218.         try
  219.         {
  220.             tag = SvgTag.valueOf(qName.toLowerCase());
  221.         }
  222.         catch(Exception e)
  223.         {
  224.             //e.printStackTrace();
  225.         }
  226.  
  227.         switch(tag)
  228.         {
  229.         case svg:
  230.         break;
  231.        
  232.         case g:
  233.             getCurrentTransform(attributes, true);
  234.         break;
  235.            
  236.         case path:
  237.         {
  238.             _data.setData(SVGUti.getPathData(attributes));
  239.            
  240.             PointData ptbuf = new PointData();
  241.            
  242.             Matrix m = getCurrentTransform(attributes, false);
  243.            
  244.             while(true)
  245.             {
  246.                 _data.skipSpaces();
  247.                
  248.                 if(_data.hasNext())
  249.                 {
  250.                     char c = _data.peekNext();
  251.  
  252.                     if(c >= 'A' && c <= 'z')
  253.                     {
  254.                         _data.next_curve = _data.getNext();
  255.                     }
  256.  
  257.                     ptbuf = parseCurve(_data, ptbuf, m);
  258.                 }
  259.                 else
  260.                 {
  261.                     break;
  262.                 }
  263.             }
  264.            
  265.             if(!ptbuf.isEmpty())
  266.                 appendElement(ptbuf);
  267.         }
  268.             break;
  269.            
  270.         case rect:
  271.         {
  272.             float x = SVGUti.getRectX(attributes);
  273.             float y = SVGUti.getRectY(attributes);
  274.             float w = SVGUti.getRectWidth(attributes);
  275.             float h = SVGUti.getRectHeight(attributes);
  276.  
  277.             float xx = x + w;
  278.             float yy = y + h;
  279.            
  280.             Matrix m = getCurrentTransform(attributes, false);
  281.            
  282.             float[] pt = {
  283.                     x, y,
  284.                     xx, y,
  285.                     xx, yy,
  286.                     x, yy,
  287.                     x, y};
  288.            
  289.             m.mapPoints(pt);
  290.            
  291.             PointData buf = new PointData();
  292.             buf.append(pt[0], pt[1]);
  293.             buf.append(pt[2], pt[3]);
  294.             buf.append(pt[4], pt[5]);
  295.             buf.append(pt[6], pt[7]);
  296.  
  297.             appendElement(buf);
  298.         }
  299.             break;
  300.         case line:
  301.         {
  302.             float x1 = SVGUti.getLineX1(attributes);
  303.             float y1 = SVGUti.getLineY1(attributes);
  304.             float x2 = SVGUti.getLineX2(attributes);
  305.             float y2 = SVGUti.getLineY2(attributes);
  306.            
  307.             Matrix m = getCurrentTransform(attributes, false);
  308.            
  309.             float[] pt = {x1, y1, x2, y2};
  310.             m.mapPoints(pt);
  311.            
  312.             PointData buf = new PointData();
  313.             buf.append(pt[0], pt[1]);
  314.             buf.append(pt[2], pt[3]);
  315.  
  316.             appendElement(buf);
  317.         }
  318.             break;
  319.            
  320.         case polyline:
  321.         {
  322.             appendElement(computePolyline(SVGUti.getPolylinePoints(attributes), false, getCurrentTransform(attributes, false)));
  323.         }
  324.             break;
  325.         case polygon:
  326.         {
  327.             appendElement(computePolyline(SVGUti.getPolygonPoints(attributes), true, getCurrentTransform(attributes, false)));
  328.         }
  329.             break;
  330.            
  331.         case circle:
  332.         {
  333.             vec cnt = SVGUti.getCircleCnt(attributes);
  334.             float r = SVGUti.getCircleRadius(attributes);
  335.  
  336.             appendElement(computeEllipse(r, r, cnt.x, cnt.y, getCurrentTransform(attributes, false)));
  337.         }
  338.             break;
  339.            
  340.         case ellipse:
  341.         {
  342.             vec cnt = SVGUti.getEllipseCnt(attributes);
  343.             vec r = SVGUti.getEllipseRadius(attributes);
  344.            
  345.             appendElement(computeEllipse(r.x, r.y, cnt.x, cnt.y, getCurrentTransform(attributes, false)));
  346.         }
  347.             break;
  348.            
  349.         case ignore:
  350.             break;
  351.         }
  352.     }
  353.    
  354.     @SuppressWarnings("unused")
  355.     private PointData parseCurve(ParserData data, PointData ptbuf, Matrix m) throws SAXException
  356.     {
  357.         data.prev_curve = data.next_curve;
  358.  
  359.         switch(data.next_curve)
  360.         {
  361.         case 'm':
  362.         {
  363.             if(!ptbuf.isEmpty())
  364.                 appendElement(ptbuf);
  365.            
  366.             ptbuf = new PointData();
  367.            
  368.             data.start_x = data.prev_x + data.parseFloat();
  369.             data.start_y = data.prev_y + data.parseFloat();
  370.            
  371.             data.prev_x = data.start_x;
  372.             data.prev_y = data.start_y;
  373.            
  374.             ptbuf.append(data.start_x, data.start_y, m);
  375.            
  376.             data.next_curve = 'l';
  377.         }
  378.             break;
  379.            
  380.         case 'M':
  381.         {
  382.             if(!ptbuf.isEmpty())
  383.                 appendElement(ptbuf);
  384.            
  385.             ptbuf = new PointData();
  386.            
  387.             data.start_x = data.parseFloat();
  388.             data.start_y = data.parseFloat();
  389.            
  390.             data.prev_x = data.start_x;
  391.             data.prev_y = data.start_y;
  392.            
  393.             ptbuf.append(data.start_x, data.start_y, m);
  394.            
  395.             data.next_curve = 'L';
  396.         }
  397.             break;
  398.  
  399.         case 'z':
  400.         case 'Z':
  401.         {
  402.             data.prev_x = data.start_x;
  403.             data.prev_y = data.start_y;
  404.            
  405.             ptbuf.append(data.start_x, data.start_y, m);
  406.         }
  407.             break;
  408.            
  409.         case 'h':
  410.         {
  411.             float x = data.prev_x + data.parseFloat();
  412.            
  413.             data.prev_x = x;
  414.            
  415.             ptbuf.append(x, data.prev_y, m);
  416.         }
  417.             break;
  418.            
  419.         case 'H':
  420.         {
  421.             float x = data.parseFloat();
  422.            
  423.             data.prev_x = x;
  424.            
  425.             ptbuf.append(x, data.prev_y, m);
  426.         }
  427.             break;
  428.            
  429.         case 'v':
  430.         {
  431.             float y = data.prev_y + data.parseFloat();
  432.  
  433.             data.prev_y = y;
  434.            
  435.             ptbuf.append(data.prev_x, y, m);
  436.         }
  437.             break;
  438.            
  439.         case 'V':
  440.         {
  441.             float y = data.parseFloat();
  442.            
  443.             data.prev_y = y;
  444.            
  445.             ptbuf.append(data.prev_x, y, m);
  446.         }
  447.             break;
  448.            
  449.         case 'l':
  450.         {
  451.             float x = data.prev_x + data.parseFloat();
  452.             float y = data.prev_y + data.parseFloat();
  453.            
  454.             data.prev_x = x;
  455.             data.prev_y = y;
  456.            
  457.             ptbuf.append(x, y, m);
  458.         }
  459.             break;
  460.            
  461.         case 'L':
  462.         {
  463.             float x = data.parseFloat();
  464.             float y = data.parseFloat();
  465.            
  466.             data.prev_x = x;
  467.             data.prev_y = y;
  468.            
  469.             ptbuf.append(x, y, m);
  470.         }          
  471.             break;
  472.            
  473.         case 'q':
  474.         {
  475.             float[] ctp = {.0f, .0f, .0f, .0f, .0f, .0f, .0f, .0f};
  476.            
  477.             ctp[0] = data.prev_x;
  478.             ctp[1] = data.prev_y;
  479.             ctp[2] = ctp[0] + data.parseFloat();
  480.             ctp[3] = ctp[1] + data.parseFloat();
  481.             ctp[4] = ctp[0] + data.parseFloat();
  482.             ctp[5] = ctp[1] + data.parseFloat();
  483.            
  484.             data.prev_x = ctp[4];
  485.             data.prev_y = ctp[5];
  486.            
  487.             computeQuadratic(ctp, ptbuf);
  488.         }
  489.             break;
  490.         case 'Q':
  491.         {
  492.             float[] ctp = {.0f, .0f, .0f, .0f, .0f, .0f, .0f, .0f};
  493.            
  494.             ctp[0] = data.prev_x;
  495.             ctp[1] = data.prev_y;
  496.             ctp[2] = data.parseFloat();
  497.             ctp[3] = data.parseFloat();
  498.             ctp[4] = data.parseFloat();
  499.             ctp[5] = data.parseFloat();
  500.            
  501.             data.prev_x = ctp[4];
  502.             data.prev_y = ctp[5];
  503.            
  504.             computeQuadratic(ctp, ptbuf);
  505.         }
  506.             break;
  507.            
  508.         case 't':
  509.             break;
  510.         case 'T':
  511.             break;
  512.            
  513.         case 'c':
  514.         {
  515.             float[] ctp = {.0f, .0f, .0f, .0f, .0f, .0f, .0f, .0f};
  516.            
  517.             ctp[0] = data.prev_x;
  518.             ctp[1] = data.prev_y;
  519.             ctp[2] = ctp[0] + data.parseFloat();
  520.             ctp[3] = ctp[1] + data.parseFloat();
  521.             ctp[4] = ctp[0] + data.parseFloat();
  522.             ctp[5] = ctp[1] + data.parseFloat();
  523.             ctp[6] = ctp[0] + data.parseFloat();
  524.             ctp[7] = ctp[1] + data.parseFloat();       
  525.            
  526.             data.prev_x = ctp[6];
  527.             data.prev_y = ctp[7];
  528.             data.prev_cx = ctp[4];
  529.             data.prev_cy = ctp[5];
  530.            
  531.             computeCubic(ctp, ptbuf);
  532.         }
  533.             break;
  534.         case 'C':
  535.         {
  536.             float[] ctp = {.0f, .0f, .0f, .0f, .0f, .0f, .0f, .0f};
  537.            
  538.             ctp[0] = data.prev_x;
  539.             ctp[1] = data.prev_y;
  540.             ctp[2] = data.parseFloat();
  541.             ctp[3] = data.parseFloat();
  542.             ctp[4] = data.parseFloat();
  543.             ctp[5] = data.parseFloat();
  544.             ctp[6] = data.parseFloat();
  545.             ctp[7] = data.parseFloat();        
  546.            
  547.             data.prev_x = ctp[6];
  548.             data.prev_y = ctp[7];
  549.             data.prev_cx = ctp[4];
  550.             data.prev_cy = ctp[5];
  551.            
  552.             computeCubic(ctp, ptbuf);
  553.         }
  554.         break;
  555.            
  556.         case 's':
  557.         {
  558.             float[] ctp = {.0f, .0f, .0f, .0f, .0f, .0f, .0f, .0f};
  559.            
  560.             ctp[0] = data.prev_x;
  561.             ctp[1] = data.prev_y;
  562.            
  563.             if( data.prev_curve == 's' || data.prev_curve == 'S' || data.prev_curve == 'c' || data.prev_curve == 'C')
  564.             {
  565.                 ctp[2] = data.prev_cx;
  566.                 ctp[3] = data.prev_cy;
  567.             }
  568.             else
  569.             {
  570.                 ctp[2] = ctp[0];
  571.                 ctp[3] = ctp[1];
  572.             }
  573.            
  574.             ctp[4] = ctp[0] + data.parseFloat();
  575.             ctp[5] = ctp[1] + data.parseFloat();
  576.             ctp[6] = ctp[0] + data.parseFloat();
  577.             ctp[7] = ctp[1] + data.parseFloat();
  578.            
  579.             data.prev_x = ctp[6];
  580.             data.prev_y = ctp[7];
  581.             data.prev_cx = ctp[4];
  582.             data.prev_cy = ctp[5];
  583.            
  584.             computeCubic(ctp, ptbuf);
  585.         }
  586.             break;
  587.            
  588.         case 'S':
  589.         {
  590.             float[] ctp = {.0f, .0f, .0f, .0f, .0f, .0f, .0f, .0f};
  591.            
  592.             ctp[0] = data.prev_x;
  593.             ctp[1] = data.prev_y;
  594.            
  595.             if( data.prev_curve == 's' || data.prev_curve == 'S' || data.prev_curve == 'c' || data.prev_curve == 'C')
  596.             {
  597.                 ctp[2] = data.prev_cx;
  598.                 ctp[3] = data.prev_cy;
  599.             }
  600.             else
  601.             {
  602.                 ctp[2] = ctp[0];
  603.                 ctp[3] = ctp[1];
  604.             }
  605.            
  606.             ctp[4] = data.parseFloat();
  607.             ctp[5] = data.parseFloat();
  608.             ctp[6] = data.parseFloat();
  609.             ctp[7] = data.parseFloat();
  610.            
  611.             data.prev_x = ctp[6];
  612.             data.prev_y = ctp[7];
  613.             data.prev_cx = ctp[4];
  614.             data.prev_cy = ctp[5];
  615.            
  616.             computeCubic(ctp, ptbuf);
  617.         }
  618.             break;
  619.            
  620.         case 'a':
  621.         {
  622.             float x0 = data.prev_x;
  623.             float y0 = data.prev_y;
  624.            
  625.             float rx = data.parseFloat();
  626.             float ry = data.parseFloat();
  627.             float angle = data.parseFloat();
  628.             boolean largeArcFlag = (int)data.parseFloat() == 1;
  629.             boolean sweepFlag = (int)data.parseFloat() == 1;
  630.             float x = x0 + data.parseFloat();
  631.             float y = y0 + data.parseFloat();
  632.            
  633.             data.prev_x = x;
  634.             data.prev_y = y;
  635.            
  636.             ptbuf.append(x, y); //Arcs not implemented
  637.         }
  638.             break;
  639.            
  640.         case 'A':
  641.         {
  642.             float x0 = data.prev_x;
  643.             float y0 = data.prev_y;
  644.            
  645.             float rx = data.parseFloat();
  646.             float ry = data.parseFloat();
  647.             float angle = data.parseFloat();
  648.             boolean largeArcFlag = (int)data.parseFloat() == 1;
  649.             boolean sweepFlag = (int)data.parseFloat() == 1;
  650.             float x = data.parseFloat();
  651.             float y = data.parseFloat();
  652.            
  653.             data.prev_x = x;
  654.             data.prev_y = y;
  655.            
  656.             ptbuf.append(x, y); //Arcs not implemented
  657.         }
  658.             break;
  659.            
  660.         default:
  661.             data.getNext();
  662.             break;
  663.         }
  664.        
  665.         return ptbuf;
  666.     }
  667.  
  668.     private void computeQuadratic(float[] ctp, PointData ptbuf)
  669.     {
  670.         final float c = 2.0f / 3.0f;
  671.        
  672.         ctp[6] = ctp[4];
  673.         ctp[7] = ctp[5];
  674.         ctp[4] = ctp[4] + c * (ctp[2] - ctp[4]);
  675.         ctp[5] = ctp[5] + c * (ctp[3] - ctp[5]);
  676.         ctp[2] = ctp[0] + c * (ctp[2] - ctp[0]);
  677.         ctp[3] = ctp[1] + c * (ctp[3] - ctp[1]);
  678.  
  679.         computeCubic(ctp, ptbuf);
  680.     }
  681.  
  682.     private void computeCubic(float[] ctp, PointData ptbuf)
  683.     {
  684.         _transform.peek().mapPoints(ctp);
  685.         _flattener.convert(false, ctp, ptbuf);
  686.     }
  687.  
  688.     PointData computePolyline(String points, boolean close, Matrix m)
  689.     {
  690.         PointData buf = new PointData();
  691.  
  692.         _data.setData(points);
  693.        
  694.         while(_data.hasNext())
  695.         {
  696.             char c = _data.peekNext();
  697.            
  698.             switch(c)
  699.             {
  700.             case ' ':
  701.             case ',':
  702.                 _data.cur++;
  703.                 break;
  704.                
  705.             default:
  706.                 buf.append(_data.parseFloat(), _data.parseFloat(), m);
  707.                 break;                 
  708.             }
  709.         }
  710.        
  711.         if(close)
  712.         {
  713.             buf.close();
  714.         }
  715.        
  716.         return buf;
  717.     }
  718.  
  719.     private PointData computeEllipse(float rx, float ry, float cntx, float cnty, Matrix m)
  720.     {
  721.         PointData buf = new PointData();
  722.  
  723.         int div = (int) Math.max(CIRCLE_ELLIPSE_SEGMENTS_MIN, (rx + rx + ry + ry) * _settings.scale * .25f);
  724.        
  725.         float da = PI2 / (float)div;
  726.         float a = da * _rnd.nextInt(div);
  727.        
  728.         for(int i = 0; i < div; i++)
  729.         {
  730.             float x = (float) (cntx + rx * Math.cos(a));
  731.             float y = (float) (cnty + ry * Math.sin(a));
  732.            
  733.             buf.append(x, y, m);
  734.            
  735.             a += da;
  736.         }
  737.        
  738.         buf.close();
  739.  
  740.         return buf;
  741.     }
  742.  
  743.     private void appendElement(PointData data) throws SAXException
  744.     {
  745.         checkAbort();
  746.        
  747.         if(data == null || data.pt.size() == 0 || data.len <= Float.MIN_VALUE)
  748.             return;
  749.  
  750.         ParserInterface p = _thread.get();
  751.        
  752.         if(p != null)
  753.         {
  754.             p.append(new Sen(data, _settings));
  755.         }
  756.         else
  757.         {
  758.             _abort = true;
  759.             _thread.clear();
  760.             throw new SAXException("Thread expired.");
  761.         }
  762.     }
  763.    
  764.     private Matrix parseTransform(String mat)
  765.     {
  766.          int index_first = mat.indexOf(SVGUti.SVG_TRANSFORM_MATRIX_START_BRACKET) + 1;
  767.          int index_last = mat.lastIndexOf(SVGUti.SVG_TRANSFORM_MATRIX_END_BRACKET);
  768.          
  769.          String[] coeff = mat.substring(index_first, index_last).split(SVGUti.SVG_TRANSFORM_MATRIX_COEFF_REGEX);
  770.          
  771.          Matrix ret = new Matrix();
  772.          
  773.          if(mat.startsWith(SVGUti.SVG_TRANSFORM_MATRIX_TYPE_MATRIX))
  774.          {
  775.              float[] fcoeff = new float[]{
  776.                      1.0f, .0f, .0f,
  777.                      .0f, 1.0f, .0f,
  778.                      .0f, .0f, 1.0f};
  779.              
  780.              //ref: http://www.w3.org/TR/SVG/coords.html#TransformMatrixDefined
  781.              SVGUti.SafeParse(coeff, 0, fcoeff, 0); //a
  782.              SVGUti.SafeParse(coeff, 1, fcoeff, 3); //c
  783.              SVGUti.SafeParse(coeff, 2, fcoeff, 1); //e
  784.              SVGUti.SafeParse(coeff, 3, fcoeff, 4); //b
  785.              SVGUti.SafeParse(coeff, 4, fcoeff, 2); //d
  786.              SVGUti.SafeParse(coeff, 5, fcoeff, 5); //f
  787.              
  788.              ret.setValues(fcoeff);
  789.          }
  790.          else if(mat.startsWith(SVGUti.SVG_TRANSFORM_MATRIX_TYPE_TRANSLATE))
  791.          {
  792.              float tx = SVGUti.SafeParse(coeff, 0);
  793.              float ty = SVGUti.SafeParse(coeff, 1);
  794.              
  795.              ret.setTranslate(tx, ty);
  796.          }
  797.          else if(mat.startsWith(SVGUti.SVG_TRANSFORM_MATRIX_TYPE_SCALE))
  798.          {
  799.              float sx = SVGUti.SafeParse(coeff, 0);
  800.              float sy = SVGUti.SafeParse(coeff, 1);
  801.              
  802.              ret.setScale(sx, sy);
  803.          }
  804.          else if(mat.startsWith(SVGUti.SVG_TRANSFORM_MATRIX_TYPE_ROTATE))
  805.          {
  806.             float a = SVGUti.SafeParse(coeff, 0);
  807.             float cx = SVGUti.SafeParse(coeff, 1);
  808.             float cy = SVGUti.SafeParse(coeff, 2);
  809.  
  810.             ret.setRotate(a, cx, cy);
  811.          }
  812.          else if(mat.startsWith(SVGUti.SVG_TRANSFORM_MATRIX_TYPE_SKEWX))
  813.          {
  814.              float sk = SVGUti.SafeParse(coeff, 0);
  815.              
  816.              ret.setSkew(sk, .0f);
  817.          }
  818.          else if(mat.startsWith(SVGUti.SVG_TRANSFORM_MATRIX_TYPE_SKEWY))
  819.          {
  820.              float sk = SVGUti.SafeParse(coeff, 0);
  821.              
  822.              ret.setSkew(.0f, sk);
  823.          }
  824.  
  825.          return ret;
  826.     }
  827.    
  828.     @Override
  829.     public void endElement(String uri, String localName, String qName) throws SAXException
  830.     {
  831.         if(qName.equalsIgnoreCase("g"))
  832.         {
  833.             _transform.pop();
  834.         }
  835.     }
  836.    
  837.     public void abort()
  838.     {
  839.         _abort = true;
  840.     }
  841.    
  842.     private void checkAbort() throws SAXException
  843.     {
  844.         if(_abort || Thread.interrupted())
  845.             throw new SAXException("Aborted by the loading thread.");
  846.     }
  847. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!