|
STreeNode |
|
1 /* 2 * STreeNode.java 3 * 4 * Copyright (c) 1998-2001, The University of Sheffield. 5 * 6 * This file is part of GATE (see http://gate.ac.uk/), and is free 7 * software, licenced under the GNU Library General Public License, 8 * Version 2, June 1991 (in the distribution as file licence.html, 9 * and also available at http://gate.ac.uk/gate/licence.html). 10 * 11 * Kalina Bontcheva, 07/08/2001 12 * 13 * $Id: STreeNode.java,v 1.10 2001/12/03 14:04:04 kalina Exp $ 14 */ 15 16 package gate.gui; 17 18 import javax.swing.tree.*; 19 20 import java.awt.Rectangle; 21 22 import java.util.*; 23 24 25 import gate.*; 26 import gate.util.*; 27 28 29 public class STreeNode extends DefaultMutableTreeNode { 30 31 /** Debug flag */ 32 private static final boolean DEBUG = false; 33 private static final String ADDEDSET = "TreeViewerTempAdded"; 34 private static final String REMOVEDSET = "TreeViewerTempRemoved"; 35 36 static int nextID = 0; 37 38 int level; // level in the syntax tree 39 int nodeID; //ID of the node 40 41 long start, end; //the start and end nodes for this annotation 42 Annotation annot; //the annotation that's created during import/export 43 //not to be used otherwise. During import span is set to 44 //be the same as the annotation span. During export the 45 //annotation span is set to be the same as the span. 46 47 public STreeNode(Annotation annot) { 48 level = -1; 49 nodeID = nextID++; 50 //span = annot.getSpans().getElementAt(0); 51 //get the first span, there should be no others 52 this.annot = annot; 53 }// public STreeNode(Annotation annot) 54 55 public STreeNode(long start, long end) { 56 level = -1; 57 nodeID = nextID++; 58 this.start = start; 59 this.end = end; 60 }// public STreeNode(int start, int end) 61 62 public STreeNode() { 63 level = -1; 64 nodeID = nextID++; 65 start = 0; 66 end = 0; 67 }// public STreeNode() 68 69 public int getLevel() { 70 return level; 71 }// public int getLevel() 72 73 public void setLevel(long level) { 74 this.level = (int) level; 75 }// public void setLevel(int level) 76 77 public void setLevel(int level) { 78 this.level = level; 79 }// public void setLevel(int level) 80 81 public int getID() { 82 return nodeID; 83 }// public int getID() 84 85 public long getStart() { 86 return start; 87 }// public int getStart() 88 89 public void setStart(long start) { 90 this.start = start; 91 }// public void setStart(int start) 92 93 public long getEnd() { 94 return end; 95 }// public int getEnd() 96 97 public void setEnd(long end) { 98 this.end = end; 99 }// public void setEnd(int end) 100 101 /** 102 * This also sets the span to match the annotation span! 103 */ 104 public void setAnnotation(Annotation annot) { 105 this.annot = annot; 106 this.start = annot.getStartNode().getOffset().longValue(); 107 this.end = annot.getEndNode().getOffset().longValue(); 108 }// public void setAnnotation(Annotation annot) 109 110 public Annotation getAnnotation() { 111 return annot; 112 }// public Annotation getAnnotation() 113 114 public void disconnectChildren() { 115 for (Iterator i = this.children.iterator(); i.hasNext(); ) 116 ((STreeNode) i.next()).setParent(null); 117 this.children.clear(); 118 }// public void disconnectChildren() 119 120 /** 121 * Creates an annotation of the given type. If the children don't have their 122 * annotation objects created, it creates them and assigns the pointers. 123 * Expects the text string relative to which all offsets were created! 124 */ 125 public boolean createAnnotation(Document doc, String type, 126 String text, long utteranceOffset) { 127 boolean created = false; 128 129 if (annot != null ) 130 return false; 131 132 //no document, so cannot add annotations 133 if (doc == null) 134 return false; 135 136 // check if it has children. If it hasn't then it shouldn't have an 137 // annotation because all our leaf nodes are actually just words 138 // from the text (e.g. "this", "that"). Their categories are always 139 // encoded as non-terminal nodes. 140 if ( ! this.getAllowsChildren()) 141 return false; 142 143 FeatureMap attribs = Factory.newFeatureMap(); 144 // the text spanned by the annotation is stored as the userObject of the 145 // tree node 146 // comes from the default Swing tree node 147 List consists = new ArrayList(); 148 149 attribs.put("text", 150 text.substring( (int) (start - utteranceOffset), 151 (int) (end - utteranceOffset) ) 152 ); 153 attribs.put("cat", (String) this.getUserObject()); 154 attribs.put("consists", consists); 155 156 // children comes from DefaultMutableTreeNode 157 for (Iterator i = children.iterator(); i.hasNext(); ) { 158 STreeNode child = (STreeNode) i.next(); 159 if (child.getAnnotation() == null) { 160 if (child.getAllowsChildren()) 161 if (createAnnotation(doc, type, text, utteranceOffset)) 162 consists.add(child.getAnnotation().getId()); 163 } else 164 consists.add(child.getAnnotation().getId()); 165 } 166 167 //!!! Need to account for the name of the Annot Set 168 AnnotationSet theSet = doc.getAnnotations(ADDEDSET); 169 try { 170 Integer Id = theSet.add(new Long(start), new Long(end), type, attribs); 171 this.annot = theSet.get(Id); 172 created = true; 173 } catch (InvalidOffsetException ex) { 174 Out.println("Invalid annotation offsets: " 175 + start + " and/or " + end); 176 created = false; 177 } 178 179 return created; 180 }// public boolean createAnnotation 181 182 183 /** 184 * Transfers the annotations from added to the given annotation set 185 * Also, for each annotation in removed, removes it from the given annotation set 186 * Called by OkAction() in the treeViewer to finalise the changes. 187 */ 188 public static boolean transferAnnotations(Document doc, AnnotationSet targetAS) { 189 if (doc == null || targetAS == null) 190 return false; 191 192 AnnotationSet addedSet = doc.getAnnotations(ADDEDSET); 193 if (addedSet != null && !addedSet.isEmpty()) { 194 targetAS.addAll(addedSet); 195 addedSet.clear(); 196 } 197 doc.removeAnnotationSet(ADDEDSET); 198 199 AnnotationSet removedSet = doc.getAnnotations(REMOVEDSET); 200 if (removedSet != null && ! removedSet.isEmpty()) { 201 targetAS.removeAll(removedSet); 202 removedSet.clear(); 203 } 204 doc.removeAnnotationSet(REMOVEDSET); 205 206 return true; 207 } 208 209 public static void undo(Document doc) { 210 AnnotationSet addedSet = doc.getAnnotations(ADDEDSET); 211 AnnotationSet removedSet = doc.getAnnotations(REMOVEDSET); 212 addedSet.clear(); 213 removedSet.clear(); 214 doc.removeAnnotationSet(ADDEDSET); 215 doc.removeAnnotationSet(REMOVEDSET); 216 } 217 218 /** Store the annotation in the deleted list so it can retrieved later */ 219 public void removeAnnotation(Document doc) { 220 if (this.annot == null || doc == null) 221 return; 222 223 doc.getAnnotations(REMOVEDSET).add(this.annot); 224 225 this.annot = null; 226 }// public void removeAnnotation(Document doc) 227 228 } // STreeNode 229 230 // $Log: STreeNode.java,v $ 231 // Revision 1.10 2001/12/03 14:04:04 kalina 232 // code cleanup in STreeNode.java 233 // 234 // Revision 1.9 2001/08/07 19:03:05 kalina 235 // Made the tree viewer use Token annotations to break the sentence for annotation 236 // 237 // Revision 1.8 2001/08/07 17:01:32 kalina 238 // Changed the AVR implementing classes in line with the updated AVR 239 // API (cancelAction() and setSpan new parameter). 240 // 241 // Also updated the TreeViewer, so now it can be used to edit and view 242 // Sentence annotations and the SyntaxTreeNodes associated with them. 243 // So if you have trees, it'll show them, if not, it'll help you build them. 244 // 245 // Revision 1.7 2001/04/09 10:36:36 oana 246 // a few changes in the code style 247 // 248 // Revision 1.6 2000/11/08 16:35:00 hamish 249 // formatting 250 // 251 // Revision 1.5 2000/10/26 10:45:25 oana 252 // Modified in the code style 253 // 254 // Revision 1.4 2000/10/18 13:26:47 hamish 255 // Factory.createResource now working, with a utility method that uses 256 // reflection (via java.beans.Introspector) to set properties on a resource 257 // from the 258 // parameter list fed to createResource. 259 // resources may now have both an interface and a class; they are indexed 260 // by interface type; the class is used to instantiate them 261 // moved createResource from CR to Factory 262 // removed Transients; use Factory instead 263 // 264 // Revision 1.3 2000/10/16 16:44:32 oana 265 // Changed the comment of DEBUG variable 266 // 267 // Revision 1.2 2000/10/10 15:36:34 oana 268 // Changed System.out in Out and System.err in Err; 269 // Added the DEBUG variable seted on false; 270 // Added in the header the licence; 271 // 272 // Revision 1.1 2000/09/20 17:03:37 kalina 273 // Added the tree viewer from the prototype. It works now with the new 274 // annotation API. 275 // 276 // Revision 1.6 1999/08/23 14:13:38 kalina 277 // Fixed resizing bugs in tree viewers 278 // 279 // Revision 1.5 1999/08/20 21:11:56 kalina 280 // Fixed most bugs and TreeViewer can now import and export annotations 281 // correctly 282 // There is still a delete bug somewhere. 283 // 284 // Revision 1.4 1999/08/18 17:55:24 kalina 285 // Added annotation export for the TreeViewer. Annotation import is the only 286 // thing that remains. 287 // 288 // Revision 1.3 1999/08/13 17:56:31 kalina 289 // Fixed the annotation of nodes in the TreeViewer to be done with click 290 // 291 // Revision 1.2 1999/08/12 16:10:12 kalina 292 // Added a new tree stereotype. Not in final version but would do for testing. 293 // 294 // Improved the tree viewer to allow dynamic creation of all nodes. 295 // Now I can build many trees or one tree; can delete non-terminal nodes; 296 // select/unselect nodes for annotation 297 // Overlapping trees are not a big problem too :-) Not wonderfully drawn but 298 // would do. 299 // 300 // Revision 1.1 1999/08/09 18:00:53 kalina 301 // Made the tree viewer to display an utterance/sentence annotation to start annotating them 302 // 303
|
STreeNode |
|