OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [swing/] [text/] [StyledEditorKit.java] - Blame information for rev 772

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 772 jeremybenn
/* StyledEditorKit.java --
2
   Copyright (C) 2002, 2004 Free Software Foundation, Inc.
3
 
4
This file is part of GNU Classpath.
5
 
6
GNU Classpath is free software; you can redistribute it and/or modify
7
it under the terms of the GNU General Public License as published by
8
the Free Software Foundation; either version 2, or (at your option)
9
any later version.
10
 
11
GNU Classpath is distributed in the hope that it will be useful, but
12
WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
General Public License for more details.
15
 
16
You should have received a copy of the GNU General Public License
17
along with GNU Classpath; see the file COPYING.  If not, write to the
18
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19
02110-1301 USA.
20
 
21
Linking this library statically or dynamically with other modules is
22
making a combined work based on this library.  Thus, the terms and
23
conditions of the GNU General Public License cover the whole
24
combination.
25
 
26
As a special exception, the copyright holders of this library give you
27
permission to link this library with independent modules to produce an
28
executable, regardless of the license terms of these independent
29
modules, and to copy and distribute the resulting executable under
30
terms of your choice, provided that you also meet, for each linked
31
independent module, the terms and conditions of the license of that
32
module.  An independent module is a module which is not derived from
33
or based on this library.  If you modify this library, you may extend
34
this exception to your version of the library, but you are not
35
obligated to do so.  If you do not wish to do so, delete this
36
exception statement from your version. */
37
 
38
 
39
package javax.swing.text;
40
 
41
import java.awt.Color;
42
import java.awt.event.ActionEvent;
43
 
44
import javax.swing.Action;
45
import javax.swing.JEditorPane;
46
import javax.swing.event.CaretEvent;
47
import javax.swing.event.CaretListener;
48
 
49
/**
50
 * An {@link EditorKit} that supports editing styled text.
51
 *
52
 * @author Andrew Selkirk
53
 * @author Roman Kennke (roman@kennke.org)
54
 */
55
public class StyledEditorKit extends DefaultEditorKit
56
{
57
  /** The serialVersionUID. */
58
  private static final long serialVersionUID = 7002391892985555948L;
59
 
60
  /**
61
   * Toggles the underline attribute for the selected text.
62
   */
63
  public static class UnderlineAction extends StyledEditorKit.StyledTextAction
64
  {
65
    /**
66
     * Creates an instance of <code>UnderlineAction</code>.
67
     */
68
    public UnderlineAction()
69
    {
70
      super("font-underline");
71
    }
72
 
73
    /**
74
     * Performs the action.
75
     *
76
     * @param event the <code>ActionEvent</code> that describes the action
77
     */
78
    public void actionPerformed(ActionEvent event)
79
    {
80
      JEditorPane editor = getEditor(event);
81
      StyledDocument doc = getStyledDocument(editor);
82
      Element el = doc.getCharacterElement(editor.getSelectionStart());
83
      boolean isUnderline = StyleConstants.isUnderline(el.getAttributes());
84
      SimpleAttributeSet atts = new SimpleAttributeSet();
85
      StyleConstants.setUnderline(atts, ! isUnderline);
86
      setCharacterAttributes(editor, atts, false);
87
    }
88
  }
89
 
90
  /**
91
   * Toggles the italic attribute for the selected text.
92
   */
93
  public static class ItalicAction extends StyledEditorKit.StyledTextAction
94
  {
95
    /**
96
     * Creates an instance of <code>ItalicAction</code>.
97
     */
98
    public ItalicAction()
99
    {
100
      super("font-italic");
101
    }
102
 
103
    /**
104
     * Performs the action.
105
     *
106
     * @param event the <code>ActionEvent</code> that describes the action
107
     */
108
    public void actionPerformed(ActionEvent event)
109
    {
110
      JEditorPane editor = getEditor(event);
111
      StyledDocument doc = getStyledDocument(editor);
112
      Element el = doc.getCharacterElement(editor.getSelectionStart());
113
      boolean isItalic = StyleConstants.isItalic(el.getAttributes());
114
      SimpleAttributeSet atts = new SimpleAttributeSet();
115
      StyleConstants.setItalic(atts, ! isItalic);
116
      setCharacterAttributes(editor, atts, false);
117
    }
118
  }
119
 
120
  /**
121
   * Toggles the bold attribute for the selected text.
122
   */
123
  public static class BoldAction extends StyledEditorKit.StyledTextAction
124
  {
125
    /**
126
     * Creates an instance of <code>BoldAction</code>.
127
     */
128
    public BoldAction()
129
    {
130
      super("font-bold");
131
    }
132
 
133
    /**
134
     * Performs the action.
135
     *
136
     * @param event the <code>ActionEvent</code> that describes the action
137
     */
138
    public void actionPerformed(ActionEvent event)
139
    {
140
      JEditorPane editor = getEditor(event);
141
      StyledDocument doc = getStyledDocument(editor);
142
      Element el = doc.getCharacterElement(editor.getSelectionStart());
143
      boolean isBold = StyleConstants.isBold(el.getAttributes());
144
      SimpleAttributeSet atts = new SimpleAttributeSet();
145
      StyleConstants.setBold(atts, ! isBold);
146
      setCharacterAttributes(editor, atts, false);
147
    }
148
  }
149
 
150
  /**
151
   * Sets the alignment attribute on the selected text.
152
   */
153
  public static class AlignmentAction extends StyledEditorKit.StyledTextAction
154
  {
155
    /**
156
     * The aligment to set.
157
     */
158
    private int a;
159
 
160
    /**
161
     * Creates a new instance of <code>AlignmentAction</code> to set the
162
     * alignment to <code>a</code>.
163
     *
164
     * @param nm the name of the Action
165
     * @param a the alignment to set
166
     */
167
    public AlignmentAction(String nm, int a)
168
    {
169
      super(nm);
170
      this.a = a;
171
    }
172
 
173
    /**
174
     * Performs the action.
175
     *
176
     * @param event the <code>ActionEvent</code> that describes the action
177
     */
178
    public void actionPerformed(ActionEvent event)
179
    {
180
      SimpleAttributeSet atts = new SimpleAttributeSet();
181
      StyleConstants.setAlignment(atts, a);
182
      setParagraphAttributes(getEditor(event), atts, false);
183
    }
184
  }
185
 
186
  /**
187
   * Sets the foreground color attribute on the selected text.
188
   */
189
  public static class ForegroundAction extends StyledEditorKit.StyledTextAction
190
  {
191
    /**
192
     * The foreground color to set.
193
     */
194
    private Color fg;
195
 
196
    /**
197
     * Creates a new instance of <code>ForegroundAction</code> to set the
198
     * foreground color to <code>fg</code>.
199
     *
200
     * @param nm the name of the Action
201
     * @param fg the foreground color to set
202
     */
203
    public ForegroundAction(String nm, Color fg)
204
    {
205
      super(nm);
206
      this.fg = fg;
207
    }
208
 
209
    /**
210
     * Performs the action.
211
     *
212
     * @param event the <code>ActionEvent</code> that describes the action
213
     */
214
    public void actionPerformed(ActionEvent event)
215
    {
216
      SimpleAttributeSet atts = new SimpleAttributeSet();
217
      StyleConstants.setForeground(atts, fg);
218
      setCharacterAttributes(getEditor(event), atts, false);
219
    }
220
  }
221
 
222
  /**
223
   * Sets the font size attribute on the selected text.
224
   */
225
  public static class FontSizeAction extends StyledEditorKit.StyledTextAction
226
  {
227
    /**
228
     * The font size to set.
229
     */
230
    private int size;
231
 
232
    /**
233
     * Creates a new instance of <code>FontSizeAction</code> to set the
234
     * font size to <code>size</code>.
235
     *
236
     * @param nm the name of the Action
237
     * @param size the font size to set
238
     */
239
    public FontSizeAction(String nm, int size)
240
    {
241
      super(nm);
242
      this.size = size;
243
    }
244
 
245
    /**
246
     * Performs the action.
247
     *
248
     * @param event the <code>ActionEvent</code> that describes the action
249
     */
250
    public void actionPerformed(ActionEvent event)
251
    {
252
      SimpleAttributeSet atts = new SimpleAttributeSet();
253
      StyleConstants.setFontSize(atts, size);
254
      setCharacterAttributes(getEditor(event), atts, false);
255
    }
256
  }
257
 
258
  /**
259
   * Sets the font family attribute on the selected text.
260
   */
261
  public static class FontFamilyAction extends StyledEditorKit.StyledTextAction
262
  {
263
    /**
264
     * The font family to set.
265
     */
266
    private String family;
267
 
268
    /**
269
     * Creates a new instance of <code>FontFamilyAction</code> to set the
270
     * font family to <code>family</code>.
271
     *
272
     * @param nm the name of the Action
273
     * @param family the font family to set
274
     */
275
    public FontFamilyAction(String nm, String family)
276
    {
277
      super(nm);
278
      this.family = family;
279
    }
280
 
281
    /**
282
     * Performs the action.
283
     *
284
     * @param event the <code>ActionEvent</code> that describes the action
285
     */
286
    public void actionPerformed(ActionEvent event)
287
    {
288
      SimpleAttributeSet atts = new SimpleAttributeSet();
289
      StyleConstants.setFontFamily(atts, family);
290
      setCharacterAttributes(getEditor(event), atts, false);
291
    }
292
  }
293
 
294
  /**
295
   * The abstract superclass of all styled TextActions. This class
296
   * provides some useful methods to manipulate the text attributes.
297
   */
298
  public abstract static class StyledTextAction extends TextAction
299
  {
300
    /**
301
     * Creates a new instance of <code>StyledTextAction</code>.
302
     *
303
     * @param nm the name of the <code>StyledTextAction</code>
304
     */
305
    public StyledTextAction(String nm)
306
    {
307
      super(nm);
308
    }
309
 
310
    /**
311
     * Returns the <code>JEditorPane</code> component from which the
312
     * <code>ActionEvent</code> originated.
313
     *
314
     * @param event the <code>ActionEvent</code>
315
     * @return the <code>JEditorPane</code> component from which the
316
     *         <code>ActionEvent</code> originated
317
     */
318
    protected final JEditorPane getEditor(ActionEvent event)
319
    {
320
      return (JEditorPane) getTextComponent(event);
321
    }
322
 
323
    /**
324
     * Sets the specified character attributes on the currently selected
325
     * text of <code>editor</code>. If <code>editor</code> does not have
326
     * a selection, then the attributes are used as input attributes
327
     * for newly inserted content.
328
     *
329
     * @param editor the <code>JEditorPane</code> component
330
     * @param atts the text attributes to set
331
     * @param replace if <code>true</code> the current attributes of the
332
     *        selection are replaces, otherwise they are merged
333
     */
334
    protected final void setCharacterAttributes(JEditorPane editor,
335
                                                AttributeSet atts,
336
                                                boolean replace)
337
    {
338
      int p0 = editor.getSelectionStart();
339
      int p1 = editor.getSelectionEnd();
340
      if (p0 != p1)
341
        {
342
          StyledDocument doc = getStyledDocument(editor);
343
          doc.setCharacterAttributes(p0, p1 - p0, atts, replace);
344
        }
345
      // Update input attributes.
346
      StyledEditorKit kit = getStyledEditorKit(editor);
347
      MutableAttributeSet inputAtts = kit.getInputAttributes();
348
      if (replace)
349
        {
350
          inputAtts.removeAttributes(inputAtts);
351
        }
352
      inputAtts.addAttributes(atts);
353
    }
354
 
355
    /**
356
     * Returns the {@link StyledDocument} that is used by <code>editor</code>.
357
     *
358
     * @param editor the <code>JEditorPane</code> from which to get the
359
     *        <code>StyledDocument</code>
360
     *
361
     * @return the {@link StyledDocument} that is used by <code>editor</code>
362
     */
363
    protected final StyledDocument getStyledDocument(JEditorPane editor)
364
    {
365
      Document doc = editor.getDocument();
366
      if (!(doc instanceof StyledDocument))
367
        throw new AssertionError("The Document for StyledEditorKits is "
368
                                 + "expected to be a StyledDocument.");
369
 
370
      return (StyledDocument) doc;
371
    }
372
 
373
    /**
374
     * Returns the {@link StyledEditorKit} that is used by <code>editor</code>.
375
     *
376
     * @param editor the <code>JEditorPane</code> from which to get the
377
     *        <code>StyledEditorKit</code>
378
     *
379
     * @return the {@link StyledEditorKit} that is used by <code>editor</code>
380
     */
381
    protected final StyledEditorKit getStyledEditorKit(JEditorPane editor)
382
    {
383
      EditorKit kit = editor.getEditorKit();
384
      if (!(kit instanceof StyledEditorKit))
385
        throw new AssertionError("The EditorKit for StyledDocuments is "
386
                                 + "expected to be a StyledEditorKit.");
387
 
388
      return (StyledEditorKit) kit;
389
    }
390
 
391
    /**
392
     * Sets the specified character attributes on the paragraph that
393
     * contains the currently selected
394
     * text of <code>editor</code>. If <code>editor</code> does not have
395
     * a selection, then the attributes are set on the paragraph that
396
     * contains the current caret position.
397
     *
398
     * @param editor the <code>JEditorPane</code> component
399
     * @param atts the text attributes to set
400
     * @param replace if <code>true</code> the current attributes of the
401
     *        selection are replaces, otherwise they are merged
402
     */
403
    protected final void setParagraphAttributes(JEditorPane editor,
404
                                                AttributeSet atts,
405
                                                boolean replace)
406
    {
407
      Document doc = editor.getDocument();
408
      if (doc instanceof StyledDocument)
409
        {
410
          StyledDocument styleDoc = (StyledDocument) editor.getDocument();
411
          EditorKit kit = editor.getEditorKit();
412
          if (!(kit instanceof StyledEditorKit))
413
            {
414
              StyledEditorKit styleKit = (StyledEditorKit) kit;
415
              int start = editor.getSelectionStart();
416
              int end = editor.getSelectionEnd();
417
              int dot = editor.getCaret().getDot();
418
              if (start == dot && end == dot)
419
                {
420
                  // If there is no selection, then we only update the
421
                  // input attributes.
422
                  MutableAttributeSet inputAttributes =
423
                    styleKit.getInputAttributes();
424
                  inputAttributes.addAttributes(atts);
425
                }
426
              else
427
                styleDoc.setParagraphAttributes(start, end, atts, replace);
428
            }
429
          else
430
            throw new AssertionError("The EditorKit for StyledTextActions "
431
                                     + "is expected to be a StyledEditorKit");
432
        }
433
      else
434
        throw new AssertionError("The Document for StyledTextActions is "
435
                                 + "expected to be a StyledDocument.");
436
    }
437
  }
438
 
439
  /**
440
   * A {@link ViewFactory} that is able to create {@link View}s for
441
   * the <code>Element</code>s that are supported by
442
   * <code>StyledEditorKit</code>, namely the following types of Elements:
443
   *
444
   * <ul>
445
   * <li>{@link AbstractDocument#ContentElementName}</li>
446
   * <li>{@link AbstractDocument#ParagraphElementName}</li>
447
   * <li>{@link AbstractDocument#SectionElementName}</li>
448
   * <li>{@link StyleConstants#ComponentElementName}</li>
449
   * <li>{@link StyleConstants#IconElementName}</li>
450
   * </ul>
451
   */
452
  static class StyledViewFactory
453
    implements ViewFactory
454
  {
455
    /**
456
     * Creates a {@link View} for the specified <code>Element</code>.
457
     *
458
     * @param element the <code>Element</code> to create a <code>View</code>
459
     *        for
460
     * @return the <code>View</code> for the specified <code>Element</code>
461
     *         or <code>null</code> if the type of <code>element</code> is
462
     *         not supported
463
     */
464
    public View create(Element element)
465
    {
466
      String name = element.getName();
467
      View view = null;
468
      if (name.equals(AbstractDocument.ContentElementName))
469
        view = new LabelView(element);
470
      else if (name.equals(AbstractDocument.ParagraphElementName))
471
        view = new ParagraphView(element);
472
      else if (name.equals(AbstractDocument.SectionElementName))
473
        view = new BoxView(element, View.Y_AXIS);
474
      else if (name.equals(StyleConstants.ComponentElementName))
475
        view = new ComponentView(element);
476
      else if (name.equals(StyleConstants.IconElementName))
477
        view = new IconView(element);
478
      else
479
        throw new AssertionError("Unknown Element type: "
480
                                 + element.getClass().getName() + " : "
481
                                 + name);
482
      return view;
483
    }
484
  }
485
 
486
  /**
487
   * Keeps track of the caret position and updates the currentRun
488
   * <code>Element</code> and the <code>inputAttributes</code>.
489
   */
490
  class CaretTracker
491
    implements CaretListener
492
  {
493
    /**
494
     * Notifies an update of the caret position.
495
     *
496
     * @param ev the event for the caret update
497
     */
498
    public void caretUpdate(CaretEvent ev)
499
    {
500
      Object source = ev.getSource();
501
      if (!(source instanceof JTextComponent))
502
        throw new AssertionError("CaretEvents are expected to come from a"
503
                                 + "JTextComponent.");
504
 
505
      JTextComponent text = (JTextComponent) source;
506
      Document doc = text.getDocument();
507
      if (!(doc instanceof StyledDocument))
508
        throw new AssertionError("The Document used by StyledEditorKits is"
509
                                 + "expected to be a StyledDocument");
510
 
511
      StyledDocument styleDoc = (StyledDocument) doc;
512
      currentRun = styleDoc.getCharacterElement(ev.getDot());
513
      createInputAttributes(currentRun, inputAttributes);
514
    }
515
  }
516
 
517
  /**
518
   * Stores the <code>Element</code> at the current caret position. This
519
   * is updated by {@link CaretTracker}.
520
   */
521
  Element currentRun;
522
 
523
  /**
524
   * The current input attributes. This is updated by {@link CaretTracker}.
525
   */
526
  MutableAttributeSet inputAttributes;
527
 
528
  /**
529
   * The CaretTracker that keeps track of the current input attributes, and
530
   * the current character run Element.
531
   */
532
  CaretTracker caretTracker;
533
 
534
  /**
535
   * The ViewFactory for StyledEditorKits.
536
   */
537
  StyledViewFactory viewFactory;
538
 
539
  /**
540
   * Creates a new instance of <code>StyledEditorKit</code>.
541
   */
542
  public StyledEditorKit()
543
  {
544
    inputAttributes = new SimpleAttributeSet();
545
  }
546
 
547
  /**
548
   * Creates an exact copy of this <code>StyledEditorKit</code>.
549
   *
550
   * @return an exact copy of this <code>StyledEditorKit</code>
551
   */
552
  public Object clone()
553
  {
554
    StyledEditorKit clone = (StyledEditorKit) super.clone();
555
    // FIXME: Investigate which fields must be copied.
556
    return clone;
557
  }
558
 
559
  /**
560
   * Returns the <code>Action</code>s supported by this {@link EditorKit}.
561
   * This includes the {@link BoldAction}, {@link ItalicAction} and
562
   * {@link UnderlineAction} as well as the <code>Action</code>s supported
563
   * by {@link DefaultEditorKit}.
564
   *
565
   * The other <code>Action</code>s of <code>StyledEditorKit</code> are not
566
   * returned here, since they require a parameter and thus custom
567
   * instantiation.
568
   *
569
   * @return the <code>Action</code>s supported by this {@link EditorKit}
570
   */
571
  public Action[] getActions()
572
  {
573
    Action[] actions1 = super.getActions();
574
    Action[] myActions = new Action[] {
575
      new FontSizeAction("font-size-8", 8),
576
      new FontSizeAction("font-size-10", 10),
577
      new FontSizeAction("font-size-12", 12),
578
      new FontSizeAction("font-size-14", 14),
579
      new FontSizeAction("font-size-16", 16),
580
      new FontSizeAction("font-size-18", 18),
581
      new FontSizeAction("font-size-24", 24),
582
      new FontSizeAction("font-size-36", 36),
583
      new FontSizeAction("font-size-48", 48),
584
      new FontFamilyAction("font-family-Serif", "Serif"),
585
      new FontFamilyAction("font-family-Monospaced", "Monospaced"),
586
      new FontFamilyAction("font-family-SansSerif", "SansSerif"),
587
      new AlignmentAction("left-justify", StyleConstants.ALIGN_LEFT),
588
      new AlignmentAction("center-justify", StyleConstants.ALIGN_CENTER),
589
      new AlignmentAction("right-justify", StyleConstants.ALIGN_RIGHT),
590
      new BoldAction(),
591
      new ItalicAction(),
592
      new UnderlineAction()
593
    };
594
    return TextAction.augmentList(actions1, myActions);
595
  }
596
 
597
  /**
598
   * Returns the current input attributes. These are automatically set on
599
   * any newly inserted content, if not specified otherwise.
600
   *
601
   * @return the current input attributes
602
   */
603
  public MutableAttributeSet getInputAttributes()
604
  {
605
    return inputAttributes;
606
  }
607
 
608
  /**
609
   * Returns the {@link Element} that represents the character run at the
610
   * current caret position.
611
   *
612
   * @return the {@link Element} that represents the character run at the
613
   *         current caret position
614
   */
615
  public Element getCharacterAttributeRun()
616
  {
617
    return currentRun;
618
  }
619
 
620
  /**
621
   * Creates the default {@link Document} supported by this
622
   * <code>EditorKit</code>. This is an instance of
623
   * {@link DefaultStyledDocument} in this case but may be overridden by
624
   * subclasses.
625
   *
626
   * @return an instance of <code>DefaultStyledDocument</code>
627
   */
628
  public Document createDefaultDocument()
629
  {
630
    return new DefaultStyledDocument();
631
  }
632
 
633
  /**
634
   * Installs this <code>EditorKit</code> on the specified {@link JEditorPane}.
635
   * This basically involves setting up required listeners on the
636
   * <code>JEditorPane</code>.
637
   *
638
   * @param component the <code>JEditorPane</code> to install this
639
   *        <code>EditorKit</code> on
640
   */
641
  public void install(JEditorPane component)
642
  {
643
    CaretTracker tracker = new CaretTracker();
644
    component.addCaretListener(tracker);
645
  }
646
 
647
  /**
648
   * Deinstalls this <code>EditorKit</code> from the specified
649
   * {@link JEditorPane}. This basically involves removing all listeners from
650
   * <code>JEditorPane</code> that have been set up by this
651
   * <code>EditorKit</code>.
652
   *
653
   * @param component the <code>JEditorPane</code> from which to deinstall this
654
   *        <code>EditorKit</code>
655
   */
656
  public void deinstall(JEditorPane component)
657
  {
658
    CaretTracker t = caretTracker;
659
    if (t != null)
660
      component.removeCaretListener(t);
661
    caretTracker = null;
662
  }
663
 
664
  /**
665
   * Returns a {@link ViewFactory} that is able to create {@link View}s
666
   * for {@link Element}s that are supported by this <code>EditorKit</code>,
667
   * namely the following types of <code>Element</code>s:
668
   *
669
   * <ul>
670
   * <li>{@link AbstractDocument#ContentElementName}</li>
671
   * <li>{@link AbstractDocument#ParagraphElementName}</li>
672
   * <li>{@link AbstractDocument#SectionElementName}</li>
673
   * <li>{@link StyleConstants#ComponentElementName}</li>
674
   * <li>{@link StyleConstants#IconElementName}</li>
675
   * </ul>
676
   *
677
   * @return a {@link ViewFactory} that is able to create {@link View}s
678
   *          for {@link Element}s that are supported by this <code>EditorKit</code>
679
   */
680
  public ViewFactory getViewFactory()
681
  {
682
    if (viewFactory == null)
683
      viewFactory = new StyledViewFactory();
684
    return viewFactory;
685
  }
686
 
687
  /**
688
   * Copies the text attributes from <code>element</code> to <code>set</code>.
689
   * This is called everytime when the caret position changes to keep
690
   * track of the current input attributes. The attributes in <code>set</code>
691
   * are cleaned before adding the attributes of <code>element</code>.
692
   *
693
   * This method filters out attributes for element names, <code>Icon</code>s
694
   * and <code>Component</code>s.
695
   *
696
   * @param element the <code>Element</code> from which to copy the text
697
   *         attributes
698
   * @param set the inputAttributes to copy the attributes to
699
   */
700
  protected void createInputAttributes(Element element,
701
                                       MutableAttributeSet set)
702
  {
703
    // FIXME: Filter out component, icon and element name attributes.
704
    set.removeAttributes(set);
705
    set.addAttributes(element.getAttributes());
706
  }
707
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.