bundles/org.simantics.g2d/src/org/simantics/g2d/elementclass/operationsymbols/OperationClasses.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.g2d.elementclass.operationsymbols;\r
  13 \r
  14 import java.awt.Color;\r
  15 import java.awt.geom.AffineTransform;\r
  16 import java.awt.geom.Rectangle2D;\r
  17 \r
  18 import org.simantics.g2d.diagram.handler.Topology.Terminal;\r
  19 import org.simantics.g2d.element.ElementClass;\r
  20 import org.simantics.g2d.element.ElementUtils;\r
  21 import org.simantics.g2d.element.IElement;\r
  22 import org.simantics.g2d.element.SceneGraphNodeKey;\r
  23 import org.simantics.g2d.element.handler.AdditionalColor;\r
  24 import org.simantics.g2d.element.handler.BorderColor;\r
  25 import org.simantics.g2d.element.handler.Clickable;\r
  26 import org.simantics.g2d.element.handler.Clickable.PressStatus;\r
  27 import org.simantics.g2d.element.handler.FillColor;\r
  28 import org.simantics.g2d.element.handler.SceneGraph;\r
  29 import org.simantics.g2d.element.handler.impl.AdditionalColorImpl;\r
  30 import org.simantics.g2d.element.handler.impl.BorderColorImpl;\r
  31 import org.simantics.g2d.element.handler.impl.DefaultTransform;\r
  32 import org.simantics.g2d.element.handler.impl.FillColorImpl;\r
  33 import org.simantics.g2d.element.handler.impl.FixedSize;\r
  34 import org.simantics.g2d.element.handler.impl.Resizeable;\r
  35 import org.simantics.g2d.element.handler.impl.StaticTerminals;\r
  36 import org.simantics.g2d.element.handler.impl.TerminalImpl;\r
  37 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.BoilerSymbol;\r
  38 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.BoilerSymbol2;\r
  39 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.ChimneySymbol;\r
  40 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.CompressorSymbol;\r
  41 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.ControlValveSymbol;\r
  42 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.GeneratorSymbol;\r
  43 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.HeatExchangerSymbol;\r
  44 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.NoSpinSymbol;\r
  45 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.PumpSymbol;\r
  46 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.ShutoffValveSymbol;\r
  47 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.SwitchSymbol;\r
  48 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.Tank2Symbol;\r
  49 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.TankSymbol;\r
  50 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.ThreeWayValveSymbol;\r
  51 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.TurbineSymbol;\r
  52 import org.simantics.g2d.elementclass.operationsymbols.OperationSymbols.VoltageTransformerSymbol;\r
  53 import org.simantics.g2d.image.Image;\r
  54 import org.simantics.g2d.utils.geom.DirectionSet;\r
  55 import org.simantics.scenegraph.Node;\r
  56 import org.simantics.scenegraph.g2d.G2DParentNode;\r
  57 import org.simantics.utils.datastructures.hints.IHintContext.Key;\r
  58 \r
  59 /**\r
  60  * Operation symbol handlers.\r
  61  * \r
  62  * @author Toni Kalajainen\r
  63  */\r
  64 public class OperationClasses {\r
  65     \r
  66         static final FillColor FILL_COLOR_HANDLER = FillColorImpl.handlerOf(Color.WHITE);\r
  67         static final BorderColor BORDER_COLOR_HANDLER = BorderColorImpl.handlerOf(Color.BLACK);\r
  68         static final AdditionalColor ADDITIONAL_COLOR_HANDLER = AdditionalColorImpl.handlerOf(Color.GREEN);\r
  69         \r
  70         public static final Terminal TERMINAL_IN = new TerminalImpl(); \r
  71         public static final Terminal TERMINAL_OUT = new TerminalImpl(); \r
  72         \r
  73         public static ElementClass BOILER_CLASS =\r
  74                 ElementClass.compile(\r
  75                                 DefaultTransform.INSTANCE,\r
  76                                 BoilerPaint.INSTANCE,\r
  77                                 FILL_COLOR_HANDLER,\r
  78                                 BORDER_COLOR_HANDLER,\r
  79                                 FixedSize.of(-10, 0, 20, 125),\r
  80                                 StaticTerminals.compile(\r
  81                                                 TERMINAL_IN,    0.0, -BoilerSymbol.DIM*3, DirectionSet.N,\r
  82                                                 TERMINAL_OUT,   0.0,  BoilerSymbol.DIM*3, DirectionSet.S\r
  83                                                 )\r
  84                                 );\r
  85         public static ElementClass BOILER_BUTTON_CLASS =\r
  86                 ElementClass.compile(\r
  87                                 Clickable.INSTANCE,\r
  88                                 DefaultTransform.INSTANCE,\r
  89                                 BoilerPaint.INSTANCE,\r
  90                                 FILL_COLOR_HANDLER,\r
  91                                 BORDER_COLOR_HANDLER,\r
  92                                 FixedSize.of(-10, 0, 20, 125),\r
  93                                 StaticTerminals.compile(\r
  94                                                 TERMINAL_IN,    0.0, -BoilerSymbol.DIM*3, DirectionSet.N,\r
  95                                                 TERMINAL_OUT,   0.0,  BoilerSymbol.DIM*3, DirectionSet.S\r
  96                                                 )\r
  97                                 );\r
  98         public static ElementClass NO_SPIN_CLASS =\r
  99                 ElementClass.compile(\r
 100                                 DefaultTransform.INSTANCE,\r
 101                                 NoSpinPaint.INSTANCE,\r
 102                                 FILL_COLOR_HANDLER,\r
 103                                 BORDER_COLOR_HANDLER,\r
 104                                 FixedSize.of(NoSpinSymbol.BOUNDS),\r
 105                                 StaticTerminals.compile(\r
 106                                                 TERMINAL_IN,    0.0, 0.0, DirectionSet.NESW\r
 107                                                 )                               \r
 108                                 );\r
 109         public static ElementClass NO_SPIN_BUTTON_CLASS =\r
 110                 ElementClass.compile(\r
 111                                 Clickable.INSTANCE,\r
 112                                 DefaultTransform.INSTANCE,\r
 113                                 NoSpinPaint.INSTANCE,\r
 114                                 FILL_COLOR_HANDLER,\r
 115                                 BORDER_COLOR_HANDLER,\r
 116                                 FixedSize.of(NoSpinSymbol.BOUNDS),\r
 117                                 StaticTerminals.compile(\r
 118                                                 TERMINAL_IN,    0.0, 0.0, DirectionSet.NESW\r
 119                                                 )                               \r
 120                                 );                      \r
 121         public static ElementClass COMPRESSOR_CLASS =\r
 122                 ElementClass.compile(\r
 123                                 DefaultTransform.INSTANCE,\r
 124                                 CompressorPaint.INSTANCE,\r
 125                                 FILL_COLOR_HANDLER,\r
 126                                 BORDER_COLOR_HANDLER,\r
 127                                 FixedSize.of(CompressorSymbol.BOUNDS),\r
 128                                 StaticTerminals.compile(\r
 129                                                 TERMINAL_IN,    0.0, 0.0, DirectionSet.NESW\r
 130                                                 )                               \r
 131                                 );\r
 132         public static ElementClass COMPRESSOR_BUTTON_CLASS =\r
 133                 ElementClass.compile(\r
 134                                 Clickable.INSTANCE,\r
 135                                 DefaultTransform.INSTANCE,\r
 136                                 CompressorPaint.INSTANCE,\r
 137                                 FILL_COLOR_HANDLER,\r
 138                                 BORDER_COLOR_HANDLER,\r
 139                                 FixedSize.of(CompressorSymbol.BOUNDS),\r
 140                                 StaticTerminals.compile(\r
 141                                                 TERMINAL_IN,    0.0, 0.0, DirectionSet.NESW\r
 142                                                 )                               \r
 143                                 );              \r
 144         public static ElementClass CONTROLVALVE_CLASS =\r
 145                 ElementClass.compile(\r
 146                                 DefaultTransform.INSTANCE,\r
 147                                 ControlValvePaint.INSTANCE,\r
 148                                 FILL_COLOR_HANDLER,\r
 149                                 BORDER_COLOR_HANDLER,\r
 150                                 FixedSize.of(ControlValveSymbol.BOUNDS),                                \r
 151                                 StaticTerminals.compile(\r
 152                                                 TERMINAL_IN,    -ControlValveSymbol.D, 0.0, DirectionSet.N,\r
 153                                                 TERMINAL_OUT,    ControlValveSymbol.D, 0.0, DirectionSet.S\r
 154                                                 )                               \r
 155                                 );      \r
 156         public static ElementClass CONTROLVALVE_BUTTON_CLASS =\r
 157                 ElementClass.compile(\r
 158                                 Clickable.INSTANCE,\r
 159                                 DefaultTransform.INSTANCE,\r
 160                                 ControlValvePaint.INSTANCE,\r
 161                                 FILL_COLOR_HANDLER,\r
 162                                 BORDER_COLOR_HANDLER,\r
 163                                 FixedSize.of(ControlValveSymbol.BOUNDS),                                \r
 164                                 StaticTerminals.compile(\r
 165                                                 TERMINAL_IN,    -ControlValveSymbol.D, 0.0, DirectionSet.N,\r
 166                                                 TERMINAL_OUT,    ControlValveSymbol.D, 0.0, DirectionSet.S\r
 167                                                 )                               \r
 168                                 );              \r
 169         public static ElementClass THREEWAYVALVE_CLASS =\r
 170                 ElementClass.compile(\r
 171                                 DefaultTransform.INSTANCE,\r
 172                                 ThreeWayValvePaint.INSTANCE,\r
 173                                 FILL_COLOR_HANDLER,\r
 174                                 BORDER_COLOR_HANDLER,\r
 175                                 FixedSize.of(ControlValveSymbol.BOUNDS),                                \r
 176                                 StaticTerminals.compile(\r
 177                                                 TERMINAL_IN,    -ThreeWayValveSymbol.D, 0.0, DirectionSet.N,\r
 178                                                 TERMINAL_OUT,    ThreeWayValveSymbol.D, 0.0, DirectionSet.S\r
 179                                                 )                               \r
 180                                 );      \r
 181         public static ElementClass THREEWAYVALVE_BUTTON_CLASS =\r
 182                 ElementClass.compile(\r
 183                                 Clickable.INSTANCE,\r
 184                                 DefaultTransform.INSTANCE,\r
 185                                 ThreeWayValvePaint.INSTANCE,\r
 186                                 FILL_COLOR_HANDLER,\r
 187                                 BORDER_COLOR_HANDLER,\r
 188                                 FixedSize.of(ControlValveSymbol.BOUNDS),                                \r
 189                                 StaticTerminals.compile(\r
 190                                                 TERMINAL_IN,    -ThreeWayValveSymbol.D, 0.0, DirectionSet.N,\r
 191                                                 TERMINAL_OUT,    ThreeWayValveSymbol.D, 0.0, DirectionSet.S\r
 192                                                 )                               \r
 193                                 );              \r
 194         public static ElementClass HEATEXCHANGER_CLASS =\r
 195                 ElementClass.compile(\r
 196                                 DefaultTransform.INSTANCE,\r
 197                                 HeatExchangerPaint.INSTANCE,\r
 198                                 FILL_COLOR_HANDLER,\r
 199                                 BORDER_COLOR_HANDLER,\r
 200                                 FixedSize.of(HeatExchangerSymbol.BOUNDS),\r
 201                                 StaticTerminals.compile(\r
 202                                                 TERMINAL_IN,    HeatExchangerSymbol.BOUNDS.getMinX(), HeatExchangerSymbol.BOUNDS.getMaxY()*0.5, DirectionSet.SW,\r
 203                                                 TERMINAL_OUT,   HeatExchangerSymbol.BOUNDS.getMaxX(), HeatExchangerSymbol.BOUNDS.getMinY()*0.5, DirectionSet.NE\r
 204                                                 )                                                               \r
 205                                 );      \r
 206         public static ElementClass HEATEXCHANGER_BUTTON_CLASS =\r
 207                 ElementClass.compile(\r
 208                                 Clickable.INSTANCE,\r
 209                                 DefaultTransform.INSTANCE,\r
 210                                 HeatExchangerPaint.INSTANCE,\r
 211                                 FILL_COLOR_HANDLER,\r
 212                                 BORDER_COLOR_HANDLER,\r
 213                                 FixedSize.of(HeatExchangerSymbol.BOUNDS),\r
 214                                 StaticTerminals.compile(\r
 215                                                 TERMINAL_IN,    HeatExchangerSymbol.BOUNDS.getMinX(), HeatExchangerSymbol.BOUNDS.getMaxY(), DirectionSet.SW,\r
 216                                                 TERMINAL_OUT,   HeatExchangerSymbol.BOUNDS.getMaxX(), HeatExchangerSymbol.BOUNDS.getMinY(), DirectionSet.NE                                             \r
 217                                                 )                                                               \r
 218                                 );              \r
 219         public static ElementClass PUMP_CLASS =\r
 220                 ElementClass.compile(\r
 221                                 DefaultTransform.INSTANCE,\r
 222                                 PumpPaint.INSTANCE,\r
 223                                 FILL_COLOR_HANDLER,\r
 224                                 BORDER_COLOR_HANDLER,\r
 225                                 FixedSize.of(PumpSymbol.BOUNDS),\r
 226                                 StaticTerminals.compile(\r
 227                                                 TERMINAL_IN,    -PumpSymbol.D2, 0.0, DirectionSet.N,\r
 228                                                 TERMINAL_OUT,    PumpSymbol.D2, 0.0, DirectionSet.S\r
 229                                                 )                                       \r
 230                                 );\r
 231         public static ElementClass PUMP_BUTTON_CLASS =\r
 232                 ElementClass.compile(\r
 233                                 Clickable.INSTANCE,\r
 234                                 DefaultTransform.INSTANCE,\r
 235                                 PumpPaint.INSTANCE,\r
 236                                 FILL_COLOR_HANDLER,\r
 237                                 BORDER_COLOR_HANDLER,\r
 238                                 FixedSize.of(PumpSymbol.BOUNDS),\r
 239                                 StaticTerminals.compile(\r
 240                                                 TERMINAL_IN,    -PumpSymbol.D2, 0.0, DirectionSet.N,\r
 241                                                 TERMINAL_OUT,    PumpSymbol.D2, 0.0, DirectionSet.S\r
 242                                                 )                                       \r
 243                                 );      \r
 244         public static ElementClass SHUTOFFVALVE_CLASS =\r
 245                 ElementClass.compile(\r
 246                                 DefaultTransform.INSTANCE,\r
 247                                 ShutoffValvePaint.INSTANCE,\r
 248                                 FILL_COLOR_HANDLER,\r
 249                                 BORDER_COLOR_HANDLER,\r
 250                                 FixedSize.of(ShutoffValveSymbol.SHAPE.getBounds()),\r
 251                                 StaticTerminals.compile(\r
 252                                                 TERMINAL_IN,    -ShutoffValveSymbol.DIM, 0.0, DirectionSet.N,\r
 253                                                 TERMINAL_OUT,    ShutoffValveSymbol.DIM, 0.0, DirectionSet.S\r
 254                                                 )                                       \r
 255                                 );      \r
 256         public static ElementClass SHUTOFFVALVE_BUTTON_CLASS =\r
 257                 ElementClass.compile(\r
 258                                 Clickable.INSTANCE,\r
 259                                 DefaultTransform.INSTANCE,\r
 260                                 ShutoffValvePaint.INSTANCE,\r
 261                                 FILL_COLOR_HANDLER,\r
 262                                 BORDER_COLOR_HANDLER,\r
 263                                 FixedSize.of(ShutoffValveSymbol.SHAPE.getBounds()),\r
 264                                 StaticTerminals.compile(\r
 265                                                 TERMINAL_IN,    -ShutoffValveSymbol.DIM, 0.0, DirectionSet.N,\r
 266                                                 TERMINAL_OUT,    ShutoffValveSymbol.DIM, 0.0, DirectionSet.S\r
 267                                                 )                                       \r
 268                                 );              \r
 269         public static ElementClass SWITCH_CLASS =\r
 270                 ElementClass.compile(\r
 271                                 DefaultTransform.INSTANCE,\r
 272                                 SwitchPaint.INSTANCE,\r
 273                                 BORDER_COLOR_HANDLER,\r
 274                                 FixedSize.of(SwitchSymbol.BOUNDS),\r
 275                                 StaticTerminals.compile(\r
 276                                                 TERMINAL_IN,    SwitchSymbol.BOUNDS.getCenterX(), SwitchSymbol.BOUNDS.getMinY(), DirectionSet.N,\r
 277                                                 TERMINAL_OUT,   SwitchSymbol.BOUNDS.getCenterX(), SwitchSymbol.BOUNDS.getMaxY(), DirectionSet.S                                         \r
 278                                                 )                                       \r
 279                                 );      \r
 280         public static ElementClass SWITCH_BUTTON_CLASS =\r
 281                 ElementClass.compile(\r
 282                                 Clickable.INSTANCE,\r
 283                                 DefaultTransform.INSTANCE,\r
 284                                 SwitchPaint.INSTANCE,\r
 285                                 BORDER_COLOR_HANDLER,\r
 286                                 FixedSize.of(SwitchSymbol.BOUNDS),\r
 287                                 StaticTerminals.compile(\r
 288                                                 TERMINAL_IN,    SwitchSymbol.BOUNDS.getCenterX(), SwitchSymbol.BOUNDS.getMinY(), DirectionSet.N,\r
 289                                                 TERMINAL_OUT,   SwitchSymbol.BOUNDS.getCenterX(), SwitchSymbol.BOUNDS.getMaxY(), DirectionSet.S                                         \r
 290                                                 )                                       \r
 291                                 );              \r
 292         public static ElementClass TURBINE_CLASS =\r
 293                 ElementClass.compile(\r
 294                                 DefaultTransform.INSTANCE,\r
 295                                 TurbinePaint.INSTANCE,\r
 296                                 FILL_COLOR_HANDLER,\r
 297                                 BORDER_COLOR_HANDLER,\r
 298                                 FixedSize.of(TurbineSymbol.SHAPE.getBounds()),\r
 299                                 StaticTerminals.compile(\r
 300                                                 TERMINAL_IN,    -TurbineSymbol.DIM, 0.0, DirectionSet.N,\r
 301                                                 TERMINAL_OUT,    TurbineSymbol.DIM, 0.0, DirectionSet.S\r
 302                                                 )                                               \r
 303                                 );              \r
 304         public static ElementClass TURBINE_BUTTON_CLASS =\r
 305                 ElementClass.compile(\r
 306                                 Clickable.INSTANCE,\r
 307                                 DefaultTransform.INSTANCE,\r
 308                                 TurbinePaint.INSTANCE,\r
 309                                 FILL_COLOR_HANDLER,\r
 310                                 BORDER_COLOR_HANDLER,\r
 311                                 FixedSize.of(TurbineSymbol.BOUNDS),\r
 312                                 StaticTerminals.compile(\r
 313                                                 TERMINAL_IN,    -TurbineSymbol.DIM, 0.0, DirectionSet.N,\r
 314                                                 TERMINAL_OUT,    TurbineSymbol.DIM, 0.0, DirectionSet.S\r
 315                                                 )                                               \r
 316                                 );              \r
 317         public static ElementClass VOLTAGETRANSFORMER_CLASS =\r
 318                 ElementClass.compile(\r
 319                                 DefaultTransform.INSTANCE,\r
 320                                 VoltageTransformerPaint.INSTANCE,\r
 321                                 ADDITIONAL_COLOR_HANDLER,\r
 322                                 BORDER_COLOR_HANDLER,\r
 323                                 FixedSize.of(VoltageTransformerSymbol.BOUNDS),\r
 324                                 StaticTerminals.compile(\r
 325                                                 TERMINAL_IN,    VoltageTransformerSymbol.BOUNDS.getCenterX(), VoltageTransformerSymbol.BOUNDS.getMinY(), DirectionSet.N,\r
 326                                                 TERMINAL_OUT,   VoltageTransformerSymbol.BOUNDS.getCenterX(), VoltageTransformerSymbol.BOUNDS.getMaxY(), DirectionSet.S\r
 327                                                 )                                                       \r
 328                                 );\r
 329         public static ElementClass VOLTAGETRANSFORMER_BUTTON_CLASS =\r
 330                 ElementClass.compile(\r
 331                                 Clickable.INSTANCE,\r
 332                                 DefaultTransform.INSTANCE,\r
 333                                 VoltageTransformerPaint.INSTANCE,\r
 334                                 ADDITIONAL_COLOR_HANDLER,\r
 335                                 BORDER_COLOR_HANDLER,\r
 336                                 FixedSize.of(VoltageTransformerSymbol.BOUNDS),\r
 337                                 StaticTerminals.compile(\r
 338                                                 TERMINAL_IN,    VoltageTransformerSymbol.BOUNDS.getCenterX(), VoltageTransformerSymbol.BOUNDS.getMinY(), DirectionSet.N,\r
 339                                                 TERMINAL_OUT,   VoltageTransformerSymbol.BOUNDS.getCenterX(), VoltageTransformerSymbol.BOUNDS.getMaxY(), DirectionSet.S\r
 340                                                 )                                                       \r
 341                                 );      \r
 342         public static ElementClass CHIMNEY_CLASS =\r
 343                 ElementClass.compile(\r
 344                                 DefaultTransform.INSTANCE,\r
 345                                 ChimneyPaint.INSTANCE,\r
 346                                 FILL_COLOR_HANDLER,\r
 347                                 BORDER_COLOR_HANDLER,\r
 348                                 FixedSize.of(ChimneySymbol.BOUNDS)\r
 349                                 );              \r
 350         public static ElementClass CHIMNEY_BUTTON_CLASS =\r
 351                 ElementClass.compile(\r
 352                                 Clickable.INSTANCE,\r
 353                                 DefaultTransform.INSTANCE,\r
 354                                 ChimneyPaint.INSTANCE,\r
 355                                 FILL_COLOR_HANDLER,\r
 356                                 BORDER_COLOR_HANDLER,\r
 357                                 FixedSize.of(ChimneySymbol.BOUNDS)\r
 358                                 );              \r
 359         public static ElementClass GENERATOR_CLASS =\r
 360                 ElementClass.compile(\r
 361                                 DefaultTransform.INSTANCE,\r
 362                                 GeneratorPaint.INSTANCE,\r
 363                                 FILL_COLOR_HANDLER,\r
 364                                 BORDER_COLOR_HANDLER,\r
 365                                 FixedSize.of(GeneratorSymbol.BOUNDS),\r
 366                                 StaticTerminals.compile(\r
 367                                                 TERMINAL_IN,    -GeneratorSymbol.DIM, 0.0, DirectionSet.W,\r
 368                                                 TERMINAL_OUT,    GeneratorSymbol.DIM, 0.0, DirectionSet.E\r
 369                                                 )                                                               \r
 370                                 );              \r
 371         public static ElementClass GENERATOR_BUTTON_CLASS =\r
 372                 ElementClass.compile(\r
 373                                 Clickable.INSTANCE,\r
 374                                 DefaultTransform.INSTANCE,\r
 375                                 GeneratorPaint.INSTANCE,\r
 376                                 FILL_COLOR_HANDLER,\r
 377                                 BORDER_COLOR_HANDLER,\r
 378                                 FixedSize.of(GeneratorSymbol.BOUNDS),\r
 379                                 StaticTerminals.compile(\r
 380                                                 TERMINAL_IN,    -GeneratorSymbol.DIM, 0.0, DirectionSet.W,\r
 381                                                 TERMINAL_OUT,    GeneratorSymbol.DIM, 0.0, DirectionSet.E\r
 382                                                 )                                                                                               \r
 383                                 );\r
 384         public static ElementClass TANK_CLASS =\r
 385                 ElementClass.compile(\r
 386                                 DefaultTransform.INSTANCE,\r
 387                                 TankPaint.INSTANCE,\r
 388                                 FILL_COLOR_HANDLER,\r
 389                                 BORDER_COLOR_HANDLER,\r
 390                                 Resizeable.initialSize(40, 15)\r
 391                                 );              \r
 392         public static ElementClass TANK_BUTTON_CLASS =\r
 393                 ElementClass.compile(\r
 394                                 Clickable.INSTANCE,\r
 395                                 DefaultTransform.INSTANCE,\r
 396                                 TankPaint.INSTANCE,\r
 397                                 FILL_COLOR_HANDLER,\r
 398                                 BORDER_COLOR_HANDLER,\r
 399                                 Resizeable.initialSize(40, 15)\r
 400                                 );              \r
 401         public static ElementClass TANK2_CLASS =\r
 402                 ElementClass.compile(\r
 403                                 DefaultTransform.INSTANCE,\r
 404                                 Tank2Paint.INSTANCE,\r
 405                                 FILL_COLOR_HANDLER,\r
 406                                 BORDER_COLOR_HANDLER,\r
 407                                 ADDITIONAL_COLOR_HANDLER,                               \r
 408                                 Resizeable.initialSize(40, 15)\r
 409                                 );              \r
 410         public static ElementClass TANK2_BUTTON_CLASS =\r
 411                 ElementClass.compile(\r
 412                                 Clickable.INSTANCE,\r
 413                                 DefaultTransform.INSTANCE,\r
 414                                 Tank2Paint.INSTANCE,\r
 415                                 FILL_COLOR_HANDLER,\r
 416                                 ADDITIONAL_COLOR_HANDLER,                               \r
 417                                 BORDER_COLOR_HANDLER,\r
 418                                 Resizeable.initialSize(40, 15)\r
 419                                 );              \r
 420         \r
 421         \r
 422         \r
 423         public static class BoilerPaint implements SceneGraph {         \r
 424 \r
 425                 private static final long serialVersionUID = -4545277680608759806L;\r
 426                 public static final BoilerPaint INSTANCE = new BoilerPaint();\r
 427                 \r
 428             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 429 \r
 430                 @Override\r
 431                 public void cleanup(IElement e) {\r
 432                Node node = e.removeHint(SG_NODE);\r
 433                if (node != null)\r
 434                    node.remove();\r
 435                 }\r
 436 \r
 437                 @Override\r
 438                 public void init(IElement e, G2DParentNode parent) {\r
 439                G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 440                if (node == null) {\r
 441                    node = parent.addNode(G2DParentNode.class);\r
 442                    e.setHint(SG_NODE, node);\r
 443                }\r
 444                         AffineTransform at      = ElementUtils.getTransform(e);\r
 445                         if(at != null) node.setTransform(at);\r
 446 \r
 447                         Color                   fc              = ElementUtils.getFillColor(e);\r
 448                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 449                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 450                         Image ps                = null;\r
 451                         \r
 452                         if (press==null) {\r
 453                                 ps = new BoilerSymbol2(fc, bc, OperationSymbols.BOILER_HES);\r
 454                         } else {\r
 455                                 ps = OperationSymbols.BOILER_SHADOW;\r
 456 // ?????????                            \r
 457 //                              if (press==PressStatus.NORMAL) \r
 458 //                                      gc.getGraphics2D().translate(-2, -3);\r
 459                         }\r
 460                         \r
 461                         ps.init(node);\r
 462                 }\r
 463         }\r
 464         \r
 465         \r
 466         public static class NoSpinPaint implements SceneGraph {\r
 467 \r
 468                 private static final long serialVersionUID = 801958319361745846L;\r
 469                 public static final NoSpinPaint INSTANCE = new NoSpinPaint();\r
 470                 \r
 471             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 472 \r
 473                 @Override\r
 474                 public void cleanup(IElement e) {\r
 475                Node node = e.removeHint(SG_NODE);\r
 476                if (node != null)\r
 477                    node.remove();\r
 478                 }\r
 479 \r
 480                 @Override\r
 481                 public void init(IElement e, G2DParentNode parent) {\r
 482                G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 483                if (node == null) {\r
 484                    node = parent.addNode(G2DParentNode.class);\r
 485                    e.setHint(SG_NODE, node);\r
 486                }\r
 487                         AffineTransform at      = ElementUtils.getTransform(e);\r
 488                         if(at != null) node.setTransform(at);\r
 489 \r
 490                         Color                   fc              = ElementUtils.getFillColor(e);\r
 491                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 492                         if (bc==null) return;\r
 493                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 494                         Image ps                = null;\r
 495                         \r
 496                         if (press==null) {\r
 497                                 ps = new NoSpinSymbol(fc, bc);\r
 498                         } else {\r
 499                                 ps = OperationSymbols.NO_SPIN_SHADOW;\r
 500 // ?????????                            \r
 501 //                              if (press==PressStatus.NORMAL)\r
 502 //                                      gc.getGraphics2D().translate(-2, -3);\r
 503                         }\r
 504                         \r
 505                         ps.init(node);\r
 506                 }\r
 507         }\r
 508 \r
 509         \r
 510         public static class ControlValvePaint implements SceneGraph {\r
 511 \r
 512                 private static final long serialVersionUID = -8208633777668762027L;\r
 513                 public static final ControlValvePaint INSTANCE = new ControlValvePaint();\r
 514             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 515 \r
 516                 @Override\r
 517                 public void cleanup(IElement e) {\r
 518                Node node = e.removeHint(SG_NODE);\r
 519                if (node != null)\r
 520                    node.remove();\r
 521                 }\r
 522 \r
 523                 @Override\r
 524                 public void init(IElement e, G2DParentNode parent) {\r
 525                G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 526                if (node == null) {\r
 527                    node = parent.addNode(G2DParentNode.class);\r
 528                    e.setHint(SG_NODE, node);\r
 529                }\r
 530                         AffineTransform at      = ElementUtils.getTransform(e);\r
 531                         if(at != null) node.setTransform(at);\r
 532 \r
 533                         Color                   fc              = ElementUtils.getFillColor(e);\r
 534                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 535                         if (bc==null) return;\r
 536                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 537                         Image ps                = null;\r
 538                         \r
 539                         if (press==null) {\r
 540                                 ps = new ControlValveSymbol(fc, bc);\r
 541                         } else {\r
 542                                 ps = OperationSymbols.CONTROLVALVE_SHADOW;\r
 543 // ?????????                            \r
 544 //                              if (press==PressStatus.NORMAL)\r
 545 //                                      gc.getGraphics2D().translate(-2, -3);\r
 546                         }\r
 547                         \r
 548                         ps.init(node);\r
 549                 }\r
 550         }       \r
 551         \r
 552         public static class ThreeWayValvePaint implements SceneGraph {\r
 553 \r
 554                 private static final long serialVersionUID = -1848763601182093048L;\r
 555                 public static final ThreeWayValvePaint INSTANCE = new ThreeWayValvePaint();\r
 556             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 557 \r
 558                 @Override\r
 559                 public void cleanup(IElement e) {\r
 560                Node node = e.removeHint(SG_NODE);\r
 561                if (node != null)\r
 562                    node.remove();\r
 563                 }\r
 564 \r
 565                 @Override\r
 566                 public void init(IElement e, G2DParentNode parent) {\r
 567                G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 568                if (node == null) {\r
 569                    node = parent.addNode(G2DParentNode.class);\r
 570                    e.setHint(SG_NODE, node);\r
 571                }\r
 572                         AffineTransform at      = ElementUtils.getTransform(e);\r
 573                         if(at != null) node.setTransform(at);\r
 574 \r
 575                         Color                   fc              = ElementUtils.getFillColor(e);\r
 576                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 577                         if (bc==null) return;\r
 578                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 579                         Image ps                = null;\r
 580                         \r
 581                         if (press==null) {\r
 582                                 ps = new ThreeWayValveSymbol(fc, bc);\r
 583                         } else {\r
 584                                 ps = OperationSymbols.THREEWAYVALVE_SHADOW;\r
 585 // ?????????                            \r
 586 //                              if (press==PressStatus.NORMAL)\r
 587 //                                      gc.getGraphics2D().translate(-2, -3);\r
 588                         }\r
 589                         \r
 590                         ps.init(node);\r
 591                 }\r
 592         }       \r
 593         \r
 594         public static class HeatExchangerPaint implements SceneGraph {\r
 595 \r
 596                 private static final long serialVersionUID = -5482316746105556083L;\r
 597                 public static final HeatExchangerPaint INSTANCE = new HeatExchangerPaint();             \r
 598             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 599 \r
 600                 @Override\r
 601                 public void cleanup(IElement e) {\r
 602                Node node = e.removeHint(SG_NODE);\r
 603                if (node != null)\r
 604                    node.remove();\r
 605                 }\r
 606 \r
 607                 @Override\r
 608                 public void init(IElement e, G2DParentNode parent) {\r
 609                G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 610                if (node == null) {\r
 611                    node = parent.addNode(G2DParentNode.class);\r
 612                    e.setHint(SG_NODE, node);\r
 613                }\r
 614                         AffineTransform at      = ElementUtils.getTransform(e);\r
 615                         if(at != null) node.setTransform(at);\r
 616 \r
 617                         Color                   fc              = ElementUtils.getFillColor(e);\r
 618                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 619                         if (bc==null) return;\r
 620                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 621                         Image ps                = null;\r
 622                         \r
 623                         if (press==null) {\r
 624                                 ps = new HeatExchangerSymbol(fc, bc);\r
 625                         } else {\r
 626                                 ps = OperationSymbols.HEATEXCHANGER_SHADOW;\r
 627 // ?????????                            \r
 628 //                              if (press==PressStatus.NORMAL)\r
 629 //                                      gc.getGraphics2D().translate(-2, -3);\r
 630                         }\r
 631                         \r
 632                         ps.init(node);\r
 633                 }\r
 634         }       \r
 635                 \r
 636         \r
 637         \r
 638         public static class PumpPaint implements SceneGraph {\r
 639 \r
 640                 private static final long serialVersionUID = 5899800511420262337L;\r
 641                 public static final PumpPaint INSTANCE = new PumpPaint();               \r
 642             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 643 \r
 644                 @Override\r
 645                 public void cleanup(IElement e) {\r
 646                Node node = e.removeHint(SG_NODE);\r
 647                if (node != null)\r
 648                    node.remove();\r
 649                 }\r
 650 \r
 651                 @Override\r
 652                 public void init(IElement e, G2DParentNode parent) {\r
 653                G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 654                if (node == null) {\r
 655                    node = parent.addNode(G2DParentNode.class);\r
 656                    e.setHint(SG_NODE, node);\r
 657                }\r
 658                         AffineTransform at      = ElementUtils.getTransform(e);\r
 659                         if(at != null) node.setTransform(at);\r
 660 \r
 661                         Color                   fc              = ElementUtils.getFillColor(e);\r
 662                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 663                         if (bc==null) return;\r
 664                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 665                         Image ps                = null;\r
 666                         \r
 667                         if (press==null) {\r
 668                                 ps = new PumpSymbol(fc, bc);\r
 669                         } else {\r
 670                                 ps = OperationSymbols.PUMP_SHADOW;\r
 671 // ?????????                            \r
 672 //                              if (press==PressStatus.NORMAL)\r
 673 //                                      gc.getGraphics2D().translate(-2, -3);\r
 674                         }\r
 675                         \r
 676                         ps.init(node);\r
 677                 }\r
 678         }       \r
 679         \r
 680         \r
 681         public static class ShutoffValvePaint implements SceneGraph {\r
 682 \r
 683                 private static final long serialVersionUID = 6258753947743405959L;\r
 684                 public static final ShutoffValvePaint INSTANCE = new ShutoffValvePaint();               \r
 685             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 686 \r
 687                 @Override\r
 688                 public void cleanup(IElement e) {\r
 689                Node node = e.removeHint(SG_NODE);\r
 690                if (node != null)\r
 691                    node.remove();\r
 692                 }\r
 693 \r
 694                 @Override\r
 695                 public void init(IElement e, G2DParentNode parent) {\r
 696                G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 697                if (node == null) {\r
 698                    node = parent.addNode(G2DParentNode.class);\r
 699                    e.setHint(SG_NODE, node);\r
 700                }\r
 701                         AffineTransform at      = ElementUtils.getTransform(e);\r
 702                         if(at != null) node.setTransform(at);\r
 703 \r
 704                         Color                   fc              = ElementUtils.getFillColor(e);\r
 705                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 706                         if (bc==null) return;\r
 707                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 708                         Image ps                = null;\r
 709                         \r
 710                         if (press==null) {\r
 711                                 ps = new ShutoffValveSymbol(fc, bc);\r
 712                         } else {\r
 713                                 ps = OperationSymbols.SHUTOFFVALVE_SHADOW;\r
 714 // ?????????                            \r
 715 //                              if (press==PressStatus.NORMAL)\r
 716 //                                      gc.getGraphics2D().translate(-2, -3);\r
 717                         }\r
 718                         \r
 719                         ps.init(node);\r
 720                 }\r
 721         }       \r
 722         \r
 723         \r
 724         \r
 725         public static class SwitchPaint implements SceneGraph {\r
 726 \r
 727                 private static final long serialVersionUID = -171980746141963729L;\r
 728                 public static final SwitchPaint INSTANCE = new SwitchPaint();\r
 729             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 730 \r
 731                 @Override\r
 732                 public void cleanup(IElement e) {\r
 733                Node node = e.removeHint(SG_NODE);\r
 734                if (node != null)\r
 735                    node.remove();\r
 736                 }\r
 737 \r
 738                 @Override\r
 739                 public void init(IElement e, G2DParentNode parent) {\r
 740                         G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 741                         if (node == null) {\r
 742                                 node = parent.addNode(G2DParentNode.class);\r
 743                                 e.setHint(SG_NODE, node);\r
 744                         }\r
 745                         AffineTransform at      = ElementUtils.getTransform(e);\r
 746                         if(at != null) node.setTransform(at);\r
 747 \r
 748                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 749                         if (bc==null) return;\r
 750                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 751                         Image ps                = null;\r
 752                         \r
 753                         if (press==null) {\r
 754                                 ps = new SwitchSymbol(bc);\r
 755                         } else {\r
 756                                 ps = OperationSymbols.SWITCH_SHADOW;\r
 757 // ?????????                            \r
 758 //                              if (press==PressStatus.NORMAL)\r
 759 //                                      gc.getGraphics2D().translate(-2, -3);\r
 760                         }\r
 761                         ps.init(node);\r
 762                 }\r
 763         }               \r
 764 \r
 765         \r
 766         public static class TurbinePaint implements SceneGraph {\r
 767 \r
 768                 private static final long serialVersionUID = -920598007509848402L;\r
 769                 public static final TurbinePaint INSTANCE = new TurbinePaint();         \r
 770             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 771 \r
 772                 @Override\r
 773                 public void cleanup(IElement e) {\r
 774                Node node = e.removeHint(SG_NODE);\r
 775                if (node != null)\r
 776                    node.remove();\r
 777                 }\r
 778 \r
 779                 @Override\r
 780                 public void init(IElement e, G2DParentNode parent) {\r
 781                         G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 782                         if (node == null) {\r
 783                                 node = parent.addNode(G2DParentNode.class);\r
 784                                 e.setHint(SG_NODE, node);\r
 785                         }\r
 786                         \r
 787                         AffineTransform at      = ElementUtils.getTransform(e);\r
 788                         if(at != null) node.setTransform(at);\r
 789 \r
 790                         Color                   fc              = ElementUtils.getFillColor(e);\r
 791                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 792                         if (bc==null) return;\r
 793                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 794                         Image ps                = null;\r
 795                         \r
 796                         if (press==null) {\r
 797                                 ps = new TurbineSymbol(bc, fc);\r
 798                         } else {\r
 799                                 ps = OperationSymbols.TURBINE_SHADOW;\r
 800 // ?????????                            \r
 801 //                              if (press==PressStatus.NORMAL)\r
 802 //                                      gc.getGraphics2D().translate(-2, -3);\r
 803                         }\r
 804                         ps.init(node);\r
 805                 }\r
 806         }               \r
 807 \r
 808         public static class CompressorPaint implements SceneGraph {\r
 809 \r
 810                 private static final long serialVersionUID = 6961201125549409431L;\r
 811                 public static final CompressorPaint INSTANCE = new CompressorPaint();           \r
 812             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 813 \r
 814                 @Override\r
 815                 public void cleanup(IElement e) {\r
 816                Node node = e.removeHint(SG_NODE);\r
 817                if (node != null)\r
 818                    node.remove();\r
 819                 }\r
 820 \r
 821                 @Override\r
 822                 public void init(IElement e, G2DParentNode parent) {\r
 823                         G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 824                         if (node == null) {\r
 825                                 node = parent.addNode(G2DParentNode.class);\r
 826                                 e.setHint(SG_NODE, node);\r
 827                         }\r
 828                         \r
 829                         AffineTransform at      = ElementUtils.getTransform(e);\r
 830                         if(at != null) node.setTransform(at);\r
 831 \r
 832                         Color                   fc              = ElementUtils.getFillColor(e);\r
 833                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 834                         if (bc==null) return;\r
 835                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 836                         Image ps                = null;\r
 837                         \r
 838                         if (press==null) {\r
 839                                 ps = new CompressorSymbol(bc, fc);\r
 840                         } else {\r
 841                                 ps = OperationSymbols.COMPRESSOR_SHADOW;\r
 842 // ?????????                            \r
 843 //                              if (press==PressStatus.NORMAL)\r
 844 //                                      gc.getGraphics2D().translate(-2, -3);\r
 845                         }\r
 846                         ps.init(node);\r
 847                 }\r
 848         }       \r
 849         \r
 850         public static class VoltageTransformerPaint implements SceneGraph {\r
 851 \r
 852                 private static final long serialVersionUID = -4935588203299292629L;\r
 853                 public static final VoltageTransformerPaint INSTANCE = new VoltageTransformerPaint();           \r
 854             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 855 \r
 856                 @Override\r
 857                 public void cleanup(IElement e) {\r
 858                Node node = e.removeHint(SG_NODE);\r
 859                if (node != null)\r
 860                    node.remove();\r
 861                 }\r
 862 \r
 863                 @Override\r
 864                 public void init(IElement e, G2DParentNode parent) {\r
 865                         G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 866                         if (node == null) {\r
 867                                 node = parent.addNode(G2DParentNode.class);\r
 868                                 e.setHint(SG_NODE, node);\r
 869                         }\r
 870                         AffineTransform at      = ElementUtils.getTransform(e);\r
 871                         if(at != null) node.setTransform(at);\r
 872 \r
 873                         Color           color1          = ElementUtils.getBorderColor(e);\r
 874                         Color           color2          = ElementUtils.getAdditionalColor(e);\r
 875                         if (color1==null || color2==null) return;\r
 876                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 877                         Image ps                = null;\r
 878                         \r
 879                         if (press==null) {\r
 880                                 ps = new VoltageTransformerSymbol(color1, color2);\r
 881                         } else {\r
 882                                 ps = OperationSymbols.VOLTAGETRANSFORMER_SHADOW;\r
 883 // ?????????                            \r
 884 //                              if (press==PressStatus.NORMAL)\r
 885 //                                      gc.getGraphics2D().translate(-2, -3);\r
 886                         }\r
 887                         ps.init(node);\r
 888                 }\r
 889         }               \r
 890         \r
 891         public static class ChimneyPaint implements SceneGraph {\r
 892 \r
 893                 private static final long serialVersionUID = 1001249555587430505L;\r
 894                 public static final ChimneyPaint INSTANCE = new ChimneyPaint();         \r
 895             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 896 \r
 897                 @Override\r
 898                 public void cleanup(IElement e) {\r
 899                Node node = e.removeHint(SG_NODE);\r
 900                if (node != null)\r
 901                    node.remove();\r
 902                 }\r
 903 \r
 904                 @Override\r
 905                 public void init(IElement e, G2DParentNode parent) {\r
 906                         G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 907                         if (node == null) {\r
 908                                 node = parent.addNode(G2DParentNode.class);\r
 909                                 e.setHint(SG_NODE, node);\r
 910                         }\r
 911                         AffineTransform at      = ElementUtils.getTransform(e);\r
 912                         if(at != null) node.setTransform(at);\r
 913 \r
 914                         Color                   fc              = ElementUtils.getFillColor(e);\r
 915                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 916                         if (bc==null) return;\r
 917                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 918                         Image ps                = null;\r
 919                         \r
 920                         if (press==null) {\r
 921                                 ps = new ChimneySymbol(fc, bc);\r
 922                         } else {\r
 923                                 ps = OperationSymbols.CHIMNEY_SHADOW;\r
 924 // ?????????                            \r
 925 //                              if (press==PressStatus.NORMAL)\r
 926 //                                      gc.getGraphics2D().translate(-2, -3);\r
 927                         }\r
 928                         ps.init(node);\r
 929                 }\r
 930         }               \r
 931         \r
 932         public static class GeneratorPaint implements SceneGraph {\r
 933 \r
 934                 private static final long serialVersionUID = -1080419588160841727L;\r
 935                 public static final GeneratorPaint INSTANCE = new GeneratorPaint();             \r
 936             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 937 \r
 938                 @Override\r
 939                 public void cleanup(IElement e) {\r
 940                Node node = e.removeHint(SG_NODE);\r
 941                if (node != null)\r
 942                    node.remove();\r
 943                 }\r
 944 \r
 945                 @Override\r
 946                 public void init(IElement e, G2DParentNode parent) {\r
 947                         G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 948                         if (node == null) {\r
 949                                 node = parent.addNode(G2DParentNode.class);\r
 950                                 e.setHint(SG_NODE, node);\r
 951                         }\r
 952                         AffineTransform at      = ElementUtils.getTransform(e);\r
 953                         if(at != null) node.setTransform(at);\r
 954 \r
 955                         Color                   fc              = ElementUtils.getFillColor(e);\r
 956                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 957                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 958                         Image ps                = null;\r
 959                         \r
 960                         if (press==null) {\r
 961                                 ps = new GeneratorSymbol(fc, bc);\r
 962                         } else {\r
 963                                 ps = OperationSymbols.GENERATOR_SHADOW;\r
 964 // ?????????                            \r
 965 //                              if (press==PressStatus.NORMAL)\r
 966 //                                      gc.getGraphics2D().translate(-2, -3);\r
 967                         }\r
 968                         ps.init(node);\r
 969                 }\r
 970         }               \r
 971         \r
 972         public static class TankPaint implements SceneGraph {\r
 973 \r
 974                 private static final long serialVersionUID = -461979630655554477L;\r
 975                 public static final TankPaint INSTANCE = new TankPaint();               \r
 976             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
 977 \r
 978                 @Override\r
 979                 public void cleanup(IElement e) {\r
 980                Node node = e.removeHint(SG_NODE);\r
 981                if (node != null)\r
 982                    node.remove();\r
 983                 }\r
 984 \r
 985                 @Override\r
 986                 public void init(IElement e, G2DParentNode parent) {\r
 987                         G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
 988                         if (node == null) {\r
 989                                 node = parent.addNode(G2DParentNode.class);\r
 990                                 e.setHint(SG_NODE, node);\r
 991                         }\r
 992                         AffineTransform at      = ElementUtils.getTransform(e);\r
 993                         if(at != null) node.setTransform(at);\r
 994 \r
 995                         Color                   fc              = ElementUtils.getFillColor(e);\r
 996                         Color                   bc              = ElementUtils.getBorderColor(e);\r
 997                         Rectangle2D             bounds  = ElementUtils.getElementBounds(e);\r
 998                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
 999                         Image ps                = null;\r
1000                         \r
1001                         if (press==null) {\r
1002                                 ps = new TankSymbol(bounds, 5.0, bc, fc);\r
1003                         } else {\r
1004                                 ps = OperationSymbols.TANK_SHADOW;\r
1005 // ?????????                            \r
1006 //                              if (press==PressStatus.NORMAL)\r
1007 //                                      gc.getGraphics2D().translate(-2, -3);\r
1008                         }\r
1009                         ps.init(node);\r
1010                 }\r
1011         }\r
1012         \r
1013         public static class Tank2Paint implements SceneGraph {\r
1014 \r
1015                 private static final long serialVersionUID = 5232349098800595743L;\r
1016                 public static final Tank2Paint INSTANCE = new Tank2Paint();\r
1017             public static final Key SG_NODE = new SceneGraphNodeKey(Node.class, "SUB_SG_NODE");\r
1018 \r
1019                 @Override\r
1020                 public void cleanup(IElement e) {\r
1021                Node node = e.removeHint(SG_NODE);\r
1022                if (node != null)\r
1023                    node.remove();\r
1024                 }\r
1025 \r
1026                 @Override\r
1027                 public void init(IElement e, G2DParentNode parent) {\r
1028                         G2DParentNode node = (G2DParentNode) e.getHint(SG_NODE);\r
1029                         if (node == null) {\r
1030                                 node = parent.addNode(G2DParentNode.class);\r
1031                                 e.setHint(SG_NODE, node);\r
1032                         }\r
1033                         AffineTransform at      = ElementUtils.getTransform(e);\r
1034                         if(at != null) node.setTransform(at);\r
1035 \r
1036                         Color                   fc              = ElementUtils.getFillColor(e);\r
1037                         Color                   bc              = ElementUtils.getBorderColor(e);\r
1038                         Color                   ac              = ElementUtils.getAdditionalColor(e);\r
1039                         Rectangle2D             bounds  = ElementUtils.getElementBounds(e);\r
1040                         PressStatus     press   = null;//ElementUtils.getPressStatus(e, ctx); // FIXME: scenegraph does not support context\r
1041                         Image ps                = null;\r
1042                         \r
1043                         if (press==null) {\r
1044                                 ps = new Tank2Symbol(bounds, 5.0, bc, fc, ac);\r
1045                         } else {\r
1046                                 ps = OperationSymbols.TANK2_SHADOW;\r
1047 // ?????????                            \r
1048 //                              if (press==PressStatus.NORMAL)\r
1049 //                                      gc.getGraphics2D().translate(-2, -3);\r
1050                         }\r
1051                         ps.init(node);\r
1052                 }\r
1053         }       \r
1054         \r
1055 }