├── .gitignore ├── Makefile ├── README.md ├── TODO.md ├── examples ├── login.coffee └── tree_view.coffee ├── notes.md ├── package.json ├── src ├── base.h ├── g_interface.h ├── g_object.cc ├── g_object.h ├── gtk.cc ├── gtk.h ├── gtk_bin.cc ├── gtk_bin.h ├── gtk_box.cc ├── gtk_box.h ├── gtk_button.cc ├── gtk_button.h ├── gtk_cell_renderer.cc ├── gtk_cell_renderer.h ├── gtk_cell_renderer_text.cc ├── gtk_cell_renderer_text.h ├── gtk_cell_renderer_toggle.cc ├── gtk_cell_renderer_toggle.h ├── gtk_container.cc ├── gtk_container.h ├── gtk_entry.cc ├── gtk_entry.h ├── gtk_hbox.cc ├── gtk_hbox.h ├── gtk_label.cc ├── gtk_label.h ├── gtk_misc.cc ├── gtk_misc.h ├── gtk_object.cc ├── gtk_object.h ├── gtk_tree_iter.cc ├── gtk_tree_iter.h ├── gtk_tree_model.h ├── gtk_tree_store.cc ├── gtk_tree_store.h ├── gtk_tree_view.cc ├── gtk_tree_view.h ├── gtk_tree_view_column.cc ├── gtk_tree_view_column.h ├── gtk_vbox.cc ├── gtk_vbox.h ├── gtk_widget.cc ├── gtk_widget.h ├── gtk_window.cc └── gtk_window.h └── wscript /.gitignore: -------------------------------------------------------------------------------- 1 | *.swp 2 | *.swo 3 | build/ 4 | .lock-wscript 5 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | node-waf configure build 3 | pre: 4 | node-waf configure prebuild 5 | tests: 6 | node ./test.js 7 | install: 8 | cp ./build/default/node-gtk.node ~/.node_libraries/node-gtk.node 9 | clean: 10 | rm -rf ./build 11 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | NodeGTK 2 | ======== 3 | 4 | **This project is not maintained and very out of date.** It was a fun experiment but has not been updated in years. It likely does not compile against current versions of node. There are a few other projects attempting to do the same thing, including https://github.com/jamrizzi/node-gtk3. Go look at those projects instead. 5 | 6 | Node.js bindings for GTK 2.6. 7 | 8 | Using NodeGTK, you can create fully functional GUI applications in Node.js. 9 | 10 | Awesome advantages over C++ etc. 11 | -------------------------------- 12 | 13 | Well, you are using JavaScript, which is pretty sweet. It allows you to do things like 14 | 15 | ```js 16 | var button = gtk.button_new("Click me!") 17 | gtk.signal_connect(button, 'click', function() { 18 | console.log("Clicked the button"); 19 | }); 20 | 21 | var window = gtk.window_new(gtk.WINDOW_TYPE); 22 | gtk.window_set_title(window, "Welcome to NodeGTK"); 23 | gtk.container_add(window, button); 24 | gtk.widget_show_all(window); 25 | ``` 26 | 27 | Anonymous function signal callbacks. Life has never been sweeter. 28 | 29 | Todo 30 | ---- 31 | 32 | Quite a bit. This is an initial work in progress release. Many things work, but many things are yet to be implemented. 33 | 34 | * Implement all GTK classes 35 | * Implement all GTK signals 36 | * Create an object oriented set up: 37 | 38 | ```js 39 | var button = new gtk.Button({label: "Click me!"}); 40 | button.signalConnect('click', function() { 41 | console.log("Clicked the button"); 42 | }); 43 | 44 | var window = new gtk.Window({type: gtk.WINDOW_TYPE}); 45 | window.set('title', 'Welcome to NodeGTK'); 46 | window.add(button); 47 | window.showAll(); 48 | ``` 49 | 50 | See the [TODO][] list for more details 51 | 52 | [TODO]: https://github.com/timheap/node-gtk/blob/master/TODO.md 53 | -------------------------------------------------------------------------------- /TODO.md: -------------------------------------------------------------------------------- 1 | TODO 2 | ==== 3 | 4 | This is only an alpha release, and as such there is still plenty of things to do. 5 | 6 | Classes to implement 7 | -------------------- 8 | 9 | Instead of listing all of the classes left to implement, the currently implemented classes are: 10 | 11 | * GtkButton 12 | * GtkWindow 13 | * GtkLabel 14 | * GtkInput 15 | * GtkBox 16 | * GtkBin 17 | * GtkContainer 18 | * GtkWidget 19 | * GtkObject 20 | * GObject 21 | 22 | These classes are not yet fully implemented, but there is enough functionality to create a basic 'log in' style window with inputs. See [login.coffee][] for an example. 23 | 24 | [login.coffee]: https://github.com/maelstrom/node-gtk/blog/master/examples/login.coffee 25 | 26 | Signals to implement 27 | -------------------- 28 | 29 | Because each different signal potentially has a unique callback signature, a new C++ callback needs to be created for each unique function signature required. This is not a difficult process as such, just a really tedious one. As such, many of the more obscure signals are not yet implemented. They are being implemented as someone requires them. If you require a signal to be connected, but do not have the requisite C++ skills to accomplish this, please create an issue and someone will do it at when they get a chance. 30 | 31 | Object oriented approach 32 | ------------------------ 33 | 34 | Unsurprisingly, the GTK library functions are designed to work in C++, and not so much in JavaScript. There are much better ways of implementing all of the classes in JavaScript. The final goal of this project is to create wrapper classes for the GTK classes and their associated functions. This will allow code such as the following: 35 | 36 | ```js 37 | var button = new gtk.Button({label: "Click me!"}); 38 | button.signalConnect('click', function() { 39 | console.log("Clicked the button"); 40 | }); 41 | 42 | var window = new gtk.Window({type: gtk.WINDOW_TYPE}); 43 | window.set('title', 'Welcome to NodeGTK'); 44 | window.add(button); 45 | window.showAll(); 46 | ``` 47 | -------------------------------------------------------------------------------- /examples/login.coffee: -------------------------------------------------------------------------------- 1 | gtk = require '../build/default/gtk' 2 | 3 | showLogin = -> 4 | 5 | usernameHbox = gtk.hbox_new true, 5 6 | usernameLabel = gtk.label_new "Username" 7 | gtk.misc_set_alignment usernameLabel, 1.0, 0.5 8 | usernameEntry = gtk.entry_new() 9 | gtk.container_add usernameHbox, control for control in [usernameLabel, usernameEntry] 10 | 11 | passwordHbox = gtk.hbox_new true, 5 12 | passwordLabel = gtk.label_new "Password" 13 | gtk.misc_set_alignment passwordLabel, 1.0, 0.5 14 | passwordEntry = gtk.entry_new() 15 | gtk.entry_set_visibility passwordEntry, false 16 | gtk.container_add passwordHbox, control for control in [passwordLabel, passwordEntry] 17 | 18 | submit = gtk.button_new() 19 | gtk.button_set_label submit, "Submit" 20 | gtk.signal_connect submit, "clicked", -> 21 | console.log "Logging in with", (gtk.entry_get_text usernameEntry), ":", (gtk.entry_get_text passwordEntry) 22 | gtk.widget_destroy window 23 | setTimeout showLogin, 1000 24 | 25 | vbox = gtk.vbox_new false, 2 26 | gtk.container_add vbox, control for control in [usernameHbox, passwordHbox, submit] 27 | 28 | window = gtk.window_new 0 29 | gtk.window_set_title window, "Enter your log in details" 30 | gtk.container_add window, vbox 31 | 32 | gtk.signal_connect window, "destroy", gtk.main_quit 33 | 34 | gtk.widget_set_can_default submit, true 35 | gtk.widget_grab_default submit 36 | gtk.widget_show_all window 37 | gtk.main() 38 | 39 | process.nextTick -> 40 | gtk.init() 41 | showLogin() 42 | -------------------------------------------------------------------------------- /examples/tree_view.coffee: -------------------------------------------------------------------------------- 1 | gtk = require '../build/default/gtk' 2 | 3 | columns = 4 | title: 0 5 | author: 1 6 | checked: 2 7 | 8 | populateTreeModel = (store) -> 9 | #Acquire a top-level iterator 10 | iter1 = gtk.tree_store_append store 11 | 12 | gtk.tree_store_set store, iter1, 13 | columns.title, "The Art of Computer Programming", 14 | columns.author, "Donald E. Knuth", 15 | columns.checked, false 16 | 17 | # Acquire a child iterator 18 | iter2 = gtk.tree_store_append store, iter1 19 | gtk.tree_store_set store, iter2, columns.title, "Volume 1: Fundamental Algorithms" 20 | 21 | iter2 = gtk.tree_store_append store, iter1 22 | gtk.tree_store_set store, iter2, columns.title, "Volume 2: Seminumerical Algorithms" 23 | 24 | iter1 = gtk.tree_store_append store 25 | gtk.tree_store_set store, iter1, 26 | columns.title, "The Principle of Reason", 27 | columns.author, "Martin Heidegger", 28 | columns.checked, true 29 | 30 | return 31 | 32 | 33 | makeTreeView = -> 34 | 35 | # Create a model. We are using the store model for now, though we 36 | # could use any other GtkTreeModel 37 | store = gtk.tree_store_new gtk.G_TYPE_STRING, gtk.G_TYPE_STRING, gtk.G_TYPE_BOOLEAN 38 | 39 | # custom function to fill the model with data 40 | populateTreeModel store 41 | 42 | # Create a view 43 | tree = gtk.tree_view_new_with_model store 44 | 45 | # The view now holds a reference. We can get rid of our own 46 | # reference 47 | delete store 48 | 49 | # Create a cell render 50 | renderer = gtk.cell_renderer_text_new() 51 | 52 | # TODO: arbitrarily make it red for demonstration purposes 53 | # gtk.g_object_set renderer, "foreground", "red" 54 | 55 | # Create a column, associating the "text" attribute of the 56 | # cell_renderer to the first column of the model 57 | column = gtk.tree_view_column_new_with_attributes "Author", renderer, "text", columns.author 58 | 59 | # Add the column to the view. 60 | gtk.tree_view_append_column tree, column 61 | 62 | # Second column.. title of the book. 63 | renderer = gtk.cell_renderer_text_new() 64 | column = gtk.tree_view_column_new_with_attributes "Title", renderer, "text", columns.title 65 | gtk.tree_view_append_column tree, column 66 | 67 | # Last column.. whether a book is checked out. 68 | renderer = gtk.cell_renderer_toggle_new() 69 | column = gtk.tree_view_column_new_with_attributes "Checked out", renderer, "active", columns.checked 70 | gtk.tree_view_append_column tree, column 71 | 72 | return tree 73 | 74 | 75 | showWindow = -> 76 | 77 | tree = makeTreeView() 78 | 79 | window = gtk.window_new 0 80 | gtk.window_set_title window, "Tree View" 81 | gtk.signal_connect window, 'destroy', gtk.main_quit 82 | 83 | vbox = gtk.vbox_new false, 1 84 | gtk.container_add vbox, tree 85 | gtk.container_add vbox, do -> 86 | button = do gtk.button_new 87 | gtk.button_set_label button, "Button" 88 | return button 89 | gtk.container_add window, vbox 90 | 91 | console.log tree.toString() 92 | gtk.widget_show_all window 93 | 94 | gtk.main() 95 | 96 | process.nextTick -> 97 | gtk.init() 98 | showWindow() 99 | -------------------------------------------------------------------------------- /notes.md: -------------------------------------------------------------------------------- 1 | Every class of NodeGtk widgets should have: 2 | 3 | ```c++ 4 | /** 5 | * Create a new Foo, wrap it, and return its object 6 | */ 7 | Handle gtk_foo_new(const Arguments &args) { 8 | GtkFoo widget = gtk_foo_new(arg1, arg2, ...); 9 | NodeGtkFoo node = NodeGtkFoo::From(widget); 10 | return node->jsObject; 11 | } 12 | 13 | /** 14 | * Get the NodeGtkFoo from a GtkFoo. If there is not one, 15 | * create a new one. This is the only way a new NodeGtkFoo is constructed 16 | */ 17 | NodeGtkFoo* NodeGtkFoo::From(GtkFoo *foo) { 18 | NodeGtkFoo *ref = (NodeGtkFoo*)(g_object_get_data(G_OBJECT(foo), "NodeGtk-wrapper")); 19 | if (ref == NULL) { 20 | ref = new NodeGtkFoo(foo); 21 | } 22 | return ref; 23 | } 24 | 25 | /** 26 | * Construct a new NodeGtkFoo by wrapping a GtkFoo 27 | */ 28 | NodeGtkFoo::NodeGtkFoo (GtkFoo *foo) { 29 | this->widget = GTK_WIDGET(foo); 30 | this->storeReference() 31 | this->makeExternal(NodeGtkFoo::constructor); 32 | this->addRef(); // If GtkWidget 33 | } 34 | ``` 35 | 36 | In this way, wrapping any Gtk object in a NodeGtk wrapper object will be simple, and does not have to be form the constructor. `gtk_` functions will only ever be called from the intermediate functions, leaving the wrapper classes clean of any messy implementation details - and also very easy to write. 37 | 38 | Problems I can see arising 39 | ========================== 40 | 41 | If there was a function such as `gtk_container_get_child` which returned a `GtkWidget`, and this widget had not been wrapped with a NodeGtk wrapper, calling `NodeGtkWidget::From` upon this would create a new `NodeGtkWidget` isntance. Unfortunately, this widget probably isnt a widget, but would be something like a `NodeGtkEntry` or `NodeGtkLabel`. I know of no easy way of fixing this, besides having a massive series of `if` statements, working top down through the heirachy of classes checking for a match. 42 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "NodeGTK" 3 | } 4 | -------------------------------------------------------------------------------- /src/base.h: -------------------------------------------------------------------------------- 1 | #ifndef BASE_H_ 2 | #define BASE_H_ 3 | 4 | #include 5 | #include "gtk.h" 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | namespace nodeGtk { 12 | 13 | class NodeBase : public node::ObjectWrap { 14 | public: 15 | 16 | v8::Local obj; 17 | 18 | /** 19 | * Makes the external reference to be returned to JavaScript 20 | */ 21 | void newJavaScriptInstance(v8::Persistent constructor) { 22 | obj = constructor->GetFunction()->NewInstance(); 23 | obj->SetInternalField(0, v8::External::New(this)); 24 | } 25 | 26 | static void SetupConstants(v8::Handle target); 27 | static void SetupMethods(v8::Handle target); 28 | static void Initialize(v8::Handle target); 29 | 30 | }; 31 | 32 | 33 | } // namespace ngtk 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /src/g_interface.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_G_INTERFACE_H_ 2 | #define NGTK_G_INTERFACE_H_ 3 | 4 | #include 5 | #include "gtk.h" 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | namespace nodeGtk { 12 | 13 | class NodeGInterface: public node::ObjectWrap { 14 | 15 | public: 16 | virtual ~NodeGInterface() {}; 17 | // virtual void OverrideMe() = 0; 18 | 19 | 20 | }; 21 | 22 | } 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /src/g_object.cc: -------------------------------------------------------------------------------- 1 | #include "g_object.h" 2 | 3 | namespace nodeGtk { 4 | 5 | using namespace v8; 6 | using namespace node; 7 | 8 | /** 9 | * Bare signal. Used as the intermediate callback for various signals. 10 | * Register a focus listener using @widget.on(signal, callback);@. Many signals 11 | * are bare, this function handles all of them. 12 | * 13 | * Parameter: 14 | * widget - The widget that triggered the signal 15 | * callback_ptr - The user data, which is the JavaScript function to call 16 | */ 17 | void signal_bare(GtkWidget *widget, gpointer callback_ptr) { 18 | Persistent *callback = reinterpret_cast*>(callback_ptr); 19 | TryCatch try_catch; 20 | 21 | (*callback)->Call(Context::GetCurrent()->Global(), 0, NULL); 22 | 23 | if (try_catch.HasCaught()) { 24 | FatalException(try_catch); 25 | } 26 | } 27 | 28 | 29 | /** 30 | * Boolean signal. Used as the intermediate callback for various signals. 31 | * Register a focus listener using @widget.on(signal, callback);@. Many signals 32 | * are bare, but return a gboolean to indicate success/failure, or if the event 33 | * should propagate. This function handles all of them. 34 | * 35 | * Parameter: 36 | * widget - The widget that triggered the signal 37 | * callback_ptr - The user data, which is the JavaScript function to call 38 | * 39 | * Returns: 40 | * True or false, what ever the callback returns 41 | */ 42 | gboolean signal_boolean(GtkWidget *widget, gpointer callback_ptr) { 43 | Persistent *callback = reinterpret_cast*>(callback_ptr); 44 | TryCatch try_catch; 45 | 46 | Local ret = (*callback)->Call(Context::GetCurrent()->Global(), 0, NULL); 47 | 48 | if (try_catch.HasCaught()) { 49 | FatalException(try_catch); 50 | } 51 | 52 | if (ret.IsEmpty()) { 53 | printf("Bad return"); 54 | } 55 | 56 | return (*ret)->IsTrue(); 57 | } 58 | 59 | std::vector *NodeGObject::callbacks = new std::vector; 60 | 61 | void NodeGObject::SetupCallbacks(std::vector *callbacks) {} 62 | void NodeGObject::SetupMethods(Handle target) {} 63 | void NodeGObject::SetupConstants(Handle target) { 64 | GTK_DEFINE_CONSTANT(target, "G_TYPE_INVALID", G_TYPE_INVALID); 65 | GTK_DEFINE_CONSTANT(target, "G_TYPE_NONE", G_TYPE_NONE); 66 | GTK_DEFINE_CONSTANT(target, "G_TYPE_INTERFACE", G_TYPE_INTERFACE); 67 | GTK_DEFINE_CONSTANT(target, "G_TYPE_CHAR", G_TYPE_CHAR); 68 | GTK_DEFINE_CONSTANT(target, "G_TYPE_UCHAR", G_TYPE_UCHAR); 69 | GTK_DEFINE_CONSTANT(target, "G_TYPE_BOOLEAN", G_TYPE_BOOLEAN); 70 | GTK_DEFINE_CONSTANT(target, "G_TYPE_INT", G_TYPE_INT); 71 | GTK_DEFINE_CONSTANT(target, "G_TYPE_UINT", G_TYPE_UINT); 72 | GTK_DEFINE_CONSTANT(target, "G_TYPE_LONG", G_TYPE_LONG); 73 | GTK_DEFINE_CONSTANT(target, "G_TYPE_ULONG", G_TYPE_ULONG); 74 | GTK_DEFINE_CONSTANT(target, "G_TYPE_INT64", G_TYPE_INT64); 75 | GTK_DEFINE_CONSTANT(target, "G_TYPE_UINT64", G_TYPE_UINT64); 76 | GTK_DEFINE_CONSTANT(target, "G_TYPE_ENUM", G_TYPE_ENUM); 77 | GTK_DEFINE_CONSTANT(target, "G_TYPE_FLAGS", G_TYPE_FLAGS); 78 | GTK_DEFINE_CONSTANT(target, "G_TYPE_FLOAT", G_TYPE_FLOAT); 79 | GTK_DEFINE_CONSTANT(target, "G_TYPE_DOUBLE", G_TYPE_DOUBLE); 80 | GTK_DEFINE_CONSTANT(target, "G_TYPE_STRING", G_TYPE_STRING); 81 | GTK_DEFINE_CONSTANT(target, "G_TYPE_POINTER", G_TYPE_POINTER); 82 | GTK_DEFINE_CONSTANT(target, "G_TYPE_BOXED", G_TYPE_BOXED); 83 | GTK_DEFINE_CONSTANT(target, "G_TYPE_PARAM", G_TYPE_PARAM); 84 | GTK_DEFINE_CONSTANT(target, "G_TYPE_OBJECT", G_TYPE_OBJECT); 85 | 86 | 87 | // Position constants. 88 | GTK_DEFINE_CONSTANT(target, "WIN_POS_NONE", GTK_WIN_POS_NONE); 89 | GTK_DEFINE_CONSTANT(target, "WIN_POS_CENTER", GTK_WIN_POS_CENTER); 90 | GTK_DEFINE_CONSTANT(target, "WIN_POS_MOUSE", GTK_WIN_POS_MOUSE); 91 | GTK_DEFINE_CONSTANT(target, "WIN_POS_CENTER_ALWAYS", GTK_WIN_POS_CENTER_ALWAYS); 92 | GTK_DEFINE_CONSTANT(target, "WIN_POS_CENTER_ON_PARENT", GTK_WIN_POS_CENTER_ON_PARENT); 93 | 94 | // MessageDialog constants 95 | GTK_DEFINE_CONSTANT(target, "DIALOG_MODAL", GTK_DIALOG_MODAL); 96 | GTK_DEFINE_CONSTANT(target, "DIALOG_DESTROY_WITH_PARENT", GTK_DIALOG_DESTROY_WITH_PARENT); 97 | GTK_DEFINE_CONSTANT(target, "DIALOG_NO_SEPARATOR", GTK_DIALOG_NO_SEPARATOR); 98 | 99 | // Message types. 100 | GTK_DEFINE_CONSTANT(target, "MESSAGE_INFO", GTK_MESSAGE_INFO); 101 | GTK_DEFINE_CONSTANT(target, "MESSAGE_WARNING", GTK_MESSAGE_WARNING); 102 | GTK_DEFINE_CONSTANT(target, "MESSAGE_QUESTION", GTK_MESSAGE_QUESTION); 103 | GTK_DEFINE_CONSTANT(target, "MESSAGE_ERROR", GTK_MESSAGE_ERROR); 104 | GTK_DEFINE_CONSTANT(target, "MESSAGE_OTHER", GTK_MESSAGE_OTHER); 105 | 106 | // Buttons. 107 | GTK_DEFINE_CONSTANT(target, "BUTTONS_NONE", GTK_BUTTONS_NONE); 108 | GTK_DEFINE_CONSTANT(target, "BUTTONS_OK", GTK_BUTTONS_OK); 109 | GTK_DEFINE_CONSTANT(target, "BUTTONS_CLOSE", GTK_BUTTONS_CLOSE); 110 | GTK_DEFINE_CONSTANT(target, "BUTTONS_CANCEL", GTK_BUTTONS_CANCEL); 111 | GTK_DEFINE_CONSTANT(target, "BUTTONS_YES_NO", GTK_BUTTONS_YES_NO); 112 | GTK_DEFINE_CONSTANT(target, "BUTTONS_OK_CANCEL", GTK_BUTTONS_OK_CANCEL); 113 | 114 | // Position 115 | GTK_DEFINE_CONSTANT(target, "POS_TOP", GTK_POS_TOP); 116 | GTK_DEFINE_CONSTANT(target, "POS_RIGHT", GTK_POS_RIGHT); 117 | GTK_DEFINE_CONSTANT(target, "POS_BOTTOM", GTK_POS_BOTTOM); 118 | GTK_DEFINE_CONSTANT(target, "POS_LEFT", GTK_POS_LEFT); 119 | 120 | // Response constants 121 | GTK_DEFINE_CONSTANT(target, "RESPONSE_NONE", GTK_RESPONSE_NONE); 122 | GTK_DEFINE_CONSTANT(target, "RESPONSE_REJECT", GTK_RESPONSE_REJECT); 123 | GTK_DEFINE_CONSTANT(target, "RESPONSE_ACCEPT", GTK_RESPONSE_ACCEPT); 124 | GTK_DEFINE_CONSTANT(target, "RESPONSE_DELETE_EVENT", GTK_RESPONSE_DELETE_EVENT); 125 | GTK_DEFINE_CONSTANT(target, "RESPONSE_OK", GTK_RESPONSE_OK); 126 | GTK_DEFINE_CONSTANT(target, "RESPONSE_CANCEL", GTK_RESPONSE_CANCEL); 127 | GTK_DEFINE_CONSTANT(target, "RESPONSE_CLOSE", GTK_RESPONSE_CLOSE); 128 | GTK_DEFINE_CONSTANT(target, "RESPONSE_YES", GTK_RESPONSE_YES); 129 | GTK_DEFINE_CONSTANT(target, "RESPONSE_NO", GTK_RESPONSE_NO); 130 | GTK_DEFINE_CONSTANT(target, "RESPONSE_APPLY", GTK_RESPONSE_APPLY); 131 | GTK_DEFINE_CONSTANT(target, "RESPONSE_HELP", GTK_RESPONSE_HELP); 132 | 133 | // Direction type constants 134 | GTK_DEFINE_CONSTANT(target, "DIR_TAB_FORWARD", GTK_DIR_TAB_FORWARD); 135 | GTK_DEFINE_CONSTANT(target, "DIR_TAB_BACKWARD", GTK_DIR_TAB_BACKWARD); 136 | GTK_DEFINE_CONSTANT(target, "DIR_UP", GTK_DIR_UP); 137 | GTK_DEFINE_CONSTANT(target, "DIR_DOWN", GTK_DIR_DOWN); 138 | GTK_DEFINE_CONSTANT(target, "DIR_LEFT", GTK_DIR_LEFT); 139 | GTK_DEFINE_CONSTANT(target, "DIR_RIGHT", GTK_DIR_RIGHT); 140 | } 141 | 142 | void NodeGObject::Initialize(v8::Handle target) { 143 | v8::HandleScope scope; 144 | 145 | SetupCallbacks(callbacks); 146 | SetupConstants(target); 147 | SetupMethods(target); 148 | } 149 | 150 | } // namespace ngtk 151 | -------------------------------------------------------------------------------- /src/g_object.h: -------------------------------------------------------------------------------- 1 | #ifndef G_OBJECT_H_ 2 | #define G_OBJECT_H_ 3 | 4 | #include "base.h" 5 | 6 | namespace nodeGtk { 7 | 8 | struct SignalCallback { 9 | 10 | const char *name; 11 | GCallback callback; 12 | 13 | SignalCallback (const char *name, GCallback callback) { 14 | this->name = name; 15 | this->callback = callback; 16 | } 17 | 18 | }; 19 | 20 | class NodeGObject : public NodeBase { 21 | public: 22 | 23 | static std::vector *callbacks; 24 | GObject *widget; 25 | 26 | /** 27 | * Stores a reference to this instance in the widget 28 | */ 29 | void storeReference() { 30 | g_object_set_data(G_OBJECT(this->widget), "NodeGTK-ref", (void *)this); 31 | } 32 | 33 | 34 | /** 35 | * Retrieves a reference to this instance from the widget 36 | * 37 | * Parameters: 38 | * object - The GObject that holds the reference 39 | */ 40 | static NodeGObject* From(GObject *object) { 41 | NodeGObject *ref = (NodeGObject*)(g_object_get_data(G_OBJECT(object), "NodeGtk-wrapper")); 42 | assert(ref != NULL); 43 | return ref; 44 | } 45 | 46 | static void SetupConstants(v8::Handle target); 47 | static void SetupCallbacks(std::vector *callbacks); 48 | static void SetupMethods(v8::Handle target); 49 | static void Initialize(v8::Handle target); 50 | 51 | }; 52 | 53 | void signal_bare(GtkWidget *widget, gpointer callback_ptr); 54 | gboolean signal_boolean(GtkWidget *widget, gpointer callback_ptr); 55 | 56 | } // namespace ngtk 57 | 58 | #endif 59 | -------------------------------------------------------------------------------- /src/gtk.cc: -------------------------------------------------------------------------------- 1 | #include "gtk.h" 2 | 3 | #include 4 | #include // malloc, free 5 | 6 | #include "g_object.h" 7 | #include "gtk_object.h" 8 | #include "gtk_widget.h" 9 | #include "gtk_bin.h" 10 | #include "gtk_container.h" 11 | #include "gtk_window.h" 12 | #include "gtk_box.h" 13 | #include "gtk_hbox.h" 14 | #include "gtk_vbox.h" 15 | #include "gtk_button.h" 16 | #include "gtk_entry.h" 17 | #include "gtk_misc.h" 18 | #include "gtk_label.h" 19 | #include "gtk_tree_store.h" 20 | #include "gtk_tree_iter.h" 21 | #include "gtk_tree_view.h" 22 | #include "gtk_tree_view_column.h" 23 | #include "gtk_cell_renderer.h" 24 | #include "gtk_cell_renderer_text.h" 25 | #include "gtk_cell_renderer_toggle.h" 26 | 27 | namespace nodeGtk { 28 | 29 | using namespace v8; 30 | 31 | struct econtext { 32 | GPollFD *pfd; 33 | ev_io *iow; 34 | int nfd, afd; 35 | gint maxpri; 36 | 37 | ev_prepare pw; 38 | ev_check cw; 39 | ev_timer tw; 40 | 41 | GMainContext *gc; 42 | }; 43 | 44 | static void timer_cb (EV_P_ ev_timer *w, int revents) { 45 | /* nop */ 46 | } 47 | 48 | static void io_cb (EV_P_ ev_io *w, int revents) { 49 | /* nop */ 50 | } 51 | 52 | static void prepare_cb (EV_P_ ev_prepare *w, int revents) { 53 | struct econtext *ctx = (struct econtext *)(((char *)w) - offsetof (struct econtext, pw)); 54 | gint timeout; 55 | int i; 56 | 57 | g_main_context_dispatch (ctx->gc); 58 | 59 | g_main_context_prepare (ctx->gc, &ctx->maxpri); 60 | 61 | while (ctx->afd < (ctx->nfd = g_main_context_query ( 62 | ctx->gc, 63 | ctx->maxpri, 64 | &timeout, 65 | ctx->pfd, 66 | ctx->afd)) 67 | ) 68 | { 69 | free (ctx->pfd); 70 | free (ctx->iow); 71 | 72 | ctx->afd = 1; 73 | while (ctx->afd < ctx->nfd) 74 | ctx->afd <<= 1; 75 | 76 | ctx->pfd = (GPollFD*) malloc (ctx->afd * sizeof (GPollFD)); 77 | ctx->iow = (ev_io*) malloc (ctx->afd * sizeof (ev_io)); 78 | } 79 | 80 | for (i = 0; i < ctx->nfd; ++i) 81 | { 82 | GPollFD *pfd = ctx->pfd + i; 83 | ev_io *iow = ctx->iow + i; 84 | 85 | pfd->revents = 0; 86 | 87 | ev_io_init ( 88 | iow, 89 | io_cb, 90 | pfd->fd, 91 | (pfd->events & G_IO_IN ? EV_READ : 0) 92 | | (pfd->events & G_IO_OUT ? EV_WRITE : 0) 93 | ); 94 | iow->data = (void *)pfd; 95 | ev_set_priority (iow, EV_MINPRI); 96 | ev_io_start (EV_A iow); 97 | } 98 | 99 | if (timeout >= 0) 100 | { 101 | ev_timer_set (&ctx->tw, timeout * 1e-3, 0.); 102 | ev_timer_start (EV_A &ctx->tw); 103 | } 104 | } 105 | 106 | static void check_cb (EV_P_ ev_check *w, int revents) { 107 | struct econtext *ctx = (struct econtext *)(((char *)w) - offsetof (struct econtext, cw)); 108 | int i; 109 | 110 | for (i = 0; i < ctx->nfd; ++i) 111 | { 112 | ev_io *iow = ctx->iow + i; 113 | 114 | if (ev_is_pending (iow)) 115 | { 116 | GPollFD *pfd = ctx->pfd + i; 117 | int revents = ev_clear_pending (EV_A iow); 118 | 119 | pfd->revents |= pfd->events & 120 | ((revents & EV_READ ? G_IO_IN : 0) 121 | | (revents & EV_WRITE ? G_IO_OUT : 0)); 122 | } 123 | 124 | ev_io_stop (EV_A iow); 125 | } 126 | 127 | if (ev_is_active (&ctx->tw)) 128 | ev_timer_stop (EV_A &ctx->tw); 129 | 130 | g_main_context_check (ctx->gc, ctx->maxpri, ctx->pfd, ctx->nfd); 131 | } 132 | 133 | static struct econtext default_context; 134 | 135 | static Handle GtkInit (const Arguments &args) { 136 | HandleScope scope; 137 | gtk_init(NULL, NULL); 138 | g_type_init(); 139 | return Undefined(); 140 | } 141 | 142 | static Handle GtkMain (const Arguments &args) { 143 | HandleScope scope; 144 | gtk_main(); 145 | return Undefined(); 146 | } 147 | 148 | static Handle GtkMainQuit (const Arguments &args) { 149 | HandleScope scope; 150 | gtk_main_quit(); 151 | return Undefined(); 152 | } 153 | 154 | extern "C" void init(Handle target) { 155 | HandleScope scope; 156 | 157 | // We can't init here. 158 | //gtk_init(NULL, NULL); 159 | 160 | // User has to init inside a nextTick etc. 161 | GTK_ATTACH_FUNCTION(target, "init", GtkInit); 162 | GTK_ATTACH_FUNCTION(target, "main", GtkMain); 163 | GTK_ATTACH_FUNCTION(target, "main_quit", GtkMainQuit); 164 | 165 | 166 | GMainContext *gc = g_main_context_default(); 167 | struct econtext *ctx = &default_context; 168 | 169 | NodeGObject::Initialize(target); 170 | NodeGtkObject::Initialize(target); 171 | NodeGtkWidget::Initialize(target); 172 | NodeGtkContainer::Initialize(target); 173 | NodeGtkBin::Initialize(target); 174 | NodeGtkBox::Initialize(target); 175 | NodeGtkHBox::Initialize(target); 176 | NodeGtkVBox::Initialize(target); 177 | NodeGtkWindow::Initialize(target); 178 | NodeGtkEntry::Initialize(target); 179 | NodeGtkButton::Initialize(target); 180 | NodeGtkMisc::Initialize(target); 181 | NodeGtkLabel::Initialize(target); 182 | NodeGtkTreeStore::Initialize(target); 183 | NodeGtkTreeIter::Initialize(target); 184 | NodeGtkTreeView::Initialize(target); 185 | NodeGtkTreeViewColumn::Initialize(target); 186 | NodeGtkCellRenderer::Initialize(target); 187 | NodeGtkCellRendererText::Initialize(target); 188 | NodeGtkCellRendererToggle::Initialize(target); 189 | 190 | ctx->gc = g_main_context_ref(gc); 191 | ctx->nfd = 0; 192 | ctx->afd = 0; 193 | ctx->iow = 0; 194 | ctx->pfd = 0; 195 | 196 | ev_prepare_init (&ctx->pw, prepare_cb); 197 | ev_set_priority (&ctx->pw, EV_MINPRI); 198 | ev_prepare_start (EV_DEFAULT_UC_ &ctx->pw); 199 | ev_unref(EV_DEFAULT_UC_); 200 | 201 | ev_check_init (&ctx->cw, check_cb); 202 | ev_set_priority (&ctx->cw, EV_MAXPRI); 203 | ev_check_start (EV_DEFAULT_UC_ &ctx->cw); 204 | ev_unref(EV_DEFAULT_UC_); 205 | 206 | ev_init (&ctx->tw, timer_cb); 207 | ev_set_priority (&ctx->tw, EV_MINPRI); 208 | } 209 | 210 | } // namespace ngtk 211 | -------------------------------------------------------------------------------- /src/gtk.h: -------------------------------------------------------------------------------- 1 | #ifndef GTK_H_ 2 | #define GTK_H_ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | namespace ngtk { 9 | 10 | #define GTK_DEFINE_CONSTANT(target, name, constant) \ 11 | (target)->Set(v8::String::NewSymbol(name), \ 12 | v8::Integer::New(constant), \ 13 | static_cast(v8::ReadOnly|v8::DontDelete)) 14 | 15 | 16 | #define GTK_NOARG_FUNCTION(target, type, function) \ 17 | Handle function (const Arguments &args) { \ 18 | HandleScope scope; \ 19 | type *widget = target::Data(args[0]->ToObject()); \ 20 | function(widget); \ 21 | return Undefined(); \ 22 | } 23 | 24 | #define GTK_ATTACH_FUNCTION(target, name, function) \ 25 | target->Set( \ 26 | v8::String::NewSymbol(name), \ 27 | v8::FunctionTemplate::New(function)->GetFunction()) 28 | 29 | #define NODE_GTK_NEW_CLASS(target, name) \ 30 | do { \ 31 | /* Create a new JavaScript class */ \ 32 | Handle fnTemplate = FunctionTemplate::New(); \ 33 | fnTemplate->SetClassName(String::New(name)); \ 34 | target = Persistent::New(fnTemplate); \ 35 | \ 36 | /* Set up the class to point to a C++ class */ \ 37 | Handle instance = fnTemplate->InstanceTemplate(); \ 38 | instance->SetInternalFieldCount(1); \ 39 | } while (0) 40 | 41 | #define NODE_GTK_SET_REF(object, Class) \ 42 | g_object_set_data(G_OBJECT(object->getWidget()), "NodeGTK-"#Class, object); 43 | 44 | #define NODE_GTK_SET_REF_WITH_GETTER(object, Class, getter) \ 45 | g_object_set_data(G_OBJECT(object->getter()), "NodeGTK-"#Class, object); 46 | 47 | #define NODE_GTK_GET_REF(object, ptr, Class) \ 48 | printf("Getting ref to NodeGTK-"#Class"\n"); \ 49 | ptr = (Class *)(g_object_get_data(G_OBJECT(object), "NodeGTK-"#Class)); \ 50 | printf("Got ref\n"); 51 | 52 | 53 | } // namespace ngtk 54 | 55 | #endif 56 | -------------------------------------------------------------------------------- /src/gtk_bin.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mx-moth/node-gtk/b849d8907bb3d054df2a6b64148355ad9c0288aa/src/gtk_bin.cc -------------------------------------------------------------------------------- /src/gtk_bin.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_BIN_H_ 2 | #define NGTK_BIN_H_ 3 | 4 | #include "gtk_container.h" 5 | 6 | namespace nodeGtk { 7 | class NodeGtkBin : public NodeGtkContainer { 8 | 9 | public: 10 | 11 | // For getting the underlying GtkWidget 12 | static inline GtkBin* Data (v8::Handle obj) { 13 | v8::HandleScope scope; 14 | return GTK_BIN(ObjectWrap::Unwrap(obj)->getWidget()); 15 | } 16 | 17 | /** 18 | * Retrieves a reference to this instance from the widget 19 | * 20 | * Parameters: 21 | * object - The GObject that holds the reference 22 | */ 23 | static NodeGtkBin* From(GtkBin *object) { 24 | return (NodeGtkBin *)(g_object_get_data(G_OBJECT(object), "NodeGTK-ref")); 25 | } 26 | 27 | }; 28 | } 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/gtk_box.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_box.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * Attach all box methods to the target 12 | * 13 | * Parameters: 14 | * target: The object to attach methods to 15 | */ 16 | void NodeGtkBox::SetupMethods (Handle target) { 17 | HandleScope scope; 18 | } 19 | 20 | /** 21 | * Attach all signals 22 | * 23 | * Parameters: 24 | * target: The object to attach methods to 25 | */ 26 | void NodeGtkBox::SetupCallbacks (std::vector *callbacks) { 27 | NodeGtkContainer::SetupCallbacks(callbacks); 28 | } 29 | 30 | /** 31 | * Sets up the environment with all things entryish 32 | * 33 | * Parameters: 34 | * target: The object to attach methods to 35 | */ 36 | void NodeGtkBox::Initialize (Handle target) { 37 | HandleScope scope; 38 | 39 | // Attach methods to the target 40 | NodeGtkBox::SetupMethods(target); 41 | NodeGtkBox::SetupCallbacks(callbacks); 42 | 43 | } 44 | } 45 | 46 | -------------------------------------------------------------------------------- /src/gtk_box.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_BOX_H_ 2 | #define NGTK_BOX_H_ 3 | 4 | #include "gtk_container.h" 5 | 6 | namespace nodeGtk { 7 | class NodeGtkBox : public NodeGtkContainer { 8 | 9 | public: 10 | 11 | // For getting the underlying GtkBox 12 | static inline GtkBox* Data (v8::Handle obj) { 13 | v8::HandleScope scope; 14 | return GTK_BOX(ObjectWrap::Unwrap(obj)->getWidget()); 15 | } 16 | 17 | static void SetupMethods (v8::Handle target); 18 | static void SetupCallbacks(std::vector *callbacks); 19 | static void Initialize (v8::Handle target); 20 | 21 | /** 22 | * Retrieves a reference to this instance from the widget 23 | * 24 | * Parameters: 25 | * object - The GtkBox that holds the reference 26 | */ 27 | static GtkBox* From(GtkBox *object) { 28 | return (GtkBox*)(g_object_get_data(G_OBJECT(object), "NodeGTK-ref")); 29 | } 30 | 31 | }; 32 | } 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/gtk_button.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_button.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for Buttons 12 | */ 13 | Persistent NodeGtkButton::constructor_template; 14 | 15 | /** 16 | * Creates a new Button 17 | * 18 | * Parameters: 19 | * type - One of the GtkButtonTypes 20 | */ 21 | NodeGtkButton::NodeGtkButton (GtkWidget *button) { 22 | widget = button; 23 | addRef(); 24 | NODE_GTK_SET_REF(this, NodeGtkWindow); 25 | newJavaScriptInstance(constructor_template); 26 | } 27 | 28 | /** 29 | * Creates a new Button and attaches it to a JavaScript object 30 | * 31 | * Parameters: 32 | * type - One of the GtkButtonTypes 33 | * 34 | * Returns: 35 | * A new instance of the Button class 36 | */ 37 | Handle node_gtk_button_new (const Arguments &args) { 38 | HandleScope scope; 39 | 40 | GtkWidget *button = gtk_button_new(); 41 | NodeGtkButton *node_button = new NodeGtkButton(button); 42 | 43 | return node_button->obj; 44 | } 45 | 46 | /* 47 | GtkWidget* gtk_button_new_with_label (const gchar *label); 48 | GtkWidget* gtk_button_new_with_mnemonic (const gchar *label); 49 | GtkWidget* gtk_button_new_from_stock (const gchar *stock_id); 50 | */ 51 | 52 | Handle node_gtk_button_pressed(const Arguments &args) { 53 | HandleScope scope; 54 | GtkButton *button = NodeGtkButton::Data(args[0]->ToObject()); 55 | gtk_button_pressed(button); 56 | return Undefined(); 57 | } 58 | Handle node_gtk_button_released(const Arguments &args) { 59 | HandleScope scope; 60 | GtkButton *button = NodeGtkButton::Data(args[0]->ToObject()); 61 | gtk_button_released(button); 62 | return Undefined(); 63 | } 64 | Handle node_gtk_button_clicked(const Arguments &args) { 65 | HandleScope scope; 66 | GtkButton *button = NodeGtkButton::Data(args[0]->ToObject()); 67 | gtk_button_clicked(button); 68 | return Undefined(); 69 | } 70 | Handle node_gtk_button_enter(const Arguments &args) { 71 | HandleScope scope; 72 | GtkButton *button = NodeGtkButton::Data(args[0]->ToObject()); 73 | gtk_button_enter(button); 74 | return Undefined(); 75 | } 76 | Handle node_gtk_button_leave(const Arguments &args) { 77 | HandleScope scope; 78 | GtkButton *button = NodeGtkButton::Data(args[0]->ToObject()); 79 | gtk_button_leave(button); 80 | return Undefined(); 81 | } 82 | 83 | /* 84 | void gtk_button_set_relief (GtkButton *button, GtkReliefStyle newstyle); 85 | GtkReliefStyle gtk_button_get_relief (GtkButton *button); 86 | */ 87 | 88 | Handle node_gtk_button_get_label(const Arguments &args) { 89 | HandleScope scope; 90 | GtkButton *button = NodeGtkButton::Data(args[0]->ToObject()); 91 | const gchar *label = gtk_button_get_label(button); 92 | return scope.Close(String::New(label)); 93 | } 94 | 95 | Handle node_gtk_button_set_label(const Arguments &args) { 96 | HandleScope scope; 97 | 98 | GtkButton *button = NodeGtkButton::Data(args[0]->ToObject()); 99 | String::AsciiValue label(args[1]->ToString()); 100 | 101 | gtk_button_set_label(button, *label); 102 | return Undefined(); 103 | } 104 | 105 | /* 106 | gboolean gtk_button_get_use_stock (GtkButton *button); 107 | void gtk_button_set_use_stock (GtkButton *button, gboolean use_stock); 108 | gboolean gtk_button_get_use_underline (GtkButton *button); 109 | void gtk_button_set_use_underline (GtkButton *button, gboolean use_underline); 110 | void gtk_button_set_focus_on_click (GtkButton *button, gboolean focus_on_click); 111 | gboolean gtk_button_get_focus_on_click (GtkButton *button); 112 | void gtk_button_set_alignment (GtkButton *button, gfloat xalign, gfloat yalign); 113 | void gtk_button_get_alignment (GtkButton *button, gfloat *xalign, gfloat *yalign); 114 | */ 115 | 116 | /** 117 | * Attach all button methods to the target 118 | * 119 | * Parameters: 120 | * target: The object to attach methods to 121 | */ 122 | void NodeGtkButton::SetupMethods (Handle target) { 123 | HandleScope scope; 124 | 125 | target->Set(v8::String::NewSymbol("button_new"), v8::FunctionTemplate::New(node_gtk_button_new)->GetFunction()); 126 | target->Set(v8::String::NewSymbol("button_pressed"), v8::FunctionTemplate::New(node_gtk_button_pressed)->GetFunction()); 127 | target->Set(v8::String::NewSymbol("button_released"), v8::FunctionTemplate::New(node_gtk_button_released)->GetFunction()); 128 | target->Set(v8::String::NewSymbol("button_clicked"), v8::FunctionTemplate::New(node_gtk_button_clicked)->GetFunction()); 129 | target->Set(v8::String::NewSymbol("button_enter"), v8::FunctionTemplate::New(node_gtk_button_enter)->GetFunction()); 130 | target->Set(v8::String::NewSymbol("button_leave"), v8::FunctionTemplate::New(node_gtk_button_leave)->GetFunction()); 131 | target->Set(v8::String::NewSymbol("button_set_label"), v8::FunctionTemplate::New(node_gtk_button_set_label)->GetFunction()); 132 | target->Set(v8::String::NewSymbol("button_get_label"), v8::FunctionTemplate::New(node_gtk_button_get_label)->GetFunction()); 133 | } 134 | 135 | void NodeGtkButton::SetupCallbacks(std::vector *callbacks) { 136 | NodeGtkBin::SetupCallbacks(callbacks); 137 | (*callbacks).push_back(SignalCallback("activate", G_CALLBACK(signal_bare))); 138 | (*callbacks).push_back(SignalCallback("clicked", G_CALLBACK(signal_bare))); 139 | (*callbacks).push_back(SignalCallback("enter", G_CALLBACK(signal_bare))); 140 | (*callbacks).push_back(SignalCallback("leave", G_CALLBACK(signal_bare))); 141 | (*callbacks).push_back(SignalCallback("pressed", G_CALLBACK(signal_bare))); 142 | (*callbacks).push_back(SignalCallback("released", G_CALLBACK(signal_bare))); 143 | } 144 | 145 | void NodeGtkButton::SetupConstants (Handle target) { } 146 | 147 | /** 148 | * Sets up the environment with all things buttonish 149 | * 150 | * Parameters: 151 | * target: The object to attach methods to 152 | */ 153 | void NodeGtkButton::Initialize (Handle target) { 154 | HandleScope scope; 155 | 156 | // Create a new JavaScript class 157 | Handle buttonTemplate = FunctionTemplate::New(); 158 | buttonTemplate->SetClassName(String::New("Button")); 159 | constructor_template = Persistent::New(buttonTemplate); 160 | 161 | // Set up the class to point to a C++ class 162 | Handle buttonInstance = buttonTemplate->InstanceTemplate(); 163 | buttonInstance->SetInternalFieldCount(1); 164 | 165 | // Attach methods to the target 166 | NodeGtkButton::SetupMethods(target); 167 | NodeGtkButton::SetupConstants(target); 168 | NodeGtkButton::SetupCallbacks(callbacks); 169 | 170 | } 171 | } 172 | -------------------------------------------------------------------------------- /src/gtk_button.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_BUTTON_H_ 2 | #define NGTK_BUTTON_H_ 3 | 4 | #include "gtk_bin.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkButton: public NodeGtkBin { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | /** 15 | * Constructor. Creates a new Button, which will wrap a new GtkButton 16 | */ 17 | NodeGtkButton(GtkWidget *button); 18 | 19 | /** 20 | * Checks to see if a v8::Object is a Button in disguise 21 | * 22 | * Parameters: 23 | * obj - The object to check for Buttonness 24 | * 25 | * Returns: 26 | * True if the object is a button, false otherwise 27 | */ 28 | static inline bool HasInstance(v8::Handle val) { 29 | v8::HandleScope scope; 30 | 31 | if (val->IsObject()) { 32 | v8::Local obj = val->ToObject(); 33 | 34 | if (constructor_template->HasInstance(obj)) { 35 | return true; 36 | } 37 | } 38 | return false; 39 | } 40 | 41 | /** 42 | * For getting the underlying GtkWidget. 43 | * 44 | * Usage: 45 | * (code) 46 | * GtkButton *button = Button::Data(args[n]->ToObject()); 47 | * (end) 48 | * 49 | * Returns: 50 | * The pointer to the GtkButton contained in this Button 51 | */ 52 | static inline GtkButton* Data (v8::Handle obj) { 53 | v8::HandleScope scope; 54 | return GTK_BUTTON(ObjectWrap::Unwrap(obj)->getWidget()); 55 | } 56 | 57 | static void SetupMethods (v8::Handle target); 58 | static void SetupConstants (v8::Handle target); 59 | static void SetupCallbacks(std::vector *callbacks); 60 | static void Initialize (v8::Handle target); 61 | 62 | /** 63 | * Retrieves a reference to this instance from the widget 64 | * 65 | * Parameters: 66 | * object - The GtkButton that holds the reference 67 | */ 68 | static NodeGtkButton* From(GtkButton *object) { 69 | NodeGtkButton *button; 70 | NODE_GTK_GET_REF(object, button, NodeGtkButton); 71 | return button; 72 | } 73 | 74 | }; 75 | 76 | } // namespace ngtk 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /src/gtk_cell_renderer.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_cell_renderer.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for CellRenderers 12 | */ 13 | Persistent NodeGtkCellRenderer::constructor_template; 14 | 15 | /** 16 | * Attach all cell renderer methods to the target 17 | * 18 | * Parameters: 19 | * target: The object to attach methods to 20 | */ 21 | void NodeGtkCellRenderer::SetupMethods (Handle target) { 22 | HandleScope scope; 23 | } 24 | void NodeGtkCellRenderer::SetupCallbacks(std::vector *callbacks) { 25 | NodeGtkWidget::SetupCallbacks(callbacks); 26 | } 27 | 28 | /** 29 | * Sets up the environment with all things cell rendery 30 | * 31 | * Parameters: 32 | * target: The object to attach methods to 33 | */ 34 | void NodeGtkCellRenderer::Initialize (Handle target) { 35 | HandleScope scope; 36 | 37 | // Attach methods to the target 38 | NodeGtkCellRenderer::SetupMethods(target); 39 | NodeGtkCellRenderer::SetupConstants(target); 40 | NodeGtkCellRenderer::SetupCallbacks(callbacks); 41 | 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/gtk_cell_renderer.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_CELL_RENDERER_H_ 2 | #define NGTK_CELL_RENDERER_H_ 3 | 4 | #include "gtk_widget.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkCellRenderer: public nodeGtk::NodeGtkObject { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | GtkCellRenderer *cellRenderer; 15 | 16 | /** 17 | * Checks to see if a v8::Object is a CellRenderer in disguise 18 | * 19 | * Parameters: 20 | * obj - The object to check for CellRendererness 21 | * 22 | * Returns: 23 | * True if the object is a cell renderer, false otherwise 24 | */ 25 | static inline bool HasInstance(v8::Handle val) { 26 | v8::HandleScope scope; 27 | 28 | if (val->IsObject()) { 29 | v8::Local obj = val->ToObject(); 30 | 31 | if (constructor_template->HasInstance(obj)) { 32 | return true; 33 | } 34 | } 35 | return false; 36 | } 37 | 38 | /** 39 | * For getting the underlying GtkWidget. 40 | * 41 | * Usage: 42 | * (code) 43 | * GtkCellRenderer *cellRenderer = CellRenderer::Data(args[n]->ToObject()); 44 | * (end) 45 | * 46 | * Returns: 47 | * The pointer to the GtkCellRenderer contained in this CellRenderer 48 | */ 49 | static inline GtkCellRenderer* Data (v8::Handle obj) { 50 | v8::HandleScope scope; 51 | return GTK_CELL_RENDERER(ObjectWrap::Unwrap(obj)->getCellRenderer()); 52 | } 53 | 54 | virtual inline GtkCellRenderer* getCellRenderer() { 55 | return cellRenderer; 56 | } 57 | virtual inline void setWidget(GtkCellRenderer *cellRenderer) { 58 | this->cellRenderer = cellRenderer; 59 | } 60 | 61 | static void SetupMethods (v8::Handle target); 62 | static void SetupCallbacks(std::vector *callbacks); 63 | static void Initialize (v8::Handle target); 64 | 65 | /** 66 | * Retrieves a reference to this instance from the widget 67 | * 68 | * Parameters: 69 | * object - The GtkCellRenderer that holds the reference 70 | */ 71 | static NodeGtkCellRenderer* From(GtkCellRenderer *object) { 72 | NodeGtkCellRenderer *button; 73 | NODE_GTK_GET_REF(object, button, NodeGtkCellRenderer); 74 | return button; 75 | } 76 | 77 | }; 78 | 79 | } // namespace ngtk 80 | 81 | #endif 82 | -------------------------------------------------------------------------------- /src/gtk_cell_renderer_text.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_cell_renderer_text.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for CellRenderers 12 | */ 13 | Persistent NodeGtkCellRendererText::constructor_template; 14 | 15 | /** 16 | * Creates a new Cell Renderer for Text 17 | * 18 | * Parameters: 19 | * cellRendererText - An instance of a GtkCellRendererText to wrap 20 | */ 21 | NodeGtkCellRendererText::NodeGtkCellRendererText(GtkCellRenderer *cellRendererText) { 22 | this->cellRenderer = cellRendererText; 23 | NODE_GTK_SET_REF_WITH_GETTER(this, NodeGtkCellRendererText, getCellRenderer); 24 | newJavaScriptInstance(constructor_template); 25 | } 26 | 27 | /** 28 | * Creates a new GtkCellRendererText and attaches it to a JavaScript object 29 | * 30 | * Parameters: 31 | * type - One of the GtkButtonTypes 32 | * 33 | * Returns: 34 | * A new instance of the Button class 35 | */ 36 | Handle node_gtk_cell_renderer_text_new (const Arguments &args) { 37 | HandleScope scope; 38 | 39 | GtkCellRenderer *cellRendererText = gtk_cell_renderer_text_new(); 40 | NodeGtkCellRendererText *nodeCellRendererText = new NodeGtkCellRendererText(cellRendererText); 41 | 42 | return nodeCellRendererText->obj; 43 | } 44 | /** 45 | * Attach all text cell renderer methods to the target 46 | * 47 | * Parameters: 48 | * target: The object to attach methods to 49 | */ 50 | void NodeGtkCellRendererText::SetupMethods (Handle target) { 51 | HandleScope scope; 52 | 53 | target->Set(v8::String::NewSymbol("cell_renderer_text_new"), v8::FunctionTemplate::New(node_gtk_cell_renderer_text_new)->GetFunction()); 54 | } 55 | 56 | void NodeGtkCellRendererText::SetupCallbacks(std::vector *callbacks) { 57 | NodeGtkWidget::SetupCallbacks(callbacks); 58 | } 59 | 60 | void NodeGtkCellRendererText::SetupConstants (Handle target) { } 61 | 62 | /** 63 | * Sets up the environment with all things cell rendery 64 | * 65 | * Parameters: 66 | * target: The object to attach methods to 67 | */ 68 | void NodeGtkCellRendererText::Initialize (Handle target) { 69 | HandleScope scope; 70 | 71 | // Create a new JavaScript class 72 | Handle cellRendererTextTemplate = FunctionTemplate::New(); 73 | cellRendererTextTemplate->SetClassName(String::New("CellRendererText")); 74 | constructor_template = Persistent::New(cellRendererTextTemplate); 75 | 76 | // Set up the class to point to a C++ class 77 | Handle cellRendererTextInstance = cellRendererTextTemplate->InstanceTemplate(); 78 | cellRendererTextInstance->SetInternalFieldCount(1); 79 | 80 | // Attach methods to the target 81 | NodeGtkCellRendererText::SetupMethods(target); 82 | NodeGtkCellRendererText::SetupConstants(target); 83 | NodeGtkCellRendererText::SetupCallbacks(callbacks); 84 | 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /src/gtk_cell_renderer_text.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_CELL_RENDERER_TEXT_H_ 2 | #define NGTK_CELL_RENDERER_TEXT_H_ 3 | 4 | #include "gtk_cell_renderer.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkCellRendererText: public NodeGtkCellRenderer { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | NodeGtkCellRendererText(GtkCellRenderer *cellRendererText); 15 | 16 | /** 17 | * Checks to see if a v8::Object is a CellRendererText in disguise 18 | * 19 | * Parameters: 20 | * obj - The object to check for CellRendererness 21 | * 22 | * Returns: 23 | * True if the object is a cell renderer, false otherwise 24 | */ 25 | static inline bool HasInstance(v8::Handle val) { 26 | v8::HandleScope scope; 27 | 28 | if (val->IsObject()) { 29 | v8::Local obj = val->ToObject(); 30 | 31 | if (constructor_template->HasInstance(obj)) { 32 | return true; 33 | } 34 | } 35 | return false; 36 | } 37 | 38 | /** 39 | * For getting the underlying GtkWidget. 40 | * 41 | * Usage: 42 | * (code) 43 | * GtkCellRendererText *cellRenderer = CellRendererText::Data(args[n]->ToObject()); 44 | * (end) 45 | * 46 | * Returns: 47 | * The pointer to the GtkCellRendererText contained in this CellRendererText 48 | */ 49 | static inline GtkCellRendererText* Data (v8::Handle obj) { 50 | v8::HandleScope scope; 51 | assert(NodeGtkCellRendererText::HasInstance(obj)); 52 | return GTK_CELL_RENDERER_TEXT(ObjectWrap::Unwrap(obj)->getCellRenderer()); 53 | } 54 | 55 | static void SetupMethods (v8::Handle target); 56 | static void SetupConstants (v8::Handle target); 57 | static void SetupCallbacks(std::vector *callbacks); 58 | static void Initialize (v8::Handle target); 59 | 60 | /** 61 | * Retrieves a reference to this instance from the widget 62 | * 63 | * Parameters: 64 | * object - The GtkCellRendererText that holds the reference 65 | */ 66 | static NodeGtkCellRendererText* From(GtkCellRendererText *object) { 67 | NodeGtkCellRendererText *button; 68 | NODE_GTK_GET_REF(object, button, NodeGtkCellRendererText); 69 | return button; 70 | } 71 | 72 | }; 73 | 74 | } // namespace ngtk 75 | 76 | #endif 77 | -------------------------------------------------------------------------------- /src/gtk_cell_renderer_toggle.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_cell_renderer_toggle.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for CellRenderers 12 | */ 13 | Persistent NodeGtkCellRendererToggle::constructor_template; 14 | 15 | /** 16 | * Creates a new Cell Renderer for Toggle 17 | * 18 | * Parameters: 19 | * cellRendererToggle - An instance of a GtkCellRendererToggle to wrap 20 | */ 21 | NodeGtkCellRendererToggle::NodeGtkCellRendererToggle(GtkCellRenderer *cellRendererToggle) { 22 | this->cellRenderer = cellRendererToggle; 23 | NODE_GTK_SET_REF_WITH_GETTER(this, NodeGtkCellRendererToggle, getCellRenderer); 24 | newJavaScriptInstance(constructor_template); 25 | } 26 | 27 | /** 28 | * Creates a new GtkCellRendererToggle and attaches it to a JavaScript object 29 | * 30 | * Parameters: 31 | * type - One of the GtkButtonTypes 32 | * 33 | * Returns: 34 | * A new instance of the Button class 35 | */ 36 | Handle node_gtk_cell_renderer_toggle_new (const Arguments &args) { 37 | HandleScope scope; 38 | 39 | GtkCellRenderer *cellRendererToggle = gtk_cell_renderer_toggle_new(); 40 | NodeGtkCellRendererToggle *nodeCellRendererToggle = new NodeGtkCellRendererToggle(cellRendererToggle); 41 | 42 | return nodeCellRendererToggle->obj; 43 | } 44 | /** 45 | * Attach all toggle cell renderer methods to the target 46 | * 47 | * Parameters: 48 | * target: The object to attach methods to 49 | */ 50 | void NodeGtkCellRendererToggle::SetupMethods (Handle target) { 51 | HandleScope scope; 52 | 53 | target->Set(v8::String::NewSymbol("cell_renderer_toggle_new"), v8::FunctionTemplate::New(node_gtk_cell_renderer_toggle_new)->GetFunction()); 54 | } 55 | 56 | void NodeGtkCellRendererToggle::SetupCallbacks(std::vector *callbacks) { 57 | NodeGtkWidget::SetupCallbacks(callbacks); 58 | } 59 | 60 | void NodeGtkCellRendererToggle::SetupConstants (Handle target) { } 61 | 62 | /** 63 | * Sets up the environment with all things cell rendery 64 | * 65 | * Parameters: 66 | * target: The object to attach methods to 67 | */ 68 | void NodeGtkCellRendererToggle::Initialize (Handle target) { 69 | HandleScope scope; 70 | 71 | // Create a new JavaScript class 72 | Handle cellRendererToggleTemplate = FunctionTemplate::New(); 73 | cellRendererToggleTemplate->SetClassName(String::New("CellRendererToggle")); 74 | constructor_template = Persistent::New(cellRendererToggleTemplate); 75 | 76 | // Set up the class to point to a C++ class 77 | Handle cellRendererToggleInstance = cellRendererToggleTemplate->InstanceTemplate(); 78 | cellRendererToggleInstance->SetInternalFieldCount(1); 79 | 80 | // Attach methods to the target 81 | NodeGtkCellRendererToggle::SetupMethods(target); 82 | NodeGtkCellRendererToggle::SetupConstants(target); 83 | NodeGtkCellRendererToggle::SetupCallbacks(callbacks); 84 | 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /src/gtk_cell_renderer_toggle.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_CELL_RENDERER_TOGGLE_H_ 2 | #define NGTK_CELL_RENDERER_TOGGLE_H_ 3 | 4 | #include "gtk_cell_renderer.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkCellRendererToggle: public NodeGtkCellRenderer { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | NodeGtkCellRendererToggle(GtkCellRenderer *cellRendererToggle); 15 | 16 | /** 17 | * Checks to see if a v8::Object is a CellRendererToggle in disguise 18 | * 19 | * Parameters: 20 | * obj - The object to check for CellRendererness 21 | * 22 | * Returns: 23 | * True if the object is a cell renderer, false otherwise 24 | */ 25 | static inline bool HasInstance(v8::Handle val) { 26 | v8::HandleScope scope; 27 | 28 | if (val->IsObject()) { 29 | v8::Local obj = val->ToObject(); 30 | 31 | if (constructor_template->HasInstance(obj)) { 32 | return true; 33 | } 34 | } 35 | return false; 36 | } 37 | 38 | /** 39 | * For getting the underlying GtkWidget. 40 | * 41 | * Usage: 42 | * (code) 43 | * GtkCellRendererToggle *cellRenderer = CellRendererToggle::Data(args[n]->ToObject()); 44 | * (end) 45 | * 46 | * Returns: 47 | * The pointer to the GtkCellRendererToggle contained in this CellRendererToggle 48 | */ 49 | static inline GtkCellRendererToggle* Data (v8::Handle obj) { 50 | v8::HandleScope scope; 51 | assert(NodeGtkCellRendererToggle::HasInstance(obj)); 52 | return GTK_CELL_RENDERER_TOGGLE(ObjectWrap::Unwrap(obj)->getCellRenderer()); 53 | } 54 | 55 | static void SetupMethods (v8::Handle target); 56 | static void SetupConstants (v8::Handle target); 57 | static void SetupCallbacks(std::vector *callbacks); 58 | static void Initialize (v8::Handle target); 59 | 60 | /** 61 | * Retrieves a reference to this instance from the widget 62 | * 63 | * Parameters: 64 | * object - The GtkCellRendererToggle that holds the reference 65 | */ 66 | static NodeGtkCellRendererToggle* From(GtkCellRendererToggle *object) { 67 | NodeGtkCellRendererToggle *button; 68 | NODE_GTK_GET_REF(object, button, NodeGtkCellRendererToggle); 69 | return button; 70 | } 71 | 72 | }; 73 | 74 | } // namespace ngtk 75 | 76 | #endif 77 | -------------------------------------------------------------------------------- /src/gtk_container.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_container.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | 11 | /** 12 | * Creates a new Container and attaches it to a JavaScript object 13 | * 14 | * Parameters: 15 | * type - One of the GtkContainerTypes 16 | * 17 | * Returns: 18 | * A new instance of the Container class 19 | */ 20 | Handle gtk_container_add (const Arguments &args) { 21 | HandleScope scope; 22 | 23 | GtkContainer *container = NodeGtkContainer::Data(args[0]->ToObject()); 24 | GtkWidget *widget = NodeGtkWidget::Data(args[1]->ToObject()); 25 | 26 | gtk_container_add(container, widget); 27 | 28 | return Undefined(); 29 | } 30 | 31 | 32 | /** 33 | * Attach all container methods to the target 34 | * 35 | * Parameters: 36 | * target: The object to attach methods to 37 | */ 38 | void NodeGtkContainer::SetupMethods (Handle target) { 39 | HandleScope scope; 40 | 41 | target->Set(v8::String::NewSymbol("container_add"), v8::FunctionTemplate::New(gtk_container_add)->GetFunction()); 42 | } 43 | 44 | /** 45 | * Attach all container signals 46 | * 47 | * Parameters: 48 | * target: The object to attach methods to 49 | */ 50 | void NodeGtkContainer::SetupCallbacks (std::vector *callbacks) { 51 | NodeGtkWidget::SetupCallbacks(callbacks); 52 | } 53 | 54 | /** 55 | * Sets up the environment with all things entryish 56 | * 57 | * Parameters: 58 | * target: The object to attach methods to 59 | */ 60 | void NodeGtkContainer::Initialize (Handle target) { 61 | HandleScope scope; 62 | 63 | // Attach methods to the target 64 | NodeGtkContainer::SetupMethods(target); 65 | NodeGtkContainer::SetupCallbacks(callbacks); 66 | 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /src/gtk_container.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_CONTAINER_H_ 2 | #define NGTK_CONTAINER_H_ 3 | 4 | #include "gtk_widget.h" 5 | 6 | namespace nodeGtk { 7 | class NodeGtkContainer : public NodeGtkWidget { 8 | 9 | public: 10 | 11 | // For getting the underlying GtkWidget 12 | static inline GtkContainer* Data (v8::Handle obj) { 13 | v8::HandleScope scope; 14 | return GTK_CONTAINER(ObjectWrap::Unwrap(obj)->getWidget()); 15 | } 16 | 17 | static void SetupMethods (v8::Handle target); 18 | static void SetupCallbacks(std::vector *callbacks); 19 | static void Initialize (v8::Handle target); 20 | 21 | /** 22 | * Retrieves a reference to this instance from the widget 23 | * 24 | * Parameters: 25 | * object - The GtkContainer that holds the reference 26 | */ 27 | static NodeGtkContainer* From(GtkContainer *object) { 28 | return (NodeGtkContainer*)(g_object_get_data(G_OBJECT(object), "NodeGTK-ref")); 29 | } 30 | 31 | }; 32 | } 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/gtk_entry.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_entry.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for Entrys 12 | */ 13 | Persistent NodeGtkEntry::constructor_template; 14 | 15 | /** 16 | * Creates a new NodeGtkEntry 17 | * 18 | * Parameters: 19 | * type - One of the GtkEntryTypes 20 | */ 21 | NodeGtkEntry::NodeGtkEntry () { 22 | widget = gtk_entry_new(); 23 | addRef(); 24 | 25 | obj = NodeGtkEntry::constructor_template->GetFunction()->NewInstance(); 26 | obj->SetInternalField(0, External::New(this)); 27 | } 28 | 29 | /** 30 | * Creates a new NodeGtkEntry and attaches it to a JavaScript object 31 | * 32 | * Parameters: 33 | * type - One of the GtkEntryTypes 34 | * 35 | * Returns: 36 | * A new instance of the NodeGtkEntry class 37 | */ 38 | Handle gtk_entry_new (const Arguments &args) { 39 | HandleScope scope; 40 | 41 | NodeGtkEntry *entry = new NodeGtkEntry(); 42 | 43 | return entry->obj; 44 | } 45 | 46 | /** 47 | * Sets the text of an entry 48 | * 49 | * Parameters: 50 | * entry - The NodeGtkEntry to set the text of 51 | * text - The text to put in the entry 52 | */ 53 | Handle gtk_entry_set_text(const Arguments &args) { 54 | HandleScope scope; 55 | 56 | GtkEntry *entry = NodeGtkEntry::Data(args[0]->ToObject()); 57 | String::AsciiValue text(args[1]->ToString()); 58 | 59 | gtk_entry_set_text(entry, *text); 60 | 61 | return Undefined(); 62 | } 63 | 64 | /** 65 | * Gets the text of an entry 66 | * 67 | * Parameters: 68 | * entry - The NodeGtkEntry to get the text from 69 | * 70 | * Returns: 71 | * The text from the NodeGtkEntry 72 | */ 73 | Handle gtk_entry_get_text(const Arguments &args) { 74 | HandleScope scope; 75 | 76 | GtkEntry *entry = NodeGtkEntry::Data(args[0]->ToObject()); 77 | 78 | return scope.Close(String::New(gtk_entry_get_text(entry))); 79 | } 80 | 81 | /** 82 | * Gets the lenght of the text of an entry 83 | * 84 | * Parameters: 85 | * entry - The NodeGtkEntry to get the text from 86 | * 87 | * Returns: 88 | * The length of the text from the NodeGtkEntry 89 | */ 90 | Handle gtk_entry_get_text_length(const Arguments &args) { 91 | HandleScope scope; 92 | 93 | GtkEntry *entry = NodeGtkEntry::Data(args[0]->ToObject()); 94 | 95 | return scope.Close(Number::New(gtk_entry_get_text_length(entry))); 96 | } 97 | 98 | /** 99 | * Sets the visibility of the entry text. If set invisible, the text is 100 | * replaced with the 'inivisible char'. In other words, this makes an 101 | * entry field in to a password field. 102 | * 103 | * Parameters: 104 | * entry - The NodeGtkEntry to work with 105 | * visible - The visibility of the text 106 | */ 107 | Handle gtk_entry_set_visibility(const Arguments &args) { 108 | HandleScope scope; 109 | 110 | GtkEntry *entry = NodeGtkEntry::Data(args[0]->ToObject()); 111 | bool visible = args[1]->ToBoolean()->Value(); 112 | 113 | gtk_entry_set_visibility(entry, visible); 114 | return Undefined(); 115 | } 116 | 117 | /** 118 | * Attach all entry methods to the target 119 | * 120 | * Parameters: 121 | * target: The object to attach methods to 122 | */ 123 | void NodeGtkEntry::SetupMethods (Handle target) { 124 | HandleScope scope; 125 | 126 | target->Set(v8::String::NewSymbol("entry_new"), v8::FunctionTemplate::New(gtk_entry_new)->GetFunction()); 127 | target->Set(v8::String::NewSymbol("entry_set_text"), v8::FunctionTemplate::New(gtk_entry_set_text)->GetFunction()); 128 | target->Set(v8::String::NewSymbol("entry_get_text"), v8::FunctionTemplate::New(gtk_entry_get_text)->GetFunction()); 129 | target->Set(v8::String::NewSymbol("entry_get_text_length"), v8::FunctionTemplate::New(gtk_entry_get_text_length)->GetFunction()); 130 | target->Set(v8::String::NewSymbol("entry_set_visibility"), v8::FunctionTemplate::New(gtk_entry_set_visibility)->GetFunction()); 131 | } 132 | 133 | void NodeGtkEntry::SetupCallbacks(std::vector *callbacks) { 134 | NodeGtkWidget::SetupCallbacks(callbacks); 135 | //TODO This should be part of the Editable class, but I've not made it yet 136 | (*callbacks).push_back(SignalCallback("changed", G_CALLBACK(signal_bare))); 137 | 138 | (*callbacks).push_back(SignalCallback("activate", G_CALLBACK(signal_bare))); 139 | (*callbacks).push_back(SignalCallback("backspace", G_CALLBACK(signal_bare))); 140 | (*callbacks).push_back(SignalCallback("copy-clipboard", G_CALLBACK(signal_bare))); 141 | (*callbacks).push_back(SignalCallback("cut-clipboard", G_CALLBACK(signal_bare))); 142 | (*callbacks).push_back(SignalCallback("toggle-overwrite", G_CALLBACK(signal_bare))); 143 | 144 | /* 145 | //TODO Unimplemented signals 146 | (*callbacks).push_back(SignalCallback("delete-from-cursor", G_CALLBACK(???))); 147 | (*callbacks).push_back(SignalCallback("icon-press", G_CALLBACK(???))); 148 | (*callbacks).push_back(SignalCallback("icon-release", G_CALLBACK(???))); 149 | (*callbacks).push_back(SignalCallback("insert-at-cursor", G_CALLBACK(???))); 150 | (*callbacks).push_back(SignalCallback("move-cursor", G_CALLBACK(???))); 151 | (*callbacks).push_back(SignalCallback("paste-clipboard", G_CALLBACK(???))); 152 | (*callbacks).push_back(SignalCallback("preedit-changed", G_CALLBACK(???))); 153 | */ 154 | } 155 | 156 | /** 157 | * Sets up the environment with all things entryish 158 | * 159 | * Parameters: 160 | * target: The object to attach methods to 161 | */ 162 | void NodeGtkEntry::Initialize (Handle target) { 163 | HandleScope scope; 164 | 165 | // Create a new JavaScript class 166 | Handle entryTemplate = FunctionTemplate::New(); 167 | entryTemplate->SetClassName(String::New("Entry")); 168 | constructor_template = Persistent::New(entryTemplate); 169 | 170 | // Set up the class to point to a C++ class 171 | Handle entryInstance = entryTemplate->InstanceTemplate(); 172 | entryInstance->SetInternalFieldCount(1); 173 | 174 | // Attach methods to the target 175 | NodeGtkEntry::SetupMethods(target); 176 | 177 | NodeGtkEntry::SetupCallbacks(callbacks); 178 | } 179 | } 180 | -------------------------------------------------------------------------------- /src/gtk_entry.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_ENTRY_H_ 2 | #define NGTK_ENTRY_H_ 3 | 4 | #include "gtk_widget.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkEntry: public NodeGtkWidget { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | /** 15 | * Constructor. Creates a new NodeGtkEntry, which will wrap a new GtkEntry 16 | */ 17 | NodeGtkEntry(); 18 | NodeGtkEntry(GtkEntry *entry); 19 | 20 | /** 21 | * Checks to see if a v8::Object is a NodeGtkEntry in disguise 22 | * 23 | * Parameters: 24 | * obj - The object to check for Entryness 25 | * 26 | * Returns: 27 | * True if the object is a entry, false otherwise 28 | */ 29 | static inline bool HasInstance(v8::Handle val) { 30 | v8::HandleScope scope; 31 | 32 | if (val->IsObject()) { 33 | v8::Local obj = val->ToObject(); 34 | 35 | if (constructor_template->HasInstance(obj)) { 36 | return true; 37 | } 38 | } 39 | return false; 40 | } 41 | 42 | /** 43 | * For getting the underlying GtkWidget. 44 | * 45 | * Usage: 46 | * (code) 47 | * GtkEntry *entry = NodeGtkEntry::Data(args[n]->ToObject()); 48 | * (end) 49 | * 50 | * Returns: 51 | * The pointer to the GtkEntry contained in this NodeGtkEntry 52 | */ 53 | static inline GtkEntry* Data (v8::Handle obj) { 54 | v8::HandleScope scope; 55 | return GTK_ENTRY(ObjectWrap::Unwrap(obj)->getWidget()); 56 | } 57 | 58 | static void SetupMethods (v8::Handle target); 59 | static void SetupCallbacks(std::vector *callbacks); 60 | static void Initialize (v8::Handle target); 61 | 62 | /** 63 | * Retrieves a reference to this instance from the widget 64 | * 65 | * Parameters: 66 | * object - The GtkEntry that holds the reference 67 | */ 68 | static NodeGtkEntry* From(GtkEntry *object) { 69 | NodeGtkEntry *button; 70 | NODE_GTK_GET_REF(object, button, NodeGtkEntry); 71 | return button; 72 | } 73 | 74 | }; 75 | 76 | } // namespace ngtk 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /src/gtk_hbox.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_hbox.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for HBoxs 12 | */ 13 | Persistent NodeGtkHBox::constructor_template; 14 | 15 | /** 16 | * Creates a new HBox 17 | * 18 | * Parameters: 19 | * type - One of the GtkHBoxTypes 20 | */ 21 | NodeGtkHBox::NodeGtkHBox (gboolean homogeneous, gint spacing) { 22 | widget = gtk_hbox_new(homogeneous, spacing); 23 | addRef(); 24 | } 25 | 26 | /** 27 | * Creates a new HBox and attaches it to a JavaScript object 28 | * 29 | * Parameters: 30 | * type - One of the GtkHBoxTypes 31 | * 32 | * Returns: 33 | * A new instance of the HBox class 34 | */ 35 | Handle gtk_hbox_new (const Arguments &args) { 36 | HandleScope scope; 37 | 38 | bool homogeneous = args[0]->ToBoolean()->Value(); 39 | int spacing = (int)args[1]->ToNumber()->Value(); 40 | 41 | NodeGtkHBox *hbox = new NodeGtkHBox((gboolean)homogeneous, (gint)spacing); 42 | 43 | // Make a new JavaScript object and return it 44 | Local obj = NodeGtkHBox::constructor_template->GetFunction()->NewInstance(); 45 | obj->SetInternalField(0, External::New(hbox)); 46 | return obj; 47 | } 48 | 49 | /** 50 | * Attach all hbox methods to the target 51 | * 52 | * Parameters: 53 | * target: The object to attach methods to 54 | */ 55 | void NodeGtkHBox::SetupMethods (Handle target) { 56 | HandleScope scope; 57 | 58 | target->Set(v8::String::NewSymbol("hbox_new"), v8::FunctionTemplate::New(gtk_hbox_new)->GetFunction()); 59 | } 60 | 61 | void NodeGtkHBox::SetupCallbacks(std::vector *callbacks) { 62 | NodeGtkBox::SetupCallbacks(callbacks); 63 | } 64 | 65 | /** 66 | * Sets up the environment with all things hboxish 67 | * 68 | * Parameters: 69 | * target: The object to attach methods to 70 | */ 71 | void NodeGtkHBox::Initialize (Handle target) { 72 | HandleScope scope; 73 | 74 | // Create a new JavaScript class 75 | Handle hboxTemplate = FunctionTemplate::New(); 76 | hboxTemplate->SetClassName(String::New("HBox")); 77 | constructor_template = Persistent::New(hboxTemplate); 78 | 79 | // Set up the class to point to a C++ class 80 | Handle hboxInstance = hboxTemplate->InstanceTemplate(); 81 | hboxInstance->SetInternalFieldCount(1); 82 | 83 | // Attach methods to the target 84 | NodeGtkHBox::SetupMethods(target); 85 | NodeGtkHBox::SetupCallbacks(callbacks); 86 | } 87 | } 88 | -------------------------------------------------------------------------------- /src/gtk_hbox.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_HBOX_H_ 2 | #define NGTK_HBOX_H_ 3 | 4 | #include "gtk_box.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkHBox: public NodeGtkBox { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | /** 15 | * Constructor. Creates a new HBox, which will wrap a new GtkHBox 16 | */ 17 | NodeGtkHBox(gboolean homogeneous, gint spacing); 18 | NodeGtkHBox(GtkHBox *hbox); 19 | 20 | /** 21 | * Checks to see if a v8::Object is a HBox in disguise 22 | * 23 | * Parameters: 24 | * obj - The object to check for HBoxness 25 | * 26 | * Returns: 27 | * True if the object is a hbox, false otherwise 28 | */ 29 | static inline bool HasInstance(v8::Handle val) { 30 | v8::HandleScope scope; 31 | 32 | if (val->IsObject()) { 33 | v8::Local obj = val->ToObject(); 34 | 35 | if (constructor_template->HasInstance(obj)) { 36 | return true; 37 | } 38 | } 39 | return false; 40 | } 41 | 42 | /** 43 | * For getting the underlying GtkWidget. 44 | * 45 | * Usage: 46 | * (code) 47 | * GtkHBox *hbox = HBox::Data(args[n]->ToObject()); 48 | * (end) 49 | * 50 | * Returns: 51 | * The pointer to the GtkHBox contained in this HBox 52 | */ 53 | static inline GtkHBox* Data (v8::Handle obj) { 54 | v8::HandleScope scope; 55 | return GTK_HBOX(ObjectWrap::Unwrap(obj)->getWidget()); 56 | } 57 | 58 | static void SetupMethods (v8::Handle target); 59 | static void SetupCallbacks(std::vector *callbacks); 60 | static void Initialize (v8::Handle target); 61 | 62 | /** 63 | * Retrieves a reference to this instance from the widget 64 | * 65 | * Parameters: 66 | * object - The GtkHBox that holds the reference 67 | */ 68 | static NodeGtkHBox* From(GtkHBox *object) { 69 | NodeGtkHBox *button; 70 | NODE_GTK_GET_REF(object, button, NodeGtkHBox); 71 | return button; 72 | } 73 | 74 | }; 75 | 76 | } // namespace ngtk 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /src/gtk_label.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_label.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for Labels 12 | */ 13 | Persistent NodeGtkLabel::constructor_template; 14 | 15 | /** 16 | * Creates a new Label 17 | * 18 | * Parameters: 19 | * type - One of the GtkLabelTypes 20 | */ 21 | NodeGtkLabel::NodeGtkLabel (gchar *text) { 22 | widget = gtk_label_new(text); 23 | addRef(); 24 | obj = NodeGtkLabel::constructor_template->GetFunction()->NewInstance(); 25 | obj->SetInternalField(0, External::New(this)); 26 | } 27 | 28 | /** 29 | * Creates a new Label and attaches it to a JavaScript object 30 | * 31 | * Parameters: 32 | * text - The text to put in the label 33 | * 34 | * Returns: 35 | * A new instance of the Label class 36 | */ 37 | Handle gtk_label_new (const Arguments &args) { 38 | HandleScope scope; 39 | 40 | String::AsciiValue text(args[0]->ToString()); 41 | NodeGtkLabel *label = new NodeGtkLabel((gchar*)*text); 42 | 43 | // Make a new JavaScript object and return it 44 | return label->obj; 45 | } 46 | 47 | /** 48 | * Sets the text of a label 49 | * 50 | * Parameters: 51 | * label - The Label to set the text of 52 | * text - The text to put in the label 53 | */ 54 | Handle gtk_label_set_text(const Arguments &args) { 55 | HandleScope scope; 56 | 57 | GtkLabel *label = NodeGtkLabel::Data(args[0]->ToObject()); 58 | String::AsciiValue text(args[1]->ToString()); 59 | 60 | gtk_label_set_text(label, *text); 61 | 62 | return Undefined(); 63 | } 64 | 65 | /** 66 | * Gets the text of a label 67 | * 68 | * Parameters: 69 | * label - The Label to get the text from 70 | * 71 | * Returns: 72 | * The text from the Label 73 | */ 74 | Handle gtk_label_get_text(const Arguments &args) { 75 | HandleScope scope; 76 | 77 | GtkLabel *label = NodeGtkLabel::Data(args[0]->ToObject()); 78 | 79 | return scope.Close(String::New(gtk_label_get_text(label))); 80 | } 81 | 82 | /** 83 | * Attach all label methods to the target 84 | * 85 | * Parameters: 86 | * target: The object to attach methods to 87 | */ 88 | void NodeGtkLabel::SetupMethods (Handle target) { 89 | HandleScope scope; 90 | 91 | target->Set(v8::String::NewSymbol("label_new"), v8::FunctionTemplate::New(gtk_label_new)->GetFunction()); 92 | target->Set(v8::String::NewSymbol("label_set_text"), v8::FunctionTemplate::New(gtk_label_set_text)->GetFunction()); 93 | target->Set(v8::String::NewSymbol("label_get_text"), v8::FunctionTemplate::New(gtk_label_get_text)->GetFunction()); 94 | } 95 | 96 | void NodeGtkLabel::SetupCallbacks(std::vector *callbacks) { 97 | NodeGtkMisc::SetupCallbacks(callbacks); 98 | //TODO Callbacks for this 99 | } 100 | 101 | /** 102 | * Sets up the environment with all things labelish 103 | * 104 | * Parameters: 105 | * target: The object to attach methods to 106 | */ 107 | void NodeGtkLabel::Initialize (Handle target) { 108 | HandleScope scope; 109 | 110 | // Create a new JavaScript class 111 | Handle labelTemplate = FunctionTemplate::New(); 112 | labelTemplate->SetClassName(String::New("Label")); 113 | constructor_template = Persistent::New(labelTemplate); 114 | 115 | // Set up the class to point to a C++ class 116 | Handle labelInstance = labelTemplate->InstanceTemplate(); 117 | labelInstance->SetInternalFieldCount(1); 118 | 119 | // Attach methods to the target 120 | NodeGtkLabel::SetupMethods(target); 121 | 122 | NodeGtkLabel::SetupCallbacks(callbacks); 123 | } 124 | } 125 | -------------------------------------------------------------------------------- /src/gtk_label.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_LABEL_H_ 2 | #define NGTK_LABEL_H_ 3 | 4 | #include "gtk_misc.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkLabel: public NodeGtkMisc { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | /** 15 | * Constructor. Creates a new Label, which will wrap a new GtkLabel 16 | */ 17 | NodeGtkLabel(gchar *text); 18 | NodeGtkLabel(GtkLabel *label); 19 | 20 | /** 21 | * Checks to see if a v8::Object is a Label in disguise 22 | * 23 | * Parameters: 24 | * obj - The object to check for Labelness 25 | * 26 | * Returns: 27 | * True if the object is a label, false otherwise 28 | */ 29 | static inline bool HasInstance(v8::Handle val) { 30 | v8::HandleScope scope; 31 | 32 | if (val->IsObject()) { 33 | v8::Local obj = val->ToObject(); 34 | 35 | if (constructor_template->HasInstance(obj)) { 36 | return true; 37 | } 38 | } 39 | return false; 40 | } 41 | 42 | /** 43 | * For getting the underlying GtkWidget. 44 | * 45 | * Usage: 46 | * (code) 47 | * GtkLabel *label = Label::Data(args[n]->ToObject()); 48 | * (end) 49 | * 50 | * Returns: 51 | * The pointer to the GtkLabel contained in this Label 52 | */ 53 | static inline GtkLabel* Data (v8::Handle obj) { 54 | v8::HandleScope scope; 55 | return GTK_LABEL(ObjectWrap::Unwrap(obj)->getWidget()); 56 | } 57 | 58 | static void SetupMethods (v8::Handle target); 59 | static void SetupCallbacks(std::vector *callbacks); 60 | static void Initialize (v8::Handle target); 61 | 62 | /** 63 | * Retrieves a reference to this instance from the widget 64 | * 65 | * Parameters: 66 | * object - The GtkLabel that holds the reference 67 | */ 68 | static NodeGtkLabel* From(GtkLabel *object) { 69 | NodeGtkLabel *button; 70 | NODE_GTK_GET_REF(object, button, NodeGtkLabel); 71 | return button; 72 | } 73 | 74 | }; 75 | 76 | } // namespace ngtk 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /src/gtk_misc.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_misc.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | Handle gtk_misc_set_alignment (const Arguments &args) { 11 | HandleScope scope; 12 | 13 | GtkMisc *misc = NodeGtkMisc::Data(args[0]->ToObject()); 14 | float xalign = args[1]->ToNumber()->Value(); 15 | float yalign = args[2]->ToNumber()->Value(); 16 | 17 | gtk_misc_set_alignment(misc, (gfloat)(xalign), (gfloat)(yalign)); 18 | 19 | return Undefined(); 20 | } 21 | 22 | Handle gtk_misc_set_padding (const Arguments &args) { 23 | HandleScope scope; 24 | 25 | GtkMisc *misc = NodeGtkMisc::Data(args[0]->ToObject()); 26 | int xpad = (int)args[1]->ToNumber()->Value(); 27 | int ypad = (int)args[2]->ToNumber()->Value(); 28 | 29 | gtk_misc_set_padding(misc, (gint)(xpad), (gint)(ypad)); 30 | 31 | return Undefined(); 32 | } 33 | 34 | Handle gtk_misc_get_alignment (const Arguments &args) { 35 | HandleScope scope; 36 | 37 | GtkMisc *misc = NodeGtkMisc::Data(args[0]->ToObject()); 38 | gfloat xalign = 0; 39 | gfloat yalign = 0; 40 | 41 | gtk_misc_get_alignment(misc, &xalign, &yalign); 42 | 43 | Handle c = Object::New(); 44 | c->Set(String::New("x"), v8::Number::New(xalign), None); 45 | c->Set(String::New("y"), v8::Number::New(xalign), None); 46 | return scope.Close(c); 47 | } 48 | 49 | Handle gtk_misc_get_padding (const Arguments &args) { 50 | HandleScope scope; 51 | 52 | GtkMisc *misc = NodeGtkMisc::Data(args[0]->ToObject()); 53 | gint xpad = 0; 54 | gint ypad = 0; 55 | 56 | gtk_misc_get_padding(misc, &xpad, &ypad); 57 | 58 | Handle c = Object::New(); 59 | c->Set(String::New("x"), v8::Number::New(xpad), None); 60 | c->Set(String::New("y"), v8::Number::New(ypad), None); 61 | return scope.Close(c); 62 | } 63 | 64 | 65 | /** 66 | * Attach all misc methods to the target 67 | * 68 | * Parameters: 69 | * target: The object to attach methods to 70 | */ 71 | void NodeGtkMisc::SetupMethods (Handle target) { 72 | HandleScope scope; 73 | 74 | target->Set(v8::String::NewSymbol("misc_set_padding"), v8::FunctionTemplate::New(gtk_misc_set_padding)->GetFunction()); 75 | target->Set(v8::String::NewSymbol("misc_set_alignment"), v8::FunctionTemplate::New(gtk_misc_set_alignment)->GetFunction()); 76 | target->Set(v8::String::NewSymbol("misc_get_padding"), v8::FunctionTemplate::New(gtk_misc_get_padding)->GetFunction()); 77 | target->Set(v8::String::NewSymbol("misc_get_alignment"), v8::FunctionTemplate::New(gtk_misc_get_alignment)->GetFunction()); 78 | } 79 | 80 | /** 81 | * Attach all misc signals 82 | * 83 | * Parameters: 84 | * target: The object to attach methods to 85 | */ 86 | void NodeGtkMisc::SetupCallbacks (std::vector *callbacks) { 87 | NodeGtkWidget::SetupCallbacks(callbacks); 88 | } 89 | 90 | /** 91 | * Sets up the environment with all things entryish 92 | * 93 | * Parameters: 94 | * target: The object to attach methods to 95 | */ 96 | void NodeGtkMisc::Initialize (Handle target) { 97 | HandleScope scope; 98 | 99 | // Attach methods to the target 100 | NodeGtkMisc::SetupMethods(target); 101 | NodeGtkMisc::SetupCallbacks(callbacks); 102 | } 103 | 104 | } 105 | -------------------------------------------------------------------------------- /src/gtk_misc.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_MISC_H_ 2 | #define NGTK_MISC_H_ 3 | 4 | #include "gtk_widget.h" 5 | 6 | namespace nodeGtk { 7 | class NodeGtkMisc : public NodeGtkWidget { 8 | 9 | public: 10 | 11 | // For getting the underlying GtkWidget 12 | static inline GtkMisc* Data (v8::Handle obj) { 13 | v8::HandleScope scope; 14 | return GTK_MISC(ObjectWrap::Unwrap(obj)->getWidget()); 15 | } 16 | 17 | static void SetupMethods (v8::Handle target); 18 | static void SetupCallbacks(std::vector *callbacks); 19 | static void Initialize (v8::Handle target); 20 | 21 | /** 22 | * Retrieves a reference to this instance from the widget 23 | * 24 | * Parameters: 25 | * object - The GtkMisc that holds the reference 26 | */ 27 | static NodeGtkMisc* From(GtkMisc *object) { 28 | return (NodeGtkMisc*)(g_object_get_data(G_OBJECT(object), "NodeGTK-ref")); 29 | } 30 | 31 | }; 32 | } 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/gtk_object.cc: -------------------------------------------------------------------------------- 1 | #include "g_object.h" 2 | #include 3 | 4 | namespace nodeGtk { 5 | 6 | } // namespace ngtk 7 | -------------------------------------------------------------------------------- /src/gtk_object.h: -------------------------------------------------------------------------------- 1 | #ifndef GTK_OBJECT_H_ 2 | #define GTK_OBJECT_H_ 3 | 4 | #include "g_object.h" 5 | 6 | 7 | namespace nodeGtk { 8 | 9 | class NodeGtkObject : public NodeGObject { 10 | public: 11 | 12 | /** 13 | * Retrieves a reference to this instance from the widget 14 | * 15 | * Parameters: 16 | * object - The GtkObject that holds the reference 17 | */ 18 | static NodeGtkObject* From(GObject *object) { 19 | return (NodeGtkObject *)(g_object_get_data(object, "NodeGTK-ref")); 20 | } 21 | }; 22 | 23 | } // namespace ngtk 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /src/gtk_tree_iter.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_tree_iter.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for TreeIters 12 | */ 13 | Persistent NodeGtkTreeIter::constructor_template; 14 | 15 | /** 16 | * Creates a new NodeGtkTreeIter 17 | * 18 | * Parameters: 19 | * type - One of the GtkTreeIterTypes 20 | */ 21 | NodeGtkTreeIter::NodeGtkTreeIter (GtkTreeIter iter) { 22 | treeIter = GtkTreeIter(iter); 23 | 24 | newJavaScriptInstance(constructor_template); 25 | } 26 | 27 | /** 28 | * Creates a new NodeGtkTreeIter and attaches it to a JavaScript object 29 | * 30 | * Parameters: 31 | * type - One of the GtkTreeIterTypes 32 | * 33 | * Returns: 34 | * A new instance of the NodeGtkTreeIter class 35 | Handle node_gtk_tree_iter (const Arguments &args) { 36 | HandleScope scope; 37 | 38 | int length = args.Length(); 39 | GType *columns = new GType[length]; 40 | for (int i = 0; i < length; i++) { 41 | GType type = (int)(args[i]->ToNumber()->Value()); 42 | columns[i] = type; 43 | } 44 | 45 | NodeGtkTreeIter *treeIter = new NodeGtkTreeIter((gint)length, columns); 46 | 47 | return treeIter->obj; 48 | } 49 | 50 | Handle node_gtk_tree_iter_append(const Arguments &args) { 51 | HandleScope scope; 52 | 53 | GtkTreeIter *treeIter = NodeGtkTreeIter::Data(args[0]->ToObject()); 54 | GtkTreeIter *parent = NodeGtkTreeIter::Data(args[1]->ToObject()); 55 | 56 | GtkTreeIter iter; 57 | 58 | gtk_tree_iter_append(treeIter, &iter, parent); 59 | 60 | NodeGtkTreeIter *node_iter = new NodeGtkTreeIter(iter); 61 | 62 | return node_iter->obj; 63 | } 64 | */ 65 | 66 | 67 | /** 68 | * Attach all treeIter methods to the target 69 | * 70 | * Parameters: 71 | * target: The object to attach methods to 72 | */ 73 | void NodeGtkTreeIter::SetupMethods (Handle target) { 74 | // target->Set(v8::String::NewSymbol("tree_iter_new"), v8::FunctionTemplate::New(node_gtk_tree_iter_new)->GetFunction()); 75 | // target->Set(v8::String::NewSymbol("tree_iter_append"), v8::FunctionTemplate::New(node_gtk_tree_iter_append)->GetFunction()); 76 | } 77 | 78 | void NodeGtkTreeIter::SetupCallbacks(std::vector *callbacks) { } 79 | 80 | void NodeGtkTreeIter::SetupConstants(Handle target) { } 81 | 82 | /** 83 | * Sets up the environment with all things treeIterish 84 | * 85 | * Parameters: 86 | * target: The object to attach methods to 87 | */ 88 | void NodeGtkTreeIter::Initialize (Handle target) { 89 | HandleScope scope; 90 | 91 | SetupCallbacks(callbacks); 92 | SetupConstants(target); 93 | SetupMethods(target); 94 | 95 | NODE_GTK_NEW_CLASS(constructor_template, "TreeIter"); 96 | } 97 | } 98 | -------------------------------------------------------------------------------- /src/gtk_tree_iter.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_TREE_ITER_H_ 2 | #define NGTK_TREE_ITER_H_ 3 | 4 | #include "g_object.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkTreeIter: public NodeGObject { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | GtkTreeIter treeIter; 15 | 16 | /** 17 | * Constructor. Creates a new NodeGtkTreeIter, which will wrap a new GtkTreeIter 18 | */ 19 | NodeGtkTreeIter(GtkTreeIter treeIter); 20 | 21 | /** 22 | * For getting the underlying GtkTreeIter. 23 | * 24 | * Returns: 25 | * The pointer to the GtkTreeIter contained in this NodeGtkTreeIter 26 | */ 27 | static inline GtkTreeIter Data (v8::Handle obj) { 28 | v8::HandleScope scope; 29 | return ObjectWrap::Unwrap(obj)->getTreeIter(); 30 | } 31 | 32 | virtual inline GtkTreeIter getTreeIter() { 33 | return treeIter; 34 | } 35 | virtual inline void setTreeIter(GtkTreeIter treeIter) { 36 | this->treeIter = GtkTreeIter(treeIter); 37 | } 38 | 39 | static void SetupMethods (v8::Handle target); 40 | static void SetupCallbacks(std::vector *callbacks); 41 | static void SetupConstants(v8::Handle target); 42 | static void Initialize (v8::Handle target); 43 | 44 | /** 45 | * Retrieves a reference to this instance from the widget 46 | * 47 | * Parameters: 48 | * object - The GtkTreeIter that holds the reference 49 | */ 50 | static NodeGtkTreeIter* From(GtkTreeIter *object) { 51 | NodeGtkTreeIter *button; 52 | NODE_GTK_GET_REF(object, button, NodeGtkTreeIter); 53 | return button; 54 | } 55 | 56 | }; 57 | 58 | } // namespace ngtk 59 | 60 | #endif 61 | 62 | -------------------------------------------------------------------------------- /src/gtk_tree_model.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_TREE_MODEL_H_ 2 | #define NGTK_TREE_MODEL_H_ 3 | 4 | #include "g_interface.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkTreeModel: public NodeGInterface { 9 | 10 | public: 11 | virtual ~NodeGtkTreeModel() {} 12 | GtkTreeModel *model; 13 | // virtual void OverrideMe() = 0; 14 | 15 | static inline GtkTreeModel* Data(v8::Handle obj) { 16 | v8::HandleScope scope; 17 | return ObjectWrap::Unwrap(obj)->getModel(); 18 | } 19 | 20 | virtual GtkTreeModel* getModel() { 21 | return model; 22 | } 23 | virtual void setModel(GtkTreeModel *model) { 24 | this->model = model; 25 | } 26 | 27 | }; 28 | 29 | } 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /src/gtk_tree_store.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_tree_store.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for TreeStores 12 | */ 13 | Persistent NodeGtkTreeStore::constructor_template; 14 | 15 | NodeGtkTreeStore::NodeGtkTreeStore (GtkTreeStore *store) { 16 | model = GTK_TREE_MODEL(store); 17 | newJavaScriptInstance(constructor_template); 18 | } 19 | 20 | Handle node_gtk_tree_store_new (const Arguments &args) { 21 | HandleScope scope; 22 | 23 | int length = args.Length(); 24 | GType *columns = new GType[length]; 25 | for (int i = 0; i < length; i++) { 26 | GType type = (int)(args[i]->ToNumber()->Value()); 27 | columns[i] = type; 28 | } 29 | 30 | GtkTreeStore *treeStore = gtk_tree_store_newv((gint)length, columns); 31 | NodeGtkTreeStore *nodeTreeStore = new NodeGtkTreeStore(treeStore); 32 | 33 | return nodeTreeStore->obj; 34 | } 35 | 36 | Handle node_gtk_tree_store_append(const Arguments &args) { 37 | HandleScope scope; 38 | 39 | GtkTreeStore *treeStore = GTK_TREE_STORE(NodeGtkTreeStore::Data(args[0]->ToObject())); 40 | GtkTreeIter iter; 41 | GtkTreeIter *parent = NULL; 42 | if (args.Length() > 1) { 43 | GtkTreeIter parentIter = NodeGtkTreeIter::Data(args[1]->ToObject()); 44 | parent = &parentIter; 45 | } 46 | 47 | gtk_tree_store_append(treeStore, &iter, parent); 48 | NodeGtkTreeIter *node_iter = new NodeGtkTreeIter(iter); 49 | 50 | return node_iter->obj; 51 | } 52 | 53 | Handle node_gtk_tree_store_set(const Arguments &args) { 54 | HandleScope scope; 55 | 56 | GtkTreeStore *treeStore = GTK_TREE_STORE(NodeGtkTreeStore::Data(args[0]->ToObject())); 57 | NodeGtkTreeIter *nodeTreeIter= ObjectWrap::Unwrap(args[1]->ToObject()); 58 | 59 | int n_values = (args.Length() - 2) / 2; 60 | int i; 61 | gint *columns = new gint[n_values]; 62 | GValue *values = new GValue[n_values]; 63 | 64 | for (i = 0; i < n_values; i++) { 65 | columns[i] = args[(i * 2) + 2]->ToNumber()->Value(); 66 | Local arg = args[(i * 2) + 3]; 67 | values[i] = {0}; 68 | if (arg->IsString()) { 69 | g_value_init(&values[i], G_TYPE_STRING); 70 | String::AsciiValue contents(arg->ToString()); 71 | g_value_set_string(&values[i], *contents); 72 | } else if (arg->IsBoolean()) { 73 | g_value_init(&values[i], G_TYPE_BOOLEAN); 74 | g_value_set_boolean(&values[i], arg->ToBoolean()->Value()); 75 | } else if (arg->IsNumber()) { 76 | g_value_init(&values[i], G_TYPE_DOUBLE); 77 | g_value_set_double(&values[i], arg->ToNumber()->Value()); 78 | } else { 79 | printf(" Unknown column!\n"); 80 | return Undefined(); 81 | } 82 | 83 | } 84 | 85 | GtkTreeIter iter = nodeTreeIter->getTreeIter(); 86 | 87 | gtk_tree_store_set_valuesv(treeStore, &iter, columns, values, n_values); 88 | 89 | return Undefined(); 90 | } 91 | 92 | 93 | /** 94 | * Attach all treeStore methods to the target 95 | * 96 | * Parameters: 97 | * target: The object to attach methods to 98 | */ 99 | void NodeGtkTreeStore::SetupMethods (Handle target) { 100 | target->Set(v8::String::NewSymbol("tree_store_new"), v8::FunctionTemplate::New(node_gtk_tree_store_new)->GetFunction()); 101 | target->Set(v8::String::NewSymbol("tree_store_append"), v8::FunctionTemplate::New(node_gtk_tree_store_append)->GetFunction()); 102 | target->Set(v8::String::NewSymbol("tree_store_set"), v8::FunctionTemplate::New(node_gtk_tree_store_set)->GetFunction()); 103 | } 104 | 105 | void NodeGtkTreeStore::SetupCallbacks(std::vector *callbacks) { } 106 | 107 | void NodeGtkTreeStore::SetupConstants(Handle target) { } 108 | 109 | /** 110 | * Sets up the environment with all things treeStoreish 111 | * 112 | * Parameters: 113 | * target: The object to attach methods to 114 | */ 115 | void NodeGtkTreeStore::Initialize (Handle target) { 116 | HandleScope scope; 117 | 118 | SetupCallbacks(callbacks); 119 | SetupConstants(target); 120 | SetupMethods(target); 121 | 122 | NODE_GTK_NEW_CLASS(constructor_template, "TreeStore"); 123 | } 124 | } 125 | -------------------------------------------------------------------------------- /src/gtk_tree_store.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_TREE_STORE_H_ 2 | #define NGTK_TREE_STORE_H_ 3 | 4 | #include "g_object.h" 5 | #include "gtk_tree_iter.h" 6 | #include "gtk_tree_model.h" 7 | 8 | namespace nodeGtk { 9 | 10 | class NodeGtkTreeStore: public NodeGObject, public NodeGtkTreeModel { 11 | 12 | public: 13 | 14 | static v8::Persistent constructor_template; 15 | 16 | GtkTreeModel *model; 17 | 18 | /** 19 | * Constructor. Creates a new NodeGtkTreeStore, which will wrap a new GtkTreeStore 20 | */ 21 | NodeGtkTreeStore(GtkTreeStore *treeStore); 22 | 23 | /** 24 | * For getting the underlying GtkTreeStore. 25 | * 26 | * Returns: 27 | * The pointer to the GtkTreeStore contained in this NodeGtkTreeStore 28 | */ 29 | static inline GtkTreeModel* Data(v8::Handle obj) { 30 | v8::HandleScope scope; 31 | return ObjectWrap::Unwrap(obj)->getModel(); 32 | } 33 | 34 | virtual GtkTreeModel* getModel() { 35 | return model; 36 | } 37 | 38 | virtual void setModel(GtkTreeModel *model) { 39 | this->model = model; 40 | } 41 | 42 | static void SetupMethods (v8::Handle target); 43 | static void SetupCallbacks(std::vector *callbacks); 44 | static void SetupConstants(v8::Handle target); 45 | static void Initialize (v8::Handle target); 46 | 47 | /** 48 | * Retrieves a reference to this instance from the widget 49 | * 50 | * Parameters: 51 | * object - The GtkTreeStore that holds the reference 52 | */ 53 | static NodeGtkTreeStore* From(GtkTreeStore *object) { 54 | NodeGtkTreeStore *button; 55 | NODE_GTK_GET_REF(object, button, NodeGtkTreeStore); 56 | return button; 57 | } 58 | 59 | }; 60 | 61 | } // namespace ngtk 62 | 63 | #endif 64 | 65 | -------------------------------------------------------------------------------- /src/gtk_tree_view.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_tree_view.h" 2 | #include "gtk_tree_view_column.h" 3 | 4 | #include 5 | 6 | namespace nodeGtk { 7 | 8 | using namespace v8; 9 | using namespace node; 10 | 11 | /** 12 | * The class constructor for TreeViews 13 | */ 14 | Persistent NodeGtkTreeView::constructor_template; 15 | 16 | /** 17 | * Creates a new NodeGtkTreeView 18 | * 19 | * Parameters: 20 | * type - One of the GtkTreeViewTypes 21 | */ 22 | NodeGtkTreeView::NodeGtkTreeView (GtkWidget *treeView) { 23 | widget = treeView; 24 | addRef(); 25 | NODE_GTK_SET_REF(this, NodeGtkTreeView); 26 | newJavaScriptInstance(constructor_template); 27 | } 28 | Handle node_gtk_tree_view_new_with_model (const Arguments &args) { 29 | HandleScope scope; 30 | 31 | GtkTreeModel *model = ObjectWrap::Unwrap(args[0]->ToObject())->getModel(); 32 | 33 | GtkWidget *treeView = gtk_tree_view_new_with_model(model); 34 | NodeGtkTreeView *nodeTreeView = new NodeGtkTreeView(treeView); 35 | 36 | return nodeTreeView->obj; 37 | } 38 | Handle node_gtk_tree_view_append_column (const Arguments &args) { 39 | HandleScope scope; 40 | 41 | GtkTreeView *treeView = GTK_TREE_VIEW(NodeGtkTreeView::Data(args[0]->ToObject())); 42 | GtkTreeViewColumn *treeViewColumn = NodeGtkTreeViewColumn::Data(args[1]->ToObject()); 43 | gtk_tree_view_append_column(treeView, treeViewColumn); 44 | 45 | return Undefined(); 46 | } 47 | 48 | /** 49 | * Attach all treeView methods to the target 50 | * 51 | * Parameters: 52 | * target: The object to attach methods to 53 | */ 54 | void NodeGtkTreeView::SetupMethods (Handle target) { 55 | target->Set(v8::String::NewSymbol("tree_view_new_with_model"), v8::FunctionTemplate::New(node_gtk_tree_view_new_with_model)->GetFunction()); 56 | target->Set(v8::String::NewSymbol("tree_view_append_column"), v8::FunctionTemplate::New(node_gtk_tree_view_append_column)->GetFunction()); 57 | } 58 | 59 | void NodeGtkTreeView::SetupCallbacks(std::vector *callbacks) { } 60 | 61 | void NodeGtkTreeView::SetupConstants(Handle target) { } 62 | 63 | /** 64 | * Sets up the environment with all things treeViewish 65 | * 66 | * Parameters: 67 | * target: The object to attach methods to 68 | */ 69 | void NodeGtkTreeView::Initialize (Handle target) { 70 | HandleScope scope; 71 | 72 | SetupCallbacks(callbacks); 73 | SetupConstants(target); 74 | SetupMethods(target); 75 | 76 | NODE_GTK_NEW_CLASS(constructor_template, "TreeView"); 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /src/gtk_tree_view.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_TREE_VIEW_H_ 2 | #define NGTK_TREE_VIEW_H_ 3 | 4 | #include "gtk_container.h" 5 | #include "gtk_tree_iter.h" 6 | #include "gtk_tree_model.h" 7 | #include "gtk_tree_store.h" 8 | 9 | namespace nodeGtk { 10 | 11 | class NodeGtkTreeView: public NodeGtkContainer { 12 | 13 | public: 14 | 15 | static v8::Persistent constructor_template; 16 | 17 | /** 18 | * Constructor. Creates a new NodeGtkTreeView, which will wrap a new GtkTreeView 19 | */ 20 | NodeGtkTreeView(GtkWidget *treeView); 21 | 22 | /** 23 | * For getting the underlying GtkTreeView. 24 | * 25 | * Returns: 26 | * The pointer to the GtkTreeView contained in this NodeGtkTreeView 27 | */ 28 | static inline GtkTreeView* Data (v8::Handle obj) { 29 | v8::HandleScope scope; 30 | return GTK_TREE_VIEW(ObjectWrap::Unwrap(obj)->getWidget()); 31 | } 32 | 33 | static void SetupMethods (v8::Handle target); 34 | static void SetupCallbacks(std::vector *callbacks); 35 | static void SetupConstants(v8::Handle target); 36 | static void Initialize (v8::Handle target); 37 | 38 | /** 39 | * Retrieves a reference to this instance from the widget 40 | * 41 | * Parameters: 42 | * object - The GtkTreeView that holds the reference 43 | */ 44 | static NodeGtkTreeView* From(GtkTreeView *object) { 45 | NodeGtkTreeView *button; 46 | NODE_GTK_GET_REF(object, button, NodeGtkTreeView); 47 | return button; 48 | } 49 | 50 | }; 51 | 52 | } // namespace ngtk 53 | 54 | #endif 55 | 56 | -------------------------------------------------------------------------------- /src/gtk_tree_view_column.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_tree_view_column.h" 2 | #include "gtk_cell_renderer.h" 3 | 4 | #include 5 | 6 | namespace nodeGtk { 7 | 8 | using namespace v8; 9 | using namespace node; 10 | 11 | /** 12 | * The class constructor for TreeViewColumns 13 | */ 14 | Persistent NodeGtkTreeViewColumn::constructor_template; 15 | 16 | /** 17 | * Creates a new TreeViewColumn 18 | */ 19 | NodeGtkTreeViewColumn::NodeGtkTreeViewColumn (GtkTreeViewColumn *treeViewColumn) { 20 | this->treeViewColumn = treeViewColumn; 21 | NODE_GTK_SET_REF_WITH_GETTER(this, NodeGtkWindow, getTreeViewColumn); 22 | newJavaScriptInstance(constructor_template); 23 | } 24 | 25 | /** 26 | * Creates a new TreeViewColumn and attaches it to a JavaScript object 27 | * 28 | * Returns: 29 | * A new instance of the TreeViewColumn class 30 | */ 31 | Handle node_gtk_tree_view_column_new (const Arguments &args) { 32 | HandleScope scope; 33 | 34 | GtkTreeViewColumn *treeViewColumn = gtk_tree_view_column_new(); 35 | NodeGtkTreeViewColumn *nodeGtkTreeViewColumn = new NodeGtkTreeViewColumn(treeViewColumn); 36 | 37 | return nodeGtkTreeViewColumn->obj; 38 | } 39 | 40 | /** 41 | * Creates a new TreeViewColumn and attaches it to a JavaScript object 42 | * 43 | * Returns: 44 | * A new instance of the TreeViewColumn class 45 | */ 46 | Handle node_gtk_tree_view_column_new_with_attributes (const Arguments &args) { 47 | HandleScope scope; 48 | 49 | String::AsciiValue title(args[0]->ToString()); 50 | GtkCellRenderer *cellRenderer = NodeGtkCellRenderer::Data(args[1]->ToObject()); 51 | 52 | GtkTreeViewColumn *treeViewColumn = gtk_tree_view_column_new_with_attributes(*title, cellRenderer, NULL); 53 | 54 | int i; 55 | for (i = 2; i < args.Length(); i = i + 2) { 56 | String::AsciiValue attribute(args[i]->ToString()); 57 | int column = args[i + 1]->ToNumber()->Value(); 58 | 59 | gtk_tree_view_column_add_attribute(treeViewColumn, cellRenderer, *attribute, column); 60 | } 61 | 62 | NodeGtkTreeViewColumn *nodeGtkTreeViewColumn = new NodeGtkTreeViewColumn(treeViewColumn); 63 | 64 | return nodeGtkTreeViewColumn->obj; 65 | } 66 | 67 | Handle node_gtk_tree_view_column_set_attributes(const Arguments &args) { 68 | HandleScope scope; 69 | 70 | GtkTreeViewColumn *treeViewColumn = NodeGtkTreeViewColumn::Data(args[0]->ToObject()); 71 | GtkCellRenderer *cellRenderer = NodeGtkCellRenderer::Data(args[1]->ToObject()); 72 | 73 | int i; 74 | for (i = 2; i < args.Length(); i = i + 2) { 75 | String::AsciiValue attribute(args[i]->ToString()); 76 | int column = args[i + 1]->ToNumber()->Value(); 77 | 78 | gtk_tree_view_column_add_attribute(treeViewColumn, cellRenderer, *attribute, column); 79 | } 80 | 81 | return Undefined(); 82 | } 83 | 84 | Handle node_gtk_tree_view_column_add_attribute(const Arguments &args) { 85 | HandleScope scope; 86 | 87 | GtkTreeViewColumn *treeViewColumn = NodeGtkTreeViewColumn::Data(args[0]->ToObject()); 88 | GtkCellRenderer *cellRenderer = NodeGtkCellRenderer::Data(args[1]->ToObject()); 89 | 90 | String::AsciiValue attribute(args[2]->ToString()); 91 | int column = args[3]->ToNumber()->Value(); 92 | 93 | gtk_tree_view_column_add_attribute(treeViewColumn, cellRenderer, *attribute, column); 94 | 95 | return Undefined(); 96 | } 97 | 98 | /* 99 | Handle node_gtk_tree_view_column_pressed(const Arguments &args) { 100 | HandleScope scope; 101 | GtkTreeViewColumn *treeViewColumn = NodeGtkTreeViewColumn::Data(args[0]->ToObject()); 102 | gtk_tree_view_column_pressed(treeViewColumn); 103 | return Undefined(); 104 | } 105 | Handle node_gtk_button_released(const Arguments &args) { 106 | HandleScope scope; 107 | GtkTreeViewColumn *treeViewColumn = NodeGtkTreeViewColumn::Data(args[0]->ToObject()); 108 | gtk_button_released(treeViewColumn); 109 | return Undefined(); 110 | } 111 | */ 112 | 113 | /** 114 | * Attach all tree view methods methods to the target 115 | * 116 | * Parameters: 117 | * target: The object to attach methods to 118 | */ 119 | void NodeGtkTreeViewColumn::SetupMethods (Handle target) { 120 | HandleScope scope; 121 | 122 | target->Set(v8::String::NewSymbol("tree_view_column_new"), v8::FunctionTemplate::New(node_gtk_tree_view_column_new)->GetFunction()); 123 | target->Set(v8::String::NewSymbol("tree_view_column_new_with_attributes"), v8::FunctionTemplate::New(node_gtk_tree_view_column_new_with_attributes)->GetFunction()); 124 | target->Set(v8::String::NewSymbol("tree_view_column_set_attributes"), v8::FunctionTemplate::New(node_gtk_tree_view_column_set_attributes)->GetFunction()); 125 | target->Set(v8::String::NewSymbol("tree_view_column_add_attribute"), v8::FunctionTemplate::New(node_gtk_tree_view_column_add_attribute)->GetFunction()); 126 | } 127 | 128 | void NodeGtkTreeViewColumn::SetupCallbacks(std::vector *callbacks) { 129 | NodeGtkObject::SetupCallbacks(callbacks); 130 | } 131 | 132 | void NodeGtkTreeViewColumn::SetupConstants (Handle target) { } 133 | 134 | /** 135 | * Sets up the environment with all things tree view columnish 136 | * 137 | * Parameters: 138 | * target: The object to attach methods to 139 | */ 140 | void NodeGtkTreeViewColumn::Initialize (Handle target) { 141 | HandleScope scope; 142 | 143 | // Create a new JavaScript class 144 | Handle treeViewColumnTemplate = FunctionTemplate::New(); 145 | treeViewColumnTemplate->SetClassName(String::New("TreeViewColumn")); 146 | constructor_template = Persistent::New(treeViewColumnTemplate); 147 | 148 | // Set up the class to point to a C++ class 149 | Handle treeViewColumnInstance = treeViewColumnTemplate->InstanceTemplate(); 150 | treeViewColumnInstance->SetInternalFieldCount(1); 151 | 152 | // Attach methods to the target 153 | NodeGtkTreeViewColumn::SetupMethods(target); 154 | NodeGtkTreeViewColumn::SetupConstants(target); 155 | NodeGtkTreeViewColumn::SetupCallbacks(callbacks); 156 | 157 | } 158 | } 159 | -------------------------------------------------------------------------------- /src/gtk_tree_view_column.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_TREE_VIEW_COLUMN_H_ 2 | #define NGTK_TREE_VIEW_COLUMN_H_ 3 | 4 | #include "gtk_object.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkTreeViewColumn: public NodeGtkObject { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | GtkTreeViewColumn *treeViewColumn; 15 | 16 | /** 17 | * Constructor. Creates a new NodeGtkTreeViewColumn, which will wrap a new GtkTreeViewColumn 18 | */ 19 | NodeGtkTreeViewColumn(GtkTreeViewColumn *treeViewColumn); 20 | 21 | /** 22 | * Checks to see if a v8::Object is a TreeViewColumn in disguise 23 | * 24 | * Parameters: 25 | * obj - The object to check for TreeViewColumnness 26 | * 27 | * Returns: 28 | * True if the object is a tree view column, false otherwise 29 | */ 30 | static inline bool HasInstance(v8::Handle val) { 31 | v8::HandleScope scope; 32 | 33 | if (val->IsObject()) { 34 | v8::Local obj = val->ToObject(); 35 | 36 | if (constructor_template->HasInstance(obj)) { 37 | return true; 38 | } 39 | } 40 | return false; 41 | } 42 | 43 | /** 44 | * For getting the underlying GtkWidget. 45 | * 46 | * Usage: 47 | * (code) 48 | * GtkTreeViewColumn *treeViewColumn = TreeViewColumn::Data(args[n]->ToObject()); 49 | * (end) 50 | * 51 | * Returns: 52 | * The pointer to the GtkTreeViewColumn contained in this TreeViewColumn 53 | */ 54 | static inline GtkTreeViewColumn* Data (v8::Handle obj) { 55 | v8::HandleScope scope; 56 | return GTK_TREE_VIEW_COLUMN(ObjectWrap::Unwrap(obj)->getTreeViewColumn()); 57 | } 58 | 59 | virtual inline GtkTreeViewColumn* getTreeViewColumn() { 60 | return treeViewColumn; 61 | } 62 | virtual inline void setTreeViewColumn(GtkTreeViewColumn *widget) { 63 | this->treeViewColumn = treeViewColumn; 64 | } 65 | 66 | static void SetupMethods (v8::Handle target); 67 | static void SetupConstants (v8::Handle target); 68 | static void SetupCallbacks(std::vector *callbacks); 69 | static void Initialize (v8::Handle target); 70 | 71 | /** 72 | * Retrieves a reference to this instance from the widget 73 | * 74 | * Parameters: 75 | * object - The GtkTreeViewColumn that holds the reference 76 | */ 77 | static NodeGtkTreeViewColumn* From(GtkTreeViewColumn *object) { 78 | NodeGtkTreeViewColumn *treeViewColumn; 79 | NODE_GTK_GET_REF(object, treeViewColumn, NodeGtkTreeViewColumn); 80 | return treeViewColumn; 81 | } 82 | 83 | }; 84 | 85 | } // namespace ngtk 86 | 87 | #endif 88 | -------------------------------------------------------------------------------- /src/gtk_vbox.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_vbox.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for VBoxs 12 | */ 13 | Persistent NodeGtkVBox::constructor_template; 14 | 15 | /** 16 | * Creates a new VBox 17 | * 18 | * Parameters: 19 | * type - One of the GtkVBoxTypes 20 | */ 21 | NodeGtkVBox::NodeGtkVBox (gboolean homogeneous, gint spacing) { 22 | widget = gtk_vbox_new(homogeneous, spacing); 23 | addRef(); 24 | } 25 | 26 | /** 27 | * Creates a new VBox and attaches it to a JavaScript object 28 | * 29 | * Parameters: 30 | * type - One of the GtkVBoxTypes 31 | * 32 | * Returns: 33 | * A new instance of the VBox class 34 | */ 35 | Handle gtk_vbox_new (const Arguments &args) { 36 | HandleScope scope; 37 | 38 | bool homogeneous = args[0]->ToBoolean()->Value(); 39 | int spacing = (int)args[1]->ToNumber()->Value(); 40 | 41 | NodeGtkVBox *vbox = new NodeGtkVBox((gboolean)homogeneous, (gint)spacing); 42 | 43 | // Make a new JavaScript object and return it 44 | Local obj = NodeGtkVBox::constructor_template->GetFunction()->NewInstance(); 45 | obj->SetInternalField(0, External::New(vbox)); 46 | return obj; 47 | } 48 | 49 | /** 50 | * Attach all vbox methods to the target 51 | * 52 | * Parameters: 53 | * target: The object to attach methods to 54 | */ 55 | void NodeGtkVBox::SetupMethods (Handle target) { 56 | HandleScope scope; 57 | 58 | target->Set(v8::String::NewSymbol("vbox_new"), v8::FunctionTemplate::New(gtk_vbox_new)->GetFunction()); 59 | } 60 | 61 | void NodeGtkVBox::SetupCallbacks(std::vector *callbacks) { 62 | NodeGtkBox::SetupCallbacks(callbacks); 63 | } 64 | 65 | /** 66 | * Sets up the environment with all things vboxish 67 | * 68 | * Parameters: 69 | * target: The object to attach methods to 70 | */ 71 | void NodeGtkVBox::Initialize (Handle target) { 72 | HandleScope scope; 73 | 74 | // Create a new JavaScript class 75 | Handle vboxTemplate = FunctionTemplate::New(); 76 | vboxTemplate->SetClassName(String::New("VBox")); 77 | constructor_template = Persistent::New(vboxTemplate); 78 | 79 | // Set up the class to point to a C++ class 80 | Handle vboxInstance = vboxTemplate->InstanceTemplate(); 81 | vboxInstance->SetInternalFieldCount(1); 82 | 83 | // Attach methods to the target 84 | NodeGtkVBox::SetupMethods(target); 85 | NodeGtkVBox::SetupCallbacks(callbacks); 86 | } 87 | } 88 | -------------------------------------------------------------------------------- /src/gtk_vbox.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_VBOX_H_ 2 | #define NGTK_VBOX_H_ 3 | 4 | #include "gtk_box.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkVBox: public NodeGtkBox { 9 | 10 | public: 11 | 12 | static v8::Persistent constructor_template; 13 | 14 | /** 15 | * Constructor. Creates a new VBox, which will wrap a new GtkVBox 16 | */ 17 | NodeGtkVBox(gboolean homogeneous, gint spacing); 18 | NodeGtkVBox(GtkVBox *vbox); 19 | 20 | /** 21 | * Checks to see if a v8::Object is a VBox in disguise 22 | * 23 | * Parameters: 24 | * obj - The object to check for VBoxness 25 | * 26 | * Returns: 27 | * True if the object is a vbox, false otherwise 28 | */ 29 | static inline bool HasInstance(v8::Handle val) { 30 | v8::HandleScope scope; 31 | 32 | if (val->IsObject()) { 33 | v8::Local obj = val->ToObject(); 34 | 35 | if (constructor_template->HasInstance(obj)) { 36 | return true; 37 | } 38 | } 39 | return false; 40 | } 41 | 42 | /** 43 | * For getting the underlying GtkWidget. 44 | * 45 | * Usage: 46 | * (code) 47 | * GtkVBox *vbox = VBox::Data(args[n]->ToObject()); 48 | * (end) 49 | * 50 | * Returns: 51 | * The pointer to the GtkVBox contained in this VBox 52 | */ 53 | static inline GtkVBox* Data (v8::Handle obj) { 54 | v8::HandleScope scope; 55 | return GTK_VBOX(ObjectWrap::Unwrap(obj)->getWidget()); 56 | } 57 | 58 | static void SetupMethods (v8::Handle target); 59 | static void SetupCallbacks(std::vector *callbacks); 60 | static void Initialize (v8::Handle target); 61 | 62 | /** 63 | * Retrieves a reference to this instance from the widget 64 | * 65 | * Parameters: 66 | * object - The GtkVBox that holds the reference 67 | */ 68 | static NodeGtkVBox* From(GtkVBox *object) { 69 | NodeGtkVBox *button; 70 | NODE_GTK_GET_REF(object, button, NodeGtkVBox); 71 | return button; 72 | } 73 | 74 | }; 75 | 76 | } // namespace ngtk 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /src/gtk_widget.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_widget.h" 2 | #include 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * Adds a reference to this widget, and sets it up for destruction later. 12 | */ 13 | void NodeGtkWidget::addRef() { 14 | addRef(widget); 15 | } 16 | 17 | void NodeGtkWidget::addRef(GtkWidget *widget) { 18 | // Listen for desruction so we can call ev_unref later 19 | g_signal_connect(G_OBJECT(widget), "destroy", G_CALLBACK(NodeGtkWidget::onDestroy), (gpointer) this); 20 | 21 | // Bump up the ev ref count 22 | ev_ref(EV_DEFAULT_UC_); 23 | } 24 | 25 | /** 26 | * Unrefs the widget, destroying the JavaScript object 27 | */ 28 | void NodeGtkWidget::onDestroy (GtkWidget *gtkWidget, NodeGtkWidget *widget) { 29 | HandleScope scope; 30 | ev_unref(EV_DEFAULT_UC_); 31 | } 32 | 33 | // Add signal handler. 34 | Handle signal_connect (const Arguments &args) { 35 | HandleScope scope; 36 | guint id = 0; 37 | 38 | if (args[1]->IsString() && args[2]->IsFunction()) { 39 | GtkWidget *widget = NodeGtkWidget::Data(args[0]->ToObject()); 40 | GObject *object = G_OBJECT(widget); 41 | 42 | Persistent *callback = new Persistent(); 43 | *callback = Persistent::New(Handle::Cast(args[2])); 44 | gpointer callback_ptr = (gpointer) callback; 45 | String::AsciiValue signalName(args[1]->ToString()); 46 | 47 | for (std::vector::iterator it = NodeGtkWidget::callbacks->begin(); it != NodeGtkWidget::callbacks->end(); ++it) { 48 | if (strcmp(it->name, *signalName) == 0) { 49 | id = g_signal_connect(object, it->name, it->callback, callback_ptr); 50 | break; 51 | } 52 | } 53 | 54 | return scope.Close(v8::Number::New(id)); 55 | } 56 | 57 | return scope.Close(v8::Boolean::New(false)); 58 | } 59 | 60 | Handle signal_handler_disconnect (const Arguments &args) { 61 | HandleScope scope; 62 | if (args[1]->IsNumber()) { 63 | 64 | GtkWidget *instance = NodeGtkWidget::Data(args[0]->ToObject()); 65 | int id = (int)(args[1]->NumberValue()); 66 | 67 | if (g_signal_handler_is_connected (instance, id)) { 68 | g_signal_handler_disconnect (instance, id); 69 | } 70 | } 71 | 72 | return Undefined(); 73 | } 74 | 75 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_destroy) 76 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_unparent) 77 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_is_focus) 78 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_show) 79 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_show_now) 80 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_show_all) 81 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_hide) 82 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_hide_all) 83 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_map) 84 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_unmap) 85 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_realize) 86 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_unrealize) 87 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_queue_draw) 88 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_queue_resize) 89 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_queue_resize_no_redraw) 90 | 91 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_grab_focus) 92 | GTK_NOARG_FUNCTION(NodeGtkWidget, GtkWidget, gtk_widget_grab_default) 93 | 94 | Handle gtk_widget_set_can_default (const Arguments &args) { 95 | HandleScope scope; 96 | 97 | GtkWidget *widget = NodeGtkWidget::Data(args[0]->ToObject()); 98 | bool canDefault = args[1]->ToBoolean()->Value(); 99 | 100 | gtk_widget_set_can_default(widget, canDefault); 101 | 102 | return Undefined(); 103 | } 104 | 105 | /** 106 | * Focus signal. Used as the intermediate callback for focus signals. 107 | * Register a focus listener using @widget.on('focus', callback);@ 108 | * 109 | * Parameter: 110 | * widget - The widget that triggered the signal 111 | * dir - Tab forward, tab backwards, etc. See enum 112 | * callback_ptr - The user data, which is the JavaScript function to call 113 | */ 114 | gboolean signal_focus(GtkWidget *widget, GtkDirectionType dir, gpointer callback_ptr) { 115 | Persistent *callback = reinterpret_cast*>(callback_ptr); 116 | TryCatch try_catch; 117 | 118 | Local argv[1] = { v8::Number::New(dir) }; 119 | 120 | Local ret = (*callback)->Call(Context::GetCurrent()->Global(), 1, argv); 121 | 122 | if (try_catch.HasCaught()) { 123 | FatalException(try_catch); 124 | } 125 | 126 | if (ret.IsEmpty()) { 127 | printf("Bad return"); 128 | } 129 | 130 | return (*ret)->IsTrue(); 131 | } 132 | 133 | 134 | /** 135 | * Attach all widget methods to the target 136 | * 137 | * Parameters: 138 | * target: The object to attach methods to 139 | */ 140 | void NodeGtkWidget::SetupMethods (Handle target) { 141 | HandleScope scope; 142 | GTK_ATTACH_FUNCTION(target, "widget_destroy", gtk_widget_destroy); 143 | GTK_ATTACH_FUNCTION(target, "widget_destroy", gtk_widget_destroy); 144 | GTK_ATTACH_FUNCTION(target, "widget_unparent", gtk_widget_unparent); 145 | GTK_ATTACH_FUNCTION(target, "widget_is_focus", gtk_widget_is_focus); 146 | GTK_ATTACH_FUNCTION(target, "widget_show", gtk_widget_show); 147 | GTK_ATTACH_FUNCTION(target, "widget_show_now", gtk_widget_show_now); 148 | GTK_ATTACH_FUNCTION(target, "widget_show_all", gtk_widget_show_all); 149 | GTK_ATTACH_FUNCTION(target, "widget_hide", gtk_widget_hide); 150 | GTK_ATTACH_FUNCTION(target, "widget_hide_all", gtk_widget_hide_all); 151 | GTK_ATTACH_FUNCTION(target, "widget_map", gtk_widget_map); 152 | GTK_ATTACH_FUNCTION(target, "widget_unmap", gtk_widget_unmap); 153 | GTK_ATTACH_FUNCTION(target, "widget_realize", gtk_widget_realize); 154 | GTK_ATTACH_FUNCTION(target, "widget_unrealize", gtk_widget_unrealize); 155 | GTK_ATTACH_FUNCTION(target, "widget_queue_draw", gtk_widget_queue_draw); 156 | GTK_ATTACH_FUNCTION(target, "widget_queue_resize", gtk_widget_queue_resize); 157 | GTK_ATTACH_FUNCTION(target, "widget_queue_resize_no_redraw", gtk_widget_queue_resize_no_redraw); 158 | 159 | GTK_ATTACH_FUNCTION(target, "widget_grab_focus", gtk_widget_grab_focus); 160 | GTK_ATTACH_FUNCTION(target, "widget_grab_default", gtk_widget_grab_default); 161 | GTK_ATTACH_FUNCTION(target, "widget_set_can_default", gtk_widget_set_can_default); 162 | 163 | GTK_ATTACH_FUNCTION(target, "signal_connect", signal_connect); 164 | GTK_ATTACH_FUNCTION(target, "signal_handler_disconnect", signal_handler_disconnect); 165 | } 166 | 167 | void NodeGtkWidget::SetupCallbacks(std::vector *callbacks) { 168 | (*callbacks).push_back(SignalCallback("focus", G_CALLBACK(signal_focus))); 169 | 170 | (*callbacks).push_back(SignalCallback("grab-focus", G_CALLBACK(signal_bare))); 171 | (*callbacks).push_back(SignalCallback("hide", G_CALLBACK(signal_bare))); 172 | (*callbacks).push_back(SignalCallback("map", G_CALLBACK(signal_bare))); 173 | (*callbacks).push_back(SignalCallback("show", G_CALLBACK(signal_bare))); 174 | (*callbacks).push_back(SignalCallback("realize", G_CALLBACK(signal_bare))); 175 | (*callbacks).push_back(SignalCallback("unmap", G_CALLBACK(signal_bare))); 176 | (*callbacks).push_back(SignalCallback("unrealize", G_CALLBACK(signal_bare))); 177 | 178 | (*callbacks).push_back(SignalCallback("popup-menu", G_CALLBACK(signal_boolean))); 179 | (*callbacks).push_back(SignalCallback("destroy", G_CALLBACK(signal_boolean))); 180 | } 181 | 182 | /** 183 | * Sets up the environment with all things widgety 184 | * 185 | * Parameters: 186 | * target: The object to attach methods to 187 | */ 188 | void NodeGtkWidget::Initialize (Handle target) { 189 | HandleScope scope; 190 | NodeGtkWidget::SetupMethods(target); 191 | 192 | NodeGtkWidget::SetupCallbacks(callbacks); 193 | } 194 | 195 | 196 | } // namespace ngtk 197 | -------------------------------------------------------------------------------- /src/gtk_widget.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_WIDGET_H_ 2 | #define NGTK_WIDGET_H_ 3 | 4 | #include "gtk_object.h" 5 | 6 | namespace nodeGtk { 7 | 8 | class NodeGtkWidget: public NodeGtkObject { 9 | 10 | public: 11 | 12 | GtkWidget *widget; 13 | 14 | // For getting the underlying GtkWidget 15 | static inline GtkWidget* Data (v8::Handle obj) { 16 | v8::HandleScope scope; 17 | return ObjectWrap::Unwrap(obj)->getWidget(); 18 | } 19 | 20 | virtual inline GtkWidget* getWidget() { 21 | return widget; 22 | } 23 | virtual inline void setWidget(GtkWidget *widget) { 24 | this->widget = widget; 25 | } 26 | 27 | static void SetupMethods(v8::Handle target); 28 | static void SetupCallbacks(std::vector *callbacks); 29 | static void Initialize(v8::Handle target); 30 | 31 | static void onDestroy (GtkWidget *gktWidget, NodeGtkWidget *widget); 32 | 33 | void addRef(); 34 | void addRef(GtkWidget *widget); 35 | 36 | /** 37 | * Retrieves a reference to this instance from the widget 38 | * 39 | * Parameters: 40 | * object - The GtkWidget that holds the reference 41 | */ 42 | static NodeGtkWidget* From(GObject *object) { 43 | return (NodeGtkWidget *)(g_object_get_data(G_OBJECT(object), "NodeGTK-ref")); 44 | } 45 | 46 | }; 47 | 48 | 49 | } // namespace ngtk 50 | 51 | #endif 52 | -------------------------------------------------------------------------------- /src/gtk_window.cc: -------------------------------------------------------------------------------- 1 | #include "gtk_window.h" 2 | 3 | #include 4 | 5 | namespace nodeGtk { 6 | 7 | using namespace v8; 8 | using namespace node; 9 | 10 | /** 11 | * The class constructor for Windows 12 | */ 13 | Persistent NodeGtkWindow::constructor_template; 14 | 15 | NodeGtkWindow::NodeGtkWindow (GtkWidget *window) { 16 | widget = GTK_WIDGET(window); 17 | addRef(); 18 | NODE_GTK_SET_REF(this, NodeGtkWindow); 19 | newJavaScriptInstance(constructor_template); 20 | } 21 | 22 | /** 23 | * Creates a new Window and attaches it to a JavaScript object 24 | * 25 | * Parameters: 26 | * type - One of the GtkWindowTypes 27 | * 28 | * Returns: 29 | * A new instance of the Window class 30 | */ 31 | Handle gtk_window_new (const Arguments &args) { 32 | HandleScope scope; 33 | 34 | assert(args[0]->IsNumber()); 35 | 36 | GtkWindowType type = (GtkWindowType)args[0]->ToNumber()->IntegerValue(); 37 | GtkWidget *window = gtk_window_new(type); 38 | NodeGtkWindow *node_window = new NodeGtkWindow(window); 39 | 40 | return node_window->obj; 41 | } 42 | 43 | /** 44 | * Sets the title of a Window 45 | * 46 | * Parameters: 47 | * title - The title of the window 48 | */ 49 | Handle gtk_window_set_title (const Arguments &args) { 50 | HandleScope scope; 51 | 52 | assert(NodeGtkWindow::HasInstance(args[0]->ToObject())); 53 | assert(args[1]->IsString()); 54 | 55 | GtkWindow *window = NodeGtkWindow::Data(args[0]->ToObject()); 56 | String::AsciiValue title(args[1]->ToString()); 57 | gtk_window_set_title(window, *title); 58 | 59 | return Undefined(); 60 | } 61 | 62 | 63 | /** 64 | * Attach all window methods to the target 65 | * 66 | * Parameters: 67 | * target: The object to attach methods to 68 | */ 69 | void NodeGtkWindow::SetupMethods (Handle target) { 70 | HandleScope scope; 71 | 72 | target->Set(v8::String::NewSymbol("window_new"), v8::FunctionTemplate::New(gtk_window_new)->GetFunction()); 73 | target->Set(v8::String::NewSymbol("window_set_title"), v8::FunctionTemplate::New(gtk_window_set_title)->GetFunction()); 74 | } 75 | 76 | /** 77 | * Sets up the environment with all things windowy 78 | * 79 | * Parameters: 80 | * target: The object to attach methods to 81 | */ 82 | void NodeGtkWindow::Initialize (Handle target) { 83 | HandleScope scope; 84 | 85 | // Create a new JavaScript class 86 | Handle windowTemplate = FunctionTemplate::New(); 87 | windowTemplate->SetClassName(String::New("Window")); 88 | constructor_template = Persistent::New(windowTemplate); 89 | 90 | // Set up the class to point to a C++ class 91 | Handle windowInstance = windowTemplate->InstanceTemplate(); 92 | windowInstance->SetInternalFieldCount(1); 93 | 94 | // Attach methods to the target 95 | NodeGtkWindow::SetupMethods(target); 96 | 97 | } 98 | } 99 | -------------------------------------------------------------------------------- /src/gtk_window.h: -------------------------------------------------------------------------------- 1 | #ifndef NGTK_WINDOW_H_ 2 | #define NGTK_WINDOW_H_ 3 | 4 | #include "gtk_bin.h" 5 | 6 | #define NGTK_WINDOW_DEFAULT_WIDTH 640 7 | #define NGTK_WINDOW_DEFAULT_HEIGHT 480 8 | 9 | namespace nodeGtk { 10 | 11 | class NodeGtkWindow: public nodeGtk::NodeGtkBin { 12 | 13 | public: 14 | 15 | static v8::Persistent constructor_template; 16 | 17 | /** 18 | * Constructor. Creates a new Window, which will wrap a new GtkWindow 19 | * 20 | * Parameters: 21 | * type - The window type 22 | */ 23 | NodeGtkWindow(GtkWidget *window); 24 | 25 | /** 26 | * Checks to see if a v8::Object is a Window in disguise 27 | * 28 | * Parameters: 29 | * obj - The object to check for Windowness 30 | * 31 | * Returns: 32 | * True if the object is a window, false otherwise 33 | */ 34 | static inline bool HasInstance(v8::Handle val) { 35 | v8::HandleScope scope; 36 | 37 | if (val->IsObject()) { 38 | v8::Local obj = val->ToObject(); 39 | 40 | if (constructor_template->HasInstance(obj)) { 41 | return true; 42 | } 43 | } 44 | return false; 45 | } 46 | 47 | /** 48 | * For getting the underlying GtkWidget. 49 | * 50 | * Usage: 51 | * (code) 52 | * GtkWindow *window = Window::Data(args[n]->ToObject()); 53 | * (end) 54 | * 55 | * Returns: 56 | * The pointer to the GtkWindow contained in this Window 57 | */ 58 | static inline GtkWindow* Data (v8::Handle obj) { 59 | v8::HandleScope scope; 60 | assert(NodeGtkWindow::HasInstance(obj)); 61 | return GTK_WINDOW(ObjectWrap::Unwrap(obj)->getWidget()); 62 | } 63 | 64 | static void SetupMethods (v8::Handle target); 65 | static void Initialize (v8::Handle target); 66 | 67 | /** 68 | * Retrieves a reference to this instance from the widget 69 | * 70 | * Parameters: 71 | * object - The GtkWindow that holds the reference 72 | */ 73 | static NodeGtkWindow* From(GtkWindow *object) { 74 | NodeGtkWindow *button; 75 | NODE_GTK_GET_REF(object, button, NodeGtkWindow); 76 | return button; 77 | } 78 | 79 | }; 80 | 81 | } // namespace ngtk 82 | 83 | #endif 84 | -------------------------------------------------------------------------------- /wscript: -------------------------------------------------------------------------------- 1 | srcdir = "." 2 | blddir = "build" 3 | VERSION = "0.0.1" 4 | 5 | def set_options(opt): 6 | opt.tool_options("compiler_cxx") 7 | 8 | def configure(conf): 9 | conf.check_tool("compiler_cxx") 10 | conf.check_tool("node_addon") 11 | conf.check_cfg(package='gtk+-2.0', uselib_store='GTK', args='--cflags --libs') 12 | conf.check_cfg(package='glib-2.0', args='--cflags --libs', uselib_store='GLIB') 13 | 14 | def build(bld): 15 | obj = bld.new_task_gen("cxx", "shlib", "node_addon", uselib = 'GTK') 16 | obj.cxxflags = ["-Wall", "-ansi", "-pedantic", "-std=c++0x"] 17 | obj.target = "gtk" 18 | obj.source = """ 19 | src/gtk.cc 20 | src/g_object.cc 21 | src/gtk_object.cc 22 | src/gtk_widget.cc 23 | src/gtk_bin.cc 24 | src/gtk_container.cc 25 | src/gtk_window.cc 26 | src/gtk_box.cc 27 | src/gtk_hbox.cc 28 | src/gtk_vbox.cc 29 | src/gtk_button.cc 30 | src/gtk_entry.cc 31 | src/gtk_misc.cc 32 | src/gtk_label.cc 33 | src/gtk_tree_store.cc 34 | src/gtk_tree_iter.cc 35 | src/gtk_tree_view.cc 36 | src/gtk_tree_view_column.cc 37 | src/gtk_cell_renderer.cc 38 | src/gtk_cell_renderer_text.cc 39 | src/gtk_cell_renderer_toggle.cc 40 | """ 41 | obj.uselib = "GTK GLIB" 42 | --------------------------------------------------------------------------------