Add keys to Feature tags while parsing inputSets - better list of keys for autocomplete
[potlatch2.git] / net / systemeD / potlatch2 / mapfeatures / Feature.as
1 package net.systemeD.potlatch2.mapfeatures {
2
3     import flash.events.EventDispatcher;
4     import flash.events.Event;
5     import flash.net.*;
6     import flash.utils.ByteArray;
7     import mx.core.BitmapAsset;
8     import mx.graphics.codec.PNGEncoder;
9
10     import net.systemeD.halcyon.connection.Entity;
11     import net.systemeD.potlatch2.utils.CachedDataLoader;
12
13         /** A "map feature" is sort of a template for a map entity. It consists of a few crucial key/value pairs that define the feature, so that
14          * entities can be recognised. It also contains optional keys, with associated editing controls, that are defined as being appropriate
15          * for the feature. */
16         public class Feature extends EventDispatcher {
17         private var mapFeatures:MapFeatures;
18         private var _xml:XML;
19         private static var variablesPattern:RegExp = /[$][{]([^}]+)[}]/g;
20         private var _tags:Array;
21         private var _withins:Array;
22         private var _editors:Array;
23
24         [Embed(source="../../../../embedded/missing_icon.png")]
25         [Bindable]
26         public var missingIconCls:Class;
27
28
29         public function Feature(mapFeatures:MapFeatures, _xml:XML) {
30             this.mapFeatures = mapFeatures;
31             this._xml = _xml;
32             parseConditions();
33             parseEditors();
34         }
35
36         private function parseConditions():void {
37             _tags = [];
38            _withins = [];
39
40                         // parse tags
41             for each(var tag:XML in definition.tag) {
42                 _tags.push( { k:String(tag.@k), v:String(tag.@v)} );
43             }
44
45                         // parse 'within'
46             for each(var within:XML in definition.within) {
47                                 var obj:Object= { entity:within.@entity, k:within.@k };
48                                 if (within.attribute('v'      ).length()>0) { obj['v'      ]=within.@v;       }
49                                 if (within.attribute('minimum').length()>0) { obj['minimum']=within.@minimum; }
50                                 if (within.attribute('role'   ).length()>0) { obj['role'   ]=within.@role;    }
51                 _withins.push(obj);
52             }
53         }
54
55         private function parseEditors():void {
56             _editors = new Array();
57
58             addEditors(definition);
59
60             _editors.sortOn(["sortOrder", "name"], [Array.DESCENDING | Array.NUMERIC, Array.CASEINSENSITIVE]);
61         }
62
63         private function addEditors(xml:XML):void {
64             var inputXML:XML;
65
66             for each(var inputSetRef:XML in xml.inputSet) {
67                 var setName:String = String(inputSetRef.@ref);
68                 for each (inputXML in mapFeatures.definition.inputSet.(@id==setName)) {
69                     addEditors(inputXML);
70                 }
71             }
72
73             for each(inputXML in xml.input) {
74                 addEditor(inputXML);
75             }
76         }
77
78         private function addEditor(inputXML:XML):void {
79             var inputType:String = inputXML.@type;
80             var presenceStr:String = inputXML.@presence;
81             var sortOrderStr:String = inputXML.@priority;
82             _tags.push( { k:String(inputXML.@key) } ); /* add the key to tags so that e.g. addr:housenumber shows up on autocomplete */
83             var editor:EditorFactory = EditorFactory.createFactory(inputType, inputXML);
84             if ( editor != null ) {
85                 editor.presence = Presence.getPresence(presenceStr);
86                 editor.sortOrder = EditorFactory.getPriority(sortOrderStr);
87                 _editors.push(editor);
88             }
89         }
90
91         /** List of editing controls associated with this feature. */
92         public function get editors():Array {
93             return _editors;
94         }
95
96         /** The XML subtree that this feature was loaded from. */
97         public function get definition():XML {
98             return _xml;
99         }
100
101         [Bindable(event="nameChanged")]
102         /** The human-readable name of the feature, or null if none. */
103         public function get name():String {
104                         if (_xml.attribute('name').length()>0) { return _xml.@name; }
105                         return null;
106         }
107
108         [Bindable(event="imageChanged")]
109         /** An icon for the feature. If none is defined, return default "missing icon". */
110         public function get image():ByteArray {
111             var icon:XMLList = _xml.icon;
112             var imageURL:String = null;
113             var img:ByteArray;
114
115             if ( icon.length() > 0 && icon[0].hasOwnProperty("@image") )
116                 imageURL = icon[0].@image;
117
118             if ( imageURL != null ) {
119                 img = CachedDataLoader.loadData(imageURL, imageLoaded);
120             }
121             if (img) {
122               return img;
123             }
124             var bitmap:BitmapAsset = new missingIconCls() as BitmapAsset;
125             return new PNGEncoder().encode(bitmap.bitmapData);
126         }
127
128         private function imageLoaded(url:String, data:ByteArray):void {
129             dispatchEvent(new Event("imageChanged"));
130         }
131
132         public function htmlDetails(entity:Entity):String {
133             var icon:XMLList = _xml.icon;
134             return makeHTMLIcon(icon, entity);
135         }
136
137         public static function makeHTMLIcon(icon:XMLList, entity:Entity):String {
138             if ( icon == null )
139                 return "";
140
141             var txt:String = icon.children().toXMLString();
142             var replaceTag:Function = function():String {
143                 var value:String = entity.getTag(arguments[1]);
144                 return value == null ? "" : htmlEscape(value);
145             };
146             txt = txt.replace(variablesPattern, replaceTag);
147             return txt;
148         }
149
150         public static function htmlEscape(str:String):String {
151             var newStr:String = str.replace(/&/g, "&");
152             newStr = newStr.replace(/</g, "&lt;");
153             newStr = newStr.replace(/>/g, "&gt;");
154             newStr = newStr.replace(/"/g, "&quot;");    // "
155             newStr = newStr.replace(/'/g, "&apos;");    // '
156             return newStr;
157         }
158
159         /** Whether this feature belongs to the given category or not, as defined by its definition in the XML file. */
160         public function isInCategory(category:String):Boolean {
161             var cats:XMLList = _xml.category;
162             if ( cats.length() == 0 )
163                 return false;
164
165             for each( var cat:XML in cats )
166                 if ( cat.text()[0] == category )
167                     return true;
168             return false;
169         }
170
171
172         /** List of {k, v} pairs that define the feature. */
173         public function get tags():Array {
174             return _tags;
175         }
176
177         /** List of "withins" which further restrict the applicability of the feature. Each within is a {entity, k, ?v, ?minimum, ?role} object. */
178         public function get withins():Array {
179             return _withins;
180         }
181
182         /** The first category that the feature belongs to, as defined by the order of the map features XML file. */
183         public function findFirstCategory():Category {
184             for each( var cat:Category in mapFeatures.categories ) {
185                 if ( isInCategory(cat.id) )
186                     return cat;
187             }
188             return null;
189         }
190
191         /** Whether the feature is of the given type (point, line/area, relation). */
192         public function isType(type:String):Boolean {
193             if (type=='area') {
194                             return (_xml.elements(type).length() > 0) || (_xml.elements('line').length() > 0);
195             } else {
196                             return _xml.elements(type).length() > 0;
197                         }
198         }
199
200         /** Whether there is a help string defined. */
201         public function hasHelpURL():Boolean {
202             return _xml.help.length() > 0;
203         }
204
205         /** The defined help string, if any. */
206         public function get helpURL():String {
207             return _xml.help;
208         }
209     }
210 }
211