src/Scripting/NasalCanvas.cxx

   1 // NasalCanvas.cxx -- expose Canvas classes to Nasal
   2 //
   3 // Written by James Turner, started 2012.
   4 //
   5 // Copyright (C) 2012 James Turner
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include "config.h"
  23 #endif
  24
  25 #include <memory>
  26 #include <string.h>
  27
  28 #include "NasalCanvas.hxx"
  29 #include <Canvas/canvas_mgr.hxx>
  30 #include <Main/globals.hxx>
  31
  32 //#include <boost/python.hpp>
  33 #include <boost/foreach.hpp>
  34 #include <boost/algorithm/string/case_conv.hpp>
  35 #include <boost/make_shared.hpp>
  36 #include <osgGA/GUIEventAdapter>
  37
  38 #include <simgear/sg_inlines.h>
  39
  40 #include <simgear/canvas/Canvas.hxx>
  41 #include <simgear/canvas/elements/CanvasElement.hxx>
  42
  43 #include <simgear/nasal/cppbind/from_nasal.hxx>
  44 #include <simgear/nasal/cppbind/to_nasal.hxx>
  45 #include <simgear/nasal/cppbind/NasalHash.hxx>
  46 #include <simgear/nasal/cppbind/Ghost.hxx>
  47
  48 extern naRef propNodeGhostCreate(naContext c, SGPropertyNode* n);
  49
  50 //void initCanvasPython()
  51 //{
  52 //  using namespace boost::python;
  53 //  class_<simgear::canvas::Canvas>("Canvas");
  54 //}
  55
  56 namespace sc = simgear::canvas;
  57
  58 naRef canvasGetNode(naContext c, sc::Canvas* canvas)
  59 {
  60   return propNodeGhostCreate(c, canvas->getProps());
  61 }
  62
  63 typedef nasal::Ghost<sc::CanvasPtr> NasalCanvas;
  64 typedef nasal::Ghost<sc::GroupPtr> NasalGroup;
  65
  66 #if 0
  67 typedef osg::ref_ptr<osgGA::GUIEventAdapter> GUIEventPtr;
  68
  69 class NasalCanvasEvent:
  70   public NasalObject<GUIEventPtr, NasalCanvasEvent>
  71 {
  72   public:
  73
  74     NasalCanvasEvent():
  75       NasalObject("CanvasEvent")
  76     {
  77       _members["type"] = &NasalCanvasEvent::getEventType;
  78     }
  79
  80     naRef getEventType(naContext c, const GUIEventPtr& event)
  81     {
  82 #define RET_EVENT_STR(type, str)\
  83   case osgGA::GUIEventAdapter::type:\
  84     return nasal::to_nasal(c, str);
  85
  86       switch( event->getEventType() )
  87       {
  88         RET_EVENT_STR(PUSH,         "push");
  89         RET_EVENT_STR(RELEASE,      "release");
  90         RET_EVENT_STR(DOUBLECLICK,  "double-click");
  91         RET_EVENT_STR(DRAG,         "drag");
  92         RET_EVENT_STR(MOVE,         "move");
  93         RET_EVENT_STR(SCROLL,       "scroll");
  94         RET_EVENT_STR(KEYUP,        "key-up");
  95         RET_EVENT_STR(KEYDOWN,      "key-down");
  96
  97 #undef RET_EVENT_STR
  98
  99         default:
 100           return naNil();
 101       }
 102     }
 103 };
 104 #endif
 105 #if 0
 106 static const char* eventGhostGetMember(naContext c, void* g, naRef field, naRef* out)
 107 {
 108   const char* fieldName = naStr_data(field);
 109   osgGA::GUIEventAdapter* gea = (osgGA::GUIEventAdapter*) g;
 110
 111   if (!strcmp(fieldName, "windowX")) *out = naNum(gea->getWindowX());
 112   else if (!strcmp(fieldName, "windowY")) *out = naNum(gea->getWindowY());
 113   else if (!strcmp(fieldName, "time")) *out = naNum(gea->getTime());
 114   else if (!strcmp(fieldName, "button")) *out = naNum(gea->getButton());
 115   else {
 116     return 0;
 117   }
 118
 119   return "";
 120 }
 121
 122 static naRef f_element_addButtonCallback(naContext c, naRef me, int argc, naRef* args)
 123 {
 124   simgear::canvas::Element* e = elementGhost(me);
 125   if (!e) {
 126     naRuntimeError(c, "element.addButtonCallback called on non-canvas-element object");
 127   }
 128
 129   return naNil();
 130 }
 131
 132 static naRef f_element_addDragCallback(naContext c, naRef me, int argc, naRef* args)
 133 {
 134   simgear::canvas::Element* e = elementGhost(me);
 135   if (!e) {
 136     naRuntimeError(c, "element.addDragCallback called on non-canvas-element object");
 137   }
 138
 139   return naNil();
 140 }
 141
 142 static naRef f_element_addMoveCallback(naContext c, naRef me, int argc, naRef* args)
 143 {
 144   simgear::canvas::Element* e = elementGhost(me);
 145   if (!e) {
 146     naRuntimeError(c, "element.addMoveCallback called on non-canvas-element object");
 147   }
 148
 149   return naNil();
 150 }
 151
 152 static naRef f_element_addScrollCallback(naContext c, naRef me, int argc, naRef* args)
 153 {
 154   simgear::canvas::Element* e = elementGhost(me);
 155   if (!e) {
 156     naRuntimeError(c, "element.addScrollCallback called on non-canvas-element object");
 157   }
 158
 159   return naNil();
 160 }
 161 #endif
 162
 163 static naRef f_createCanvas(naContext c, naRef me, int argc, naRef* args)
 164 {
 165   CanvasMgr* canvas_mgr =
 166     static_cast<CanvasMgr*>(globals->get_subsystem("Canvas"));
 167   if( !canvas_mgr )
 168     return naNil();
 169
 170   return NasalCanvas::create(c, canvas_mgr->createCanvas());
 171 }
 172
 173 naRef f_canvasCreateGroup( sc::Canvas& canvas,
 174                            naContext c,
 175                            int argc,
 176                            naRef* args )
 177 {
 178   std::string name;
 179   if( argc > 0 )
 180     name = nasal::from_nasal<std::string>(c, args[0]);
 181
 182   return NasalGroup::create(c, canvas.createGroup(name));
 183 }
 184
 185 naRef initNasalCanvas(naRef globals, naContext c, naRef gcSave)
 186 {
 187 #if 0
 188     elementPrototype = naNewHash(c);
 189     hashset(c, gcSave, "elementProto", elementPrototype);
 190
 191     hashset(c, elementPrototype, "addButtonCallback", naNewFunc(c, naNewCCode(c, f_element_addButtonCallback)));
 192     hashset(c, elementPrototype, "addDragCallback", naNewFunc(c, naNewCCode(c, f_element_addDragCallback)));
 193     hashset(c, elementPrototype, "addMoveCallback", naNewFunc(c, naNewCCode(c, f_element_addMoveCallback)));
 194     hashset(c, elementPrototype, "addScrollCallback", naNewFunc(c, naNewCCode(c, f_element_addScrollCallback)));
 195 #endif
 196   NasalCanvas::init("Canvas")
 197     .member("_node_ghost", &canvasGetNode)
 198     .member("size_x", &sc::Canvas::getSizeX)
 199     .member("size_y", &sc::Canvas::getSizeY)
 200     .method<&f_canvasCreateGroup>("createGroup");
 201   nasal::Ghost<sc::ElementPtr>::init("canvas.Element");
 202   nasal::Ghost<sc::GroupPtr>::init("canvas.Group")
 203     .bases<sc::ElementPtr>();
 204
 205   nasal::Hash globals_module(globals, c),
 206               canvas_module = globals_module.createHash("canvas");
 207
 208   canvas_module.set("_newCanvasGhost", f_createCanvas);
 209
 210   return naNil();
 211 }