- added support for conditions

- added support for group layers

src/Cockpit/panel.cxx

@@ -48,6 +48,11 @@
 #define WIN_W 1024
 #define WIN_H 768
 
+#ifdef NONE
+#pragma warn A sloppy coder has defined NONE as a macro!!!
+#undef NONE
+#endif
+
 
 
 ////////////////////////////////////////////////////////////////////////
@@ -460,10 +465,12 @@ FGPanelAction::addBinding (const FGBinding &binding)
 void
 FGPanelAction::doAction ()
 {
+  if (test()) {
     int nBindings = _bindings.size();
     for (int i = 0; i < nBindings; i++) {
       _bindings[i].fire();
     }
+  }
 }
 
 
@@ -558,6 +565,7 @@ FGPanelInstrument::addAction (FGPanelAction * action)
 bool
 FGPanelInstrument::doMouseAction (int button, int x, int y)
 {
+  if (test()) {
     action_list_type::iterator it = _actions.begin();
     action_list_type::iterator last = _actions.end();
     for ( ; it != last; it++) {
@@ -566,6 +574,7 @@ FGPanelInstrument::doMouseAction (int button, int x, int y)
 	return true;
       }
     }
+  }
   return false;
 }
 
@@ -591,12 +600,14 @@ FGLayeredInstrument::~FGLayeredInstrument ()
 void
 FGLayeredInstrument::draw ()
 {
+  if (test()) {
     for (int i = 0; i < (int)_layers.size(); i++) {
       glPushMatrix();
       glTranslatef(0.0, 0.0, (i / 100.0) + 0.1);
       _layers[i]->draw();
       glPopMatrix();
     }
+  }
 }
 
 int
@@ -656,6 +667,7 @@ FGInstrumentLayer::transform () const
   transformation_list::const_iterator last = _transformations.end();
   while (it != last) {
     FGPanelTransformation *t = *it;
+    if (t->test()) {
       float val = (t->node == 0 ? 0.0 : t->node->getFloatValue());
       if (val < t->min) {
 	val = t->min;
@@ -679,6 +691,7 @@ FGInstrumentLayer::transform () const
 	glRotatef(-val, 0.0, 0.0, 1.0);
 	break;
       }
+    }
     it++;
   }
 }
@@ -690,6 +703,38 @@ FGInstrumentLayer::addTransformation (FGPanelTransformation * transformation)
 }
 
 
+
+////////////////////////////////////////////////////////////////////////
+// Implementation of FGGroupLayer.
+////////////////////////////////////////////////////////////////////////
+
+FGGroupLayer::FGGroupLayer ()
+{
+}
+
+FGGroupLayer::~FGGroupLayer ()
+{
+  for (int i = 0; i < _layers.size(); i++)
+    delete _layers[i];
+}
+
+void
+FGGroupLayer::draw ()
+{
+  if (test()) {
+    int nLayers = _layers.size();
+    for (int i = 0; i < nLayers; i++)
+      _layers[i]->draw();
+  }
+}
+
+void
+FGGroupLayer::addLayer (FGInstrumentLayer * layer)
+{
+  _layers.push_back(layer);
+}
+
+
 
 ////////////////////////////////////////////////////////////////////////
 // Implementation of FGTexturedLayer.
@@ -711,6 +756,7 @@ FGTexturedLayer::~FGTexturedLayer ()
 void
 FGTexturedLayer::draw ()
 {
+  if (test()) {
     int w2 = _w / 2;
     int h2 = _h / 2;
     
@@ -732,6 +778,7 @@ FGTexturedLayer::draw ()
     glTexCoord2f(_texture.getMaxX(), _texture.getMaxY()); glVertex2f(w2, h2);
     glTexCoord2f(_texture.getMinX(), _texture.getMaxY()); glVertex2f(-w2, h2);
     glEnd();
+  }
 }
 
 
@@ -760,6 +807,7 @@ FGTextLayer::~FGTextLayer ()
 void
 FGTextLayer::draw ()
 {
+  if (test()) {
     glPushMatrix();
     glColor4fv(_color);
     transform();
@@ -778,6 +826,7 @@ FGTextLayer::draw ()
     text_renderer.end();
     glColor4f(1.0, 1.0, 1.0, 1.0);	// FIXME
     glPopMatrix();
+  }
 }
 
 void
@@ -849,6 +898,7 @@ FGTextLayer::Chunk::Chunk (ChunkType type, const SGPropertyNode * node,
 const char *
 FGTextLayer::Chunk::getValue () const
 {
+  if (test()) {
     switch (_type) {
     case TEXT:
       sprintf(_buf, _fmt.c_str(), _text.c_str());
@@ -861,6 +911,9 @@ FGTextLayer::Chunk::getValue () const
       break;
     }
     return _buf;
+  } else {
+    return "";
+  }
 }
 
 
@@ -885,12 +938,14 @@ FGSwitchLayer::~FGSwitchLayer ()
 void
 FGSwitchLayer::draw ()
 {
+  if (test()) {
     transform();
     if (_node->getBoolValue()) {
       _layer1->draw();
     } else {
       _layer2->draw();
     }
+  }
 }
 
 

src/Cockpit/panel_io.cxx

@@ -184,6 +184,24 @@ readTexture (const SGPropertyNode * node)
 }
 
 
+/**
+ * Test for a condition in the current node.
+ */
+
+////////////////////////////////////////////////////////////////////////
+// Read a condition and use it if necessary.
+////////////////////////////////////////////////////////////////////////
+
+static void
+readConditions (FGConditional * component, const SGPropertyNode * node)
+{
+  const SGPropertyNode * conditionNode = node->getChild("condition");
+  if (conditionNode != 0)
+				// The top level is implicitly AND
+    component->setCondition(fgReadCondition(conditionNode));
+}
+
+
 /**
  * Read an action from the instrument's property list.
  *
@@ -230,6 +248,7 @@ readAction (const SGPropertyNode * node, float w_scale, float h_scale)
     action->addBinding(FGBinding(bindings[i])); // TODO: allow modifiers
   }
 
+  readConditions(action, node);
   return action;
 }
 
@@ -340,6 +359,7 @@ readTransformation (const SGPropertyNode * node, float w_scale, float h_scale)
     return 0;
   }
 
+  readConditions(t, node);
   SG_LOG( SG_COCKPIT, SG_DEBUG, "Read transformation " << name );
   return t;
 }
@@ -405,6 +425,7 @@ readTextChunk (const SGPropertyNode * node)
     return 0;
   }
 
+  readConditions(chunk, node);
   return chunk;
 }
 
@@ -458,6 +479,19 @@ readLayer (const SGPropertyNode * node, float w_scale, float h_scale)
     layer = new FGTexturedLayer(texture, w, h);
   }
 
+				// A group of sublayers.
+  else if (type == "group") {
+    layer = new FGGroupLayer();
+    for (int i = 0; i < node->nChildren(); i++) {
+      const SGPropertyNode * child = node->getChild(i);
+      cerr << "Trying child " << child->getName() << endl;
+      if (child->getName() == "layer") {
+	cerr << "succeeded!" << endl;
+	((FGGroupLayer *)layer)->addLayer(readLayer(child, w_scale, h_scale));
+      }
+    }
+  }
+
 
 				// A textual instrument layer.
   else if (type == "text") {
@@ -552,6 +586,7 @@ readLayer (const SGPropertyNode * node, float w_scale, float h_scale)
     }
   }
 
+  readConditions(layer, node);
   SG_LOG( SG_COCKPIT, SG_DEBUG, "Read layer " << name );
   return layer;
 }
@@ -639,6 +674,7 @@ readInstrument (const SGPropertyNode * node)
     }
   }
 
+  readConditions(instrument, node);
   SG_LOG( SG_COCKPIT, SG_DEBUG, "Done reading instrument " << name );
   return instrument;
 }