net/systemeD/halcyon/MapPaint.as

   1 package net.systemeD.halcyon {
   2
   3         import flash.display.Sprite;
   4         import flash.display.DisplayObject;
   5         import net.systemeD.halcyon.NodeUI;
   6         import net.systemeD.halcyon.WayUI;
   7         import net.systemeD.halcyon.connection.Node;
   8         import net.systemeD.halcyon.connection.Way;
   9         import net.systemeD.halcyon.styleparser.RuleSet;
  10         import net.systemeD.halcyon.Globals;
  11
  12     public class MapPaint extends Sprite {
  13
  14                 public var map:Map;
  15                 public var minlayer:int;
  16                 public var maxlayer:int;
  17                 public var ruleset:RuleSet;                                             // rules
  18                 public var wayuis:Object=new Object();                  // sprites for ways and (POI/tagged) nodes
  19                 public var nodeuis:Object=new Object();                 //  |
  20                 public var isBackground:Boolean = true;                 // is it a background layer or the core paint object?
  21                 public var sublayerIndex:Object={};                             // hash of index->position
  22
  23                 private const VERYBIG:Number=Math.pow(2,16);
  24
  25                 // Set up layering
  26
  27                 public function MapPaint(map:Map,minlayer:int,maxlayer:int) {
  28                         mouseEnabled=false;
  29
  30                         this.map=map;
  31                         this.minlayer=minlayer;
  32                         this.maxlayer=maxlayer;
  33                         sublayerIndex[1]=0;
  34                         var s:Sprite, l:int;
  35
  36                         // Add paint sprites
  37                         for (l=minlayer; l<=maxlayer; l++) {                    // each layer (10 is +5, 0 is -5)
  38                                 s = getPaintSprite();                                           //  |
  39                                 s.addChild(getPaintSprite());                           //      | 0 fill
  40                                 s.addChild(getPaintSprite());                           //      | 1 casing
  41                                 var t:Sprite = getPaintSprite();                        //  | 2 stroke
  42                                 t.addChild(getPaintSprite());                           //  |  | sublayer
  43                                 s.addChild(t);                                                          //  |  |
  44                                 s.addChild(getPaintSprite());                           //      | 3 names
  45                                 addChild(s);                                                            //  |
  46                         }
  47
  48                         // Add hit sprites
  49                         for (l=minlayer; l<=maxlayer; l++) {                    // each layer (21 is +5, 11 is -5)
  50                                 s = getHitSprite();                                                     //  |
  51                                 s.addChild(getHitSprite());                                     //      | 0 way hit tests
  52                                 s.addChild(getHitSprite());                                 //  | 1 node hit tests
  53                                 addChild(s);
  54                         }
  55                 }
  56
  57                 public function getPaintSpriteAt(l:int):Sprite {
  58                         return getChildAt(l-minlayer) as Sprite;
  59                 }
  60
  61                 public function getHitSpriteAt(l:int):Sprite {
  62                         return getChildAt((l-minlayer) + (maxlayer-minlayer+1)) as Sprite;
  63                 }
  64
  65                 public function get ready():Boolean {
  66                         if (!ruleset) { return false; }
  67                         if (!ruleset.loaded) { return false; }
  68                         return true;
  69                 }
  70
  71                 public function sublayer(layer:int,sublayer:Number):Sprite {
  72                         var l:DisplayObject;
  73                         var o:DisplayObject;
  74                         var index:String, ix:Number;
  75                         if (!sublayerIndex.hasOwnProperty(sublayer)) {
  76                                 // work out which position to add at
  77                                 var lowestAbove:Number=VERYBIG;
  78                                 var lowestAbovePos:int=-1;
  79                                 var indexLength:uint=0;
  80                                 for (index in sublayerIndex) {
  81                                         ix=Number(index);
  82                                         if (ix>sublayer && ix<lowestAbove) {
  83                                                 lowestAbove=ix;
  84                                                 lowestAbovePos=sublayerIndex[index];
  85                                         }
  86                                         indexLength++;
  87                                 }
  88                                 if (lowestAbovePos==-1) { lowestAbovePos=indexLength; }
  89
  90                                 // add sprites
  91                                 for (var i:int=minlayer; i<=maxlayer; i++) {
  92                                         l=getChildAt(i-minlayer);
  93                                         o=(l as Sprite).getChildAt(2);
  94                                         (o as Sprite).addChildAt(getPaintSprite(),lowestAbovePos);
  95                                 }
  96
  97                                 // update index
  98                                 // (we do it in this rather indirect way because if you alter sublayerIndex directly
  99                                 //  within the loop, it confuses the iterator)
 100                                 var toUpdate:Array=[];
 101                                 for (index in sublayerIndex) {
 102                                         ix=Number(index);
 103                                         if (ix>sublayer) { toUpdate.push(index); }
 104                                 }
 105                                 for each (index in toUpdate) { sublayerIndex[index]++; }
 106                                 sublayerIndex[sublayer]=lowestAbovePos;
 107                         }
 108
 109                         l=getChildAt(layer-minlayer);
 110                         o=(l as Sprite).getChildAt(2);
 111                         return ((o as Sprite).getChildAt(sublayerIndex[sublayer]) as Sprite);
 112                 }
 113
 114                 public function updateEntityUIs(o:Object, redraw:Boolean, remove:Boolean):void {
 115                         var way:Way, node:Node;
 116
 117                         for each (way in o.waysInside) {
 118                                 if (!wayuis[way.id]) { createWayUI(way); }
 119                                 else if (redraw) { wayuis[way.id].recalculate(); wayuis[way.id].redraw(); }
 120                         }
 121
 122                         if (remove) {
 123                                 for each (way in o.waysOutside) {
 124                                         if (wayuis[way.id] && !wayuis[way.id].purgable) {
 125                                                 if (redraw) { wayuis[way.id].recalculate(); wayuis[way.id].redraw(); }
 126                                         } else {
 127                                                 deleteWayUI(way);
 128                                         }
 129                                 }
 130                         }
 131
 132                         for each (node in o.nodesInside) {
 133                                 if (!nodeuis[node.id]) { createNodeUI(node); }
 134                                 else if (redraw) { nodeuis[node.id].redraw(); }
 135                         }
 136
 137                         if (remove) {
 138                                 for each (node in o.nodesOutside) {
 139                                         if (nodeuis[node.id] && !nodeuis[node.id].purgable) {
 140                                                 if (redraw) { nodeuis[node.id].redraw(); }
 141                                         } else {
 142                                                 deleteNodeUI(node);
 143                                         }
 144                                 }
 145                         }
 146                 }
 147
 148                 public function createWayUI(way:Way):WayUI {
 149                         if (!wayuis[way.id]) { wayuis[way.id]=new WayUI(way,this); }
 150                         return wayuis[way.id];
 151                 }
 152
 153         public function createNodeUI(node:Node):NodeUI {
 154             if (!nodeuis[node.id]) {
 155               nodeuis[node.id]=new NodeUI(node,this,0);
 156             } else {
 157               nodeuis[node.id].redraw();
 158             }
 159             return nodeuis[node.id];
 160         }
 161
 162                 public function deleteWayUI(way:Way):void {
 163                         if (!wayuis[way.id]) { return; }
 164                         wayuis[way.id].removeSprites();
 165                         delete wayuis[way.id];
 166                         for (var i:uint=0; i<way.length; i++) {
 167                                 var node:Node=way.getNode(i);
 168                                 if (nodeuis[node.id]) { deleteNodeUI(node); }
 169                         }
 170                 }
 171
 172                 public function deleteNodeUI(node:Node):void {
 173                         if (!nodeuis[node.id]) { return; }
 174                         if (!nodeuis[node.id].purgable) { return; }
 175                         nodeuis[node.id].removeSprites();
 176                         delete nodeuis[node.id];
 177                 }
 178
 179                 public function renumberWayUI(way:Way,oldID:Number):void {
 180                         if (!wayuis[oldID]) { return; }
 181                         wayuis[way.id]=wayuis[oldID];
 182                         delete wayuis[oldID];
 183                 }
 184
 185                 public function renumberNodeUI(node:Node,oldID:Number):void {
 186                         if (!nodeuis[oldID]) { return; }
 187                         nodeuis[node.id]=nodeuis[oldID];
 188                         delete nodeuis[oldID];
 189                 }
 190
 191         private function getPaintSprite():Sprite {
 192             var s:Sprite = new Sprite();
 193             s.mouseEnabled = false;
 194             s.mouseChildren = false;
 195             return s;
 196         }
 197
 198         private function getHitSprite():Sprite {
 199             var s:Sprite = new Sprite();
 200             return s;
 201         }
 202
 203                 public function redraw():void {
 204                         for each (var w:WayUI in wayuis) { w.recalculate(); w.invalidateStyleList(); w.redraw(); }
 205             /* sometimes (e.g. in Map.setStyle) Mappaint.redrawPOIs() is called immediately afterwards anyway. FIXME? */
 206                         for each (var p:NodeUI in nodeuis) { p.invalidateStyleList(); p.redraw(); }
 207                 }
 208
 209                 public function redrawPOIs():void {
 210                         for each (var p:NodeUI in nodeuis) { p.invalidateStyleList(); p.redraw(); }
 211                 }
 212
 213                 public function findSource():VectorLayer {
 214                         var v:VectorLayer;
 215                         for each (v in map.vectorlayers) {
 216                                 if (v.paint==this) { return v; }
 217                         }
 218                         return null;
 219                 }
 220         }
 221 }