KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > batik > parser > FragmentIdentifierParser


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 JavaDoc;
21
22 import org.apache.batik.xml.XMLUtilities;
23
24 /**
25  * This class represents an event-based parser for the SVG
26  * fragment identifiers.
27  *
28  * @author <a HREF="mailto:stephane@hillion.org">Stephane Hillion</a>
29  * @version $Id: FragmentIdentifierParser.java,v 1.14 2005/03/27 08:58:35 cam Exp $
30  */
31 public class FragmentIdentifierParser extends NumberParser {
32     
33     /**
34      * The buffer used for numbers.
35      */
36     protected char[] buffer = new char[16];
37
38     /**
39      * The buffer size.
40      */
41     protected int bufferSize;
42
43     /**
44      * The FragmentIdentifierHandler.
45      */
46     protected FragmentIdentifierHandler fragmentIdentifierHandler;
47
48     /**
49      * Creates a new FragmentIdentifier parser.
50      */
51     public FragmentIdentifierParser() {
52         fragmentIdentifierHandler =
53             DefaultFragmentIdentifierHandler.INSTANCE;
54     }
55
56     /**
57      * Allows an application to register a fragment identifier handler.
58      *
59      * <p>If the application does not register a handler, all
60      * events reported by the parser will be silently ignored.
61      *
62      * <p>Applications may register a new or different handler in the
63      * middle of a parse, and the parser must begin using the new
64      * handler immediately.</p>
65      * @param handler The transform list handler.
66      */
67     public void
68         setFragmentIdentifierHandler(FragmentIdentifierHandler handler) {
69         fragmentIdentifierHandler = handler;
70     }
71
72     /**
73      * Returns the points handler in use.
74      */
75     public FragmentIdentifierHandler getFragmentIdentifierHandler() {
76         return fragmentIdentifierHandler;
77     }
78
79     /**
80      * Parses the current reader.
81      */
82     protected void doParse() throws ParseException, IOException JavaDoc {
83         bufferSize = 0;
84                 
85         current = reader.read();
86
87         fragmentIdentifierHandler.startFragmentIdentifier();
88
89         ident: {
90             String JavaDoc id = null;
91
92             switch (current) {
93             case 'x':
94                 bufferize();
95                 current = reader.read();
96                 if (current != 'p') {
97                     parseIdentifier();
98                     break;
99                 }
100                 bufferize();
101                 current = reader.read();
102                 if (current != 'o') {
103                     parseIdentifier();
104                     break;
105                 }
106                 bufferize();
107                 current = reader.read();
108                 if (current != 'i') {
109                     parseIdentifier();
110                     break;
111                 }
112                 bufferize();
113                 current = reader.read();
114                 if (current != 'n') {
115                     parseIdentifier();
116                     break;
117                 }
118                 bufferize();
119                 current = reader.read();
120                 if (current != 't') {
121                     parseIdentifier();
122                     break;
123                 }
124                 bufferize();
125                 current = reader.read();
126                 if (current != 'e') {
127                     parseIdentifier();
128                     break;
129                 }
130                 bufferize();
131                 current = reader.read();
132                 if (current != 'r') {
133                     parseIdentifier();
134                     break;
135                 }
136                 bufferize();
137                 current = reader.read();
138                 if (current != '(') {
139                     parseIdentifier();
140                     break;
141                 }
142                 bufferSize = 0;
143                 current = reader.read();
144                 if (current != 'i') {
145                     reportError("character.expected",
146                                 new Object JavaDoc[] { new Character JavaDoc('i'),
147                                                 new Integer JavaDoc(current) });
148                     break ident;
149                 }
150                 current = reader.read();
151                 if (current != 'd') {
152                     reportError("character.expected",
153                                 new Object JavaDoc[] { new Character JavaDoc('d'),
154                                                new Integer JavaDoc(current) });
155                     break ident;
156                 }
157                 current = reader.read();
158                 if (current != '(') {
159                     reportError("character.expected",
160                                 new Object JavaDoc[] { new Character JavaDoc('('),
161                                                new Integer JavaDoc(current) });
162                     break ident;
163                 }
164                 current = reader.read();
165                 if (current != '"' && current != '\'') {
166                     reportError("character.expected",
167                                 new Object JavaDoc[] { new Character JavaDoc('\''),
168                                                new Integer JavaDoc(current) });
169                     break ident;
170                 }
171                 char q = (char)current;
172                 current = reader.read();
173                 parseIdentifier();
174
175                 id = getBufferContent();
176                 bufferSize = 0;
177                 fragmentIdentifierHandler.idReference(id);
178
179                 if (current != q) {
180                     reportError("character.expected",
181                                 new Object JavaDoc[] { new Character JavaDoc(q),
182                                                new Integer JavaDoc(current) });
183                     break ident;
184                 }
185                 current = reader.read();
186                 if (current != ')') {
187                     reportError("character.expected",
188                                 new Object JavaDoc[] { new Character JavaDoc(')'),
189                                                new Integer JavaDoc(current) });
190                     break ident;
191                 }
192                 current = reader.read();
193                 if (current != ')') {
194                     reportError("character.expected",
195                                 new Object JavaDoc[] { new Character JavaDoc(')'),
196                                                new Integer JavaDoc(current) });
197                 }
198                 break ident;
199
200             case 's':
201                 bufferize();
202                 current = reader.read();
203                 if (current != 'v') {
204                     parseIdentifier();
205                     break;
206                 }
207                 bufferize();
208                 current = reader.read();
209                 if (current != 'g') {
210                     parseIdentifier();
211                     break;
212                 }
213                 bufferize();
214                 current = reader.read();
215                 if (current != 'V') {
216                     parseIdentifier();
217                     break;
218                 }
219                 bufferize();
220                 current = reader.read();
221                 if (current != 'i') {
222                     parseIdentifier();
223                     break;
224                 }
225                 bufferize();
226                 current = reader.read();
227                 if (current != 'e') {
228                     parseIdentifier();
229                     break;
230                 }
231                 bufferize();
232                 current = reader.read();
233                 if (current != 'w') {
234                     parseIdentifier();
235                     break;
236                 }
237                 bufferize();
238                 current = reader.read();
239                 if (current != '(') {
240                     parseIdentifier();
241                     break;
242                 }
243                 bufferSize = 0;
244                 current = reader.read();
245                 parseViewAttributes();
246
247                 if (current != ')') {
248                     reportError("character.expected",
249                                 new Object JavaDoc[] { new Character JavaDoc(')'),
250                                                new Integer JavaDoc(current) });
251                 }
252                 break ident;
253
254             default:
255                 if (current == -1 ||
256                     !XMLUtilities.isXMLNameFirstCharacter((char)current)) {
257                     break ident;
258                 }
259                 bufferize();
260                 current = reader.read();
261                 parseIdentifier();
262             }
263             id = getBufferContent();
264             fragmentIdentifierHandler.idReference(id);
265         }
266
267         fragmentIdentifierHandler.endFragmentIdentifier();
268     }
269
270     /**
271      * Parses the svgView attributes.
272      */
273     protected void parseViewAttributes() throws ParseException, IOException JavaDoc {
274         boolean first = true;
275         loop: for (;;) {
276             switch (current) {
277             case -1:
278             case ')':
279                 if (first) {
280                     reportError("character.unexpected",
281                                 new Object JavaDoc[] { new Integer JavaDoc(current) });
282                     break loop;
283                 }
284             default:
285                 break loop;
286             case ';':
287                 if (first) {
288                     reportError("character.unexpected",
289                                 new Object JavaDoc[] { new Integer JavaDoc(current) });
290                     break loop;
291                 }
292                 current = reader.read();
293                 break;
294             case 'v':
295                 first = false;
296                 current = reader.read();
297                 if (current != 'i') {
298                     reportError("character.expected",
299                                 new Object JavaDoc[] { new Character JavaDoc('i'),
300                                                new Integer JavaDoc(current) });
301                     break loop;
302                 }
303                 current = reader.read();
304                 if (current != 'e') {
305                     reportError("character.expected",
306                                 new Object JavaDoc[] { new Character JavaDoc('e'),
307                                                new Integer JavaDoc(current) });
308                     break loop;
309                 }
310                 current = reader.read();
311                 if (current != 'w') {
312                     reportError("character.expected",
313                                 new Object JavaDoc[] { new Character JavaDoc('w'),
314                                                new Integer JavaDoc(current) });
315                     break loop;
316                 }
317                 current = reader.read();
318
319                 switch (current) {
320                 case 'B':
321                     current = reader.read();
322                     if (current != 'o') {
323                         reportError("character.expected",
324                                     new Object JavaDoc[] { new Character JavaDoc('o'),
325                                                    new Integer JavaDoc(current) });
326                         break loop;
327                     }
328                     current = reader.read();
329                     if (current != 'x') {
330                         reportError("character.expected",
331                                     new Object JavaDoc[] { new Character JavaDoc('x'),
332                                                    new Integer JavaDoc(current) });
333                         break loop;
334                     }
335                     current = reader.read();
336                     if (current != '(') {
337                         reportError("character.expected",
338                                     new Object JavaDoc[] { new Character JavaDoc('('),
339                                                    new Integer JavaDoc(current) });
340                         break loop;
341                     }
342                     current = reader.read();
343
344                     float x = parseFloat();
345                     if (current != ',') {
346                         reportError("character.expected",
347                                     new Object JavaDoc[] { new Character JavaDoc(','),
348                                                    new Integer JavaDoc(current) });
349                         break loop;
350                     }
351                     current = reader.read();
352                     
353                     float y = parseFloat();
354                     if (current != ',') {
355                         reportError("character.expected",
356                                     new Object JavaDoc[] { new Character JavaDoc(','),
357                                                    new Integer JavaDoc(current) });
358                         break loop;
359                     }
360                     current = reader.read();
361                     
362                     float w = parseFloat();
363                     if (current != ',') {
364                         reportError("character.expected",
365                                     new Object JavaDoc[] { new Character JavaDoc(','),
366                                                    new Integer JavaDoc(current) });
367                         break loop;
368                     }
369                     current = reader.read();
370                     
371                     float h = parseFloat();
372                     if (current != ')') {
373                         reportError("character.expected",
374                                     new Object JavaDoc[] { new Character JavaDoc(')'),
375                                                    new Integer JavaDoc(current) });
376                         break loop;
377                     }
378                     current = reader.read();
379                     fragmentIdentifierHandler.viewBox(x, y, w, h);
380                     if (current != ')' && current != ';') {
381                         reportError("character.expected",
382                                     new Object JavaDoc[] { new Character JavaDoc(')'),
383                                                    new Integer JavaDoc(current) });
384                         break loop;
385                     }
386                     break;
387
388                 case 'T':
389                     current = reader.read();
390                     if (current != 'a') {
391                         reportError("character.expected",
392                                     new Object JavaDoc[] { new Character JavaDoc('a'),
393                                                    new Integer JavaDoc(current) });
394                         break loop;
395                     }
396                     current = reader.read();
397                     if (current != 'r') {
398                         reportError("character.expected",
399                                     new Object JavaDoc[] { new Character JavaDoc('r'),
400                                                    new Integer JavaDoc(current) });
401                         break loop;
402                     }
403                     current = reader.read();
404                     if (current != 'g') {
405                         reportError("character.expected",
406                                     new Object JavaDoc[] { new Character JavaDoc('g'),
407                                                    new Integer JavaDoc(current) });
408                         break loop;
409                     }
410                     current = reader.read();
411                     if (current != 'e') {
412                         reportError("character.expected",
413                                     new Object JavaDoc[] { new Character JavaDoc('e'),
414                                                    new Integer JavaDoc(current) });
415                         break loop;
416                     }
417                     current = reader.read();
418                     if (current != 't') {
419                         reportError("character.expected",
420                                     new Object JavaDoc[] { new Character JavaDoc('t'),
421                                                    new Integer JavaDoc(current) });
422                         break loop;
423                     }
424                     current = reader.read();
425                     if (current != '(') {
426                         reportError("character.expected",
427                                     new Object JavaDoc[] { new Character JavaDoc('('),
428                                                    new Integer JavaDoc(current) });
429                         break loop;
430                     }
431                     current = reader.read();
432
433                     fragmentIdentifierHandler.startViewTarget();
434
435                     id: for (;;) {
436                         bufferSize = 0;
437                         if (current == -1 ||
438                             !XMLUtilities.isXMLNameFirstCharacter((char)current)) {
439                             reportError("character.unexpected",
440                                         new Object JavaDoc[] { new Integer JavaDoc(current) });
441                             break loop;
442                         }
443                         bufferize();
444                         current = reader.read();
445                         parseIdentifier();
446                         String JavaDoc s = getBufferContent();
447
448                         fragmentIdentifierHandler.viewTarget(s);
449
450                         bufferSize = 0;
451                         switch (current) {
452                         case ')':
453                             current = reader.read();
454                             break id;
455                         case ',':
456                         case ';':
457                             current = reader.read();
458                             break;
459                         default:
460                             reportError("character.unexpected",
461                                         new Object JavaDoc[] { new Integer JavaDoc(current) });
462                             break loop;
463                         }
464                     }
465
466                     fragmentIdentifierHandler.endViewTarget();
467                     break;
468
469                 default:
470                     reportError("character.unexpected",
471                                 new Object JavaDoc[] { new Integer JavaDoc(current) });
472                     break loop;
473                 }
474                 break;
475             case 'p':
476                 first = false;
477                 current = reader.read();
478                 if (current != 'r') {
479                     reportError("character.expected",
480                                 new Object JavaDoc[] { new Character JavaDoc('r'),
481                                                new Integer JavaDoc(current) });
482                     break loop;
483                 }
484                 current = reader.read();
485                 if (current != 'e') {
486                     reportError("character.expected",
487                                 new Object JavaDoc[] { new Character JavaDoc('e'),
488                                                new Integer JavaDoc(current) });
489                     break loop;
490                 }
491                 current = reader.read();
492                 if (current != 's') {
493                     reportError("character.expected",
494                                 new Object JavaDoc[] { new Character JavaDoc('s'),
495                                                new Integer JavaDoc(current) });
496                     break loop;
497                 }
498                 current = reader.read();
499                 if (current != 'e') {
500                     reportError("character.expected",
501                                 new Object JavaDoc[] { new Character JavaDoc('e'),
502                                                new Integer JavaDoc(current) });
503                     break loop;
504                 }
505                 current = reader.read();
506                 if (current != 'r') {
507                     reportError("character.expected",
508                                 new Object JavaDoc[] { new Character JavaDoc('r'),
509                                                new Integer JavaDoc(current) });
510                     break loop;
511                 }
512                 current = reader.read();
513                 if (current != 'v') {
514                     reportError("character.expected",
515                                 new Object JavaDoc[] { new Character JavaDoc('v'),
516                                                new Integer JavaDoc(current) });
517                     break loop;
518                 }
519                 current = reader.read();
520                 if (current != 'e') {
521                     reportError("character.expected",
522                                 new Object JavaDoc[] { new Character JavaDoc('e'),
523                                                new Integer JavaDoc(current) });
524                     break loop;
525                 }
526                 current = reader.read();
527                 if (current != 'A') {
528                     reportError("character.expected",
529                                 new Object JavaDoc[] { new Character JavaDoc('A'),
530                                                new Integer JavaDoc(current) });
531                     break loop;
532                 }
533                 current = reader.read();
534                 if (current != 's') {
535                     reportError("character.expected",
536                                 new Object JavaDoc[] { new Character JavaDoc('s'),
537                                                new Integer JavaDoc(current) });
538                     break loop;
539                 }
540                 current = reader.read();
541                 if (current != 'p') {
542                     reportError("character.expected",
543                                 new Object JavaDoc[] { new Character JavaDoc('p'),
544                                                new Integer JavaDoc(current) });
545                     break loop;
546     &nb