GNOME.org
 

[gtkmm-documentation] New chapter: Keyboard Events

commit fbfd2d9fd7022b4933ac16565501cf3c1798a5bf
Author: Pedro Ferreira <darkiiiiii gmail com>
Date:   Tue Nov 1 15:43:45 2011 +0100

    New chapter: Keyboard Events
    
    * docs/tutorial/C/gtkmm-tutorial-in.xml: Add new chapter "Keyboard Events".
    Add a paragraph on event propagation in Appendix B "Signals".
    * docs/tutorial/C/figures/keyboardevents_propagation.png:
    * docs/tutorial/C/figures/keyboardevents_simple.png: New screenshots.
    * docs/tutorial/Makefile.am: Add the new files.
    * examples/book/keyboard_events/propagation/event_propagation.[h|cc]:
    * examples/book/keyboard_events/propagation/main.cc:
    * examples/book/keyboard_events/simple/keyboard_events.[h|cc]:
    * examples/book/keyboard_events/simple/main.cc: New example programs.
    * examples/Makefile.am: Add the new files.
    Bug #661857.

 ChangeLog                                          |   16 +++
 .../C/figures/keyboardevents_propagation.png       |  Bin 0 -> 6935 bytes
 docs/tutorial/C/figures/keyboardevents_simple.png  |  Bin 0 -> 6066 bytes
 docs/tutorial/C/gtkmm-tutorial-in.xml              |  137 +++++++++++++++++++-
 docs/tutorial/Makefile.am                          |    2 +
 examples/Makefile.am                               |   12 ++
 .../propagation/event_propagation.cc               |  122 +++++++++++++++++
 .../propagation/event_propagation.h                |   50 +++++++
 examples/book/keyboard_events/propagation/main.cc  |   30 +++++
 .../book/keyboard_events/simple/keyboard_events.cc |  100 ++++++++++++++
 .../book/keyboard_events/simple/keyboard_events.h  |   46 +++++++
 examples/book/keyboard_events/simple/main.cc       |   30 +++++
 12 files changed, 543 insertions(+), 2 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 458e50f..de4da74 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,19 @@
+2011-11-01  Pedro Ferreira <darkiiiiii gmail com>
+
+	New chapter: Keyboard Events
+
+	* docs/tutorial/C/gtkmm-tutorial-in.xml: Add new chapter "Keyboard Events".
+	Add a paragraph on event propagation in Appendix B "Signals".
+	* docs/tutorial/C/figures/keyboardevents_propagation.png:
+	* docs/tutorial/C/figures/keyboardevents_simple.png: New screenshots.
+	* docs/tutorial/Makefile.am: Add the new files.
+	* examples/book/keyboard_events/propagation/event_propagation.[h|cc]:
+	* examples/book/keyboard_events/propagation/main.cc:
+	* examples/book/keyboard_events/simple/keyboard_events.[h|cc]:
+	* examples/book/keyboard_events/simple/main.cc: New example programs.
+	* examples/Makefile.am: Add the new files.
+	Bug #661857.
+
 2011-10-12  Murray Cumming  <murrayc murrayc com>
 
 	gmmproc appendix. More about Gtk::Object
diff --git a/docs/tutorial/C/figures/keyboardevents_propagation.png b/docs/tutorial/C/figures/keyboardevents_propagation.png
new file mode 100644
index 0000000..8a4c67b
Binary files /dev/null and b/docs/tutorial/C/figures/keyboardevents_propagation.png differ
diff --git a/docs/tutorial/C/figures/keyboardevents_simple.png b/docs/tutorial/C/figures/keyboardevents_simple.png
new file mode 100644
index 0000000..f34e3ca
Binary files /dev/null and b/docs/tutorial/C/figures/keyboardevents_simple.png differ
diff --git a/docs/tutorial/C/gtkmm-tutorial-in.xml b/docs/tutorial/C/gtkmm-tutorial-in.xml
index 8e25a3a..fc237ac 100644
--- a/docs/tutorial/C/gtkmm-tutorial-in.xml
+++ b/docs/tutorial/C/gtkmm-tutorial-in.xml
@@ -5795,6 +5795,128 @@ A plug was added</screen>
   </sect1>
 </chapter>
 
+<chapter id="chapter-keyboardevents">
+  <title>Keyboard Events</title>
+  <para>
+    X events differ in some ways from other signals. These differences are described
+    in the <link linkend="sec-xeventsignals">X Event signals</link> section in
+    the appendix. Here we will use keyboard events to show how X events can be
+    used in a program.
+  </para>
+  <sect1 id="sec-keyboardevents-overview">
+    <title>Overview</title>
+    <para>
+      Whenever you press or release a key, an event is emitted. You can connect
+      a signal handler to handle such events.
+    </para>
+    <para>
+      To receive the keyboard events, you must first call the
+      <methodname>Gtk::Widget::add_events()</methodname> function with a bit
+      mask of the events you're interested in. The event signal handler will
+      receive an argument that depends on the type of event. For keyboard
+      events it's a <type>GdkEventKey*</type>. As discribed in the
+      <link linkend="sec-xeventsignals">appendix</link>, the event signal handler
+      returns a <type>bool</type> value, to indicate that the signal is fully
+      handled (<literal>true</literal>) or allow event propagation
+      (<literal>false</literal>).
+    </para>
+    <para>
+      To determine which key was pressed or released, you read the value of
+      <varname>GdkEventKey::keyval</varname> and compare it with a constant in the
+      <filename>&lt;gdk/gdkkeysyms.h&gt;</filename> header file. The states of
+      modifier keys (shift, ctrl, etc.) are available as bit-flags in
+      <varname>GdkEventKey::state</varname>.
+    </para>
+    <para>
+      Here's a simple example:
+<programlisting>
+bool on_key_press_or_release_event(GdkEventKey* event)
+{
+  if (event->type == GDK_KEY_PRESS &amp;&amp;
+    event->keyval == GDK_KEY_1 &amp;&amp;
+    (event->state &amp; (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == GDK_MOD1_MASK)
+  {
+    handle_alt_1_press(); // GDK_MOD1_MASK is normally the Alt key
+    return true;
+  }
+  return false;
+}
+
+Gtk::Entry m_entry; // in a class definition
+
+// in the class constructor
+m_entry.signal_key_press_event().connect( sigc::ptr_fun(&amp;on_key_press_or_release_event) );
+m_entry.signal_key_release_event().connect( sigc::ptr_fun(&amp;on_key_press_or_release_event) );
+m_entry.add_events(Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK);
+</programlisting>
+    </para>
+
+    <sect2 id="keyboardevents-simple-example">
+    <title>Example</title>
+      <para>
+        In this example there are three keyboard shortcuts:
+        <keycap>Alt</keycap>+<keycap>1</keycap> selects the first radio button,
+        <keycap>Alt</keycap>+<keycap>2</keycap> selects the second one, and the
+        <keycap>Esc</keycap> key hides (closes) the window.
+      </para>
+
+      <figure id="figure-keyboardevents-simple">
+        <title>Keyboard Events - Simple</title>
+        <screenshot>
+          <graphic format="PNG" fileref="&url_figures_base;keyboardevents_simple.png"/>
+        </screenshot>
+      </figure>
+
+      <para><ulink url="&url_examples_base;keyboard_events/simple/">Source Code</ulink></para>
+    </sect2>
+  </sect1>
+
+  <sect1 id="sec-keyboardevents-propagation">
+    <title>Event Propagation</title>
+    <para>
+      Event propagation means that, when an event is emitted on a particular
+      widget, it can be passed to its parent widget (and that widget can pass
+      it to its parent, and so on) and, if the parent has an event handler,
+      that handler will be called. 
+    </para>
+    <para>
+      The event will propagate until it reaches the top-level widget, or until
+      you stop the propagation by returning <literal>true</literal> from an
+      event handler.
+    </para>
+    <para>
+      Notice, that after canceling an event, no other function will be called
+      (even if it is from the same widget).
+    </para>
+
+    <sect2 id="keyboardevents-propagation-example">
+    <title>Example</title>
+      <para>
+        In this example there are three event handlers, one in the
+        <classname>Gtk::Entry</classname>, one in the <classname>Gtk::Grid</classname>
+        and one in the <classname>Gtk::Window</classname>.
+      </para>
+      <para>
+        When you write in the entry, a key release event will be emitted first
+        in the <classname>Entry</classname> and, depending on whether we let
+        it propagate, it can reach the <classname>Grid</classname>'s and the
+        <classname>Window</classname>'s event handlers. If it propagates,
+        the text you're writing will appear in the <classname>Label</classname>
+        above the <classname>Entry</classname>.
+      </para>
+
+      <figure id="figure-keyboardevents-propagation">
+        <title>Keyboard Events - Event Propagation</title>
+        <screenshot>
+          <graphic format="PNG" fileref="&url_figures_base;keyboardevents_propagation.png"/>
+        </screenshot>
+      </figure>
+
+      <para><ulink url="&url_examples_base;keyboard_events/propagation/">Source Code</ulink></para>
+    </sect2>
+  </sect1>
+</chapter>
+
 <chapter id="chapter-chapter-timeouts">
 <title>Timeouts, I/O and Idle Functions </title>
 
@@ -7779,12 +7901,23 @@ for the various events.
 
 <sect2 id="signal-handler-sequence">
 <title>Signal Handler sequence</title>
-<para>By default, your signal handlers are called after any previously-connected signal handlers. However, this can be a problem with the X Event signals. For instance, the existing signal handlers, or the default signal handler, might return true to stop other signal handlers from being called. To specify that your signal handler should be called before the other signal handlers, so that will always be called, you can specify <literal>false</literal> for the optional <literal>after</literal> parameter. For instance,
+<para>By default, your signal handlers are called after any previously-connected
+signal handlers. However, this can be a problem with the X Event signals. For instance,
+the existing signal handlers, or the default signal handler, might return <literal>true</literal>
+to stop other signal handlers from being called. To specify that your signal handler
+should be called before the other signal handlers, so that it will always be called,
+you can specify <literal>false</literal> for the optional <literal>after</literal>
+parameter. For instance,
 <programlisting>
 button.signal_button_press_event().connect( sigc::ptr_fun(&amp;on_mywindow_button_press), false );
 </programlisting>
 </para>
-
+<para>The event is delivered first to the widget the event occurred in. If all
+signal handlers in that widget return <literal>false</literal> (indicating that
+the event has not been handled), then the signal will be propagated to the parent
+widget and emitted there. This continues all the way up to the top-level widget
+if no one handles the event. 
+</para>
 </sect2>
 
 </sect1>
diff --git a/docs/tutorial/Makefile.am b/docs/tutorial/Makefile.am
index 1f130f8..242d393 100644
--- a/docs/tutorial/Makefile.am
+++ b/docs/tutorial/Makefile.am
@@ -62,6 +62,8 @@ DOC_FIGURES =					\
 	figures/helloworld2.png			\
 	figures/idle.png			\
 	figures/infobar.png			\
+	figures/keyboardevents_simple.png			\
+	figures/keyboardevents_propagation.png		\
 	figures/label.png			\
 	figures/main_menu.png			\
 	figures/menu_popup.png			\
diff --git a/examples/Makefile.am b/examples/Makefile.am
index 11af541..498605c 100644
--- a/examples/Makefile.am
+++ b/examples/Makefile.am
@@ -63,6 +63,8 @@ check_PROGRAMS =					\
 	book/idle/idle					\
 	book/infobar/example				\
 	book/input/example				\
+	book/keyboard_events/simple/example	\
+	book/keyboard_events/propagation/example	\
 	book/label/example				\
 	book/menus/main_menu/main_menu			\
 	book/menus/popup/popup				\
@@ -405,6 +407,16 @@ book_infobar_example_SOURCES =		\
 book_input_example_SOURCES = \
 	book/input/main.cc
 
+book_keyboard_events_simple_example_SOURCES =		\
+	book/keyboard_events/simple/keyboard_events.cc	\
+	book/keyboard_events/simple/keyboard_events.h	\
+	book/keyboard_events/simple/main.cc
+
+book_keyboard_events_propagation_example_SOURCES =		\
+	book/keyboard_events/propagation/event_propagation.cc	\
+	book/keyboard_events/propagation/event_propagation.h	\
+	book/keyboard_events/propagation/main.cc
+
 book_label_example_SOURCES =		\
 	book/label/examplewindow.cc	\
 	book/label/examplewindow.h	\
diff --git a/examples/book/keyboard_events/propagation/event_propagation.cc b/examples/book/keyboard_events/propagation/event_propagation.cc
new file mode 100644
index 0000000..228ece1
--- /dev/null
+++ b/examples/book/keyboard_events/propagation/event_propagation.cc
@@ -0,0 +1,122 @@
+/* gtkmm example Copyright (C) 2011 gtkmm development team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "event_propagation.h"
+
+
+EventPropagation::EventPropagation()
+{
+  m_label.set_label ("A label");
+
+  m_canPropagate.set_label ("Can Propagate");
+
+  m_canPropagate.set_active (true);
+
+
+    // Main Container
+
+  m_container.set_orientation (Gtk::ORIENTATION_VERTICAL);
+
+  m_container.add (m_label);
+  m_container.add (m_entry);
+  m_container.add (m_canPropagate);
+
+
+    // Window
+
+  add (m_container);
+
+  set_title ("Event Propagation");
+
+  set_border_width (10);
+
+  show_all_children();
+
+
+    // Events
+
+  add_events (Gdk::KEY_RELEASE_MASK);
+
+
+  m_entry.signal_key_release_event().connect(sigc::mem_fun(*this,
+                                         &EventPropagation::entryKeyRelease));
+
+  m_container.signal_key_release_event().connect(sigc::mem_fun(*this,
+                                         &EventPropagation::gridKeyRelease));
+
+  signal_key_release_event().connect(sigc::mem_fun(*this,
+                                         &EventPropagation::windowKeyRelease));
+}
+
+
+
+
+/*
+    By changing the return value, we allow or not the event to propagate to other elements
+ */
+
+bool EventPropagation::entryKeyRelease(GdkEventKey* /* event */ )
+{
+  std::cout << "Entry" << std::endl;
+
+  if (m_canPropagate.get_active() == true)
+  {
+    return false;
+  }
+
+  return true;
+}
+
+
+
+
+bool EventPropagation::gridKeyRelease(GdkEventKey* /* event */ )
+{
+  std::cout << "Grid" << std::endl;
+
+    //let it propagate
+  return false;
+}
+
+
+
+
+/*
+    This will set the entry's text in the label, everytime a key is pressed
+ */
+
+bool EventPropagation::windowKeyRelease(GdkEventKey* /* event */ )
+{
+  std::cout << "Window" << std::endl;
+
+      //checking if the entry is on focus, otherwise the label would get changed by pressing keys
+      //on the window (when the entry is not on focus), even if canPropagate wasn't active
+  if (m_entry.has_focus() == true)
+  {
+    m_label.set_text (m_entry.get_text());
+  }
+
+
+  return true;
+}
+
+
+
+EventPropagation::~EventPropagation()
+{
+
+}
+
diff --git a/examples/book/keyboard_events/propagation/event_propagation.h b/examples/book/keyboard_events/propagation/event_propagation.h
new file mode 100644
index 0000000..8f8cd28
--- /dev/null
+++ b/examples/book/keyboard_events/propagation/event_propagation.h
@@ -0,0 +1,50 @@
+/* gtkmm example Copyright (C) 2011 gtkmm development team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef GTKMM_EVENT_PROPAGATION_H
+#define GTKMM_EVENT_PROPAGATION_H
+
+#include <gtkmm.h>
+#include <iostream>
+
+class EventPropagation : public Gtk::Window
+{
+  public:
+
+    EventPropagation();
+    virtual ~EventPropagation();
+
+
+  private:
+
+    bool entryKeyRelease (GdkEventKey *event);
+
+    bool gridKeyRelease (GdkEventKey *event);
+
+    bool windowKeyRelease (GdkEventKey *event);
+
+        //ui elements
+
+    Gtk::Grid m_container;
+
+    Gtk::Label m_label;
+    Gtk::Entry m_entry;
+    Gtk::CheckButton m_canPropagate;
+
+};
+
+
+#endif //GTKMM_EVENT_PROPAGATION_H
diff --git a/examples/book/keyboard_events/propagation/main.cc b/examples/book/keyboard_events/propagation/main.cc
new file mode 100644
index 0000000..80ccf93
--- /dev/null
+++ b/examples/book/keyboard_events/propagation/main.cc
@@ -0,0 +1,30 @@
+/* gtkmm example Copyright (C) 2011 gtkmm development team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "event_propagation.h"
+
+
+int main (int argc, char** argv)
+{
+  Gtk::Main kit (argc, argv);
+
+
+  EventPropagation mainWindow;
+
+  Gtk::Main::run (mainWindow);
+
+  return 0;
+}
diff --git a/examples/book/keyboard_events/simple/keyboard_events.cc b/examples/book/keyboard_events/simple/keyboard_events.cc
new file mode 100644
index 0000000..0d87815
--- /dev/null
+++ b/examples/book/keyboard_events/simple/keyboard_events.cc
@@ -0,0 +1,100 @@
+/* gtkmm example Copyright (C) 2011 gtkmm development team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "keyboard_events.h"
+
+
+KeyboardEvents::KeyboardEvents()
+{
+    // Radio buttons
+
+  m_first.set_label ("First");
+  m_second.set_label ("Second");
+
+  Gtk::RadioButton::Group group = m_first.get_group();
+
+  m_second.set_group (group);
+
+
+  m_first.set_active();
+
+
+    // Main Container
+
+  m_container.add (m_first);
+  m_container.add (m_second);
+
+
+    // Window
+
+  add (m_container);
+
+  set_title ("Keyboard Events");
+
+  set_border_width (10);
+
+  show_all_children();
+
+
+    // Events
+
+  add_events (Gdk::KEY_PRESS_MASK);
+
+
+  signal_key_press_event().connect(sigc::mem_fun(*this,
+                                   &KeyboardEvents::onKeyPress));
+}
+
+
+
+
+bool KeyboardEvents::onKeyPress (GdkEventKey *event)
+{
+    //GDK_MOD1_MASK -> the 'alt' key (mask)
+    //GDK_KEY_1     -> the '1' key
+    //GDK_KEY_2     -> the '2' key
+
+    //select the first radio button, when we press alt + 1
+  if ((event->keyval == GDK_KEY_1) &&
+     (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == GDK_MOD1_MASK)
+  {
+    m_first.set_active();
+  }
+
+    //and the second radio button, when we press alt + 2
+  else if ((event->keyval == GDK_KEY_2) &&
+          (event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK)) == GDK_MOD1_MASK)
+  {
+    m_second.set_active();
+  }
+
+
+    //close the window, when the 'esc' key is pressed
+  else if (event->keyval == GDK_KEY_Escape)
+  {
+    hide();
+  }
+
+
+    //returning true, cancels the propagation of the event
+  return true;
+}
+
+
+KeyboardEvents::~KeyboardEvents()
+{
+
+}
diff --git a/examples/book/keyboard_events/simple/keyboard_events.h b/examples/book/keyboard_events/simple/keyboard_events.h
new file mode 100644
index 0000000..7683933
--- /dev/null
+++ b/examples/book/keyboard_events/simple/keyboard_events.h
@@ -0,0 +1,46 @@
+/* gtkmm example Copyright (C) 2011 gtkmm development team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef GTKMM_KEYBOARD_EVENTS_H
+#define GTKMM_KEYBOARD_EVENTS_H
+
+#include <gtkmm.h>
+
+
+class KeyboardEvents : public Gtk::Window
+{
+  public:
+
+    KeyboardEvents();
+    virtual ~KeyboardEvents();
+
+
+  private:
+
+    bool onKeyPress (GdkEventKey *event);
+
+
+        //ui related elements
+
+    Gtk::Grid m_container;
+
+    Gtk::RadioButton m_first;
+    Gtk::RadioButton m_second;
+
+};
+
+
+#endif //GTKMM_KEYBOARD_EVENTS_H
diff --git a/examples/book/keyboard_events/simple/main.cc b/examples/book/keyboard_events/simple/main.cc
new file mode 100644
index 0000000..ca870a8
--- /dev/null
+++ b/examples/book/keyboard_events/simple/main.cc
@@ -0,0 +1,30 @@
+/* gtkmm example Copyright (C) 2011 gtkmm development team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "keyboard_events.h"
+
+
+int main (int argc, char** argv)
+{
+  Gtk::Main kit (argc, argv);
+
+
+  KeyboardEvents mainWindow;
+
+  Gtk::Main::run (mainWindow);
+
+  return 0;
+}
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]