TransformListParser


1   /*
2   
3      Copyright 2000-2003  The Apache Software Foundation 
4   
5      Licensed under the Apache License, Version 2.0 (the "License");
6      you may not use this file except in compliance with the License.
7      You may obtain a copy of the License at
8   
9          http://www.apache.org/licenses/LICENSE-2.0
10  
11     Unless required by applicable law or agreed to in writing, software
12     distributed under the License is distributed on an "AS IS" BASIS,
13     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14     See the License for the specific language governing permissions and
15     limitations under the License.
16  
17   */
18  package org.apache.batik.parser;
19  
20  import java.io.IOException  ;
21  
22  /**
23   * This class implements an event-based parser for the SVG transform
24   * attribute values.
25   *
26   * @author <a HREF="mailto:stephane@hillion.org">Stephane Hillion</a>
27   * @version $Id: TransformListParser.java,v 1.10 2004/08/18 07:14:47 vhardy Exp $
28   */
29  public class TransformListParser extends NumberParser {
30  
31      /**
32       * The transform list handler used to report parse events.
33       */
34      protected TransformListHandler transformListHandler;
35  
36      /**
37       * Creates a new TransformListParser.
38       */
39      public TransformListParser() {
40      transformListHandler = DefaultTransformListHandler.INSTANCE;
41      }
42  
43      /**
44       * Allows an application to register a transform list handler.
45       *
46       * <p>If the application does not register a handler, all
47       * events reported by the parser will be silently ignored.
48       *
49       * <p>Applications may register a new or different handler in the
50       * middle of a parse, and the parser must begin using the new
51       * handler immediately.</p>
52       * @param handler The transform handler.
53       */
54      public void setTransformListHandler(TransformListHandler handler) {
55      transformListHandler = handler;
56      }
57  
58      /**
59       * Returns the transform list handler in use.
60       */
61      public TransformListHandler getTransformListHandler() {
62      return transformListHandler;
63      }
64  
65      /**
66       * Parses the current reader.
67       */
68      protected void doParse() throws ParseException, IOException   {
69      transformListHandler.startTransformList();
70  
71      loop: for (;;) {
72              try {
73                  current = reader.read();
74                  switch (current) {
75                  case 0xD:
76                  case 0xA:
77                  case 0x20:
78                  case 0x9:
79                  case ',':
80                      break;
81                  case 'm':
82                      parseMatrix();
83                      break;
84                  case 'r':
85                      parseRotate();
86                      break;
87                  case 't':
88                      parseTranslate();
89                      break;
90                  case 's':
91                      current = reader.read();
92                      switch (current) {
93                      case 'c':
94                          parseScale();
95                          break;
96                      case 'k':
97                          parseSkew();
98                          break;
99                      default:
100                         reportError("character.unexpected",
101                                     new Object  [] { new Integer  (current) });
102                         skipTransform();
103                     }
104                     break;
105                 case -1:
106                     break loop;
107                 default:
108                     reportError("character.unexpected",
109                                 new Object  [] { new Integer  (current) });
110                     skipTransform();
111                 }
112             } catch (ParseException e) {
113                 errorHandler.error(e);
114                 skipTransform();
115             }
116         }
117     skipSpaces();
118     if (current != -1) {
119         reportError("end.of.stream.expected",
120             new Object  [] { new Integer  (current) });
121     }
122 
123     transformListHandler.endTransformList();
124     }
125 
126     /**
127      * Parses a matrix transform. 'm' is assumed to be the current character.
128      */
129     protected void parseMatrix() throws ParseException, IOException   {
130     current = reader.read();
131 
132     // Parse 'atrix wsp? ( wsp?'
133     if (current != 'a') {
134         reportError("character.expected",
135             new Object  [] { new Character  ('a'),
136                        new Integer  (current) });
137         skipTransform();
138         return;
139     }
140     current = reader.read();
141     if (current != 't') {
142         reportError("character.expected",
143             new Object  [] { new Character  ('t'),
144                        new Integer  (current) });
145         skipTransform();
146         return;
147     }
148     current = reader.read();
149     if (current != 'r') {
150         reportError("character.expected",
151             new Object  [] { new Character  ('r'),
152                        new Integer  (current) });
153         skipTransform();
154         return;
155     }
156     current = reader.read();
157     if (current != 'i') {
158         reportError("character.expected",
159             new Object  [] { new Character  ('i'),
160                        new Integer  (current) });
161         skipTransform();
162         return;
163     }
164     current = reader.read();
165     if (current != 'x') {
166         reportError("character.expected",
167             new Object  [] { new Character  ('x'),
168                        new Integer  (current) });
169         skipTransform();
170         return;
171     }
172     current = reader.read();
173     skipSpaces();
174     if (current != '(') {
175         reportError("character.expected",
176             new Object  [] { new Character  ('('),
177                        new Integer  (current) });
178         skipTransform();
179         return;
180     }
181     current = reader.read();
182     skipSpaces();
183 
184         float a = parseFloat();
185         skipCommaSpaces();
186         float b = parseFloat();
187         skipCommaSpaces();
188         float c = parseFloat();
189         skipCommaSpaces();
190         float d = parseFloat();
191         skipCommaSpaces();
192         float e = parseFloat();
193         skipCommaSpaces();
194         float f = parseFloat();
195     
196         skipSpaces();
197         if (current != ')') {
198             reportError("character.expected",
199                         new Object  [] { new Character  (')'),
200                                        new Integer  (current) });
201             skipTransform();
202             return;
203         }
204 
205         transformListHandler.matrix(a, b, c, d, e, f);
206     }
207 
208     /**
209      * Parses a rotate transform. 'r' is assumed to be the current character.
210      * @return the current character.
211      */
212     protected void parseRotate() throws ParseException, IOException   {
213     current = reader.read();
214 
215     // Parse 'otate wsp? ( wsp?'
216     if (current != 'o') {
217         reportError("character.expected",
218             new Object  [] { new Character  ('o'),
219                        new Integer  (current) });
220         skipTransform();
221         return;
222     }
223     current = reader.read();
224     if (current != 't') {
225         reportError("character.expected",
226             new Object  [] { new Character  ('t'),
227                        new Integer  (current) });
228         skipTransform();
229         return;
230     }
231     current = reader.read();
232     if (current != 'a') {
233         reportError("character.expected",
234             new Object  [] { new Character  ('a'),
235                        new Integer  (current) });
236         skipTransform();
237         return;
238     }
239     current = reader.read();
240     if (current != 't') {
241         reportError("character.expected",
242             new Object  [] { new Character  ('t'),
243                        new Integer  (current) });
244         skipTransform();
245         return;
246     }
247     current = reader.read();
248     if (current != 'e') {
249         reportError("character.expected",
250             new Object  [] { new Character  ('e'),
251                        new Integer  (current) });
252         skipTransform();
253         return;
254     }
255     current = reader.read();
256     skipSpaces();
257 
258     if (current != '(') {
259         reportError("character.expected",
260             new Object  [] { new Character  ('('),
261                        new Integer  (current) });
262         skipTransform();
263         return;
264     }
265     current = reader.read();
266     skipSpaces();
267 
268         float theta = parseFloat();
269         skipSpaces();
270         
271         switch (current) {
272         case ')':
273             transformListHandler.rotate(theta);
274             return;
275         case ',':
276             current = reader.read();
277             skipSpaces();
278         }
279         
280         float cx = parseFloat();
281         skipCommaSpaces();
282         float cy = parseFloat();
283         
284         skipSpaces();
285         if (current != ')') {
286             reportError("character.expected",
287                         new Object  [] { new Character  (')'),
288                                        new Integer  (current) });
289             skipTransform();
290             return;
291         }
292 
293         transformListHandler.rotate(theta, cx, cy);
294     }
295 
296     /**
297      * Parses a translate transform. 't' is assumed to be
298      * the current character.
299      * @return the current character.
300      */
301     protected void parseTranslate() throws ParseException, IOException   {
302     current = reader.read();
303 
304     // Parse 'ranslate wsp? ( wsp?'
305     if (current != 'r') {
306         reportError("character.expected",
307             new Object  [] { new Character  ('r'),
308                        new Integer  (current) });
309         skipTransform();
310         return;
311     }
312     current = reader.read();
313     if (current != 'a') {
314         reportError("character.expected",
315             new Object  [] { new Character  ('a'),
316                        new Integer  (current) });
317         skipTransform();
318         return;
319     }
320     current = reader.read();
321     if (current != 'n') {
322         reportError("character.expected",
323             new Object  [] { new Character  ('n'),
324                        new Integer  (current) });
325         skipTransform();
326         return;
327     }
328     current = reader.read();
329     if (current != 's') {
330         reportError("character.expected",
331             new Object  [] { new Character  ('s'),
332                        new Integer  (current) });
333         skipTransform();
334         return;
335     }
336     current = reader.read();
337     if (current != 'l') {
338         reportError("character.expected",
339             new Object  [] { new Character  ('l'),
340                        new Integer  (current) });
341         skipTransform();
342         return;
343     }
344     current = reader.read();
345     if (current != 'a') {
346         reportError("character.expected",
347             new Object  [] { new Character  ('a'),
348                        new Integer  (current) });
349         skipTransform();
350         return;
351     }
352     current = reader.read();
353     if (current != 't') {
354         reportError("character.expected",
355             new Object  [] { new Character  ('t'),
356                        new Integer  (current) });
357         skipTransform();
358         return;
359     }
360     current = reader.read();
361     if (current != 'e') {
362         reportError("character.expected",
363             new Object  [] { new Character  ('e'),
364                        new Integer  (current) });
365         skipTransform();
366         return;
367     }
368     current = reader.read();
369     skipSpaces();
370     if (current != '(') {
371         reportError("character.expected",
372             new Object  [] { new Character  ('('),
373                        new Integer  (current) });
374         skipTransform();
375         return;
376     }
377     current = reader.read();
378     skipSpaces();
379 
380         float tx = parseFloat();
381         skipSpaces();
382 
383         switch (current) {
384         case ')':
385             transformListHandler.translate(tx);
386             return;
387         case ',':
388             current = reader.read();
389             skipSpaces();
390         }
391 
392         float ty = parseFloat();
393 
394         skipSpaces();
395         if (current != ')') {
396             reportError("character.expected",
397                         new Object  [] { new Character  (')'),
398                                        new Integer  (current) });
399             skipTransform();
400             return;
401         }
402 
403         transformListHandler.translate(tx, ty);
404     }
405 
406     /**
407      * Parses a scale transform. 'c' is assumed to be the current character.
408      * @return the current character.
409      */
410     protected void parseScale() throws ParseException, IOException   {
411     current = reader.read();
412 
413     // Parse 'ale wsp? ( wsp?'
414     if (current != 'a') {
415         reportError("character.expected",
416             new Object  [] { new Character  ('a'),
417                        new Integer  (current) });
418         skipTransform();
419         return;
420     }
421     current = reader.read();
422     if (current != 'l') {
423         reportError("character.expected",
424             new Object  [] { new Character  ('l'),
425                        new Integer  (current) });
426         skipTransform();
427         return;
428     }
429     current = reader.read();
430     if (current != 'e') {
431         reportError("character.expected",
432             new Object  [] { new Character  ('e'),
433                        new Integer  (current) });
434         skipTransform();
435         return;
436     }
437     current = reader.read();
438     skipSpaces();
439     if (current != '(') {
440         reportError("character.expected",
441             new Object  [] { new Character  ('('),
442                        new Integer  (current) });
443         skipTransform();
444         return;
445     }
446     current = reader.read();
447     skipSpaces();
448 
449         float sx = parseFloat();
450         skipSpaces();
451 
452         switch (current) {
453         case ')':
454             transformListHandler.scale(sx);
455             return;
456         case ',':
457             current = reader.read();
458             skipSpaces();
459         }
460 
461         float sy = parseFloat();
462 
463         skipSpaces();
464         if (current != ')') {
465             reportError("character.expected",
466                         new Object  [] { new Character  (')'),
467                                        new Integer  (current) });
468             skipTransform();
469             return;
470         }
471         
472         transformListHandler.scale(sx, sy);
473     }
474 
475     /**
476      * Parses a skew transform. 'e' is assumed to be the current character.
477      * @return the current character.
478      */
479     protected void parseSkew() throws ParseException, IOException   {
480     current = reader.read();
481 
482     // Parse 'ew[XY] wsp? ( wsp?'
483     if (current != 'e') {
484         reportError("character.expected",
485             new Object  [] { new Character  ('e'),
486                        new Integer  (current) });
487         skipTransform();
488         return;
489     }
490     current = reader.read();
491     if (current != 'w') {
492         reportError("character.expected",
493             new Object  [] { new Character  ('w'),
494                        new Integer  (current) });
495         skipTransform();
496         return;
497     }
498     current = reader.read();
499 
500     boolean skewX = false;
501     switch (current) {
502     case 'X':
503         skewX = true;
504     case 'Y':
505         break;
506     default:
507         reportError("character.expected",
508             new Object  [] { new Character  ('X'),
509                        new Integer  (current) });
510         skipTransform();
511         return;
512     }
513     current = reader.read();
514     skipSpaces();
515     if (current != '(') {
516         reportError("character.expected",
517             new Object  [] { new Character  ('('),
518                        new Integer  (current) });
519         skipTransform();
520         return;
521     }
522     current = reader.read();
523     skipSpaces();
524 
525         float sk = parseFloat();
526 
527         skipSpaces();
528         if (current != ')') {
529             reportError("character.expected",
530                         new Object  [] { new Character  (')'),
531                                        new Integer  (current) });
532             skipTransform();
533             return;
534         }
535         
536         if (skewX) {
537             transformListHandler.skewX(sk);
538         } else {
539             transformListHandler.skewY(sk);
540         }
541     }
542 
543     /**
544      * Skips characters in the given reader until a ')' is encountered.
545      * @return the first character after the ')'.
546      */
547     protected void skipTransform() throws IOException   {
548     loop: for (;;) {
549         current = reader.read();
550         switch (current) {
551         case ')':
552         break loop;
553         default:
554         if (current == -1) {
555             break loop;
556         }
557         }
558     }
559     }
560 }
561
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags