|
0
|
1 /*
|
|
|
2 * CDDL HEADER START
|
|
|
3 *
|
|
|
4 * The contents of this file are subject to the terms of the
|
|
|
5 * Common Development and Distribution License, Version 1.0 only
|
|
|
6 * (the "License"). You may not use this file except in compliance
|
|
|
7 * with the License.
|
|
|
8 *
|
|
|
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
|
|
10 * or http://www.opensolaris.org/os/licensing.
|
|
|
11 * See the License for the specific language governing permissions
|
|
|
12 * and limitations under the License.
|
|
|
13 *
|
|
|
14 * When distributing Covered Code, include this CDDL HEADER in each
|
|
|
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
|
|
16 * If applicable, add the following below this CDDL HEADER, with the
|
|
|
17 * fields enclosed by brackets "[]" replaced with your own identifying
|
|
|
18 * information: Portions Copyright [yyyy] [name of copyright owner]
|
|
|
19 *
|
|
|
20 * CDDL HEADER END
|
|
|
21 */
|
|
|
22 /*
|
|
|
23 * ident "@(#)Converter.java 1.2 05/06/08 SMI"
|
|
|
24 *
|
|
|
25 * Copyright (c) 2000 by Sun Microsystems, Inc.
|
|
|
26 * All rights reserved.
|
|
|
27 */
|
|
|
28
|
|
|
29 /*
|
|
|
30 * Copyright (C) 1996 Active Software, Inc.
|
|
|
31 * All rights reserved.
|
|
|
32 *
|
|
|
33 * @(#) Converter.java 1.65 - last change made 08/20/97
|
|
|
34 */
|
|
|
35
|
|
|
36 package sunsoft.jws.visual.rt.type;
|
|
|
37
|
|
|
38 import sunsoft.jws.visual.rt.base.Global;
|
|
|
39
|
|
|
40 import sunsoft.jws.visual.rt.base.*;
|
|
|
41
|
|
|
42 import java.util.*;
|
|
|
43
|
|
|
44 /**
|
|
|
45 * Base class for all converters. Converts a type of
|
|
|
46 * object to a string
|
|
|
47 * and back again.
|
|
|
48 *
|
|
|
49 * @version 1.65, 08/20/97
|
|
|
50 */
|
|
|
51
|
|
|
52 public abstract class Converter {
|
|
|
53 /**
|
|
|
54 * Table of names for each registered converter.
|
|
|
55 */
|
|
|
56 private static Hashtable converterNameTable = new Hashtable();
|
|
|
57
|
|
|
58 /**
|
|
|
59 * Table of instances for each converter that has
|
|
|
60 * been instantiated.
|
|
|
61 */
|
|
|
62 private static Hashtable converterInstanceTable = new Hashtable();
|
|
|
63
|
|
|
64 /**
|
|
|
65 * Adds a new type converter to the global table of converters. A
|
|
|
66 * converter must be listed for this table in order for the search
|
|
|
67 * for a converter for that particular type to be successful.
|
|
|
68 *
|
|
|
69 * @param typeName the name of the type (what is returned by a
|
|
|
70 * call to getClass().getType() for an instance of that type)
|
|
|
71 * @param converterClassName the full name of the converter class
|
|
|
72 */
|
|
|
73 public static void addConverter(String typeName,
|
|
|
74 String converterClassName) {
|
|
|
75 converterNameTable.put(typeName, converterClassName);
|
|
|
76 }
|
|
|
77
|
|
|
78 /**
|
|
|
79 * Initialize the type converters for the types we know about.
|
|
|
80 */
|
|
|
81 static {
|
|
|
82 addConverter(/* NOI18N */"[I", /* NOI18N */
|
|
|
83 "sunsoft.jws.visual.rt.type.IntArrayConverter");
|
|
|
84 addConverter(/* NOI18N */"[D", /* NOI18N */
|
|
|
85 "sunsoft.jws.visual.rt.type.DoubleArrayConverter");
|
|
|
86 addConverter(/* NOI18N */"java.lang.String",
|
|
|
87 /* NOI18N */"sunsoft.jws.visual.rt.type.StringConverter");
|
|
|
88 addConverter(/* NOI18N */"[Ljava.lang.String;",
|
|
|
89 /* NOI18N */"sunsoft.jws.visual.rt.type.StringArrayConverter");
|
|
|
90 addConverter(/* NOI18N */"java.lang.Boolean",
|
|
|
91 /* NOI18N */"sunsoft.jws.visual.rt.type.BooleanConverter");
|
|
|
92 addConverter(/* NOI18N */"java.lang.Character",
|
|
|
93 /* NOI18N */"sunsoft.jws.visual.rt.type.CharacterConverter");
|
|
|
94 addConverter(/* NOI18N */"java.lang.Integer",
|
|
|
95 /* NOI18N */"sunsoft.jws.visual.rt.type.IntegerConverter");
|
|
|
96 addConverter(/* NOI18N */"java.awt.Color",
|
|
|
97 /* NOI18N */"sunsoft.jws.visual.rt.type.ColorConverter");
|
|
|
98 addConverter(/* NOI18N */"java.awt.SystemColor",
|
|
|
99 /* NOI18N */"sunsoft.jws.visual.rt.type.ColorConverter");
|
|
|
100 addConverter(/* NOI18N */"java.awt.Font",
|
|
|
101 /* NOI18N */"sunsoft.jws.visual.rt.type.FontConverter");
|
|
|
102 addConverter(/* NOI18N */"java.awt.Point",
|
|
|
103 /* NOI18N */"sunsoft.jws.visual.rt.type.PointConverter");
|
|
|
104 addConverter(/* NOI18N */"java.awt.Dimension",
|
|
|
105 /* NOI18N */"sunsoft.jws.visual.rt.type.DimensionConverter");
|
|
|
106 addConverter(/* NOI18N */"java.awt.Insets",
|
|
|
107 /* NOI18N */"sunsoft.jws.visual.rt.type.InsetsConverter");
|
|
|
108 addConverter(/* NOI18N */
|
|
|
109 "sunsoft.jws.visual.rt.awt.GBConstraints",
|
|
|
110 /* NOI18N */"sunsoft.jws.visual.rt.type.GBConstraintsConverter");
|
|
|
111 addConverter(/* NOI18N */
|
|
|
112 "sunsoft.jws.visual.rt.base.AttributeManager",
|
|
|
113 /* NOI18N */"sunsoft.jws.visual.rt.type.AMConverter");
|
|
|
114 addConverter(/* NOI18N */"sunsoft.jws.visual.rt.type.AMRef",
|
|
|
115 /* NOI18N */"sunsoft.jws.visual.rt.type.AMRefConverter");
|
|
|
116 addConverter(/* NOI18N */
|
|
|
117 "sunsoft.jws.visual.rt.base.Attribute",
|
|
|
118 /* NOI18N */"sunsoft.jws.visual.rt.type.AttributeConverter");
|
|
|
119 addConverter(/* NOI18N */
|
|
|
120 "sunsoft.jws.visual.rt.base.AttributeList",
|
|
|
121 /* NOI18N */"sunsoft.jws.visual.rt.type.AttributeListConverter");
|
|
|
122 addConverter(/* NOI18N */"sunsoft.jws.visual.rt.type.ImageRef",
|
|
|
123 /* NOI18N */"sunsoft.jws.visual.rt.type.ImageRefConverter");
|
|
|
124 addConverter(/* NOI18N */
|
|
|
125 "sunsoft.jws.visual.rt.type.AlignmentEnum",
|
|
|
126 /* NOI18N */"sunsoft.jws.visual.rt.type.BaseEnumConverter");
|
|
|
127 addConverter(/* NOI18N */
|
|
|
128 "sunsoft.jws.visual.rt.type.AnchorEnum",
|
|
|
129 /* NOI18N */"sunsoft.jws.visual.rt.type.BaseEnumConverter");
|
|
|
130 addConverter(/* NOI18N */
|
|
|
131 "sunsoft.jws.visual.rt.type.OrientationEnum",
|
|
|
132 /* NOI18N */"sunsoft.jws.visual.rt.type.BaseEnumConverter");
|
|
|
133 addConverter(/* NOI18N */
|
|
|
134 "sunsoft.jws.visual.rt.type.ReliefEnum",
|
|
|
135 /* NOI18N */"sunsoft.jws.visual.rt.type.BaseEnumConverter");
|
|
|
136 addConverter(/* NOI18N */"sunsoft.jws.visual.rt.type.ModeEnum",
|
|
|
137 /* NOI18N */"sunsoft.jws.visual.rt.type.BaseEnumConverter");
|
|
|
138 addConverter(/* NOI18N */"unknown", /* NOI18N */
|
|
|
139 "sunsoft.jws.visual.rt.type.UnknownTypeConverter");
|
|
|
140 }
|
|
|
141
|
|
|
142 /**
|
|
|
143 * Returns an existing converter for the given type. Creates a new
|
|
|
144 * converter only if necessary (typically the first
|
|
|
145 * time one is asked for.)
|
|
|
146 */
|
|
|
147 public static Converter getConverter(String typeName) {
|
|
|
148 Converter converter;
|
|
|
149
|
|
|
150 converter = (Converter)converterInstanceTable.get(typeName);
|
|
|
151 if (converter != null)
|
|
|
152 return converter;
|
|
|
153
|
|
|
154 String converterType = (String) converterNameTable.get
|
|
|
155 (typeName);
|
|
|
156 if (converterType == null) {
|
|
|
157 /* JSTYLED */
|
|
|
158 // Load the class for the type and try again. Some types have
|
|
|
159 // static initializers that register their converters.
|
|
|
160 loadType(typeName);
|
|
|
161 converterType = (String) converterNameTable.get(typeName);
|
|
|
162 }
|
|
|
163
|
|
|
164 if (converterType == null) {
|
|
|
165 converterType = (String) converterNameTable.get
|
|
|
166 (/* NOI18N */"unknown");
|
|
|
167 if (converterType == null)
|
|
|
168 /* JSTYLED */
|
|
|
169 throw new Error(Global.getMsg("sunsoft.jws.visual.rt.type.Converter.No__converter__defined.20"));
|
|
|
170 }
|
|
|
171 try {
|
|
|
172 Class c = Class.forName(converterType);
|
|
|
173 converter = (Converter) c.newInstance();
|
|
|
174 converter.setConverterType(typeName);
|
|
|
175 converterInstanceTable.put(typeName, converter);
|
|
|
176 return converter;
|
|
|
177 }
|
|
|
178 catch (Exception e) {
|
|
|
179 throw new Error(e.getMessage());
|
|
|
180 }
|
|
|
181 }
|
|
|
182
|
|
|
183 private static void loadType(String typeName) {
|
|
|
184 // For arrays, use the array type
|
|
|
185 if (typeName.charAt(0) == /* NOI18N */ '[') {
|
|
|
186 int i;
|
|
|
187 int len = typeName.length();
|
|
|
188 for (i = 0; i < len; i++) {
|
|
|
189 if (typeName.charAt(i) != /* NOI18N */ '[')
|
|
|
190 break;
|
|
|
191 }
|
|
|
192 i++;
|
|
|
193 if (i < len)
|
|
|
194 typeName = typeName.substring(i, len-1);
|
|
|
195 }
|
|
|
196
|
|
|
197 try {
|
|
|
198 Class.forName(typeName);
|
|
|
199 }
|
|
|
200 catch (ClassNotFoundException ex) {
|
|
|
201 /* JSTYLED */
|
|
|
202 System.out.println(Global.getMsg("sunsoft.jws.visual.rt.type.Converter.Class__not__found__for__.21") + typeName + /* NOI18N */"\".");
|
|
|
203 }
|
|
|
204 }
|
|
|
205
|
|
|
206 /**
|
|
|
207 * Returns true if there is a converter for the given type.
|
|
|
208 */
|
|
|
209 public static boolean hasConverter(String typeName) {
|
|
|
210 return (converterNameTable.containsKey(typeName));
|
|
|
211 }
|
|
|
212
|
|
|
213 /**
|
|
|
214 * The type editors (for more complex types.)
|
|
|
215 */
|
|
|
216 private static Hashtable typeEditorNameTable = new Hashtable();
|
|
|
217
|
|
|
218 /**
|
|
|
219 * Registers a type editor for a type. At run-time (in generated
|
|
|
220 * applications) there will typically be no editors, but they are
|
|
|
221 * needed for the attribute editor in the designer. The designer
|
|
|
222 * will set up all the standard ones.
|
|
|
223 *
|
|
|
224 * @see TypeEditor
|
|
|
225 */
|
|
|
226 public static void addTypeEditor(String typeName,
|
|
|
227 String editorClassName) {
|
|
|
228 typeEditorNameTable.put(typeName, editorClassName);
|
|
|
229 }
|
|
|
230
|
|
|
231 /**
|
|
|
232 * Returns true if there is an editor for the given type.
|
|
|
233 *
|
|
|
234 * @see TypeEditor
|
|
|
235 */
|
|
|
236 public static boolean hasTypeEditor(String typeName) {
|
|
|
237 return (typeEditorNameTable.containsKey(typeName));
|
|
|
238 }
|
|
|
239
|
|
|
240 /* BEGIN JSTYLED */
|
|
|
241 /**
|
|
|
242 * Returns a new instance of a type editor.
|
|
|
243 * The caller (typically the
|
|
|
244 * Designer) gets a new one of these every time, one for each
|
|
|
245 * attribute being edited, even if they are the same type. Caching
|
|
|
246 * instances of these type editors is up to the caller.
|
|
|
247 */
|
|
|
248 /* END JSTYLED */
|
|
|
249
|
|
|
250 public static TypeEditor newTypeEditor(String typeName) {
|
|
|
251 String editorType = (String) typeEditorNameTable.get(typeName);
|
|
|
252
|
|
|
253 if (editorType != null) {
|
|
|
254 try {
|
|
|
255 // instances of type editors are NOT cached
|
|
|
256 Class c = Class.forName(editorType);
|
|
|
257 return ((TypeEditor) c.newInstance());
|
|
|
258 }
|
|
|
259 catch (Exception ex) {
|
|
|
260 /* JSTYLED */
|
|
|
261 throw new VJException(Global.newline() + /* NOI18N */" " + ex.toString());
|
|
|
262 }
|
|
|
263 }
|
|
|
264
|
|
|
265 return null;
|
|
|
266 }
|
|
|
267
|
|
|
268 /**
|
|
|
269 * Returns whether a converter instance has an
|
|
|
270 * associated type editor.
|
|
|
271 *
|
|
|
272 * @see TypeEditor
|
|
|
273 */
|
|
|
274 public boolean hasTypeEditor() {
|
|
|
275 return (hasTypeEditor(getConverterType()));
|
|
|
276 }
|
|
|
277
|
|
|
278 /**
|
|
|
279 * Returns a new instance of the type editor associated with this
|
|
|
280 * converter.
|
|
|
281 */
|
|
|
282 public TypeEditor newTypeEditor() {
|
|
|
283 return (newTypeEditor(getConverterType()));
|
|
|
284 }
|
|
|
285 /* JSTYLED */
|
|
|
286 // ------ Interfaces for Sub-Classers -----------------------------------
|
|
|
287
|
|
|
288 /**
|
|
|
289 * The name of the type being edited.
|
|
|
290 */
|
|
|
291 protected String converterType;
|
|
|
292
|
|
|
293 /**
|
|
|
294 * An interface that can be overridden in sub-classes
|
|
|
295 * to whom the type
|
|
|
296 * converted is important.
|
|
|
297 *
|
|
|
298 * @see BaseEnumConverter
|
|
|
299 */
|
|
|
300 protected void setConverterType(String type) {
|
|
|
301 converterType = type;
|
|
|
302 }
|
|
|
303
|
|
|
304 /**
|
|
|
305 * Returns the type of object converted by this converter.
|
|
|
306 */
|
|
|
307 public String getConverterType() {
|
|
|
308 return (converterType);
|
|
|
309 }
|
|
|
310
|
|
|
311 /* BEGIN JSTYLED */
|
|
|
312 /**
|
|
|
313 * Returns the string representation for an instance of
|
|
|
314 * the type this
|
|
|
315 * converter converts. Must be declared in subclasses
|
|
|
316 * to convert an
|
|
|
317 * object of the type specific to that subclass of Converter.
|
|
|
318 * <p>
|
|
|
319 * One of the two "convertToString" methods must be overridden in
|
|
|
320 * the converter sub-class. The overridden "convertToString"
|
|
|
321 * method
|
|
|
322 * should NOT call "super.convertToString". It is preferrable to
|
|
|
323 * override the StringBuffer version (the other one) because this
|
|
|
324 * will result in better performance.
|
|
|
325 */
|
|
|
326 /* END JSTYLED */
|
|
|
327 public String convertToString(Object obj) {
|
|
|
328 enterConvert(TOSTRING, false);
|
|
|
329 StringBuffer buf = new StringBuffer();
|
|
|
330 convertToString(obj, buf);
|
|
|
331 exitConvert(TOSTRING, false);
|
|
|
332
|
|
|
333 return buf.toString();
|
|
|
334 }
|
|
|
335
|
|
|
336 /**
|
|
|
337 * Places a string representation of an instance of the type this
|
|
|
338 * converter converts into a string buffer.
|
|
|
339 */
|
|
|
340 public void convertToString(Object obj, StringBuffer buf) {
|
|
|
341 enterConvert(TOSTRING, true);
|
|
|
342 buf.append(convertToString(obj));
|
|
|
343 exitConvert(TOSTRING, true);
|
|
|
344 }
|
|
|
345
|
|
|
346 /**
|
|
|
347 * Returns a new instance of the type this converter converts, as
|
|
|
348 * specified by the string given. Must be declared
|
|
|
349 * in subclasses of
|
|
|
350 * Converter to convert a string representation into an object of
|
|
|
351 * the type converted by the subclass.
|
|
|
352 */
|
|
|
353 public abstract Object convertFromString(String s);
|
|
|
354
|
|
|
355 /**
|
|
|
356 * Converts an instance of the type into a block of code.
|
|
|
357 */
|
|
|
358 public void convertToCodeBlock(String amName,
|
|
|
359 Attribute a, int indent, StringBuffer buf) {
|
|
|
360
|
|
|
361 Converter c = getConverter(a.getType());
|
|
|
362 String attr_name;
|
|
|
363
|
|
|
364 indent(buf, indent);
|
|
|
365 buf.append(amName);
|
|
|
366 buf.append(/* NOI18N */".set(\"");
|
|
|
367 attr_name = a.getName();
|
|
|
368 buf.append(attr_name);
|
|
|
369 buf.append(/* NOI18N */"\", ");
|
|
|
370 buf.append(c.convertToCode(a.getValue()));
|
|
|
371 buf.append(/* NOI18N */");");
|
|
|
372 newline(buf);
|
|
|
373 }
|
|
|
374
|
|
|
375 /**
|
|
|
376 * Converts an instance of the type converted into a line of code.
|
|
|
377 * This method provides a default way for any type to get a
|
|
|
378 * convertToCode method into it. It generates code that will feed
|
|
|
379 * the string representation of the object into the
|
|
|
380 * appropriate type
|
|
|
381 * converter. The performance isn't as good as customized
|
|
|
382 * convertToCode functions in subclasses since more classes have to
|
|
|
383 * be loaded at runtime.
|
|
|
384 */
|
|
|
385 public String convertToCode(Object obj) {
|
|
|
386 if (obj != null)
|
|
|
387 return (/* NOI18N */"convert(\"" +
|
|
|
388 obj.getClass().getName() + /* NOI18N */"\", \""
|
|
|
389 + convertToString(obj) + /* NOI18N */"\")");
|
|
|
390 else
|
|
|
391 return (/* NOI18N */"null");
|
|
|
392 }
|
|
|
393
|
|
|
394 /**
|
|
|
395 * Returns the string that should be displayed in the attribute
|
|
|
396 * editor. Subclassers that want something displayed other than
|
|
|
397 * what is returned from convertToString should override this
|
|
|
398 * method to return that.
|
|
|
399 */
|
|
|
400 public String displayString(Object obj) {
|
|
|
401 return (convertToString(obj));
|
|
|
402 }
|
|
|
403
|
|
|
404 /**
|
|
|
405 * Returns true if this type should be displayed in an editor.
|
|
|
406 *
|
|
|
407 * For the attribute editor, a return value of false means that the
|
|
|
408 * the textfield will be hidden.
|
|
|
409 *
|
|
|
410 * @return true
|
|
|
411 */
|
|
|
412 public boolean viewableAsString() {
|
|
|
413 return true;
|
|
|
414 }
|
|
|
415
|
|
|
416 /**
|
|
|
417 * Returns true if this type is simple enough to be
|
|
|
418 * edited as a string
|
|
|
419 * in an editor.
|
|
|
420 *
|
|
|
421 * Sub-classers that represent type too complex for
|
|
|
422 * this should override
|
|
|
423 * this function to return false. For the attribute editor,
|
|
|
424 * this means
|
|
|
425 * that the textfield will be read-only.
|
|
|
426 *
|
|
|
427 * @see #viewableAsString
|
|
|
428 * @return same as viewableAsString
|
|
|
429 */
|
|
|
430 public boolean editableAsString() {
|
|
|
431 return viewableAsString();
|
|
|
432 }
|
|
|
433
|
|
|
434 /**
|
|
|
435 * These weird looking enter/exit methods ensure that the converter
|
|
|
436 * sub-class is overriding at least one of the "convertToString"
|
|
|
437 * methods, and at least one of the "convertToCode" methods.
|
|
|
438 * An error will be thrown at runtime if this in not the case.
|
|
|
439 * If this check wasn't done here , then the failure to
|
|
|
440 * override one
|
|
|
441 * of the methods would result in an infinite loop.
|
|
|
442 */
|
|
|
443 private static final int TOSTRING = 0;
|
|
|
444 private static final int TOCODE = 1;
|
|
|
445
|
|
|
446 private boolean converting[] = {false, false};
|
|
|
447 private boolean isBuffered[] = {false, false};
|
|
|
448 private int convertRecurse[] = {0, 0};
|
|
|
449
|
|
|
450 private void enterConvert(int c, boolean isBuffered) {
|
|
|
451 if (converting[c] && this.isBuffered[c] != isBuffered)
|
|
|
452 throw new Error(Global.getMsg(
|
|
|
453 "sunsoft.jws.visual.rt.type.Converter.Sub-classes__of__Conve.22"));
|
|
|
454
|
|
|
455 this.isBuffered[c] = isBuffered;
|
|
|
456 converting[c] = true;
|
|
|
457 convertRecurse[c]++;
|
|
|
458 }
|
|
|
459
|
|
|
460 private void exitConvert(int c, boolean isBuffered) {
|
|
|
461 if (!converting[c])
|
|
|
462 /* BEGIN JSTYLED */
|
|
|
463 throw new Error(Global.getMsg("sunsoft.jws.visual.rt.type.Converter.Convert__exit__without.25"));
|
|
|
464
|
|
|
465 if (this.isBuffered[c] != isBuffered)
|
|
|
466 throw new Error(Global.getMsg("sunsoft.jws.visual.rt.type.Converter.isBuffered__mismatch__.26"));
|
|
|
467
|
|
|
468 /* END JSTYLED */
|
|
|
469 convertRecurse[c]--;
|
|
|
470 if (convertRecurse[c] == 0)
|
|
|
471 converting[c] = false;
|
|
|
472 }
|
|
|
473 /* BEGIN JSTYLED */
|
|
|
474 // ------ Utility Functions ----------------------------------------------
|
|
|
475
|
|
|
476 /**
|
|
|
477 * Returns a string that can be used as a newline.
|
|
|
478 * This string includes
|
|
|
479 * a carriage return if we are running on Windows.
|
|
|
480 */
|
|
|
481 /* END JSTYLED */
|
|
|
482 public static String newline() {
|
|
|
483 return Global.newline();
|
|
|
484 }
|
|
|
485
|
|
|
486 /**
|
|
|
487 * Appends a newline to buf. This also appends a carriage return
|
|
|
488 * if we are running on Windows.
|
|
|
489 */
|
|
|
490 public static void newline(StringBuffer buf) {
|
|
|
491 Global.newline(buf);
|
|
|
492 }
|
|
|
493
|
|
|
494 private static final String indentString = /* NOI18N */" ";
|
|
|
495 private static int indentLevel = 0;
|
|
|
496
|
|
|
497 /**
|
|
|
498 * Appends spaces to "buf" based on the current indent level.
|
|
|
499 */
|
|
|
500 protected static void indent(StringBuffer buf) {
|
|
|
501 for (int i = 0; i < indentLevel; i++)
|
|
|
502 buf.append(indentString);
|
|
|
503 }
|
|
|
504
|
|
|
505 /**
|
|
|
506 * Appends spaces to "buf" based on the given indent level.
|
|
|
507 */
|
|
|
508 protected static void indent(StringBuffer buf, int indentLevel) {
|
|
|
509 for (int i = 0; i < indentLevel; i++)
|
|
|
510 buf.append(/* NOI18N */ ' ');
|
|
|
511 }
|
|
|
512
|
|
|
513 /**
|
|
|
514 * Increments the indent level.
|
|
|
515 */
|
|
|
516 protected static void incrIndent() {
|
|
|
517 indentLevel++;
|
|
|
518 }
|
|
|
519
|
|
|
520 /**
|
|
|
521 * Decrements the indent level.
|
|
|
522 */
|
|
|
523 protected static void decrIndent() {
|
|
|
524 indentLevel--;
|
|
|
525 }
|
|
|
526
|
|
|
527 /**
|
|
|
528 * Returns the current indent level.
|
|
|
529 */
|
|
|
530 protected static int indentLevel() {
|
|
|
531 return indentLevel;
|
|
|
532 }
|
|
|
533
|
|
|
534 /**
|
|
|
535 * Returns the last token in a class name. i.e. the name that you
|
|
|
536 * can use for a class when you've imported the class already.
|
|
|
537 */
|
|
|
538 public static String shortClassName(String className) {
|
|
|
539 int index = className.lastIndexOf(/* NOI18N */ '.');
|
|
|
540 if (index == -1)
|
|
|
541 return (className);
|
|
|
542 else
|
|
|
543 return (className.substring(index + 1));
|
|
|
544 }
|
|
|
545
|
|
|
546 }
|
