From: <wda...@us...> - 2008-05-07 20:34:35
|
Revision: 2488 http://oorexx.svn.sourceforge.net/oorexx/?rev=2488&view=rev Author: wdashley Date: 2008-05-07 13:34:41 -0700 (Wed, 07 May 2008) Log Message: ----------- ArtifactID: None Comment: Added methods to the menuitem class. This completes the menu classes. Modified Paths: -------------- sandbox/david/4x/grxmenuitem.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Modified: sandbox/david/4x/grxmenuitem.cpp =================================================================== --- sandbox/david/4x/grxmenuitem.cpp 2008-05-07 19:54:31 UTC (rev 2487) +++ sandbox/david/4x/grxmenuitem.cpp 2008-05-07 20:34:41 UTC (rev 2488) @@ -123,6 +123,141 @@ } /** + * Method: set_right_justified + * + * Set the right justification flag. + * + * @param state The right justification state + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxMenuItemSetRightJustified, // Object_method name + logical_t, state) // The state boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuItem *myWidget = (GtkMenuItem *)context->PointerValue(rxptr); + + gtk_menu_item_set_right_justified(myWidget, state); + + return 0; +} + +/** + * Method: get_right_justified + * + * Get the right justification flag. + * + * @return Zero + **/ +RexxMethod0(logical_t, // Return type + GrxMenuItemGetRightJustified) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuItem *myWidget = (GtkMenuItem *)context->PointerValue(rxptr); + + return gtk_menu_item_get_right_justified(myWidget); +} + +/** + * Method: set_submenu + * + * Set a submenu. + * + * @param subm The submenu + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxMenuItemSetSubmenu, // Object_method name + RexxObjectPtr, subm) // The submenu +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuItem *myWidget = (GtkMenuItem *)context->PointerValue(rxptr); + RexxPointerObject submptr = (RexxPointerObject)context->SendMessage0(subm, "POINTER"); + GtkWidget *subWidget = (GtkWidget *)context->PointerValue(submptr); + + gtk_menu_item_set_submenu(myWidget, subWidget); + + return 0; +} + +/** + * Method: remove_submenu + * + * Remove a submenu. + * + * @return Zero + **/ +RexxMethod0(int, // Return type + GrxMenuItemRemoveSubmenu) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuItem *myWidget = (GtkMenuItem *)context->PointerValue(rxptr); + + gtk_menu_item_remove_submenu(myWidget); + + return 0; +} + +/** + * Method: set_accel_path + * + * Set the accelerator path. + * + * @param path The accel path + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxMenuItemSetAccelPath, // Object_method name + CSTRING, path) // The accel path +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuItem *myWidget = (GtkMenuItem *)context->PointerValue(rxptr); + + gtk_menu_item_set_accel_path(myWidget, path); + + return 0; +} + +/** + * Method: select + * + * Select the menu item. + * + * @return Zero + **/ +RexxMethod0(int, // Return type + GrxMenuItemSelect) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuItem *myWidget = (GtkMenuItem *)context->PointerValue(rxptr); + + gtk_menu_item_select(myWidget); + + return 0; +} + +/** + * Method: deselect + * + * Deselect the menu item. + * + * @return Zero + **/ +RexxMethod0(int, // Return type + GrxMenuItemDeselect) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuItem *myWidget = (GtkMenuItem *)context->PointerValue(rxptr); + + gtk_menu_item_deselect(myWidget); + + return 0; +} + +/** * Method: signal_connect * * Connect a signal to an ooRexx method. Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-05-07 19:54:31 UTC (rev 2487) +++ sandbox/david/4x/rexxgtk.cls 2008-05-07 20:34:41 UTC (rev 2488) @@ -1854,6 +1854,13 @@ return self~new(label, .true) ::METHOD init EXTERNAL "LIBRARY rexxgtk GrxMenuItemNew" +::METHOD set_right _justified EXTERNAL "LIBRARY rexxgtk GrxMenuItemSetRightJustified" +::METHOD get_right _justified EXTERNAL "LIBRARY rexxgtk GrxMenuItemGetRightJustified" +::METHOD set_submenu EXTERNAL "LIBRARY rexxgtk GrxMenuItemSetSubmenu" +::METHOD remove_submenu EXTERNAL "LIBRARY rexxgtk GrxMenuItemRemoveSubmenu" +::METHOD set_accel_path EXTERNAL "LIBRARY rexxgtk GrxMenuItemSetAccelPath" +::METHOD select EXTERNAL "LIBRARY rexxgtk GrxMenuItemSelect" +::METHOD deselect EXTERNAL "LIBRARY rexxgtk GrxMenuItemDeselect" ::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxMenuItemSignalConnect" -- The following are the methods that can be connected to signals. By default Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-05-07 19:54:31 UTC (rev 2487) +++ sandbox/david/4x/rexxgtk.cpp 2008-05-07 20:34:41 UTC (rev 2488) @@ -702,6 +702,13 @@ REXX_METHOD(GrxMenuGetAttachWidget, GrxMenuGetAttachWidget), REXX_METHOD(GrxMenuSignalConnect, GrxMenuSignalConnect), REXX_METHOD(GrxMenuItemNew, GrxMenuItemNew), + REXX_METHOD(GrxMenuItemSetRightJustified, GrxMenuItemSetRightJustified), + REXX_METHOD(GrxMenuItemGetRightJustified, GrxMenuItemGetRightJustified), + REXX_METHOD(GrxMenuItemSetSubmenu, GrxMenuItemSetSubmenu), + REXX_METHOD(GrxMenuItemRemoveSubmenu, GrxMenuItemRemoveSubmenu), + REXX_METHOD(GrxMenuItemSetAccelPath, GrxMenuItemSetAccelPath), + REXX_METHOD(GrxMenuItemSelect, GrxMenuItemSelect), + REXX_METHOD(GrxMenuItemDeselect, GrxMenuItemDeselect), REXX_METHOD(GrxMenuItemSignalConnect, GrxMenuItemSignalConnect), REXX_METHOD(GrxSeparatorMenuItemNew, GrxSeparatorMenuItemNew), REXX_LAST_METHOD() Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-05-07 19:54:31 UTC (rev 2487) +++ sandbox/david/4x/rexxgtk.h 2008-05-07 20:34:41 UTC (rev 2488) @@ -403,6 +403,13 @@ REXX_METHOD_PROTOTYPE(GrxMenuGetAttachWidget) REXX_METHOD_PROTOTYPE(GrxMenuSignalConnect) REXX_METHOD_PROTOTYPE(GrxMenuItemNew) +REXX_METHOD_PROTOTYPE(GrxMenuItemSetRightJustified) +REXX_METHOD_PROTOTYPE(GrxMenuItemGetRightJustified) +REXX_METHOD_PROTOTYPE(GrxMenuItemSetSubmenu) +REXX_METHOD_PROTOTYPE(GrxMenuItemRemoveSubmenu) +REXX_METHOD_PROTOTYPE(GrxMenuItemSetAccelPath) +REXX_METHOD_PROTOTYPE(GrxMenuItemSelect) +REXX_METHOD_PROTOTYPE(GrxMenuItemDeselect) REXX_METHOD_PROTOTYPE(GrxMenuItemSignalConnect) REXX_METHOD_PROTOTYPE(GrxSeparatorMenuItemNew) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-05-09 21:20:19
|
Revision: 2489 http://oorexx.svn.sourceforge.net/oorexx/?rev=2489&view=rev Author: wdashley Date: 2008-05-09 14:20:17 -0700 (Fri, 09 May 2008) Log Message: ----------- ArtifactID: None Comment: Added support for events to all widgets. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/grxwidget.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxevents.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-05-07 20:34:41 UTC (rev 2488) +++ sandbox/david/4x/Makefile 2008-05-09 21:20:17 UTC (rev 2489) @@ -76,7 +76,8 @@ grxeventbox.o \ grxmenushell.o \ grxmenu.o \ - grxmenuitem.o + grxmenuitem.o \ + grxevents.o # Build the shared library @@ -178,8 +179,11 @@ grxmenuitem.o: grxmenuitem.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxmenuitem.cpp +grxevents.o: grxevents.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxevents.cpp + clean: rm *.so *.o Added: sandbox/david/4x/grxevents.cpp =================================================================== --- sandbox/david/4x/grxevents.cpp (rev 0) +++ sandbox/david/4x/grxevents.cpp 2008-05-09 21:20:17 UTC (rev 2489) @@ -0,0 +1,1221 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Function: create_GdkEvent + * + * Handle a GdkEvent signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEvent(GtkWidget *window, + GdkEvent *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventKey"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventKey + * + * Handle a GdkEventKey signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventKey(GtkWidget *window, + GdkEventKey *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventKey"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "state=", + context->UnsignedNumberToObject((size_t)event->state)); + context->SendMessage1(rxevent, "keyval=", + context->UnsignedNumberToObject((size_t)event->keyval)); + context->SendMessage1(rxevent, "length=", + context->NumberToObject((wholenumber_t)event->length)); + context->SendMessage1(rxevent, "string=", + context->NewStringFromAsciiz(event->string)); + context->SendMessage1(rxevent, "hardware_keycode=", + context->UnsignedNumberToObject((size_t)event->hardware_keycode)); + context->SendMessage1(rxevent, "group=", + context->UnsignedNumberToObject((size_t)event->group)); + context->SendMessage1(rxevent, "is_modifier=", + context->UnsignedNumberToObject((size_t)event->is_modifier)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventButton + * + * Handle a GdkEventButton signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventButton(GtkWidget *window, + GdkEventButton *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventButton"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "x=", + context->DoubleToObject(event->x)); + context->SendMessage1(rxevent, "y=", + context->DoubleToObject(event->y)); + context->SendMessage1(rxevent, "axes=", + context->DoubleToObject(*event->axes)); + context->SendMessage1(rxevent, "state=", + context->UnsignedNumberToObject((size_t)event->state)); + context->SendMessage1(rxevent, "button=", + context->UnsignedNumberToObject((size_t)event->button)); + // TODO - fix this. + context->SendMessage1(rxevent, "device=", context->Nil()); + context->SendMessage1(rxevent, "x_root=", + context->DoubleToObject(event->x_root)); + context->SendMessage1(rxevent, "y_root=", + context->DoubleToObject(event->y_root)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventScroll + * + * Handle a GdkEventScroll signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventScroll(GtkWidget *window, + GdkEventScroll *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventScroll"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "x=", + context->DoubleToObject(event->x)); + context->SendMessage1(rxevent, "y=", + context->DoubleToObject(event->y)); + context->SendMessage1(rxevent, "state=", + context->UnsignedNumberToObject((size_t)event->state)); + context->SendMessage1(rxevent, "direction=", + context->NumberToObject((wholenumber_t)event->direction)); + // TODO - fix this. + context->SendMessage1(rxevent, "device=", context->Nil()); + context->SendMessage1(rxevent, "x_root=", + context->DoubleToObject(event->x_root)); + context->SendMessage1(rxevent, "y_root=", + context->DoubleToObject(event->y_root)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventMotion + * + * Handle a GdkEventMotion signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventMotion(GtkWidget *window, + GdkEventMotion *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventMotion"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "x=", + context->DoubleToObject(event->x)); + context->SendMessage1(rxevent, "y=", + context->DoubleToObject(event->y)); + context->SendMessage1(rxevent, "axes=", + context->DoubleToObject(*event->axes)); + context->SendMessage1(rxevent, "state=", + context->UnsignedNumberToObject((size_t)event->state)); + context->SendMessage1(rxevent, "is_hint=", + context->UnsignedNumberToObject((size_t)event->is_hint)); + // TODO - fix this. + context->SendMessage1(rxevent, "device=", context->Nil()); + context->SendMessage1(rxevent, "x_root=", + context->DoubleToObject(event->x_root)); + context->SendMessage1(rxevent, "y_root=", + context->DoubleToObject(event->y_root)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventExpose + * + * Handle a GdkEventExpose signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventExpose(GtkWidget *window, + GdkEventExpose *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventExpose"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + eobj = context->FindClass("GdkEventExpose"); + temp = context->SendMessage0(eobj, "NEW"); + context->SendMessage1(temp, "x=", + context->NumberToObject((wholenumber_t)event->area.x)); + context->SendMessage1(temp, "y=", + context->NumberToObject((wholenumber_t)event->area.y)); + context->SendMessage1(temp, "width=", + context->NumberToObject((wholenumber_t)event->area.width)); + context->SendMessage1(temp, "height=", + context->NumberToObject((wholenumber_t)event->area.height)); + context->SendMessage1(rxevent, "area=", temp); + // TODO - fix this. + context->SendMessage1(rxevent, "region=", context->Nil()); + context->SendMessage1(rxevent, "count=", + context->NumberToObject((wholenumber_t)event->count)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventVisibility + * + * Handle a GdkEventVisibility signal by invoking the Rexx + * method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventVisibility(GtkWidget *window, + GdkEventVisibility *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventVisibility"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "state=", + context->UnsignedNumberToObject((size_t)event->state)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventCrossing + * + * Handle a GdkEventCrossing signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventCrossing(GtkWidget *window, + GdkEventCrossing *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventCrossing"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->subwindow), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "subwindow=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "subwindow=", temp); + } + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "x=", + context->DoubleToObject(event->x)); + context->SendMessage1(rxevent, "y=", + context->DoubleToObject(event->y)); + context->SendMessage1(rxevent, "x_root=", + context->DoubleToObject(event->x_root)); + context->SendMessage1(rxevent, "y_root=", + context->DoubleToObject(event->y_root)); + context->SendMessage1(rxevent, "mode=", + context->NumberToObject((wholenumber_t)event->mode)); + context->SendMessage1(rxevent, "detail=", + context->NumberToObject((wholenumber_t)event->detail)); + context->SendMessage1(rxevent, "focus=", + context->NumberToObject((wholenumber_t)event->focus)); + context->SendMessage1(rxevent, "state=", + context->UnsignedNumberToObject((size_t)event->state)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventFocus + * + * Handle a GdkEventFocus signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventFocus(GtkWidget *window, + GdkEventFocus *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventFocus"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "in=", + context->NumberToObject((wholenumber_t)event->in)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventConfigure + * + * Handle a GdkEventConfigure signal by invoking the Rexx + * method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventConfigure(GtkWidget *window, + GdkEventConfigure *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventConfigure"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "x=", + context->NumberToObject((wholenumber_t)event->x)); + context->SendMessage1(rxevent, "y=", + context->NumberToObject((wholenumber_t)event->y)); + context->SendMessage1(rxevent, "width=", + context->NumberToObject((wholenumber_t)event->width)); + context->SendMessage1(rxevent, "height=", + context->NumberToObject((wholenumber_t)event->height)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventProperty + * + * Handle a GdkEventProperty signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventProperty(GtkWidget *window, + GdkEventProperty *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventProperty"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "atom=", + context->NumberToObject((wholenumber_t)event->atom)); + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "state=", + context->UnsignedNumberToObject((size_t)event->state)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventSelection + * + * Handle a GdkEventSelection signal by invoking the Rexx + * method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventSelection(GtkWidget *window, + GdkEventSelection *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventSelection"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "selection=", + context->NumberToObject((wholenumber_t)event->selection)); + context->SendMessage1(rxevent, "target=", + context->NumberToObject((wholenumber_t)event->target)); + context->SendMessage1(rxevent, "property=", + context->NumberToObject((wholenumber_t)event->property)); + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "requestor=", context->Nil()); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventDND + * + * Handle a GdkEventDND signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventDND(GtkWidget *window, + GdkEventDND *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventDND"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + // TODO - fix this. + context->SendMessage1(rxevent, "context=", context->Nil()); + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "x_root=", + context->NumberToObject((wholenumber_t)event->x_root)); + context->SendMessage1(rxevent, "y_root=", + context->NumberToObject((wholenumber_t)event->y_root)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventProximity + * + * Handle a GdkEventProximity signal by invoking the Rexx + * method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventProximity(GtkWidget *window, + GdkEventProximity *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventProximity"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "device=", context->Nil()); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventClient + * + * Handle a GdkEventClient signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventClient(GtkWidget *window, + GdkEventClient *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventClient"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "message_type=", + context->NumberToObject((wholenumber_t)event->message_type)); + context->SendMessage1(rxevent, "data_format=", + context->NumberToObject((wholenumber_t)event->data_format)); + RexxArrayObject temparr = context->NewArray(20); + if (event->data_format == 8) { + for (int i = 0; i < 20; i++) { + context->ArrayPut(temparr, + context->NumberToObject((wholenumber_t)event->data.b[i]), + i + 1); + } + } + else if (event->data_format == 16) { + for (int i = 0; i < 10; i++) { + context->ArrayPut(temparr, + context->NumberToObject((wholenumber_t)event->data.s[i]), + i + 1); + } + } + else if (event->data_format == 32) { + for (int i = 0; i < 5; i++) { + context->ArrayPut(temparr, + context->NumberToObject((wholenumber_t)event->data.l[i]), + i + 1); + } + } + context->SendMessage1(rxevent, "data=", temp); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventNoExpose + * + * Handle a GdkEventNoExpose signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventNoExpose(GtkWidget *window, + GdkEventNoExpose *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventNoExpose"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventWindowState + * + * Handle a GdkEventWindowState signal by invoking the Rexx + * method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventWindowState(GtkWidget *window, + GdkEventWindowState *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventWindowState"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "changed_mask=", + context->NumberToObject((wholenumber_t)event->changed_mask)); + context->SendMessage1(rxevent, "new_window_state=", + context->NumberToObject((wholenumber_t)event->new_window_state)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventSetting + * + * Handle a GdkEventSetting signal by invoking the Rexx method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventSetting(GtkWidget *window, + GdkEventSetting *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventSetting"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "action=", + context->NumberToObject((wholenumber_t)event->action)); + context->SendMessage1(rxevent, "name=", + context->NewStringFromAsciiz(event->name)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventOwnerChange + * + * Handle a GdkEventOwnerChange signal by invoking the Rexx + * method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventOwnerChange(GtkWidget *window, + GdkEventOwnerChange *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventOwnerChange"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "owner=", context->Nil()); + context->SendMessage1(rxevent, "reason=", + context->NumberToObject((wholenumber_t)event->reason)); + context->SendMessage1(rxevent, "selection=", + context->NumberToObject((wholenumber_t)event->selection)); + context->SendMessage1(rxevent, "time=", + context->UnsignedNumberToObject((size_t)event->time)); + context->SendMessage1(rxevent, "selection_time=", + context->UnsignedNumberToObject((size_t)event->selection_time)); + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + +/** + * Function: create_GdkEventGrabBroken + * + * Handle a GdkEventGrabBroken signal by invoking the Rexx + * method. + * + * @param window The widget pointer of the window + * + * @param event The event being signaled + * + * @param data The user specific data + * + * @return boolean + **/ +gboolean signal_GdkEventGrabBroken(GtkWidget *window, + GdkEventGrabBroken *event, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + RexxObjectPtr rxevent, temp; + gboolean retc; + + cblock->instance->AttachThread(&context); + + // Create the instance + RexxClassObject eobj = context->FindClass("GdkEventGrabBroken"); + rxevent = context->SendMessage0(eobj, "NEW"); + // Assign the standard event data + context->SendMessage1(rxevent, "type=", + context->NumberToObject((wholenumber_t)event->type)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "window=", temp); + } + context->SendMessage1(rxevent, "send_event=", + context->NumberToObject((wholenumber_t)event->send_event)); + // Assign the event specific data + context->SendMessage1(rxevent, "keyboard=", + context->NumberToObject((wholenumber_t)event->keyboard)); + context->SendMessage1(rxevent, "implicit=", + context->NumberToObject((wholenumber_t)event->implicit)); + temp = (RexxObjectPtr)g_object_get_data(G_OBJECT(event->grab_window), "OORXOBJECT"); + if (temp == NULL) { + context->SendMessage1(rxevent, "grab_window=", context->Nil()); + } + else { + context->SendMessage1(rxevent, "grab_window=", temp); + } + + temp = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, rxevent); + context->ObjectToNumber(temp, &retc); + context->DetachThread(); + return retc; +} + Property changes on: sandbox/david/4x/grxevents.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/grxwidget.cpp =================================================================== --- sandbox/david/4x/grxwidget.cpp 2008-05-07 20:34:41 UTC (rev 2488) +++ sandbox/david/4x/grxwidget.cpp 2008-05-09 21:20:17 UTC (rev 2489) @@ -934,6 +934,25 @@ } /** + * Method: set_events + * + * Set the event mask. + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxWidgetSetEvents, // Object_method name + int, events) // Event mask +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + + gtk_widget_set_events(myWidget, events); + + return 0; +} + +/** * Method: signal_connect * * Connect a signal to an ooRexx method. @@ -1103,6 +1122,230 @@ G_CALLBACK(signal_func_1b), cblock); return context->True(); } + else if (strcmp(name, "button_press_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_button_press_event"; + g_signal_connect(G_OBJECT(myWidget), "button-press-event", + G_CALLBACK(signal_GdkEventButton), cblock); + return context->True(); + } + else if (strcmp(name, "button_release_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_button_release_event"; + g_signal_connect(G_OBJECT(myWidget), "button-release-event", + G_CALLBACK(signal_GdkEventButton), cblock); + return context->True(); + } + else if (strcmp(name, "client_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_client_event"; + g_signal_connect(G_OBJECT(myWidget), "client-event", + G_CALLBACK(signal_GdkEventClient), cblock); + return context->True(); + } + else if (strcmp(name, "configure_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_configure_event"; + g_signal_connect(G_OBJECT(myWidget), "configure-event", + G_CALLBACK(signal_GdkEventConfigure), cblock); + return context->True(); + } + else if (strcmp(name, "delete_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_delete_event"; + g_signal_connect(G_OBJECT(myWidget), "delete-event", + G_CALLBACK(signal_GdkEvent), cblock); + return context->True(); + } + else if (strcmp(name, "destroy_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_destroy_event"; + g_signal_connect(G_OBJECT(myWidget), "destroy-event", + G_CALLBACK(signal_GdkEvent), cblock); + return context->True(); + } + else if (strcmp(name, "enter_notify_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_enter_notify_event"; + g_signal_connect(G_OBJECT(myWidget), "enter-notify-event", + G_CALLBACK(signal_GdkEventCrossing), cblock); + return context->True(); + } + else if (strcmp(name, "event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_event"; + g_signal_connect(G_OBJECT(myWidget), "event", + G_CALLBACK(signal_GdkEvent), cblock); + return context->True(); + } + else if (strcmp(name, "event_after") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_event_after"; + g_signal_connect(G_OBJECT(myWidget), "event-after", + G_CALLBACK(signal_GdkEvent), cblock); + return context->True(); + } + else if (strcmp(name, "expose_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_expose_event"; + g_signal_connect(G_OBJECT(myWidget), "expose-event", + G_CALLBACK(signal_GdkEventExpose), cblock); + return context->True(); + } + else if (strcmp(name, "focus_in_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_focus_in_event"; + g_signal_connect(G_OBJECT(myWidget), "focus-in-event", + G_CALLBACK(signal_GdkEventFocus), cblock); + return context->True(); + } + else if (strcmp(name, "focus_out_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_focus_out_event"; + g_signal_connect(G_OBJECT(myWidget), "focus-out-event", + G_CALLBACK(signal_GdkEventFocus), cblock); + return context->True(); + } + else if (strcmp(name, "grab_broken_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_grab_broken_event"; + g_signal_connect(G_OBJECT(myWidget), "grab-broken-event", + G_CALLBACK(signal_GdkEventGrabBroken), cblock); + return context->True(); + } + else if (strcmp(name, "key_press_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_key_press_event"; + g_signal_connect(G_OBJECT(myWidget), "key-press-event", + G_CALLBACK(signal_GdkEventKey), cblock); + return context->True(); + } + else if (strcmp(name, "key_release_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_key_release_event"; + g_signal_connect(G_OBJECT(myWidget), "key-release-event", + G_CALLBACK(signal_GdkEventKey), cblock); + return context->True(); + } + else if (strcmp(name, "leave_notify_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_leave_notify_event"; + g_signal_connect(G_OBJECT(myWidget), "leave-notify-event", + G_CALLBACK(signal_GdkEventCrossing), cblock); + return context->True(); + } + else if (strcmp(name, "map_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_map_event"; + g_signal_connect(G_OBJECT(myWidget), "map-event", + G_CALLBACK(signal_GdkEvent), cblock); + return context->True(); + } + else if (strcmp(name, "motion_notify_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_motion_notify_event"; + g_signal_connect(G_OBJECT(myWidget), "motion-notify-event", + G_CALLBACK(signal_GdkEventMotion), cblock); + return context->True(); + } + else if (strcmp(name, "no_expose_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_no_expose_event"; + g_signal_connect(G_OBJECT(myWidget), "no-expose-event", + G_CALLBACK(signal_GdkEventNoExpose), cblock); + return context->True(); + } + else if (strcmp(name, "property_notify_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_property_notify_event"; + g_signal_connect(G_OBJECT(myWidget), "property-notify-event", + G_CALLBACK(signal_GdkEventProperty), cblock); + return context->True(); + } + else if (strcmp(name, "proximity_in_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_proximity_in_event"; + g_signal_connect(G_OBJECT(myWidget), "proximity-in-event", + G_CALLBACK(signal_GdkEventProximity), cblock); + return context->True(); + } + else if (strcmp(name, "proximity_out_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_proximity_out_event"; + g_signal_connect(G_OBJECT(myWidget), "proximity-out-event", + G_CALLBACK(signal_GdkEventProximity), cblock); + return context->True(); + } + else if (strcmp(name, "scroll_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_scroll_event"; + g_signal_connect(G_OBJECT(myWidget), "scroll-event", + G_CALLBACK(signal_GdkEventScroll), cblock); + return context->True(); + } + else if (strcmp(name, "selection_clear_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_selection_clear_event"; + g_signal_connect(G_OBJECT(myWidget), "selection-clear-event", + G_CALLBACK(signal_GdkEventSelection), cblock); + return context->True(); + } + else if (strcmp(name, "selection_notify_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_selection_notify_event"; + g_signal_connect(G_OBJECT(myWidget), "selection-notify-event", + G_CALLBACK(signal_GdkEventSelection), cblock); + return context->True(); + } + else if (strcmp(name, "selection_request_event") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_selection_request_event"; + g_signal_connect(G_OBJECT(myWidget), "selection-request-event", + G_CALLBACK(signal_GdkEventSelection), cblock); + return context->True(); + ... [truncated message content] |
From: <wda...@us...> - 2008-05-19 15:29:29
|
Revision: 2498 http://oorexx.svn.sourceforge.net/oorexx/?rev=2498&view=rev Author: wdashley Date: 2008-05-19 08:28:56 -0700 (Mon, 19 May 2008) Log Message: ----------- ArtifactID: None Comment: Added missings chapter 3 tests. Added Paths: ----------- sandbox/david/4x/test3-4.rex sandbox/david/4x/test3-5.rex sandbox/david/4x/test3-6.rex sandbox/david/4x/test3-7.rex sandbox/david/4x/test3-8.rex sandbox/david/4x/test3-9.rex Added: sandbox/david/4x/test3-4.rex =================================================================== --- sandbox/david/4x/test3-4.rex (rev 0) +++ sandbox/david/4x/test3-4.rex 2008-05-19 15:28:56 UTC (rev 2498) @@ -0,0 +1,80 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 3-4 +-- Foundations of GTK+ Development +-- by Andrew Krause + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Tables') +window~signal_connect("destroy") +window~set_border_width(10) +window~set_size_request(350, 100) -- the sizes in the book are too small + +table = .GtkTable~new(2, 2, .true) +label = .GtkLabel~new('Enter the following information ...') +label2 = .GtkLabel~new('Name: ') +name = .GtkEntry~new() + +table~attach(label, 0, 2, 0, 1, .gtk~GTK_EXPAND, .gtk~GTK_SHRINK, 0, 0) +table~attach(label2, 0, 1, 1, 2, .gtk~GTK_EXPAND, .gtk~GTK_SHRINK, 0, 0) +table~attach(name, 1, 2, 1, 2, .gtk~GTK_EXPAND, .gtk~GTK_SHRINK, 0, 0) + +table~set_row_spacings(5) +table~set_col_spacings(5) + +window~add(table) +window~show_all() + +call gtk_main + +return + + +::requires 'rexxgtk.cls' + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + Property changes on: sandbox/david/4x/test3-4.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native Added: sandbox/david/4x/test3-5.rex =================================================================== --- sandbox/david/4x/test3-5.rex (rev 0) +++ sandbox/david/4x/test3-5.rex 2008-05-19 15:28:56 UTC (rev 2498) @@ -0,0 +1,84 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 3-5 +-- Foundations of GTK+ Development +-- by Andrew Krause + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Fixed') +window~signal_connect("destroy") +window~set_border_width(10) + +fixed = .GtkFixed~new() +button1 = .MyButton~new('Pixed by Pixel ...') +button2 = .MyButton~new('you choose by fate.') + +button1~signal_connect("clicked") +button2~signal_connect("clicked") + +fixed~put(button1, 0, 0) +fixed~put(button2, 20, 30) + +window~add(fixed) +window~show_all() + +call gtk_main + +return + + +::requires 'rexxgtk.cls' + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + +::class MyButton subclass GtkButton_With_Label + +::method signal_clicked +widget = upper(GrxWidgetGetTopLevel(self)) +widget~destroy() +return + Property changes on: sandbox/david/4x/test3-5.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native Added: sandbox/david/4x/test3-6.rex =================================================================== --- sandbox/david/4x/test3-6.rex (rev 0) +++ sandbox/david/4x/test3-6.rex 2008-05-19 15:28:56 UTC (rev 2498) @@ -0,0 +1,74 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 3-6 +-- Foundations of GTK+ Development +-- by Andrew Krause + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Expander') +window~signal_connect("destroy") +window~set_border_width(10) +window~set_size_request(200, 100) + +expander = .GtkExpander_With_Mnemonic~new('Click _Me For More!') +label = .GtkLabel~new('Hide me or show me,' || '0A'x || 'that is your choice') + +expander~add(label) +expander~set_expanded(.true) +window~add(expander) + +window~show_all() + +call gtk_main + +return + + +::requires 'rexxgtk.cls' + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + Property changes on: sandbox/david/4x/test3-6.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native Added: sandbox/david/4x/test3-7.rex =================================================================== --- sandbox/david/4x/test3-7.rex (rev 0) +++ sandbox/david/4x/test3-7.rex 2008-05-19 15:28:56 UTC (rev 2498) @@ -0,0 +1,75 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 3-7 +-- Foundations of GTK+ Development +-- by Andrew Krause + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Handle Box') +window~signal_connect("destroy") +window~set_border_width(10) +window~set_size_request(200, 100) + +handle = .GtkHandleBox~new() +label = .GtkLabel~new('Detach Me') + +handle~set_shadow_type(.gtk~GTK_SHADOW_IN) +handle~set_handle_position(.gtk~GTK_POS_LEFT) +handle~set_snap_edge(.gtk~GTK_POS_TOP) + +handle~add(label) +window~add(handle) +window~show_all() + +call gtk_main +return + + +::requires 'rexxgtk.cls' + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + Property changes on: sandbox/david/4x/test3-7.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native Added: sandbox/david/4x/test3-8.rex =================================================================== --- sandbox/david/4x/test3-8.rex (rev 0) +++ sandbox/david/4x/test3-8.rex 2008-05-19 15:28:56 UTC (rev 2498) @@ -0,0 +1,98 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 3-8 +-- Foundations of GTK+ Development +-- by Andrew Krause + +-- Note: The source code in the book is wrong. The downloaded source for the +-- book is correct. Label controls do not respond to the "clicked" signal so +-- we need buttons instead. + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Notebook') +window~signal_connect("destroy") +window~set_border_width(10) +window~set_size_request(200, 100) + +notebook = .GtkNotebook~new() +label1 = .GtkLabel~new('Page One') +label2 = .GtkLabel~new('Page Two') +child1 = .MyButton~new('Go to page 2 to find the answer.') +child2 = .MyButton~new('Go to page 1 to find the answer.') + +child1~signal_connect('clicked') +child2~signal_connect('clicked') +-- Store the notebook widget so we can get access to it in the callbacks +child1~user_data = notebook +child2~user_data = notebook + +notebook~append_page(child1, label1) +notebook~append_page(child2, label2) + +notebook~set_tab_pos(.gtk~GTK_POS_BOTTOM) + +window~add(notebook) +window~show_all() + +call gtk_main +return + + +::requires 'rexxgtk.cls' + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + +::class MyButton subclass GtkButton_With_Label + +::method signal_clicked +notebook = self~user_data -- get the notebook widget +page = notebook~get_current_page() +if page = 0 then notebook~set_current_page(1) +else if page = 1 then notebook~set_current_page(0) +else nop +return + Property changes on: sandbox/david/4x/test3-8.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native Added: sandbox/david/4x/test3-9.rex =================================================================== --- sandbox/david/4x/test3-9.rex (rev 0) +++ sandbox/david/4x/test3-9.rex 2008-05-19 15:28:56 UTC (rev 2498) @@ -0,0 +1,94 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 3-9 +-- Foundations of GTK+ Development +-- by Andrew Krause + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Event Box') +window~signal_connect("destroy") +window~set_border_width(10) +window~set_size_request(200, 50) + +eventbox = .MyEventBox~new() +label = .GtkLabel~new('Double-Click Me!') + +eventbox~set_above_child(.false) + +eventbox~user_data = label +eventbox~signal_connect('button_press_event') + +eventbox~add(label) +window~add(eventbox) +eventbox~set_events(gtk~GDK_BUTTON_PRESS_MASK) +eventbox~realize() +-- FIX THIS! Need to set the cursor to a hand. +window~show_all() + +call gtk_main +return + + +::requires 'rexxgtk.cls' + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + +::class MyEventBox subclass GtkEventBox + +::method signal_button_press_event +use strict arg event +if event~type() =.gtk~GDK_2BUTTON_PRESS then do + text = self~user_data~get_text() + if text~substr(1, 1) = 'D' then do + self~user_data~set_text('I was Double-Clicked!') + end + else do + self~user_data~set_text('Double-Click Me Again!') + end + end +return .false + Property changes on: sandbox/david/4x/test3-9.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-05-21 16:08:34
|
Revision: 2500 http://oorexx.svn.sourceforge.net/oorexx/?rev=2500&view=rev Author: wdashley Date: 2008-05-21 09:04:36 -0700 (Wed, 21 May 2008) Log Message: ----------- ArtifactID: None Comment: Added Accellerator methods to the widget class. Modified Paths: -------------- sandbox/david/4x/grxwidget.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Modified: sandbox/david/4x/grxwidget.cpp =================================================================== --- sandbox/david/4x/grxwidget.cpp 2008-05-19 15:45:37 UTC (rev 2499) +++ sandbox/david/4x/grxwidget.cpp 2008-05-21 16:04:36 UTC (rev 2500) @@ -953,6 +953,100 @@ } /** + * Method: add_accelerator + * + * Add an accelerator to the widget + * + * @param signame The accel signal name + * + * @param accelgrp The accelerator group + * + * @param key The accel key binding + * + * @param mods The accel modifiers + * + * @param flags The accel flags + * + * @return Zero. + **/ +RexxMethod5(int, // Return type + GrxWidgetAddAccelerator, // Object_method name + CSTRING, signame, // Accelerator signal name + RexxObjectPtr, accelgrp, // Accelerator group + int, key, // Accelerator key + int, mods, // Accelerator modifiers + int, flags) // Accelerator flags +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + RexxPointerObject grpptr = (RexxPointerObject)context->SendMessage0(accelgrp, "POINTER"); + GtkAccelGroup *grpWidget = (GtkAccelGroup *)context->PointerValue(grpptr); + + gtk_widget_add_accelerator(myWidget, signame, grpWidget, key, + (GdkModifierType)mods, (GtkAccelFlags)flags); + + return 0; +} + +/** + * Method: remove_accelerator + * + * Remove an accelerator from the widget + * + * @param accelgrp The accelerator group + * + * @param key The accel key binding + * + * @param mods The accel modifiers + * + * @return Zero. + **/ +RexxMethod3(int, // Return type + GrxWidgetRemoveAccelerator, // Object_method name + RexxObjectPtr, accelgrp, // Accelerator group + int, key, // Accelerator key + int, mods) // Accelerator modifiers +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + RexxPointerObject grpptr = (RexxPointerObject)context->SendMessage0(accelgrp, "POINTER"); + GtkAccelGroup *grpWidget = (GtkAccelGroup *)context->PointerValue(grpptr); + + gtk_widget_remove_accelerator(myWidget, grpWidget, key, + (GdkModifierType)mods); + + return 0; +} + +/** + * Method: set_accel_path + * + * Set the path for an accelerator. + * + * @param accelgrp The accelerator group + * + * @param key The accel key binding + * + * @param mods The accel modifiers + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxWidgetSetAccelPath, // Object_method name + CSTRING, path, // Accelerator path + RexxObjectPtr, accelgrp) // Accelerator group +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + RexxPointerObject grpptr = (RexxPointerObject)context->SendMessage0(accelgrp, "POINTER"); + GtkAccelGroup *grpWidget = (GtkAccelGroup *)context->PointerValue(grpptr); + + gtk_widget_set_accel_path(myWidget, path, grpWidget); + + return 0; +} + +/** * Method: signal_connect * * Connect a signal to an ooRexx method. Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-05-19 15:45:37 UTC (rev 2499) +++ sandbox/david/4x/rexxgtk.cls 2008-05-21 16:04:36 UTC (rev 2500) @@ -764,6 +764,9 @@ ::METHOD get_root_window EXTERNAL "LIBRARY rexxgtk GrxWidgetGetRootWindow" ::METHOD root_window EXTERNAL "LIBRARY rexxgtk GrxWidgetGetRootWindow" ::METHOD get_menus EXTERNAL "LIBRARY rexxgtk GrxWidgetGetMenus" +::METHOD add_accelerator EXTERNAL "LIBRARY rexxgtk GrxWidgetAddAccelerator" +::METHOD remove_accelerator EXTERNAL "LIBRARY rexxgtk GrxWidgetRemoveAccelerator" +::METHOD set_accel_path EXTERNAL "LIBRARY rexxgtk GrxWidgetSetAccelPath" ::METHOD set_events EXTERNAL "LIBRARY rexxgtk GrxWidgetSetEvents" ::METHOD 'events=' EXTERNAL "LIBRARY rexxgtk GrxWidgetSetEvents" ::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxWidgetSignalConnect" Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-05-19 15:45:37 UTC (rev 2499) +++ sandbox/david/4x/rexxgtk.cpp 2008-05-21 16:04:36 UTC (rev 2500) @@ -411,6 +411,9 @@ REXX_METHOD(GrxWidgetGetParent, GrxWidgetGetParent), REXX_METHOD(GrxWidgetGetMenus, GrxWidgetGetMenus), REXX_METHOD(GrxWidgetSetEvents, GrxWidgetSetEvents), + REXX_METHOD(GrxWidgetAddAccelerator, GrxWidgetAddAccelerator), + REXX_METHOD(GrxWidgetRemoveAccelerator, GrxWidgetRemoveAccelerator), + REXX_METHOD(GrxWidgetSetAccelPath, GrxWidgetSetAccelPath), REXX_METHOD(GrxWidgetSignalConnect, GrxWidgetSignalConnect), REXX_METHOD(GrxWindowNew, GrxWindowNew), REXX_METHOD(GrxWindowGetTitle, GrxWindowGetTitle), Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-05-19 15:45:37 UTC (rev 2499) +++ sandbox/david/4x/rexxgtk.h 2008-05-21 16:04:36 UTC (rev 2500) @@ -177,6 +177,9 @@ REXX_METHOD_PROTOTYPE(GrxWidgetGetParent) REXX_METHOD_PROTOTYPE(GrxWidgetGetMenus) REXX_METHOD_PROTOTYPE(GrxWidgetSetEvents) +REXX_METHOD_PROTOTYPE(GrxWidgetAddAccelerator) +REXX_METHOD_PROTOTYPE(GrxWidgetRemoveAccelerator) +REXX_METHOD_PROTOTYPE(GrxWidgetSetAccelPath) REXX_METHOD_PROTOTYPE(GrxWidgetSignalConnect) REXX_METHOD_PROTOTYPE(GrxWindowNew) REXX_METHOD_PROTOTYPE(GrxWindowGetTitle) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-05-21 18:18:27
|
Revision: 2501 http://oorexx.svn.sourceforge.net/oorexx/?rev=2501&view=rev Author: wdashley Date: 2008-05-21 11:18:09 -0700 (Wed, 21 May 2008) Log Message: ----------- ArtifactID: None Comment: Added the start files for accelerator supptor. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/grxcombobox.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxaccelgroup.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-05-21 16:04:36 UTC (rev 2500) +++ sandbox/david/4x/Makefile 2008-05-21 18:18:09 UTC (rev 2501) @@ -77,7 +77,8 @@ grxmenushell.o \ grxmenu.o \ grxmenuitem.o \ - grxevents.o + grxevents.o \ + grxaccelgroup.o # Build the shared library @@ -182,8 +183,11 @@ grxevents.o: grxevents.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxevents.cpp +grxaccelgroup.o: grxaccelgroup.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxaccelgroup.cpp + clean: rm *.so *.o Added: sandbox/david/4x/grxaccelgroup.cpp =================================================================== --- sandbox/david/4x/grxaccelgroup.cpp (rev 0) +++ sandbox/david/4x/grxaccelgroup.cpp 2008-05-21 18:18:09 UTC (rev 2501) @@ -0,0 +1,170 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + +static gboolean signal_func_3a(GtkAccelGroup *accelgrp, + GObject *arg1, + guint arg2, + GdkModifierType arg3, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(accelgrp), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(arg1), "OORXOBJECT"); + context->ArrayPut(arr, tempobj, 1); + tempobj = context->NumberToObject((wholenumber_t)arg2);; + context->ArrayPut(arr, tempobj, 2); + tempobj = context->NumberToObject((wholenumber_t)arg3);; + context->ArrayPut(arr, tempobj, 2); + tempobj = context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + +static void signal_func_3b(GtkAccelGroup *accelgrp, + guint arg1, + GdkModifierType arg2, + GClosure *arg3, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(accelgrp), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = context->NumberToObject((wholenumber_t)arg1);; + context->ArrayPut(arr, tempobj, 1); + tempobj = context->NumberToObject((wholenumber_t)arg2);; + context->ArrayPut(arr, tempobj, 2); + tempobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(arg3), "OORXOBJECT"); + context->ArrayPut(arr, tempobj, 3); + context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->DetachThread(); + return; +} + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create an accelerator group. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxAccelGroupNew, // Object_method name + OSELF, self) // Self +{ + GtkAccelGroup *accelgrp; + + accelgrp = gtk_accel_group_new(); + + context->SetObjectVariable("!POINTER", context->NewPointer(accelgrp)); + g_object_set_data(G_OBJECT(accelgrp), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxAccelGroupSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "accel_activate") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_accel_activate"; + g_signal_connect(G_OBJECT(myWidget), "accel-activate", + G_CALLBACK(signal_func_3a), cblock); + return context->True(); + } + else if (strcmp(name, "accel_changed") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_accel_changed"; + g_signal_connect(G_OBJECT(myWidget), "accel-changed", + G_CALLBACK(signal_func_3b), cblock); + return context->True(); + } + return context->False(); +} + Property changes on: sandbox/david/4x/grxaccelgroup.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/grxcombobox.cpp =================================================================== --- sandbox/david/4x/grxcombobox.cpp 2008-05-21 16:04:36 UTC (rev 2500) +++ sandbox/david/4x/grxcombobox.cpp 2008-05-21 18:18:09 UTC (rev 2501) @@ -80,7 +80,7 @@ RexxThreadContext *context; cblock->instance->AttachThread(&context); - RexxObjectPtr scrolltype = context->NumberToObject((wholenumber_t)arg1);; + RexxObjectPtr scrolltype = context->NumberToObject((wholenumber_t)arg1); context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, scrolltype); context->DetachThread(); return; Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-05-21 16:04:36 UTC (rev 2500) +++ sandbox/david/4x/rexxgtk.cls 2008-05-21 18:18:09 UTC (rev 2501) @@ -2340,8 +2340,27 @@ /*============================================================================*/ +/* Class: GtkAccelGroup */ /*============================================================================*/ + +::class GtkAccelGroup public + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxAccelGroupNew" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxAccelGroupSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_accel_activate +return .false + +::method signal_accel_changed +return + + /*============================================================================*/ +/*============================================================================*/ +/*============================================================================*/ /* These are classes and routines specific to Glib. */ /*============================================================================*/ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-05-21 16:04:36 UTC (rev 2500) +++ sandbox/david/4x/rexxgtk.cpp 2008-05-21 18:18:09 UTC (rev 2501) @@ -715,6 +715,7 @@ REXX_METHOD(GrxMenuItemDeselect, GrxMenuItemDeselect), REXX_METHOD(GrxMenuItemSignalConnect, GrxMenuItemSignalConnect), REXX_METHOD(GrxSeparatorMenuItemNew, GrxSeparatorMenuItemNew), + REXX_METHOD(GrxAccelGroupNew, GrxAccelGroupNew), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-05-21 16:04:36 UTC (rev 2500) +++ sandbox/david/4x/rexxgtk.h 2008-05-21 18:18:09 UTC (rev 2501) @@ -482,6 +482,7 @@ REXX_METHOD_PROTOTYPE(GrxMenuItemDeselect) REXX_METHOD_PROTOTYPE(GrxMenuItemSignalConnect) REXX_METHOD_PROTOTYPE(GrxSeparatorMenuItemNew) +REXX_METHOD_PROTOTYPE(GrxAccelGroupNew) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-05-22 15:01:57
|
Revision: 2502 http://oorexx.svn.sourceforge.net/oorexx/?rev=2502&view=rev Author: wdashley Date: 2008-05-22 08:01:59 -0700 (Thu, 22 May 2008) Log Message: ----------- ArtifactID: None Comment: Added more accelerator stuff and an accel test. Modified Paths: -------------- sandbox/david/4x/grxwindow.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/test9-3.rex Modified: sandbox/david/4x/grxwindow.cpp =================================================================== --- sandbox/david/4x/grxwindow.cpp 2008-05-21 18:18:09 UTC (rev 2501) +++ sandbox/david/4x/grxwindow.cpp 2008-05-22 15:01:59 UTC (rev 2502) @@ -151,6 +151,29 @@ } /** + * Method: add_accel_group + * + * Add an accelerator group to the window, + * + * @param group The accel group. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxWindowAddAccelGroup, // Object_method name + RexxObjectPtr, accelgrp) // Accelerator group +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWindow *myWidget = (GtkWindow *)context->PointerValue(rxptr); + RexxPointerObject accelgrpptr = (RexxPointerObject)context->SendMessage0(accelgrp, "POINTER"); + GtkAccelGroup *accelgrpWidget = (GtkAccelGroup *)context->PointerValue(accelgrpptr); + + gtk_window_add_accel_group(myWidget, accelgrpWidget); + + return 0; +} + +/** * Method: signal_connect * * Connect a signal to an ooRexx method. Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-05-21 18:18:09 UTC (rev 2501) +++ sandbox/david/4x/rexxgtk.cls 2008-05-22 15:01:59 UTC (rev 2502) @@ -1117,6 +1117,7 @@ ::METHOD set_title EXTERNAL "LIBRARY rexxgtk GrxWindowSetTitle" ::METHOD 'modal=' EXTERNAL "LIBRARY rexxgtk GrxWindowSetModal" ::METHOD set_modal EXTERNAL "LIBRARY rexxgtk GrxWindowSetModal" +::METHOD add_accel_group EXTERNAL "LIBRARY rexxgtk GrxWindowAddAccelGroup" ::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxWindowSignalConnect" -- The following are the methods that can be connected to signals. By default Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-05-21 18:18:09 UTC (rev 2501) +++ sandbox/david/4x/rexxgtk.cpp 2008-05-22 15:01:59 UTC (rev 2502) @@ -418,6 +418,7 @@ REXX_METHOD(GrxWindowNew, GrxWindowNew), REXX_METHOD(GrxWindowGetTitle, GrxWindowGetTitle), REXX_METHOD(GrxWindowSetTitle, GrxWindowSetTitle), + REXX_METHOD(GrxWindowAddAccelGroup, GrxWindowAddAccelGroup), REXX_METHOD(GrxWindowSignalConnect, GrxWindowSignalConnect), REXX_METHOD(GrxContainerAdd, GrxContainerAdd), REXX_METHOD(GrxContainerRemove, GrxContainerRemove), Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-05-21 18:18:09 UTC (rev 2501) +++ sandbox/david/4x/rexxgtk.h 2008-05-22 15:01:59 UTC (rev 2502) @@ -184,6 +184,7 @@ REXX_METHOD_PROTOTYPE(GrxWindowNew) REXX_METHOD_PROTOTYPE(GrxWindowGetTitle) REXX_METHOD_PROTOTYPE(GrxWindowSetTitle) +REXX_METHOD_PROTOTYPE(GrxWindowAddAccelGroup) REXX_METHOD_PROTOTYPE(GrxWindowSignalConnect) REXX_METHOD_PROTOTYPE(GrxContainerAdd) REXX_METHOD_PROTOTYPE(GrxContainerRemove) Added: sandbox/david/4x/test9-3.rex =================================================================== --- sandbox/david/4x/test9-3.rex (rev 0) +++ sandbox/david/4x/test9-3.rex 2008-05-22 15:01:59 UTC (rev 2502) @@ -0,0 +1,148 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 9-1 +-- Foundations of GTK+ Development +-- by Andrew Krause + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Popup Menus') +window~signal_connect('destroy') +window~set_border_width(10) +window~set_size_request(250, -1) + +menu = .GtkMenu~new() +eventbox = .myEventBox~new() +progress = .GtkProgressBar~new() +progress~set_text('Nothing Yet Happened') +call create_popup_menu menu, window, progress + +progress~set_pulse_step(0.05) +eventbox~set_above_child(.false) + +eventbox~user_data = menu +eventbox~signal_connect('button_press_event') + +eventbox~add(progress) +eventbox~realize() + +window~add(scrolled_win) +window~show_all() + +call gtk_main +return + + +::requires 'rexxgtk.cls' + +::routine create_popup_menu +use strict arg menu, window, progress + +group = .GtkAccelGroup~new() +window~add_accel_group(group) +menu ~set_accel_group(group) + +pulse = .MyPulse~new_with_label('Pulse Progress') +fill = .MyFill~new_with_label('Set as Complete') +clear = .MyClear~new_with_label('Clear Progress') +separator = .GtkSeparatorMenuItem~new() + +pulse~add_accelerator('activate', group, .gtk~GDL_P, .gtk~GDK_CONTROL_MASK, + .gtk~GTK_ACCEL_VISIBLE) +fill~add_accelerator('activate', group, .gtk~GDL_F, .gtk~GDK_CONTROL_MASK, + .gtk~GTK_ACCEL_VISIBLE) +clear~add_accelerator('activate', group, .gtk~GDL_C, .gtk~GDK_CONTROL_MASK, + .gtk~GTK_ACCEL_VISIBLE) + +-- set up the user data for the signals +pulse~user_data = progress +fill~user_data = progress +clear~user_data = progress + +pulse~signal_connect('activate') +fill~signal_connect('activate') +clear~signal_connect('activate') + +menu~append(pulse) +menu~append(separator) +menu~append(fill) +menu~append(clear) + +menu~attach_to_widget(progress) +menu~show_all() +return + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + +::class myEventBox subclass GtkEventBox + +::method signal_button_press_event +if event~button = 3 then do + menu~popup() + end +return .true + +::class MyPulse subclass GtkMenuItem + +::method signal_activate +self~user_data~pulse() +self~user_data~set_text('Pulse!') +return + +::class MyFill subclass GtkMenuItem + +::method signal_activate +self~user_data~set_fraction(1.0) +self~user_data~set_text('One Hundred Percent') +return + +::class MyClear subclass GtkMenuItem + +::method signal_activate +self~user_data~set_fraction(0.0) +self~user_data~set_text('Reset to Zero') +return + Property changes on: sandbox/david/4x/test9-3.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-05-22 22:19:03
|
Revision: 2503 http://oorexx.svn.sourceforge.net/oorexx/?rev=2503&view=rev Author: wdashley Date: 2008-05-22 15:19:06 -0700 (Thu, 22 May 2008) Log Message: ----------- ArtifactID: None Comment: Added a status bar test and the status bar class. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxstatusbar.cpp sandbox/david/4x/test9-4.rex Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-05-22 15:01:59 UTC (rev 2502) +++ sandbox/david/4x/Makefile 2008-05-22 22:19:06 UTC (rev 2503) @@ -78,7 +78,8 @@ grxmenu.o \ grxmenuitem.o \ grxevents.o \ - grxaccelgroup.o + grxaccelgroup.o \ + grxstatusbar.o # Build the shared library @@ -186,8 +187,11 @@ grxaccelgroup.o: grxaccelgroup.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxaccelgroup.cpp +grxstatusbar.o: grxstatusbar.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxstatusbar.cpp + clean: rm *.so *.o Added: sandbox/david/4x/grxstatusbar.cpp =================================================================== --- sandbox/david/4x/grxstatusbar.cpp (rev 0) +++ sandbox/david/4x/grxstatusbar.cpp 2008-05-22 22:19:06 UTC (rev 2503) @@ -0,0 +1,261 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + +static void signal_func_2(GtkStatusbar *window, + guint arg1, + gchar *arg2, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(window), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + context->SendMessage2(rxobj, ((cbcb *)data)->signal_name, + context->NumberToObject((wholenumber_t)arg1), + context->NewStringFromAsciiz(arg2)); + context->DetachThread(); + return; +} + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create a status bar. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxStatusbarNew, // Object_method name + OSELF, self) // Self +{ + GtkWidget *myWidget; + + myWidget = gtk_statusbar_new(); + context->SetObjectVariable("!POINTER", context->NewPointer(myWidget)); + g_object_set_data(G_OBJECT(myWidget), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: get_context_id + * + * Get the context id for the status bar. + * + * @param desc The context description + * + * @return Context id + **/ +RexxMethod1(int, // Return type + GrxStatusbarGetContextId, // Object_method name + CSTRING, desc) // Description +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkStatusbar *myWidget = (GtkStatusbar *)context->PointerValue(rxptr); + + return gtk_statusbar_get_context_id(myWidget, desc); +} + +/** + * Method: push + * + * Push the message onto the status bar.. + * + * @param cid The context id + * + * @param text The message text + * + * @return Message id + **/ +RexxMethod2(int, // Return type + GrxStatusbarPush, // Object_method name + int, cid, // Context id + CSTRING, text) // Message text +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkStatusbar *myWidget = (GtkStatusbar *)context->PointerValue(rxptr); + + return gtk_statusbar_push(myWidget, cid, text); +} + +/** + * Method: pop + * + * Pop a message from the status bar.. + * + * @param cid The context id + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxStatusbarPop, // Object_method name + int, cid) // Context id +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkStatusbar *myWidget = (GtkStatusbar *)context->PointerValue(rxptr); + + gtk_statusbar_pop(myWidget, cid); + + return 0; +} + +/** + * Method: remove + * + * Remove a message from the status bar.. + * + * @param cid The context id + * + * @param mid The message id + * + * @return Zero + **/ +RexxMethod2(int, // Return type + GrxStatusbarRemove, // Object_method name + int, cid, // Context id + int, mid) // Message id +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkStatusbar *myWidget = (GtkStatusbar *)context->PointerValue(rxptr); + + gtk_statusbar_remove(myWidget, cid, mid); + + return 0; +} + +/** + * Method: set_has_resize_grip + * + * Add a resize grip to the status bar. + * + * @param flag The boolean flag + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxStatusbarSetHasResizeGrip, // Object_method name + logical_t, flag) // Boolean flag +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkStatusbar *myWidget = (GtkStatusbar *)context->PointerValue(rxptr); + + gtk_statusbar_set_has_resize_grip(myWidget, flag); + + return 0; +} + +/** + * Method: get_has_resize_grip + * + * Return the bollean flag for the resize grip. + * + * @return Zero + **/ +RexxMethod0(logical_t, // Return type + GrxStatusbarGetHasResizeGrip) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkStatusbar *myWidget = (GtkStatusbar *)context->PointerValue(rxptr); + + return gtk_statusbar_get_has_resize_grip(myWidget); +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxStatusbarSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "text_popped") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_text_popped"; + g_signal_connect(G_OBJECT(myWidget), "text-popped", + G_CALLBACK(signal_func_2), cblock); + return context->True(); + } + else if (strcmp(name, "text_pushed") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_text_pushed"; + g_signal_connect(G_OBJECT(myWidget), "text-pushed", + G_CALLBACK(signal_func_2), cblock); + return context->True(); + } + return context->SendSuperMessage("signal_connect", args); +} + Property changes on: sandbox/david/4x/grxstatusbar.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-05-22 15:01:59 UTC (rev 2502) +++ sandbox/david/4x/rexxgtk.cls 2008-05-22 22:19:06 UTC (rev 2503) @@ -2360,8 +2360,33 @@ /*============================================================================*/ +/* Class: GtkStatusbar */ /*============================================================================*/ + +::class GtkStatusbar public subclass GtkHBox + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxStatusbarNew" +::METHOD get_context_id EXTERNAL "LIBRARY rexxgtk GrxStatusbarGetContextId" +::METHOD push EXTERNAL "LIBRARY rexxgtk GrxStatusbarPush" +::METHOD pop EXTERNAL "LIBRARY rexxgtk GrxStatusbarPop" +::METHOD remove EXTERNAL "LIBRARY rexxgtk GrxStatusbarRemove" +::METHOD set_has_resize_grip EXTERNAL "LIBRARY rexxgtk GrxStatusbarSetHasResizeGrip" +::METHOD get_has_resize_grip EXTERNAL "LIBRARY rexxgtk GrxStatusbarGetHasResizeGrip" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxStatusbarSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_text_popped +return + +::method signal_text_pushed +return + + /*============================================================================*/ +/*============================================================================*/ +/*============================================================================*/ /* These are classes and routines specific to Glib. */ /*============================================================================*/ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-05-22 15:01:59 UTC (rev 2502) +++ sandbox/david/4x/rexxgtk.cpp 2008-05-22 22:19:06 UTC (rev 2503) @@ -717,6 +717,14 @@ REXX_METHOD(GrxMenuItemSignalConnect, GrxMenuItemSignalConnect), REXX_METHOD(GrxSeparatorMenuItemNew, GrxSeparatorMenuItemNew), REXX_METHOD(GrxAccelGroupNew, GrxAccelGroupNew), + REXX_METHOD(GrxStatusbarNew, GrxStatusbarNew), + REXX_METHOD(GrxStatusbarGetContextId, GrxStatusbarGetContextId), + REXX_METHOD(GrxStatusbarPush, GrxStatusbarPush), + REXX_METHOD(GrxStatusbarPop, GrxStatusbarPop), + REXX_METHOD(GrxStatusbarRemove, GrxStatusbarRemove), + REXX_METHOD(GrxStatusbarSetHasResizeGrip, GrxStatusbarSetHasResizeGrip), + REXX_METHOD(GrxStatusbarGetHasResizeGrip, GrxStatusbarGetHasResizeGrip), + REXX_METHOD(GrxStatusbarSignalConnect, GrxStatusbarSignalConnect), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-05-22 15:01:59 UTC (rev 2502) +++ sandbox/david/4x/rexxgtk.h 2008-05-22 22:19:06 UTC (rev 2503) @@ -484,6 +484,14 @@ REXX_METHOD_PROTOTYPE(GrxMenuItemSignalConnect) REXX_METHOD_PROTOTYPE(GrxSeparatorMenuItemNew) REXX_METHOD_PROTOTYPE(GrxAccelGroupNew) +REXX_METHOD_PROTOTYPE(GrxStatusbarNew) +REXX_METHOD_PROTOTYPE(GrxStatusbarGetContextId) +REXX_METHOD_PROTOTYPE(GrxStatusbarPush) +REXX_METHOD_PROTOTYPE(GrxStatusbarPop) +REXX_METHOD_PROTOTYPE(GrxStatusbarRemove) +REXX_METHOD_PROTOTYPE(GrxStatusbarSetHasResizeGrip) +REXX_METHOD_PROTOTYPE(GrxStatusbarGetHasResizeGrip) +REXX_METHOD_PROTOTYPE(GrxStatusbarSignalConnect) #endif /* REXXGTK_H */ Added: sandbox/david/4x/test9-4.rex =================================================================== --- sandbox/david/4x/test9-4.rex (rev 0) +++ sandbox/david/4x/test9-4.rex 2008-05-22 22:19:06 UTC (rev 2503) @@ -0,0 +1,202 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 9-4 +-- Foundations of GTK+ Development +-- by Andrew Krause + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Popup Menus') +window~signal_connect('destroy') +window~set_border_width(10) +window~set_size_request(250, -1) + +menu = .GtkMenu~new() +eventbox = .myEventBox~new() +progress = .GtkProgressBar~new() +statusbar = .MyStatusbar +progress~set_text('Nothing Yet Happened') +call create_popup_menu menu, progress, statusbar + +progress~set_pulse_step(0.05) +eventbox~set_above_child(.false) + +eventbox~user_data = menu +eventbox~signal_connect('button_press_event') + +vbox = .GtkVBox~new(.false, 5) +eventbox~add(progress) +vbox~pack_start_defaults(eventbox) +vbox~pack_start_defaults(statusbar) +window~add(vbox) + +eventbox~set_events(.gtk~GDK_BUTTON_PRESS_MASK) +eventbox~realize() + +window~show_all() +call gtk_main +return + + +::requires 'rexxgtk.cls' + +::routine create_popup_menu +use strict arg menu, progress, statusbar + +group = .GtkAccelGroup~new() +window~add_accel_group(group) +menu~set_accel_group(group) + +pulse = .MyPulse~new_with_label('Pulse Progress') +fill = .MyFill~new_with_label('Set as Complete') +clear = .MyClear~new_with_label('Clear Progress') +separator = .GtkSeparatorMenuItem~new() + +-- set up the user data for the signals +pulse~user_data = .array~new(1) +fill~user_data = .array~new(1) +clear~user_data = .array~new(1) +pulse~user_data[1] = progress +fill~user_data[1] = progress +clear~user_data[1] = progress +pulse~user_data[2] = statusbar +fill~user_data[2] = statusbar +clear~user_data[2] = statusbar + +pulse~signal_connect('activate') +fill~signal_connect('activate') +clear~signal_connect('activate') + +pulse~signal_connect('enter_notify_event') +pulse~signal_connect('leave_notify_event') +fill~signal_connect('enter_notify_event') +fill~signal_connect('leave_notify_event') +clear~signal_connect('enter_notify_event') +clear~signal_connect('leave_notify_event') + +menu~append(pulse) +menu~append(separator) +menu~append(fill) +menu~append(clear) + +menu~attach_to_widget(progress) +menu~show_all() +return + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + +::class myEventBox subclass GtkEventBox + +::method signal_button_press_event +if event~button = 3 then do + menu~popup() + end +return .true + +::class MyPulse subclass GtkMenuItem + +::method signal_activate +self~user_data[1]~pulse() +self~user_data[1]~set_text('Pulse!') +return + +::method signal_enter_notify_event +use strict arg event +call statusbar_hint self~userdata[1], event, self~user_data[2] +return .false + +::method signal_leave_notify_event +use strict arg event +call statusbar_hint self~userdata[1], event, self~user_data[2] +return .false + +::class MyFill subclass GtkMenuItem + +::method signal_activate +self~user_data[1]~set_fraction(1.0) +self~user_data[1]~set_text('One Hundred Percent') +return + +::method signal_enter_notify_event +use strict arg event +call statusbar_hint self~userdata[1], event, self~user_data[2] +return .false + +::method signal_leave_notify_event +use strict arg event +call statusbar_hint self~userdata[1], event, self~user_data[2] +return .false + +::class MyClear subclass GtkMenuItem + +::method signal_activate +self~user_data[1]~set_fraction(0.0) +self~user_data[1]~set_text('Reset to Zero') +return + +::method signal_enter_notify_event +use strict arg event +call statusbar_hint self~userdata[1], event, self~user_data[2] +return .false + +::method signal_leave_notify_event +use strict arg event +call statusbar_hint self~userdata[1], event, self~user_data[2] +return .false + +::routine statusbar_hint +use strict arg menuitem, event, statusbar +id = statusbar~get_context_id('MenuItemHints') +if event~type = .gtk~GDK_ENTER_NOTIFY then do + hint = menuitem~get_data('menuhint') + statusbar~push(id, hint) + end +else do + statusbar~pop(id, hint) + end +return + + Property changes on: sandbox/david/4x/test9-4.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-05-25 00:58:11
|
Revision: 2505 http://oorexx.svn.sourceforge.net/oorexx/?rev=2505&view=rev Author: wdashley Date: 2008-05-24 17:58:15 -0700 (Sat, 24 May 2008) Log Message: ----------- ArtifactID: None Comment: Added menu bar class and test. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/grxmenuitem.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxmenubar.cpp sandbox/david/4x/test9-5.rex Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-05-23 16:23:17 UTC (rev 2504) +++ sandbox/david/4x/Makefile 2008-05-25 00:58:15 UTC (rev 2505) @@ -77,6 +77,7 @@ grxmenushell.o \ grxmenu.o \ grxmenuitem.o \ + grxmenubar.o \ grxevents.o \ grxaccelgroup.o \ grxstatusbar.o @@ -181,6 +182,9 @@ grxmenuitem.o: grxmenuitem.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxmenuitem.cpp +grxmenubar.o: grxmenubar.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxmenubar.cpp + grxevents.o: grxevents.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxevents.cpp Added: sandbox/david/4x/grxmenubar.cpp =================================================================== --- sandbox/david/4x/grxmenubar.cpp (rev 0) +++ sandbox/david/4x/grxmenubar.cpp 2008-05-25 00:58:15 UTC (rev 2505) @@ -0,0 +1,234 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create a menu bar. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxMenuBarNew, // Object_method name + OSELF, self) // Self +{ + GtkWidget *myWidget; + + myWidget = gtk_menu_bar_new(); + context->SetObjectVariable("!POINTER", context->NewPointer(myWidget)); + g_object_set_data(G_OBJECT(myWidget), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: append + * + * Append a menu. + * + * @param child The child menu. + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxMenuBarAppend, // Object_method name + RexxObjectPtr, child) // The child menu +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuBar *myWidget = (GtkMenuBar *)context->PointerValue(rxptr); + RexxPointerObject childptr = (RexxPointerObject)context->SendMessage0(child, "POINTER"); + GtkWidget *childWidget = (GtkWidget *)context->PointerValue(childptr); + + gtk_menu_bar_append(myWidget, childWidget); + + return 0; +} + +/** + * Method: prepend + * + * Prepend a menu. + * + * @param child The child menu. + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxMenuBarPrepend, // Object_method name + RexxObjectPtr, child) // The child menu +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuBar *myWidget = (GtkMenuBar *)context->PointerValue(rxptr); + RexxPointerObject childptr = (RexxPointerObject)context->SendMessage0(child, "POINTER"); + GtkWidget *childWidget = (GtkWidget *)context->PointerValue(childptr); + + gtk_menu_bar_prepend(myWidget, childWidget); + + return 0; +} + +/** + * Method: insert + * + * Insert a menu. + * + * @param child The child menu + * + * @param pos The position + * + * @return Zero + **/ +RexxMethod2(int, // Return type + GrxMenuBarInsert, // Object_method name + RexxObjectPtr, child, // The child menu + int, pos) // Position +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuBar *myWidget = (GtkMenuBar *)context->PointerValue(rxptr); + RexxPointerObject childptr = (RexxPointerObject)context->SendMessage0(child, "POINTER"); + GtkWidget *childWidget = (GtkWidget *)context->PointerValue(childptr); + + gtk_menu_bar_insert(myWidget, childWidget, pos); + + return 0; +} + +/** + * Method: set_pack_direction + * + * Set the packing direction. + * + * @param dir The direction + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxMenuBarSetPackDirection, // Object_method name + int, dir) // Position +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuBar *myWidget = (GtkMenuBar *)context->PointerValue(rxptr); + + gtk_menu_bar_set_pack_direction(myWidget, (GtkPackDirection)dir); + + return 0; +} + +/** + * Method: get_pack_direction + * + * Get the packing direction. + * + * @return Direction + **/ +RexxMethod0(int, // Return type + GrxMenuBarGetPackDirection) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuBar *myWidget = (GtkMenuBar *)context->PointerValue(rxptr); + + return gtk_menu_bar_get_pack_direction(myWidget); + + return 0; +} + +/** + * Method: set_child_pack_direction + * + * Set the child packing direction. + * + * @param dir The direction + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxMenuBarSetChildPackDirection, // Object_method name + int, dir) // Position +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuBar *myWidget = (GtkMenuBar *)context->PointerValue(rxptr); + + gtk_menu_bar_set_child_pack_direction(myWidget, (GtkPackDirection)dir); + + return 0; +} + +/** + * Method: get_child_pack_direction + * + * Get the child packing direction. + * + * @return Direction + **/ +RexxMethod0(int, // Return type + GrxMenuBarGetChildPackDirection) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuBar *myWidget = (GtkMenuBar *)context->PointerValue(rxptr); + + return gtk_menu_bar_get_child_pack_direction(myWidget); + + return 0; +} + Property changes on: sandbox/david/4x/grxmenubar.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/grxmenuitem.cpp =================================================================== --- sandbox/david/4x/grxmenuitem.cpp 2008-05-23 16:23:17 UTC (rev 2504) +++ sandbox/david/4x/grxmenuitem.cpp 2008-05-25 00:58:15 UTC (rev 2505) @@ -330,3 +330,97 @@ return 0; } +/** + * Method: init + * + * Create an image menu item. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxImageMenuItemNew, // Object_method name + OSELF, self) // Self +{ + GtkWidget *myWidget; + + myWidget = gtk_image_menu_item_new(); + context->SetObjectVariable("!POINTER", context->NewPointer(myWidget)); + g_object_set_data(G_OBJECT(myWidget), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: init + * + * Create an image menu item. + * + * @param stockid The stock id string + * + * @param accelgrp The accelerator group + * + * @return Zero. + **/ +RexxMethod3(int, // Return type + GrxImageMenuItemNewFromStock, // Object_method name + OSELF, self, // Self + CSTRING, stockid, // Stock id string + RexxObjectPtr, accelgrp) // Self +{ + GtkWidget *myWidget; + RexxPointerObject accelgrpptr = (RexxPointerObject)context->SendMessage0(accelgrp, "POINTER"); + GtkAccelGroup *accelgrpWidget = (GtkAccelGroup *)context->PointerValue(accelgrpptr); + + myWidget = gtk_image_menu_item_new_from_stock(stockid, accelgrpWidget); + context->SetObjectVariable("!POINTER", context->NewPointer(myWidget)); + g_object_set_data(G_OBJECT(myWidget), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: init + * + * Create an image menu item. + * + * @param text The label text + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxImageMenuItemNewWithLabel, // Object_method name + OSELF, self, // Self + CSTRING, text) // label string +{ + GtkWidget *myWidget; + + myWidget = gtk_image_menu_item_new_with_label(text); + context->SetObjectVariable("!POINTER", context->NewPointer(myWidget)); + g_object_set_data(G_OBJECT(myWidget), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: init + * + * Create an image menu item. + * + * @param text The label text + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxImageMenuItemNewWithMnemonic, // Object_method name + OSELF, self, // Self + CSTRING, text) // label string +{ + GtkWidget *myWidget; + + myWidget = gtk_image_menu_item_new_with_mnemonic(text); + context->SetObjectVariable("!POINTER", context->NewPointer(myWidget)); + g_object_set_data(G_OBJECT(myWidget), "OORXOBJECT", self); + + return 0; +} + Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-05-23 16:23:17 UTC (rev 2504) +++ sandbox/david/4x/rexxgtk.cls 2008-05-25 00:58:15 UTC (rev 2505) @@ -2332,9 +2332,50 @@ /*============================================================================*/ -/* Class: GtkMenuItem */ +/* Class: GtkImageMenuItem */ /*============================================================================*/ +::class GtkImageMenuItem public subclass GtkMenuItem + +::method new_from_stock class +use strict arg id, accelgrp +return self~new_from_stock_p id, accelgrp + +::method new_with label class +use strict arg label +return self~new_with_label_p label + +::method new_with_mnemonic class +use strict arg label +return self~new_with_mnemonic_p label + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxImageMenuItemNew" + +::METHOD new_from_stock_p private EXTERNAL "LIBRARY rexxgtk GrxImageMenuItemNewFromStock" +::METHOD new_with_label_p private EXTERNAL "LIBRARY rexxgtk GrxImageMenuItemNewWithLabel" +::METHOD new_with_mnemonic_p private EXTERNAL "LIBRARY rexxgtk GrxImageMenuItemNewWithMnemonic" + + +/*============================================================================*/ +/* Class: GtkMenuBar */ +/*============================================================================*/ + +::class GtkMenuBar public subclass GtkMenuShell + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxMenuBarNew" +::METHOD append EXTERNAL "LIBRARY rexxgtk GrxMenuBarAppend" +::METHOD prepend EXTERNAL "LIBRARY rexxgtk GrxMenuBarPrepend" +::METHOD insert EXTERNAL "LIBRARY rexxgtk GrxMenuBarInsert" +::METHOD set_pack_direction EXTERNAL "LIBRARY rexxgtk GrxMenuBarSetPackDirection" +::METHOD get_pack_direction EXTERNAL "LIBRARY rexxgtk GrxMenuBarGetPackDirection" +::METHOD set_child_pack_direction EXTERNAL "LIBRARY rexxgtk GrxMenuBarSetChildPackDirection" +::METHOD get_child_pack_direction EXTERNAL "LIBRARY rexxgtk GrxMenuBarGetChildPackDirection" + + +/*============================================================================*/ +/* Class: GtkSeparatorMenuItem */ +/*============================================================================*/ + ::class GtkSeparatorMenuItem public subclass GtkMenuItem ::METHOD init EXTERNAL "LIBRARY rexxgtk GrxSeparatorMenuItemNew" Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-05-23 16:23:17 UTC (rev 2504) +++ sandbox/david/4x/rexxgtk.cpp 2008-05-25 00:58:15 UTC (rev 2505) @@ -715,6 +715,18 @@ REXX_METHOD(GrxMenuItemSelect, GrxMenuItemSelect), REXX_METHOD(GrxMenuItemDeselect, GrxMenuItemDeselect), REXX_METHOD(GrxMenuItemSignalConnect, GrxMenuItemSignalConnect), + REXX_METHOD(GrxImageMenuItemNew, GrxImageMenuItemNew), + REXX_METHOD(GrxImageMenuItemNewFromStock, GrxImageMenuItemNewFromStock), + REXX_METHOD(GrxImageMenuItemNewWithLabel, GrxImageMenuItemNewWithLabel), + REXX_METHOD(GrxImageMenuItemNewWithMnemonic, GrxImageMenuItemNewWithMnemonic), + REXX_METHOD(GrxMenuBarNew, GrxMenuBarNew), + REXX_METHOD(GrxMenuBarAppend, GrxMenuBarAppend), + REXX_METHOD(GrxMenuBarPrepend, GrxMenuBarPrepend), + REXX_METHOD(GrxMenuBarInsert, GrxMenuBarInsert), + REXX_METHOD(GrxMenuBarSetPackDirection, GrxMenuBarSetPackDirection), + REXX_METHOD(GrxMenuBarGetPackDirection, GrxMenuBarGetPackDirection), + REXX_METHOD(GrxMenuBarSetChildPackDirection, GrxMenuBarSetChildPackDirection), + REXX_METHOD(GrxMenuBarGetChildPackDirection, GrxMenuBarGetChildPackDirection), REXX_METHOD(GrxSeparatorMenuItemNew, GrxSeparatorMenuItemNew), REXX_METHOD(GrxAccelGroupNew, GrxAccelGroupNew), REXX_METHOD(GrxStatusbarNew, GrxStatusbarNew), Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-05-23 16:23:17 UTC (rev 2504) +++ sandbox/david/4x/rexxgtk.h 2008-05-25 00:58:15 UTC (rev 2505) @@ -492,6 +492,18 @@ REXX_METHOD_PROTOTYPE(GrxStatusbarSetHasResizeGrip) REXX_METHOD_PROTOTYPE(GrxStatusbarGetHasResizeGrip) REXX_METHOD_PROTOTYPE(GrxStatusbarSignalConnect) +REXX_METHOD_PROTOTYPE(GrxMenuBarNew) +REXX_METHOD_PROTOTYPE(GrxMenuBarAppend) +REXX_METHOD_PROTOTYPE(GrxMenuBarPrepend) +REXX_METHOD_PROTOTYPE(GrxMenuBarInsert) +REXX_METHOD_PROTOTYPE(GrxMenuBarSetPackDirection) +REXX_METHOD_PROTOTYPE(GrxMenuBarGetPackDirection) +REXX_METHOD_PROTOTYPE(GrxMenuBarSetChildPackDirection) +REXX_METHOD_PROTOTYPE(GrxMenuBarGetChildPackDirection) +REXX_METHOD_PROTOTYPE(GrxImageMenuItemNew) +REXX_METHOD_PROTOTYPE(GrxImageMenuItemNewFromStock) +REXX_METHOD_PROTOTYPE(GrxImageMenuItemNewWithLabel) +REXX_METHOD_PROTOTYPE(GrxImageMenuItemNewWithMnemonic) #endif /* REXXGTK_H */ Added: sandbox/david/4x/test9-5.rex =================================================================== --- sandbox/david/4x/test9-5.rex (rev 0) +++ sandbox/david/4x/test9-5.rex 2008-05-25 00:58:15 UTC (rev 2505) @@ -0,0 +1,102 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 9-5 +-- Foundations of GTK+ Development +-- by Andrew Krause + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Popup Menus') +window~signal_connect('destroy') +window~set_size_request(250, -1) + +group = .GtkAccelGroup~new() +menubar = .GtkMenuBar~new() +file = /GtkMenuItem~new_with_label('File') +edit = /GtkMenuItem~new_with_label('Edit') +help = /GtkMenuItem~new_with_label('Help') +filemenu = .GtkMenu~new() +editemenu = .GtkMenu~new() +helpmenu = .GtkMenu~new() + +file~set_submenu(filemenu) +edit~set_submenu(editmenu) +help~set_submenu(helpmenu) + +menubar~append(file) +menubar~append(edit) +menubar~append(help) + +new = .GtkImageMenu~new_from_stock(.gtk~GTK_STOCK_NEW, group) +open = .GtkImageMenu~new_from_stock(.gtk~GTK_STOCK_OPEN, group) +filemenu~append(new) +filemenu~append(open) + +cut = .GtkImageMenu~new_from_stock(.gtk~GTK_STOCK_CUT, group) +copy = .GtkImageMenu~new_from_stock(.gtk~GTK_STOCK_COPY, group) +paste = .GtkImageMenu~new_from_stock(.gtk~GTK_STOCK_PASTE, group) +editmenu~append(cut) +editmenu~append(copy) +editmenu~append(paste) + +contents = .GtkImageMenu~new_from_stock(.gtk~GTK_STOCK_HELP, group) +about = .GtkImageMenu~new_from_stock(.gtk~GTK_STOCK_ABOUT, group) +helpmenu~append(contents) +aboutmenu~append(contents) + +window~add(menubar) +window~add_accel_group(group) + +window~show_all() +call gtk_main +return + + +::requires 'rexxgtk.cls' + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + + Property changes on: sandbox/david/4x/test9-5.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-05-29 02:23:47
|
Revision: 2506 http://oorexx.svn.sourceforge.net/oorexx/?rev=2506&view=rev Author: wdashley Date: 2008-05-28 19:23:56 -0700 (Wed, 28 May 2008) Log Message: ----------- ArtifactID: None Comment: Added toolbar class. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxtoolbar.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-05-25 00:58:15 UTC (rev 2505) +++ sandbox/david/4x/Makefile 2008-05-29 02:23:56 UTC (rev 2506) @@ -80,7 +80,8 @@ grxmenubar.o \ grxevents.o \ grxaccelgroup.o \ - grxstatusbar.o + grxstatusbar.o \ + grxtoolbar.o # Build the shared library @@ -194,8 +195,11 @@ grxstatusbar.o: grxstatusbar.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxstatusbar.cpp +grxtoolbar.o: grxtoolbar.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxtoolbar.cpp + clean: rm *.so *.o Added: sandbox/david/4x/grxtoolbar.cpp =================================================================== --- sandbox/david/4x/grxtoolbar.cpp (rev 0) +++ sandbox/david/4x/grxtoolbar.cpp 2008-05-29 02:23:56 UTC (rev 2506) @@ -0,0 +1,1090 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + +static void signal_func_0(GtkWidget *toolbar, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(toolbar), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + context->SendMessage0(rxobj, ((cbcb *)data)->signal_name); + context->DetachThread(); + return; +} + +static gboolean signal_func_1a(GtkToolbar *toolbar, + gboolean arg1, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(toolbar), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxObjectPtr tempobj = context->NumberToObject((wholenumber_t)arg1);; + tempobj = context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, tempobj); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + +static void signal_func_1b(GtkToolbar *toolbar, + gint arg1, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(toolbar), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + RexxObjectPtr tempobj = context->NumberToObject((wholenumber_t)arg1);; + context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, tempobj); + context->DetachThread(); + return; +} + +static gboolean signal_func_3(GtkToolbar *toolbar, + gint arg1, + gint arg2, + gint arg3, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(toolbar), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = context->NumberToObject((wholenumber_t)arg1);; + context->ArrayPut(arr, tempobj, 1); + tempobj = context->NumberToObject((wholenumber_t)arg2);; + context->ArrayPut(arr, tempobj, 2); + tempobj = context->NumberToObject((wholenumber_t)arg3);; + context->ArrayPut(arr, tempobj, 2); + tempobj = context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create an tool bar. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxToolbarNew, // Object_method name + OSELF, self) // Self +{ + GtkWidget *toolbar; + + toolbar = gtk_toolbar_new(); + + context->SetObjectVariable("!POINTER", context->NewPointer(toolbar)); + g_object_set_data(G_OBJECT(toolbar), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: insert + * + * Insert a tool item. + * + * @param child The child item + * + * @param pos The position + * + * @return Zero + **/ +RexxMethod2(int, // Return type + GrxToolbarInsert, // Object_method name + RexxObjectPtr, child, // The child item + int, pos) // Position +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject childptr = (RexxPointerObject)context->SendMessage0(child, "POINTER"); + GtkToolItem *childWidget = (GtkToolItem *)context->PointerValue(childptr); + + gtk_toolbar_insert(myWidget, childWidget, pos); + + return 0; +} + +/** + * Method: get_item_index + * + * Get an item index. + * + * @param child The child item + * + * @return Index + **/ +RexxMethod1(int, // Return type + GrxToolbarGetItemIndex, // Object_method name + RexxObjectPtr, child) // The child item +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject childptr = (RexxPointerObject)context->SendMessage0(child, "POINTER"); + GtkToolItem *childWidget = (GtkToolItem *)context->PointerValue(childptr); + + return gtk_toolbar_get_item_index(myWidget, childWidget); +} + +/** + * Method: get_n_items + * + * Get the number of items. + * + * @return Items + **/ +RexxMethod0(int, // Return type + GrxToolbarGetNItems) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + return gtk_toolbar_get_n_items(myWidget); +} + +/** + * Method: get_nth_item + * + * Get the nth item. + * + * @param pos The position + * + * @return Items + **/ +RexxMethod1(RexxObjectPtr, // Return type + GrxToolbarGetNthItem, // Object_method name + int, pos) // The child position +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + GtkToolItem *item; + + item = gtk_toolbar_get_nth_item(myWidget, pos); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: get_drop_index + * + * Get drop index.. + * + * @param x The x coordinate on the toolbar + * + * @param y The y coordinate on the toolbar + * + * @return Index + **/ +RexxMethod2(int, // Return type + GrxToolbarGetDropIndex, // Object_method name + int, x, // The x coordinate + int, y) // The y coordinate +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + GtkToolItem item; + + return gtk_toolbar_get_drop_index(myWidget, x, y); +} + +/** + * Method: set_drop_highlight_item + * + * Insert a tool item. + * + * @param child The child item + * + * @param idx The index + * + * @return Zero + **/ +RexxMethod2(int, // Return type + GrxToolbarSetDropHighlightItem, // Object_method name + RexxObjectPtr, child, // The child item + int, idx) // Position index +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject childptr = (RexxPointerObject)context->SendMessage0(child, "POINTER"); + GtkToolItem *childWidget = (GtkToolItem *)context->PointerValue(childptr); + + gtk_toolbar_set_drop_highlight_item(myWidget, childWidget, idx); + + return 0; +} + +/** + * Method: set_show_arrow + * + * Set to show an overflow menu. + * + * @param flag Boolean flag + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolbarSetShowArrow, // Object_method name + logical_t, flag) // Show boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_set_show_arrow(myWidget, flag); + + return 0; +} + +/** + * Method: set_orientation + * + * Set the orientation. + * + * @param orient Orientationg + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolbarSetOrientation, // Object_method name + int, orient) // Orientation +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_set_orientation(myWidget, (GtkOrientation)orient); + + return 0; +} + +/** + * Method: set_tooltips + * + * Set to show tooltips. + * + * @param flag Boolean flag + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolbarSetTooltips, // Object_method name + logical_t, flag) // Show boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_set_tooltips(myWidget, flag); + + return 0; +} + +/** + * Method: unset_icon_size + * + * Unset the icon size. + * + * @return Zero + **/ +RexxMethod0(int, // Return type + GrxToolbarUnsetIconSize) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_unset_icon_size(myWidget); + + return 0; +} + +/** + * Method: get_show_arrow + * + * Get to show an overflow menu. + * + * @return Flag + **/ +RexxMethod0(logical_t, // Return type + GrxToolbarGetShowArrow) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + return gtk_toolbar_get_show_arrow(myWidget); +} + +/** + * Method: get_orientation + * + * Get the orientation. + * + * @return Orientation + **/ +RexxMethod0(int, // Return type + GrxToolbarGetOrientation) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + return (int)gtk_toolbar_get_orientation(myWidget); +} + +/** + * Method: get_style + * + * Get the style. + * + * @return Style + **/ +RexxMethod0(int, // Return type + GrxToolbarGetStyle) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + return (int)gtk_toolbar_get_style(myWidget); +} + +/** + * Method: get_icon_size + * + * Get the icon size. + * + * @return Size + **/ +RexxMethod0(int, // Return type + GrxToolbarGetIconSize) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + return (int)gtk_toolbar_get_icon_size(myWidget); +} + +/** + * Method: get_tooltips + * + * Get to show tooltips. + * + * @return Flag + **/ +RexxMethod0(logical_t, // Return type + GrxToolbarGetTooltips) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + return gtk_toolbar_get_tooltips(myWidget); +} + +/** + * Method: get_relief_style + * + * Get the relief style. + * + * @return Style + **/ +RexxMethod0(int, // Return type + GrxToolbarGetReliefStyle) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + return (int)gtk_toolbar_get_relief_style(myWidget); +} + +/** + * Method: append_item + * + * Append a tool item. + * + * @param text Button label text + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @param icon Widget icon + * + * @param method The ooRexx method name + * + * @return Style + **/ +RexxMethod5(RexxObjectPtr, // Return type + GrxToolbarAppenItem, // Object_method name + CSTRING, text, // Button text + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + RexxObjectPtr, icon, // Widget icon + CSTRING, method) // The ooRexx method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + cbcb *cblock; + GtkWidget *item; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + item = gtk_toolbar_append_item(myWidget, text, ttext, tptext, iconWidget, + GTK_SIGNAL_FUNC(signal_func_0), cblock); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: prepend_item + * + * Prepend a tool item. + * + * @param text Button label text + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @param icon Widget icon + * + * @param method The ooRexx method name + * + * @return Style + **/ +RexxMethod5(RexxObjectPtr, // Return type + GrxToolbarPrependItem, // Object_method name + CSTRING, text, // Button text + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + RexxObjectPtr, icon, // Widget icon + CSTRING, method) // The ooRexx method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + cbcb *cblock; + GtkWidget *item; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + item = gtk_toolbar_prepend_item(myWidget, text, ttext, tptext, iconWidget, + GTK_SIGNAL_FUNC(signal_func_0), cblock); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: insert_item + * + * Insert a tool item. + * + * @param text Button label text + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @param icon Widget icon + * + * @param method The ooRexx method name + * + * @param pos The position + * + * @return Style + **/ +RexxMethod6(RexxObjectPtr, // Return type + GrxToolbarInsertItem, // Object_method name + CSTRING, text, // Button text + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + RexxObjectPtr, icon, // Widget icon + CSTRING, method, // The ooRexx method name + int, pos) // Insert position +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + cbcb *cblock; + GtkWidget *item; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + item = gtk_toolbar_insert_item(myWidget, text, ttext, tptext, iconWidget, + GTK_SIGNAL_FUNC(signal_func_0), cblock, pos); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: append_space + * + * Append a space. + * + * @return Style + **/ +RexxMethod0(int, // Return type + GrxToolbarAppendSpace) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_append_space(myWidget); + + return 0; +} + +/** + * Method: prepend_space + * + * Prepend a space. + * + * @return Style + **/ +RexxMethod0(int, // Return type + GrxToolbarPrependSpace) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_prepend_space(myWidget); + + return 0; +} + +/** + * Method: insert_space + * + * Insert a space. + * + * @param pos The position + * + * @return Style + **/ +RexxMethod1(int, // Return type + GrxToolbarInsertSpace, // Object_method name + int, pos) // Position +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_insert_space(myWidget, pos); + + return 0; +} + +/** + * Method: append_element + * + * Append an element. + * + * @param type Toolbar child type + * + * @param text Button label text + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @param icon Widget icon + * + * @param method The ooRexx method name + * + * @return Style + **/ +RexxMethod7(RexxObjectPtr, // Return type + GrxToolbarAppenElement, // Object_method name + int, type, // Child type + RexxObjectPtr, elem, // Widget element + CSTRING, text, // Button text + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + RexxObjectPtr, icon, // Widget icon + CSTRING, method) // The ooRexx method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(elem, "POINTER"); + GtkWidget *elemWidget = (GtkWidget *)context->PointerValue(widgetptr); + widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + cbcb *cblock; + GtkWidget *item; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + item = gtk_toolbar_append_element(myWidget, (GtkToolbarChildType)type, + elemWidget, text, ttext, tptext, iconWidget, + GTK_SIGNAL_FUNC(signal_func_0), cblock); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: prepend_element + * + * Prepend an element. + * + * @param type Toolbar child type + * + * @param text Button label text + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @param icon Widget icon + * + * @param method The ooRexx method name + * + * @return Style + **/ +RexxMethod7(RexxObjectPtr, // Return type + GrxToolbarPrependElement, // Object_method name + int, type, // Child type + RexxObjectPtr, elem, // Widget element + CSTRING, text, // Button text + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + RexxObjectPtr, icon, // Widget icon + CSTRING, method) // The ooRexx method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(elem, "POINTER"); + GtkWidget *elemWidget = (GtkWidget *)context->PointerValue(widgetptr); + widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + cbcb *cblock; + GtkWidget *item; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + item = gtk_toolbar_prepend_element(myWidget, (GtkToolbarChildType)type, + elemWidget, text, ttext, tptext, iconWidget, + GTK_SIGNAL_FUNC(signal_func_0), cblock); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: insert_element + * + * Insert an element. + * + * @param type Toolbar child type + * + * @param text Button label text + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @param icon Widget icon + * + * @param method The ooRexx method name + * + * @param pos The position + * + * @return Style + **/ +RexxMethod8(RexxObjectPtr, // Return type + GrxToolbarInsertElement, // Object_method name + int, type, // Child type + RexxObjectPtr, elem, // Widget element + CSTRING, text, // Button text + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + RexxObjectPtr, icon, // Widget icon + CSTRING, method, // The ooRexx method name + int, pos) // The ooRexx method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(elem, "POINTER"); + GtkWidget *elemWidget = (GtkWidget *)context->PointerValue(widgetptr); + widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + cbcb *cblock; + GtkWidget *item; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + item = gtk_toolbar_insert_element(myWidget, (GtkToolbarChildType)type, + elemWidget, text, ttext, tptext, iconWidget, + GTK_SIGNAL_FUNC(signal_func_0), cblock, pos); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: append_widget + * + * Append a widget. + * + * @param tool Widget + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @return Zero + **/ +RexxMethod7(RexxObjectPtr, // Return type + GrxToolbarAppendWidget, // Object_method name + int, type, // Child type + RexxObjectPtr, tool, // Widget icon + CSTRING, text, // Button text + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + RexxObjectPtr, icon, // Widget icon + CSTRING, method) // The ooRexx method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(tool, "POINTER"); + GtkWidget *toolWidget = (GtkWidget *)context->PointerValue(widgetptr); + widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + cbcb *cblock; + GtkWidget *item; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + item = gtk_toolbar_append_element(myWidget, (GtkToolbarChildType)type, + toolWidget, text, ttext, tptext, + iconWidget, GTK_SIGNAL_FUNC(signal_func_0), + cblock); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: prepend_widget + * + * Prepend a widget. + * + * @param tool Widget + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @return Zero + **/ +RexxMethod7(RexxObjectPtr, // Return type + GrxToolbarPrependWidget, // Object_method name + int, type, // Child type + RexxObjectPtr, tool, // Widget icon + CSTRING, text, // Button text + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + RexxObjectPtr, icon, // Widget icon + CSTRING, method) // The ooRexx method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(tool, "POINTER"); + GtkWidget *toolWidget = (GtkWidget *)context->PointerValue(widgetptr); + widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + cbcb *cblock; + GtkWidget *item; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + item = gtk_toolbar_prepend_element(myWidget, (GtkToolbarChildType)type, + toolWidget, text, ttext, tptext, + iconWidget, GTK_SIGNAL_FUNC(signal_func_0), + cblock); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: insert_widget + * + * Insert a widget. + * + * @param tool Widget + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @param pos Position + * + * @return Zero + **/ +RexxMethod8(RexxObjectPtr, // Return type + GrxToolbarInsertWidget, // Object_method name + int, type, // Child type + RexxObjectPtr, tool, // Widget icon + CSTRING, text, // Button text + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + RexxObjectPtr, icon, // Widget icon + CSTRING, method, // The ooRexx method name + int, pos) // Tooltips private text +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(tool, "POINTER"); + GtkWidget *toolWidget = (GtkWidget *)context->PointerValue(widgetptr); + widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + cbcb *cblock; + GtkWidget *item; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + item = gtk_toolbar_insert_element(myWidget, (GtkToolbarChildType)type, + toolWidget, text, ttext, tptext, + iconWidget, GTK_SIGNAL_FUNC(signal_func_0), + cblock, pos); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(item), "OORXOBJECT"); +} + +/** + * Method: set_style + * + * Set the toolbar style. + * + * @param style Toolbar style + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolbarSetStyle, // Object_method name + int, style) // Toolbar style +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_set_style(myWidget, (GtkToolbarStyle)style); + + return 0; +} + +/** + * Method: insert_stock + * + * Insert a stock item. + * + * @param id Stock id + * + * @param ttext Tooltips text + * + * @param tptext Tooltips private text + * + * @param method Method name + * + * @param pos Position + * + * @return Zero + **/ +RexxMethod5(RexxObjectPtr, // Return type + GrxToolbarInsertStock, // Object_method name + CSTRING, id, // Stock id + CSTRING, ttext, // Tooltips text + CSTRING, tptext, // Tooltips private text + CSTRING, method, // The ooRexx method name + int, pos) // Tooltips private text +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + cbcb *cblock; + + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = method; + gtk_toolbar_insert_stock(myWidget, id, ttext, tptext, + GTK_SIGNAL_FUNC(signal_func_0), cblock, pos); + + return 0; +} + +/** + * Method: set_icon_size + * + * Set the toolbar icon size. + * + * @param size Toolbar icon size + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolbarSetIconSize, // Object_method name + int, size) // Toolbar style +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_set_icon_size(myWidget, (GtkIconSize)size); + + return 0; +} + +/** + * Method: remove_space + * + * Remove a space. + * + * @param pos Position + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolbarRemoveSpace, // Object_method name + int, pos) // Position +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_remove_space(myWidget, pos); + + return 0; +} + +/** + * Method: unset_style + * + * Unset the toolbar style. + * + * @return Zero + **/ +RexxMethod0(int, // Return type + GrxToolbarUnsetStyle) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolbar *myWidget = (GtkToolbar *)context->PointerValue(rxptr); + + gtk_toolbar_unset_style(myWidget); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxToolbarSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "focus_home_or_end") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_focus_home_or_end"; + g_signal_connect(G_OBJECT(myWidget), "focus-home-or-end", + G_CALLBACK(signal_func_1a), cblock); + return context->True(); + } + else if (strcmp(name, "orientation_changed") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_orientation_changed"; + g_signal_connect(G_OBJECT(myWidget), "orientation-changed", + G_CALLBACK(signal_func_1b), cblock); + return context->True(); + } + else if (strcmp(name, "popup_context_menu") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_popup_context_menu"; + g_signal_connect(G_OBJECT(myWidget), "popup-context-menu", + G_CALLBACK(signal_func_3), cblock); + return context->True(); + } + else if (strcmp(name, "style_changed") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_style_changed"; + g_signal_connect(G_OBJECT(myWidget), "style-changed", + G_CALLBACK(signal_func_1b), cblock); + return context->True(); + } + return context->False(); +} + Property changes on: sandbox/david/4x/grxtoolbar.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-05-25 00:58:15 UTC (rev 2505) +++ sandbox/david/4x/rexxgtk.cls 2008-05-29 02:23:56 UTC (rev 2506) @@ -224,10 +224,10 @@ ::constant GTK_ASSISTANT_PAGE_CONFIRM 2 ::constant GTK_ASSISTANT_PAGE_SUMMARY 3 ::constant GTK_ASSISTANT_PAGE_PROGRESS 4 - -- GtkReliefType + -- GtkReliefStyle ::constant GTK_RELIEF_NORMAL 0 ::constant GTK_RELIEF_HALF 1 -::constant GTK_RELIEF_NONO 2 +::constant GTK_RELIEF_NONE 2 -- GtkAtom ::constant GTK_SELECTION_PRIMARY 1 ::constant GTK_SELECTION_SECONDARY 2 @@ -275,6 +275,28 @@ ::constant GTK_STATE_PRELIGHT 2 ::constant GTK_STATE_SELECTED 3 ::constant GTK_STATE_INSENSITIVE 4 + -- GtkPachDirection +::constant GTK_PACK_DIRECTION_LTR 0 +::constant GTK_PACK_DIRECTION_RTL 1 +::constant GTK_PACK_DIRECTION_TTB 2 +::constant GTK_PACK_DIRECTION_BTT 3 + -- GtkOrientation +::constant GTK_ORIENTATION_HORIZONTAL 0 +::constant GTK_ORIENTATION_VERTICAL 1 + -- GtkToolbarStyle +::constant GTK_TOOLBAR_ICONS 0 +::constant GTK_TOOLBAR_TEXT 1 +::constant GTK_TOOLBAR_BOTH 2 +::constant GTK_TOOLBAR_BOTH_HORIZ 3 + -- GtkToolbarChildType +::constant GTK_TOOLBAR_CHILD_SPACE 0 +::constant GTK_TOOLBAR_CHILD_BUTTON 1 +::constant GTK_TOOLBAR_CHILD_TOGGLEBUTTON 2 +::constant GTK_TOOLBAR_CHILD_RADIOBUTTON 3 +::constant GTK_TOOLBAR_CHILD_WIDGET 4 + -- GtkToolbarSpaceStyle +::constant GTK_TOOLBAR_SPACE_EMPTY 0 +::constant GTK_TOOLBAR_SPACE_LINE 1 -- Pango scale factors ::constant PANGO_SCALE_XX_SMALL 0.5787037037037 ::constant PANGO_SCALE_X_SMALL 0.6444444444444 @@ -2373,6 +2395,63 @@ /*============================================================================*/ +/* Class: GtkToolbarm */ +/*============================================================================*/ + +::class GtkToolbar public subclass GtkContainer + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxToolbarNew" +::METHOD insert EXTERNAL "LIBRARY rexxgtk GrxToolbarInsert" +::METHOD get_item_index EXTERNAL "LIBRARY rexxgtk GrxToolbarGetItemIndex" +::METHOD get_n_items EXTERNAL "LIBRARY rexxgtk GrxToolbarGetNItems" +::METHOD get_nth_item EXTERNAL "LIBRARY rexxgtk GrxToolbarGetNthItem" +::METHOD get_drop_index EXTERNAL "LIBRARY rexxgtk GrxToolbarGetDropIndex" +::METHOD set_drop_highlight_item EXTERNAL "LIBRARY rexxgtk GrxToolbarSetDropHighlightItem" +::METHOD set_show_arrow EXTERNAL "LIBRARY rexxgtk GrxToolbarSetShowArrow" +::METHOD set_orientation EXTERNAL "LIBRARY rexxgtk GrxToolbarSetOrientation" +::METHOD set_tooltips EXTERNAL "LIBRARY rexxgtk GrxToolbarSetTooltips" +::METHOD set_icon_size EXTERNAL "LIBRARY rexxgtk GrxToolbarSetIconSize" +::METHOD get_show_arrow EXTERNAL "LIBRARY rexxgtk GrxToolbarGetShowArrow" +::METHOD get_orientation EXTERNAL "LIBRARY rexxgtk GrxToolbarGetOrientation" +::METHOD get_style EXTERNAL "LIBRARY rexxgtk GrxToolbarGetStyle" +::METHOD get_icon_size EXTERNAL "LIBRARY rexxgtk GrxToolbarGetIconSize" +::METHOD get_tooltips EXTERNAL "LIBRARY rexxgtk GrxToolbarGetTooltips" +::METHOD append_item EXTERNAL "LIBRARY rexxgtk GrxToolbarAppendItem" +::METHOD prepend_item EXTERNAL "LIBRARY rexxgtk GrxToolbarPrependItem" +::METHOD insert_item EXTERNAL "LIBRARY rexxgtk GrxToolbarInsertItem" +::METHOD append_space EXTERNAL "LIBRARY rexxgtk GrxToolbarAppendSpace" +::METHOD prepend_space EXTERNAL "LIBRARY rexxgtk GrxToolbarPrependSpace" +::METHOD insert_space EXTERNAL "LIBRARY rexxgtk GrxToolbarInsertSpace" +::METHOD append_element EXTERNAL "LIBRARY rexxgtk GrxToolbarAppendElement" +::METHOD prepend_element EXTERNAL "LIBRARY rexxgtk GrxToolbarPrependElement" +::METHOD insert_element EXTERNAL "LIBRARY rexxgtk GrxToolbarInsertElement" +::METHOD append_widget EXTERNAL "LIBRARY rexxgtk GrxToolbarAppendWidget" +::METHOD prepend_widget EXTERNAL "LIBRARY rexxgtk GrxToolbarPrependWidget" +::METHOD insert_widget EXTERNAL "LIBRARY rexxgtk GrxToolbarInsertWidget" +::METHOD set_style EXTERNAL "LIBRARY rexxgtk GrxToolbarSetStyle" +::METHOD insert_stock EXTERNAL "LIBRARY rexxgtk GrxToolbarInsertStock" +::METHOD set_icon_size EXTERNAL "LIBRARY rexxgtk GrxToolbarSetIconSize" +::METHOD remove_space EXTERNAL "LIBRARY rexxgtk GrxToolbarRemoveSpace" +::METHOD unset_style EXTERNAL "LIBRARY rexxgtk GrxToolbarUnsetStyle" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxToolbarSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method focus_home_or_end +return .false + +::method signal_orientation_changed +return + +::method signal_popup_context_menu +return .false + +::method signal_style_changed +return + + +/*============================================================================*/ /* Class: GtkSeparatorMenuItem */ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-05-25 00:58:15 UTC (rev 2505) +++ sandbox/david/4x/rexxgtk.cpp 2008-05-29 02:23:56 UTC (rev 2506) @@ -737,6 +737,41 @@ REXX_METHOD(GrxStatusbarSetHasResizeGrip, GrxStatusbarSetHasResizeGrip), REXX_METHOD(GrxStatusbarGetHasResizeGrip, GrxStatusbarGetHasResizeGrip), REXX_METHOD(GrxStatusbarSignalConnect, GrxStatusbarSignalConnect), + REXX_METHOD(GrxToolbarNew, GrxToolbarNew), + REXX_METHOD(GrxToolbarInsert, GrxToolbarInsert), + REXX_METHOD(GrxToolbarGetItemIndex, GrxToolbarGetItemIndex), + REXX_METHOD(GrxToolbarGetNItems, GrxToolbarGetNItems), + REXX_METHOD(GrxToolbarGetNthItem, GrxToolbarGetNthItem), + REXX_METHOD(GrxToolbarGetDropIndex, GrxToolbarGetDropIndex), + REXX_METHOD(GrxToolbarSetDropHighlightItem, GrxToolbarSetDropHighlightItem), + REXX_METHOD(GrxToolbarSetShowArrow, GrxToolbarSetShowArrow), + REXX_METHOD(GrxToolbarSetOrientation, GrxToolbarSetOrientation), + REXX_METHOD(GrxToolbarSetTooltips, GrxToolbarSetTooltips), + REXX_METHOD(GrxToolbarUnsetIconSize, GrxToolbarUnsetIconSize), + REXX_METHOD(GrxToolbarGetShowArrow, GrxToolbarGetShowArrow), + REXX_METHOD(GrxToolbarGetOrientation, GrxToolbarGetOrientation), + REXX_METHOD(GrxToolbarGetStyle, GrxToolbarGetStyle), + REXX_METHOD(GrxToolbarGetIconSize, GrxToolbarGetIconSize), + REXX_METHOD(GrxToolbarGetTooltips, GrxToolbarGetTooltips), + REXX_METHOD(GrxToolbarGetReliefStyle, GrxToolbarGetReliefStyle), + REXX_METHOD(GrxToolbarAppendItem, GrxToolbarAppendItem), + REXX_METHOD(GrxToolbarPrependItem, GrxToolbarPrependItem), + REXX_METHOD(GrxToolbarInsertItem, GrxToolbarInsertItem), + REXX_METHOD(GrxToolbarAppendSpace, GrxToolbarAppendSpace), + REXX_METHOD(GrxToolbarPrependSpace, GrxToolbarPrependSpace), + REXX_METHOD(GrxToolbarInsertSpace, GrxToolbarInsertSpace), + REXX_METHOD(GrxToolbarAppendElement, GrxToolbarAppendElement), + REXX_METHOD(GrxToolbarPrependElement, GrxToolbarPrependElement), + REXX_METHOD(GrxToolbarInsertElement, GrxToolbarInsertElement), + REXX_METHOD(GrxToolbarAppendWidget, GrxToolbarAppendWidget), + REXX_METHOD(GrxToolbarPrependWidget, GrxToolbarPrependWidget), + REXX_METHOD(GrxToolbarInsertWidget, GrxToolbarInsertWidget), + REXX_METHOD(GrxToolbarSetStyle, GrxToolbarSetStyle), + REXX_METHOD(GrxToolbarInsertStock, GrxToolbarInsertStock), + REXX_METHOD(GrxToolbarSetIconSize, GrxToolbarSetIconSize), + REXX_METHOD(GrxToolbarRemoveSpace, GrxToolbarRemoveSpace), + REXX_METHOD(GrxToolbarUnsetStyle, GrxToolbarUnsetStyle), + REXX_METHOD(GrxToolbarSignalConnect, GrxToolbarSignalConnect), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-05-25 00:58:15 UTC (rev 2505) +++ sandbox/david/4x/rexxgtk.h 2008-05-29 02:23:56 UTC (rev 2506) @@ -63,7 +63,7 @@ typedef struct _cbcb { RexxInstance *instance; // Rexx instance - char *signal_name; // Name of the ooRexx method + const char *signal_name; // Name of the ooRexx method } cbcb; @@ -504,6 +504,41 @@ REXX_METHOD_PROTOTYPE(GrxImageMenuItemNewFromStock) REXX_METHOD_PROTOTYPE(GrxImageMenuItemNewWithLabel) REXX_METHOD_PROTOTYPE(GrxImageMenuItemNewWithMnemonic) +REXX_METHOD_PROTOTYPE(GrxToolbarNew) +REXX_METHOD_PROTOTYPE(GrxToolbarInsert) +REXX_METHOD_PROTOTYPE(GrxToolbarGetItemIndex) +REXX_METHOD_PROTOTYPE(GrxToolbarGetNItems) +REXX_METHOD_PROTOTYPE(GrxToolbarGetNthItem) +REXX_METHOD_PROTOTYPE(GrxToolbarGetDropIndex) +REXX_METHOD_PROTOTYPE(GrxToolbarSetDropHighlightItem) +REXX_METHOD_PROTOTYPE(GrxToolbarSetShowArrow) +REXX_METHOD_PROTOTYPE(GrxToolbarSetOrientation) +REXX_METHOD_PROTOTYPE(GrxToolbarSetTooltips) +REXX_METHOD_PROTOTYPE(GrxToolbarUnsetIconSize) +REXX_METHOD_PROTOTYPE(GrxToolbarGetShowArrow) +REXX_METHOD_PROTOTYPE(GrxToolbarGetOrientation) +REXX_METHOD_PROTOTYPE(GrxToolbarGetStyle) +REXX_METHOD_PROTOTYPE(GrxToolbarGetIconSize) +REXX_METHOD_PROTOTYPE(GrxToolbarGetTooltips) +REXX_METHOD_PROTOTYPE(GrxToolbarGetReliefStyle) +REXX_METHOD_PROTOTYPE(GrxToolbarAppendItem) +REXX_METHOD_PROTOTYPE(GrxToolbarPrependItem) +REXX_METHOD_PROTOTYPE(GrxToolbarInsertItem) +REXX_METHOD_PROTOTYPE(GrxToolbarAppendSpace) +REXX_METHOD_PROTOTYPE(GrxToolbarPrependSpace) +REXX_METHOD_PROTOTYPE(GrxToolbarInsertSpace) +REXX_METHOD_PROTOTYPE(GrxToolbarAppendElement) +REXX_METHOD_PROTOTYPE(GrxToolbarPrependElement) +REXX_METHOD_PROTOTYPE(GrxToolbarInsertElement) +REXX_METHOD_PROTOTYPE(GrxToolbarAppendWidget) +REXX_METHOD_PROTOTYPE(GrxToolbarPrependWidget) +REXX_METHOD_PROTOTYPE(GrxToolbarInsertWidget) +REXX_METHOD_PROTOTYPE(GrxToolbarSetStyle) +REXX_METHOD_PROTOTYPE(GrxToolbarInsertStock) +REXX_METHOD_PROTOTYPE(GrxToolbarSetIconSize) +REXX_METHOD_PROTOTYPE(GrxToolbarRemoveSpace) +REXX_METHOD_PROTOTYPE(GrxToolbarUnsetStyle) +REXX_METHOD_PROTOTYPE(GrxToolbarSignalConnect) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-05-29 21:47:50
|
Revision: 2507 http://oorexx.svn.sourceforge.net/oorexx/?rev=2507&view=rev Author: wdashley Date: 2008-05-29 14:47:08 -0700 (Thu, 29 May 2008) Log Message: ----------- ArtifactID: None Comment: Added the toolitem class. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxtoolitem.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-05-29 02:23:56 UTC (rev 2506) +++ sandbox/david/4x/Makefile 2008-05-29 21:47:08 UTC (rev 2507) @@ -81,7 +81,8 @@ grxevents.o \ grxaccelgroup.o \ grxstatusbar.o \ - grxtoolbar.o + grxtoolbar.o \ + grxtoolitem.o # Build the shared library @@ -198,8 +199,11 @@ grxtoolbar.o: grxtoolbar.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxtoolbar.cpp +grxtoolitem.o: grxtoolitem.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxtoolitem.cpp + clean: rm *.so *.o Added: sandbox/david/4x/grxtoolitem.cpp =================================================================== --- sandbox/david/4x/grxtoolitem.cpp (rev 0) +++ sandbox/david/4x/grxtoolitem.cpp 2008-05-29 21:47:08 UTC (rev 2507) @@ -0,0 +1,575 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + +static gboolean signal_func_0(GtkWidget *toolitem, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(toolitem), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxObjectPtr tempobj = context->SendMessage0(rxobj, ((cbcb *)data)->signal_name); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + +static void signal_func_0a(GtkWidget *toolitem, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(toolitem), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + context->SendMessage0(rxobj, ((cbcb *)data)->signal_name); + context->DetachThread(); + return; +} + +static gboolean signal_func_3(GtkToolbar *toolitem, + GtkTooltips *arg1, + char *arg2, + char *arg3, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(toolitem), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(arg1), "OORXOBJECT"); + context->ArrayPut(arr, tempobj, 1); + tempobj = context->NewStringFromAsciiz(arg2);; + context->ArrayPut(arr, tempobj, 2); + tempobj = context->NewStringFromAsciiz(arg3);; + context->ArrayPut(arr, tempobj, 2); + tempobj = context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create an tool item. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxToolItemNew, // Object_method name + OSELF, self) // Self +{ + GtkToolItem *toolitem; + + toolitem = gtk_tool_item_new(); + + context->SetObjectVariable("!POINTER", context->NewPointer(toolitem)); + g_object_set_data(G_OBJECT(toolitem), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: set_homogeneous + * + * Set the item homogeneous. + * + * @param homo The homogeneous boolean + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolItemSetHomogemeous, // Object_method name + logical_t, homo) // Homogeneous boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + gtk_tool_item_set_homogeneous(myWidget, homo); + + return 0; +} + +/** + * Method: get_homogeneous + * + * Get the item homogeneous. + * + * @return Homogeneous boolean + **/ +RexxMethod0(logical_t, // Return type + GrxToolItemGetHomogemeous) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_homogeneous(myWidget); +} + +/** + * Method: set_expand + * + * Set the item expand flag. + * + * @param expand The expand boolean + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolItemSetExpand, // Object_method name + logical_t, expand) // Expand boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + gtk_tool_item_set_expand(myWidget, expand); + + return 0; +} + +/** + * Method: get_expand + * + * Get the item expand. + * + * @return Expand boolean + **/ +RexxMethod0(logical_t, // Return type + GrxToolItemGetExoand) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_expand(myWidget); +} + +/** + * Method: set_tooltip + * + * Set an item tooltip. + * + * @param tooltip The tooltip + * + * @param text The tooltip text + * + * @param ptext The tooltip private text + * + * @return Zero + **/ +RexxMethod3(int, // Return type + GrxToolItemSetTooltip, // Object_method name + RexxObjectPtr, tooltip, // The tooltips + CSTRING, text, // The tooltip text + CSTRING, ptext) // The tooltip private text +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + RexxPointerObject toolptr = (RexxPointerObject)context->SendMessage0(tooltip, "POINTER"); + GtkTooltips *tooltWidget = (GtkTooltips *)context->PointerValue(toolptr); + + gtk_tool_item_set_tooltip(myWidget, tooltWidget, text, ptext); + + return 0; +} + +/** + * Method: set_use_drag_window + * + * Set the item use drag window flag. + * + * @param drag The drag boolean + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolItemSetUseDragWindow, // Object_method name + logical_t, drag) // Drag boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + gtk_tool_item_set_use_drag_window(myWidget, drag); + + return 0; +} + +/** + * Method: get_use_drag_window + * + * Get the item use drag window flag. + * + * @return Flag + **/ +RexxMethod0(logical_t, // Return type + GrxToolItemGetUseDragWindow) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_use_drag_window(myWidget); +} + +/** + * Method: set_visible_horizontal + * + * Set the item visible horizontal flag. + * + * @param visible The visible boolean + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolItemSetVisibleHorizontal, // Object_method name + logical_t, visible) // Visible boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + gtk_tool_item_set_visible_horizontal(myWidget, visible); + + return 0; +} + +/** + * Method: get_visible_horizontal + * + * Get the item visible horizontal flag. + * + * @return Zero + **/ +RexxMethod0(logical_t, // Return type + GrxToolItemGetVisibleHorizontal) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_visible_horizontal(myWidget); +} + +/** + * Method: set_visible_vertical + * + * Set the item visible vertical flag. + * + * @param visible The visible boolean + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolItemSetVisibleVertical, // Object_method name + logical_t, visible) // Visible boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + gtk_tool_item_set_visible_vertical(myWidget, visible); + + return 0; +} + +/** + * Method: get_visible_vertical + * + * Get the item visible vertical flag. + * + * @return Zero + **/ +RexxMethod0(logical_t, // Return type + GrxToolItemGetVisibleVertical) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_visible_vertical(myWidget); +} + +/** + * Method: set_is_important + * + * Set the item is important flag. + * + * @param import The import boolean + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxToolItemSetIsImportant, // Object_method name + logical_t, import) // Important boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + gtk_tool_item_set_is_important(myWidget, import); + + return 0; +} + +/** + * Method: get_is_important + * + * Get the item is important flag. + * + * @return Flag + **/ +RexxMethod0(logical_t, // Return type + GrxToolItemGetIsImportant) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_is_important(myWidget); +} + +/** + * Method: get_icon_size + * + * Get the item icon size. + * + * @return Size + **/ +RexxMethod0(int, // Return type + GrxToolItemGetIconSize) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_icon_size(myWidget); +} + +/** + * Method: get_orientation + * + * Get the item orientation. + * + * @return Orientation + **/ +RexxMethod0(int, // Return type + GrxToolItemGetOrientation) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_orientation(myWidget); +} + +/** + * Method: get_toolbar_style + * + * Get the item toolbar style. + * + * @return Style + **/ +RexxMethod0(int, // Return type + GrxToolItemGetToolbarStyle) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_toolbar_style(myWidget); +} + +/** + * Method: get_relief_style + * + * Get the item relief style. + * + * @return Style + **/ +RexxMethod0(int, // Return type + GrxToolItemGetReliefStyle) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + return gtk_tool_item_get_relief_style(myWidget); +} + +/** + * Method: retrieve_proxy_menu_item + * + * Get the item proxy menu item. + * + * @return Iteme + **/ +RexxMethod0(RexxObjectPtr, // Return type + GrxToolItemRetriveProxyMenuItem) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + GtkWidget *temp; + + temp = gtk_tool_item_retrieve_proxy_menu_item(myWidget); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(temp), "OORXOBJECT"); +} + +/** + * Method: get_proxy_meny_item + * + * Get the item proxy menu item. + * + * @return Iteme + **/ +RexxMethod1(RexxObjectPtr, // Return type + GrxToolItemGetProxyMenuItem, // Object_method name + CSTRING, id) // The id +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + GtkWidget *temp; + + temp = gtk_tool_item_get_proxy_menu_item(myWidget, id); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(temp), "OORXOBJECT"); +} + +/** + * Method: set_proxy_meny_item + * + * Set the item proxy menu item. + * + * @return Zero + **/ +RexxMethod2(int, // Return type + GrxToolItemSetProxyMenuItem, // Object_method name + CSTRING, id, // Item id + RexxObjectPtr, item) // Proxy menu itemame +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + RexxPointerObject itemptr = (RexxPointerObject)context->SendMessage0(item, "POINTER"); + GtkWidget *itemWidget = (GtkWidget *)context->PointerValue(itemptr); + + gtk_tool_item_set_proxy_menu_item(myWidget, id, itemWidget); + + return 0; +} + +/** + * Method: rebuild_menu + * + * Rebuild the menu. + * + * @return Zero + **/ +RexxMethod0(RexxObjectPtr, // Return type + GrxToolItemRebuildMenu) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolItem *myWidget = (GtkToolItem *)context->PointerValue(rxptr); + + gtk_tool_item_rebuild_menu(myWidget); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxToolItemSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "create_menu_proxy") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_create_menu_proxy"; + g_signal_connect(G_OBJECT(myWidget), "create-menu-proxy", + G_CALLBACK(signal_func_0), cblock); + return context->True(); + } + else if (strcmp(name, "set_tooltip") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_set_tooltip"; + g_signal_connect(G_OBJECT(myWidget), "set-tooltip", + G_CALLBACK(signal_func_3), cblock); + return context->True(); + } + else if (strcmp(name, "toolbar_reconfigured") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_toolbar_reconfigured"; + g_signal_connect(G_OBJECT(myWidget), "toolbar-reconfigured", + G_CALLBACK(signal_func_0a), cblock); + return context->True(); + } + return context->False(); +} + Property changes on: sandbox/david/4x/grxtoolitem.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-05-29 02:23:56 UTC (rev 2506) +++ sandbox/david/4x/rexxgtk.cls 2008-05-29 21:47:08 UTC (rev 2507) @@ -2395,7 +2395,7 @@ /*============================================================================*/ -/* Class: GtkToolbarm */ +/* Class: GtkToolbar */ /*============================================================================*/ ::class GtkToolbar public subclass GtkContainer @@ -2438,7 +2438,7 @@ -- The following are the methods that can be connected to signals. By default -- they do nothing. -::method focus_home_or_end +::method signal_focus_home_or_end return .false ::method signal_orientation_changed @@ -2452,6 +2452,49 @@ /*============================================================================*/ +/* Class: GtkToolItem */ +/*============================================================================*/ + +::class GtkToolItem public subclass GtkContainer + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxToolItemNew" +::METHOD set_homogeneous EXTERNAL "LIBRARY rexxgtk GrxToolItemSetHomogeneous" +::METHOD get_homogeneous EXTERNAL "LIBRARY rexxgtk GrxToolItemGetHomogeneous" +::METHOD set_expand EXTERNAL "LIBRARY rexxgtk GrxToolItemSetExpand" +::METHOD get_expand EXTERNAL "LIBRARY rexxgtk GrxToolItemGetExpand" +::METHOD set_tooltip EXTERNAL "LIBRARY rexxgtk GrxToolItemSetTooltip" +::METHOD set_use_drag_window EXTERNAL "LIBRARY rexxgtk GrxToolItemSetUseDragWindow" +::METHOD get_use_drag_window EXTERNAL "LIBRARY rexxgtk GrxToolItemGetUseDragWindow" +::METHOD set_visible_horizontal EXTERNAL "LIBRARY rexxgtk GrxToolItemSetVisibleHorizontal" +::METHOD get_visible_horizontal EXTERNAL "LIBRARY rexxgtk GrxToolItemGetVisibleHorizontal" +::METHOD set_visible_vertical EXTERNAL "LIBRARY rexxgtk GrxToolItemSetVisibleVertical" +::METHOD get_visible_vertical EXTERNAL "LIBRARY rexxgtk GrxToolItemGetVisibleVertical" +::METHOD set_is_important EXTERNAL "LIBRARY rexxgtk GrxToolItemSetIsImportant" +::METHOD get_is_important EXTERNAL "LIBRARY rexxgtk GrxToolItemGetIsImportant" +::METHOD get_icon_size EXTERNAL "LIBRARY rexxgtk GrxToolItemGetIconSize" +::METHOD get_orientation EXTERNAL "LIBRARY rexxgtk GrxToolItemGetOrientation" +::METHOD get_toolbar_style EXTERNAL "LIBRARY rexxgtk GrxToolItemGetToolbarStyle" +::METHOD get_relief_style EXTERNAL "LIBRARY rexxgtk GrxToolItemGetReliefStyle" +::METHOD retrieve_proxy_menu_item EXTERNAL "LIBRARY rexxgtk GrxToolItemRetrieveProxyMenuItem" +::METHOD get_proxy_menu_item EXTERNAL "LIBRARY rexxgtk GrxToolItemGetProxyMenuItem" +::METHOD set_proxy_menu_item EXTERNAL "LIBRARY rexxgtk GrxToolItemSetProxyMenuItem" +::METHOD rebuild_menu EXTERNAL "LIBRARY rexxgtk GrxToolItemRebuildMenu" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxToolItemSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_create_menu_proxy +return .false + +::method signal_set_tooltip +return .false + +::method signal_toolbar_reconfigured +return + + +/*============================================================================*/ /* Class: GtkSeparatorMenuItem */ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-05-29 02:23:56 UTC (rev 2506) +++ sandbox/david/4x/rexxgtk.cpp 2008-05-29 21:47:08 UTC (rev 2507) @@ -772,6 +772,28 @@ REXX_METHOD(GrxToolbarRemoveSpace, GrxToolbarRemoveSpace), REXX_METHOD(GrxToolbarUnsetStyle, GrxToolbarUnsetStyle), REXX_METHOD(GrxToolbarSignalConnect, GrxToolbarSignalConnect), + REXX_METHOD(GrxToolItemNew, GrxToolItemNew), + REXX_METHOD(GrxToolItemSetHomogeneous, GrxToolItemSetHomogeneous), + REXX_METHOD(GrxToolItemGetHomogeneous, GrxToolItemGetHomogeneous), + REXX_METHOD(GrxToolItemSetExpand, GrxToolItemSetExpand), + REXX_METHOD(GrxToolItemGetExpand, GrxToolItemGetExpand), + REXX_METHOD(GrxToolItemSetTooltip, GrxToolItemSetTooltip), + REXX_METHOD(GrxToolItemSetUseDragWindow, GrxToolItemSetUseDragWindow), + REXX_METHOD(GrxToolItemGetUseDragWindow, GrxToolItemGetUseDragWindow), + REXX_METHOD(GrxToolItemSetVisibleHorizontal, GrxToolItemSetVisibleHorizontal), + REXX_METHOD(GrxToolItemGetVisibleHorizontal, GrxToolItemGetVisibleHorizontal), + REXX_METHOD(GrxToolItemSetVisibleVertical, GrxToolItemSetVisibleVertical), + REXX_METHOD(GrxToolItemGetVisibleVertical, GrxToolItemGetVisibleVertical), + REXX_METHOD(GrxToolItemSetIsImportant, GrxToolItemSetIsImportant), + REXX_METHOD(GrxToolItemGetIsImportant, GrxToolItemGetIsImportant), + REXX_METHOD(GrxToolItemGetIconSize, GrxToolItemGetIconSize), + REXX_METHOD(GrxToolItemGetOrientation, GrxToolItemGetOrientation), + REXX_METHOD(GrxToolItemGetToolbarStyle, GrxToolItemGetToolbarStyle), + REXX_METHOD(GrxToolItemGetReliefStyle, GrxToolItemGetReliefStyle), + REXX_METHOD(GrxToolItemRetrieveProxyMenuItem, GrxToolItemRetrieveProxyMenuItem), + REXX_METHOD(GrxToolItemGetProxyMenuItem, GrxToolItemGetProxyMenuItem), + REXX_METHOD(GrxToolItemRebuildMenu, GrxToolItemRebuildMenu), + REXX_METHOD(GrxToolItemSignalConnect, GrxToolItemSignalConnect), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-05-29 02:23:56 UTC (rev 2506) +++ sandbox/david/4x/rexxgtk.h 2008-05-29 21:47:08 UTC (rev 2507) @@ -539,6 +539,28 @@ REXX_METHOD_PROTOTYPE(GrxToolbarRemoveSpace) REXX_METHOD_PROTOTYPE(GrxToolbarUnsetStyle) REXX_METHOD_PROTOTYPE(GrxToolbarSignalConnect) +REXX_METHOD_PROTOTYPE(GrxToolItemNew) +REXX_METHOD_PROTOTYPE(GrxToolItemSetHomogeneous) +REXX_METHOD_PROTOTYPE(GrxToolItemGetHomogeneous) +REXX_METHOD_PROTOTYPE(GrxToolItemSetExpand) +REXX_METHOD_PROTOTYPE(GrxToolItemGetExpand) +REXX_METHOD_PROTOTYPE(GrxToolItemSetTooltip) +REXX_METHOD_PROTOTYPE(GrxToolItemSetUseDragWindow) +REXX_METHOD_PROTOTYPE(GrxToolItemGetUseDragWindow) +REXX_METHOD_PROTOTYPE(GrxToolItemSetVisibleHorizontal) +REXX_METHOD_PROTOTYPE(GrxToolItemGetVisibleHorizontal) +REXX_METHOD_PROTOTYPE(GrxToolItemSetVisibleVertical) +REXX_METHOD_PROTOTYPE(GrxToolItemGetVisibleVertical) +REXX_METHOD_PROTOTYPE(GrxToolItemSetIsImportant) +REXX_METHOD_PROTOTYPE(GrxToolItemGetIsImportant) +REXX_METHOD_PROTOTYPE(GrxToolItemGetIconSize) +REXX_METHOD_PROTOTYPE(GrxToolItemGetOrientation) +REXX_METHOD_PROTOTYPE(GrxToolItemGetToolbarStyle) +REXX_METHOD_PROTOTYPE(GrxToolItemGetReliefStyle) +REXX_METHOD_PROTOTYPE(GrxToolItemRetrieveProxyMenuItem) +REXX_METHOD_PROTOTYPE(GrxToolItemGetProxyMenuItem) +REXX_METHOD_PROTOTYPE(GrxToolItemRebuildMenu) +REXX_METHOD_PROTOTYPE(GrxToolItemSignalConnect) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-02 18:58:16
|
Revision: 2516 http://oorexx.svn.sourceforge.net/oorexx/?rev=2516&view=rev Author: wdashley Date: 2008-06-02 11:57:25 -0700 (Mon, 02 Jun 2008) Log Message: ----------- ArtifactID: None Comment: Added the toolbutton class. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxtoolbutton.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-06-02 00:09:42 UTC (rev 2515) +++ sandbox/david/4x/Makefile 2008-06-02 18:57:25 UTC (rev 2516) @@ -82,7 +82,8 @@ grxaccelgroup.o \ grxstatusbar.o \ grxtoolbar.o \ - grxtoolitem.o + grxtoolitem.o \ + grxtoolbutton.o # Build the shared library @@ -202,8 +203,11 @@ grxtoolitem.o: grxtoolitem.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxtoolitem.cpp +grxtoolitem.o: grxtoolbutton.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxtoolbutton.cpp + clean: rm *.so *.o Added: sandbox/david/4x/grxtoolbutton.cpp =================================================================== --- sandbox/david/4x/grxtoolbutton.cpp (rev 0) +++ sandbox/david/4x/grxtoolbutton.cpp 2008-06-02 18:57:25 UTC (rev 2516) @@ -0,0 +1,385 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + +static void signal_func_0(GtkWidget *toolitem, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(toolitem), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + context->SendMessage0(rxobj, ((cbcb *)data)->signal_name); + context->DetachThread(); + return; +} + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create an tool button. + * + * @param label The button label + * + * @return Zero. + **/ +RexxMethod3(int, // Return type + GrxToolButtonNew, // Object_method name + OSELF, self, // Self + RexxObjectPtr, icon, // Icon widget + CSTRING, label) // Button label text +{ + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + GtkToolItem *toolitem; + + toolitem = gtk_tool_button_new(iconWidget, label); + + context->SetObjectVariable("!POINTER", context->NewPointer(toolitem)); + g_object_set_data(G_OBJECT(toolitem), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: init + * + * Create an tool button from stock. + * + * @param id The stockid + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxToolButtonNewFronStock, // Object_method name + OSELF, self, // Self + CSTRING, id) // Button label text +{ + GtkToolItem *toolitem; + + toolitem = gtk_tool_button_new_from_stock(id); + + context->SetObjectVariable("!POINTER", context->NewPointer(toolitem)); + g_object_set_data(G_OBJECT(toolitem), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: set_label + * + * Sets the button label. + * + * @param label The button label + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxToolButtonSetLabel, // Object_method name + CSTRING, label) // Button label text +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + gtk_tool_button_set_label(myWidget, label); + + return 0; +} + +/** + * Method: get_label + * + * Gets the button label. + * + * @return Label + **/ +RexxMethod0(CSTRING, // Return type + GrxToolButtonGetLabel) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + return gtk_tool_button_get_label(myWidget); +} + +/** + * Method: set_use_underline + * + * Sets the accelerator key.. + * + * @param flag The use underline boolean + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxToolButtonSetUseUnderline, // Object_method name + logical_t, flag) // Use underline boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + gtk_tool_button_set_use_underline(myWidget, flag); + + return 0; +} + +/** + * Method: get_use_underline + * + * Gets the use underline boolean. + * + * @return Flag + **/ +RexxMethod0(logical_t, // Return type + GrxToolButtonGetUseUnderline) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + return gtk_tool_button_get_use_underline(myWidget); +} + +/** + * Method: set_stock_id + * + * Sets the stock id. + * + * @param id The stock id + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxToolButtonSetStockId, // Object_method name + CSTRING, id) // The stock id +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + gtk_tool_button_set_stock_id(myWidget, id); + + return 0; +} + +/** + * Method: get_stock_id + * + * Gets the stock_id + * + * @return StockID string + **/ +RexxMethod0(CSTRING, // Return type + GrxToolButtonGetStockId) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + return gtk_tool_button_get_stock_id(myWidget); +} + +/** + * Method: set_icon_name + * + * Sets the icon name. + * + * @param name The icon name + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxToolButtonSetIconName, // Object_method name + CSTRING, name) // The icon name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + gtk_tool_button_set_icon_name(myWidget, name); + + return 0; +} + +/** + * Method: get_icon_name + * + * Gets the icon name. + * + * @return Icon name + **/ +RexxMethod0(CSTRING, // Return type + GrxToolButtonGetIconName) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + return gtk_tool_button_get_icon_name(myWidget); +} + +/** + * Method: set_icon_widget + * + * Sets the icon widget. + * + * @param name The icon widget. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxToolButtonSetIconWidget, // Object_method name + RexxObjectPtr, rxobj) // The icon widget +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + + gtk_tool_button_set_icon_widget(myWidget, iconWidget); + + return 0; +} + +/** + * Method: get_icon_widget + * + * Gets the icon widget. + * + * @return Icon widget + **/ +RexxMethod0(RexxObjectPtr, // Return type + GrxToolButtonGetIconWidget) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + GtkWidget *iconWidget = gtk_tool_button_get_icon_widget(myWidget); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(iconWidget), "OORXOBJECT"); +} + +/** + * Method: set_label_widget + * + * Sets the label widget. + * + * @param name The label widget. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxToolButtonSetLabelWidget, // Object_method name + RexxObjectPtr, rxobj) // The icon widget +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkWidget *labelWidget = (GtkWidget *)context->PointerValue(widgetptr); + + gtk_tool_button_set_label_widget(myWidget, labelWidget); + + return 0; +} + +/** + * Method: get_label_widget + * + * Gets the label widget. + * + * @return Label widget + **/ +RexxMethod0(RexxObjectPtr, // Return type + GrxToolButtonGetLabelWidget) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkToolButton *myWidget = (GtkToolButton *)context->PointerValue(rxptr); + + GtkWidget *labelWidget = gtk_tool_button_get_label_widget(myWidget); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(labelWidget), "OORXOBJECT"); +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxToolButtonSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "clicked") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_clicked"; + g_signal_connect(G_OBJECT(myWidget), "clicked", + G_CALLBACK(signal_func_0), cblock); + return context->True(); + } + return context->False(); +} + Property changes on: sandbox/david/4x/grxtoolbutton.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-06-02 00:09:42 UTC (rev 2515) +++ sandbox/david/4x/rexxgtk.cls 2008-06-02 18:57:25 UTC (rev 2516) @@ -2504,6 +2504,34 @@ /*============================================================================*/ +/* Class: GtkToolButton */ +/*============================================================================*/ + +::class GtkToolButton public subclass GtkToolItem + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxToolButtonNew" +::METHOD get_label EXTERNAL "LIBRARY rexxgtk GrxToolButtonGetLabel" +::METHOD set_label EXTERNAL "LIBRARY rexxgtk GrxToolButtonSetLabel" +::METHOD get_use_underline EXTERNAL "LIBRARY rexxgtk GrxToolButtonGetUseUnderline" +::METHOD set_use_underline EXTERNAL "LIBRARY rexxgtk GrxToolButtonSetUseUnderline" +::METHOD get_stock_id EXTERNAL "LIBRARY rexxgtk GrxToolButtonGetStockId" +::METHOD set_stock_id EXTERNAL "LIBRARY rexxgtk GrxToolButtonSetStockId" +::METHOD get_icon_name EXTERNAL "LIBRARY rexxgtk GrxToolButtonGetIconName" +::METHOD set_icon_name EXTERNAL "LIBRARY rexxgtk GrxToolButtonSetIconName" +::METHOD get_icon_widget EXTERNAL "LIBRARY rexxgtk GrxToolButtonGetIconWidget" +::METHOD set_icon_widget EXTERNAL "LIBRARY rexxgtk GrxToolButtonSetIconWidget" +::METHOD get_label_widget EXTERNAL "LIBRARY rexxgtk GrxToolButtonGetLabelWidget" +::METHOD set_label_widget EXTERNAL "LIBRARY rexxgtk GrxToolButtonSetLabelWidget" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxToolButtonSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_clicked +return + + +/*============================================================================*/ /* Class: GtkAccelGroup */ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-06-02 00:09:42 UTC (rev 2515) +++ sandbox/david/4x/rexxgtk.cpp 2008-06-02 18:57:25 UTC (rev 2516) @@ -794,6 +794,21 @@ REXX_METHOD(GrxToolItemGetProxyMenuItem, GrxToolItemGetProxyMenuItem), REXX_METHOD(GrxToolItemRebuildMenu, GrxToolItemRebuildMenu), REXX_METHOD(GrxToolItemSignalConnect, GrxToolItemSignalConnect), + REXX_METHOD(GrxToolButtonNew, GrxToolButtonNew), + REXX_METHOD(GrxToolButtonNewFromStock, GrxToolButtonNewFromStock), + REXX_METHOD(GrxToolButtonSetLabel, GrxToolButtonSetLabel), + REXX_METHOD(GrxToolButtonGetLabel, GrxToolButtonGetLabel), + REXX_METHOD(GrxToolButtonSetUseUnderline, GrxToolButtonSetUseUnderline), + REXX_METHOD(GrxToolButtonGetUseUnderline, GrxToolButtonGetUseUnderline), + REXX_METHOD(GrxToolButtonSetStockId, GrxToolButtonSetStockId), + REXX_METHOD(GrxToolButtonGetStockId, GrxToolButtonGetStockId), + REXX_METHOD(GrxToolButtonSetIconName, GrxToolButtonSetIconName), + REXX_METHOD(GrxToolButtonGetIconName, GrxToolButtonGetIconName), + REXX_METHOD(GrxToolButtonSetIconWidget, GrxToolButtonSetIconWidget), + REXX_METHOD(GrxToolButtonGetIconWidget, GrxToolButtonGetIconWidget), + REXX_METHOD(GrxToolButtonSetLabelWidget, GrxToolButtonSetLabelWidget), + REXX_METHOD(GrxToolButtonGetLabelWidget, GrxToolButtonGetLabelWidget), + REXX_METHOD(GrxToolButtonSignalConnect, GrxToolButtonSignalConnect), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-06-02 00:09:42 UTC (rev 2515) +++ sandbox/david/4x/rexxgtk.h 2008-06-02 18:57:25 UTC (rev 2516) @@ -561,6 +561,21 @@ REXX_METHOD_PROTOTYPE(GrxToolItemGetProxyMenuItem) REXX_METHOD_PROTOTYPE(GrxToolItemRebuildMenu) REXX_METHOD_PROTOTYPE(GrxToolItemSignalConnect) +REXX_METHOD_PROTOTYPE(GrxToolButtonNew) +REXX_METHOD_PROTOTYPE(GrxToolButtonNewFromStock) +REXX_METHOD_PROTOTYPE(GrxToolButtonSetLabel) +REXX_METHOD_PROTOTYPE(GrxToolButtonGetLabel) +REXX_METHOD_PROTOTYPE(GrxToolButtonSetUseUnderline) +REXX_METHOD_PROTOTYPE(GrxToolButtonGetUseUnderline) +REXX_METHOD_PROTOTYPE(GrxToolButtonSetStockId) +REXX_METHOD_PROTOTYPE(GrxToolButtonGetStockId) +REXX_METHOD_PROTOTYPE(GrxToolButtonSetIconName) +REXX_METHOD_PROTOTYPE(GrxToolButtonGetIconName) +REXX_METHOD_PROTOTYPE(GrxToolButtonSetIconWidget) +REXX_METHOD_PROTOTYPE(GrxToolButtonGetIconWidget) +REXX_METHOD_PROTOTYPE(GrxToolButtonSetLabelWidget) +REXX_METHOD_PROTOTYPE(GrxToolButtonGetLabelWidget) +REXX_METHOD_PROTOTYPE(GrxToolButtonSignalConnect) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-02 19:21:03
|
Revision: 2517 http://oorexx.svn.sourceforge.net/oorexx/?rev=2517&view=rev Author: wdashley Date: 2008-06-02 12:21:04 -0700 (Mon, 02 Jun 2008) Log Message: ----------- ArtifactID: None Comment: Added the separatortoolitem class and adjusted the toolbutton class. Modified Paths: -------------- sandbox/david/4x/grxtoolbutton.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Modified: sandbox/david/4x/grxtoolbutton.cpp =================================================================== --- sandbox/david/4x/grxtoolbutton.cpp 2008-06-02 18:57:25 UTC (rev 2516) +++ sandbox/david/4x/grxtoolbutton.cpp 2008-06-02 19:21:04 UTC (rev 2517) @@ -103,30 +103,6 @@ } /** - * Method: init - * - * Create an tool button from stock. - * - * @param id The stockid - * - * @return Zero. - **/ -RexxMethod2(int, // Return type - GrxToolButtonNewFronStock, // Object_method name - OSELF, self, // Self - CSTRING, id) // Button label text -{ - GtkToolItem *toolitem; - - toolitem = gtk_tool_button_new_from_stock(id); - - context->SetObjectVariable("!POINTER", context->NewPointer(toolitem)); - g_object_set_data(G_OBJECT(toolitem), "OORXOBJECT", self); - - return 0; -} - -/** * Method: set_label * * Sets the button label. @@ -383,3 +359,61 @@ return context->False(); } +/** + * Method: init + * + * Create an tool button separator. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxSeparatorToolItemNew, // Object_method name + OSELF, self) // Self +{ + GtkToolItem *toolitem; + + toolitem = gtk_separator_tool_item_new(); + + context->SetObjectVariable("!POINTER", context->NewPointer(toolitem)); + g_object_set_data(G_OBJECT(toolitem), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: set_draw + * + * Sets the fraw flag. + * + * @param flag The draw boolean + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxSeparatorToolItemSetDraw, // Object_method name + logical_t, flag) // The draw boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkSeparatorToolItem *myWidget = (GtkSeparatorToolItem *)context->PointerValue(rxptr); + + gtk_separator_tool_item_set_draw(myWidget, flag); + + return 0; +} + +/** + * Method: get_draw + * + * Gets the draw flag. + * + * @return Draw boolean + **/ +RexxMethod0(logical_t, // Return type + GrxSeparatorToolItemGetDraw) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkSeparatorToolItem *myWidget = (GtkSeparatorToolItem *)context->PointerValue(rxptr); + + return gtk_separator_tool_item_get_draw(myWidget); +} + Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-06-02 18:57:25 UTC (rev 2516) +++ sandbox/david/4x/rexxgtk.cls 2008-06-02 19:21:04 UTC (rev 2517) @@ -2509,6 +2509,12 @@ ::class GtkToolButton public subclass GtkToolItem +::METHOD new_from_stock class +use strict arg id +obj = .GtkToolButton~new(.nil, .nil) +obj~set_stock_id(id) +return obj + ::METHOD init EXTERNAL "LIBRARY rexxgtk GrxToolButtonNew" ::METHOD get_label EXTERNAL "LIBRARY rexxgtk GrxToolButtonGetLabel" ::METHOD set_label EXTERNAL "LIBRARY rexxgtk GrxToolButtonSetLabel" @@ -2532,6 +2538,17 @@ /*============================================================================*/ +/* Class: GtkToolButton */ +/*============================================================================*/ + +::class GtkSeparatorToolItem public subclass GtkToolItem + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxSeparatorToolItemNew" +::METHOD set_draw EXTERNAL "LIBRARY rexxgtk GrxSeparatorToolItemSetDraw" +::METHOD get_draw EXTERNAL "LIBRARY rexxgtk GrxSeparatorToolItemGetDraw" + + +/*============================================================================*/ /* Class: GtkAccelGroup */ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-06-02 18:57:25 UTC (rev 2516) +++ sandbox/david/4x/rexxgtk.cpp 2008-06-02 19:21:04 UTC (rev 2517) @@ -795,7 +795,6 @@ REXX_METHOD(GrxToolItemRebuildMenu, GrxToolItemRebuildMenu), REXX_METHOD(GrxToolItemSignalConnect, GrxToolItemSignalConnect), REXX_METHOD(GrxToolButtonNew, GrxToolButtonNew), - REXX_METHOD(GrxToolButtonNewFromStock, GrxToolButtonNewFromStock), REXX_METHOD(GrxToolButtonSetLabel, GrxToolButtonSetLabel), REXX_METHOD(GrxToolButtonGetLabel, GrxToolButtonGetLabel), REXX_METHOD(GrxToolButtonSetUseUnderline, GrxToolButtonSetUseUnderline), @@ -809,6 +808,9 @@ REXX_METHOD(GrxToolButtonSetLabelWidget, GrxToolButtonSetLabelWidget), REXX_METHOD(GrxToolButtonGetLabelWidget, GrxToolButtonGetLabelWidget), REXX_METHOD(GrxToolButtonSignalConnect, GrxToolButtonSignalConnect), + REXX_METHOD(GrxSeparatorToolItemNew, GrxSeparatorToolItemNew), + REXX_METHOD(GrxSeparatorToolItemSetDraw, GrxSeparatorToolItemSetDraw), + REXX_METHOD(GrxSeparatorToolItemGetDraw, GrxSeparatorToolItemGetDraw), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-06-02 18:57:25 UTC (rev 2516) +++ sandbox/david/4x/rexxgtk.h 2008-06-02 19:21:04 UTC (rev 2517) @@ -562,7 +562,6 @@ REXX_METHOD_PROTOTYPE(GrxToolItemRebuildMenu) REXX_METHOD_PROTOTYPE(GrxToolItemSignalConnect) REXX_METHOD_PROTOTYPE(GrxToolButtonNew) -REXX_METHOD_PROTOTYPE(GrxToolButtonNewFromStock) REXX_METHOD_PROTOTYPE(GrxToolButtonSetLabel) REXX_METHOD_PROTOTYPE(GrxToolButtonGetLabel) REXX_METHOD_PROTOTYPE(GrxToolButtonSetUseUnderline) @@ -576,6 +575,9 @@ REXX_METHOD_PROTOTYPE(GrxToolButtonSetLabelWidget) REXX_METHOD_PROTOTYPE(GrxToolButtonGetLabelWidget) REXX_METHOD_PROTOTYPE(GrxToolButtonSignalConnect) +REXX_METHOD_PROTOTYPE(GrxSeparatorToolItemNew) +REXX_METHOD_PROTOTYPE(GrxSeparatorToolItemSetDraw) +REXX_METHOD_PROTOTYPE(GrxSeparatorToolItemGetDraw) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-03 14:39:34
|
Revision: 2519 http://oorexx.svn.sourceforge.net/oorexx/?rev=2519&view=rev Author: wdashley Date: 2008-06-03 07:39:23 -0700 (Tue, 03 Jun 2008) Log Message: ----------- ArtifactID: None Comment: Added the menutoolbutton class. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h sandbox/david/4x/test9-6.rex Added Paths: ----------- sandbox/david/4x/grxmenutoolbutton.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-06-03 00:35:41 UTC (rev 2518) +++ sandbox/david/4x/Makefile 2008-06-03 14:39:23 UTC (rev 2519) @@ -83,7 +83,8 @@ grxstatusbar.o \ grxtoolbar.o \ grxtoolitem.o \ - grxtoolbutton.o + grxtoolbutton.o \ + grxmenutoolbutton.o # Build the shared library @@ -203,11 +204,14 @@ grxtoolitem.o: grxtoolitem.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxtoolitem.cpp -grxtoolitem.o: grxtoolbutton.cpp rexxgtk.h +grxtoolbutton.o: grxtoolbutton.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxtoolbutton.cpp +grxmenutoolbutton.o: grxmenutoolbutton.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxmenutoolbutton.cpp + clean: rm *.so *.o Added: sandbox/david/4x/grxmenutoolbutton.cpp =================================================================== --- sandbox/david/4x/grxmenutoolbutton.cpp (rev 0) +++ sandbox/david/4x/grxmenutoolbutton.cpp 2008-06-03 14:39:23 UTC (rev 2519) @@ -0,0 +1,202 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + +static void signal_func_0(GtkWidget *toolitem, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(toolitem), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + context->SendMessage0(rxobj, ((cbcb *)data)->signal_name); + context->DetachThread(); + return; +} + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create an tool button. + * + * @param label The button label + * + * @return Zero. + **/ +RexxMethod3(int, // Return type + GrxMenuToolButtonNew, // Object_method name + OSELF, self, // Self + RexxObjectPtr, icon, // Icon widget + CSTRING, label) // Button label text +{ + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(icon, "POINTER"); + GtkWidget *iconWidget = (GtkWidget *)context->PointerValue(widgetptr); + GtkToolItem *toolitem; + + toolitem = gtk_menu_tool_button_new(iconWidget, label); + + context->SetObjectVariable("!POINTER", context->NewPointer(toolitem)); + g_object_set_data(G_OBJECT(toolitem), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: set_menu + * + * Sets the menu. + * + * @param menu The menu + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxToolButtonSetMenu, // Object_method name + RexxObjectPtr, rxobj) // The icon widget +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuToolButton *myWidget = (GtkMenuToolButton *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkWidget *menuWidget = (GtkWidget *)context->PointerValue(widgetptr); + + gtk_menu_tool_button_set_menu(myWidget, menuWidget); + + return 0; +} + +/** + * Method: get_menu + * + * Gets the menu. + * + * @return Icon widget + **/ +RexxMethod0(RexxObjectPtr, // Return type + GrxMenuToolButtonGetMenu) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuToolButton *myWidget = (GtkMenuToolButton *)context->PointerValue(rxptr); + + GtkWidget *menuWidget = gtk_menu_tool_button_get_menu(myWidget); + return (RexxObjectPtr)g_object_get_data(G_OBJECT(menuWidget), "OORXOBJECT"); +} + +/** + * Method: set_arrow_tooltip + * + * Sets the arrow tooltip. + * + * @param tt The tooltip + * + * @param text The tooltip text + * + * @param ptext The tooltip private text + * + * @return Zero. + **/ +RexxMethod3(int, // Return type + GrxToolButtonSetArrowTooltip, // Object_method name + RexxObjectPtr, rxobj, // The tooltip + CSTRING, text, // The tooltip text + CSTRING, ptext) // The tooltip private text +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkMenuToolButton *myWidget = (GtkMenuToolButton *)context->PointerValue(rxptr); + RexxPointerObject widgetptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkTooltips *ttWidget = (GtkTooltips *)context->PointerValue(widgetptr); + + gtk_menu_tool_button_set_arrow_tooltip(myWidget, ttWidget, text, ptext); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxMenuToolButtonSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "show_menu") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_show_menu"; + g_signal_connect(G_OBJECT(myWidget), "show-menu", + G_CALLBACK(signal_func_0), cblock); + return context->True(); + } + return context->False(); +} + Property changes on: sandbox/david/4x/grxmenutoolbutton.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-06-03 00:35:41 UTC (rev 2518) +++ sandbox/david/4x/rexxgtk.cls 2008-06-03 14:39:23 UTC (rev 2519) @@ -2538,6 +2538,31 @@ /*============================================================================*/ +/* Class: GtkMenuToolButton */ +/*============================================================================*/ + +::class GtkMenuToolButton public subclass GtkToolButton + +::METHOD new_from_stock class +use strict arg id +obj = .GtkMenuToolButton~new(.nil, .nil) +obj~set_stock_id(id) +return obj + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxMenuToolButtonNew" +::METHOD get_menu EXTERNAL "LIBRARY rexxgtk GrxMenuToolButtonGetMenu" +::METHOD set_menu EXTERNAL "LIBRARY rexxgtk GrxMenuToolButtonSetMenu" +::METHOD set_arrow_tooltip EXTERNAL "LIBRARY rexxgtk GrxMenuToolButtonSetArrowTooltip" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxMenuToolButtonSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_show_menu +return + + +/*============================================================================*/ /* Class: GtkToolButton */ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-06-03 00:35:41 UTC (rev 2518) +++ sandbox/david/4x/rexxgtk.cpp 2008-06-03 14:39:23 UTC (rev 2519) @@ -811,6 +811,11 @@ REXX_METHOD(GrxSeparatorToolItemNew, GrxSeparatorToolItemNew), REXX_METHOD(GrxSeparatorToolItemSetDraw, GrxSeparatorToolItemSetDraw), REXX_METHOD(GrxSeparatorToolItemGetDraw, GrxSeparatorToolItemGetDraw), + REXX_METHOD(GrxMenuToolButtonNew, GrxMenuToolButtonNew), + REXX_METHOD(GrxMenuToolButtonSetMenu, GrxMenuToolButtonSetMenu), + REXX_METHOD(GrxMenuToolButtonGetMenu, GrxMenuToolButtonGetMenu), + REXX_METHOD(GrxMenuToolButtonSetArrowTooltip, GrxMenuToolButtonSetArrowTooltip), + REXX_METHOD(GrxMenuToolButtonSignalConnect, GrxMenuToolButtonSignalConnect), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-06-03 00:35:41 UTC (rev 2518) +++ sandbox/david/4x/rexxgtk.h 2008-06-03 14:39:23 UTC (rev 2519) @@ -578,6 +578,11 @@ REXX_METHOD_PROTOTYPE(GrxSeparatorToolItemNew) REXX_METHOD_PROTOTYPE(GrxSeparatorToolItemSetDraw) REXX_METHOD_PROTOTYPE(GrxSeparatorToolItemGetDraw) +REXX_METHOD_PROTOTYPE(GrxMenuToolButtonNew) +REXX_METHOD_PROTOTYPE(GrxMenuToolButtonSetMenu) +REXX_METHOD_PROTOTYPE(GrxMenuToolButtonGetMenu) +REXX_METHOD_PROTOTYPE(GrxMenuToolButtonSetArrowTooltip) +REXX_METHOD_PROTOTYPE(GrxMenuToolButtonSignalConnect) #endif /* REXXGTK_H */ Modified: sandbox/david/4x/test9-6.rex =================================================================== --- sandbox/david/4x/test9-6.rex 2008-06-03 00:35:41 UTC (rev 2518) +++ sandbox/david/4x/test9-6.rex 2008-06-03 14:39:23 UTC (rev 2519) @@ -74,25 +74,25 @@ ::class myCut subclass .GtkToolItem :method signal_clicked -entry~cut_clipboard() +self~user_data~cut_clipboard() return ::class myCopy subclass .GtkToolItem :method signal_clicked -entry~copy_clipboard() +self~user_data~copy_clipboard() return ::class myPaste subclass .GtkToolItem :method signal_clicked -entry~paste_clipboard() +self~user_data~paste_clipboard() return ::class mySelectall subclass .GtkToolItem :method signal_clicked -entry~select_region(self~user_data, 0, -1) +self~user_data~select_region(self~user_data, 0, -1) return ::routine create_toolbar @@ -113,6 +113,12 @@ toolbar~insert(separator, 3) toolbar~insert(selectall, 4) +-- save user data for the callbacks +cut~user_data = entry +copy~user_data = entry +paste~user_data = entry +selectall~user_data = entry + cut~signal_connect('clicked') copy~signal_connect('clicked') paste~signal_connect('clicked') This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-04 14:02:46
|
Revision: 2520 http://oorexx.svn.sourceforge.net/oorexx/?rev=2520&view=rev Author: wdashley Date: 2008-06-04 07:02:22 -0700 (Wed, 04 Jun 2008) Log Message: ----------- ArtifactID: None Comment: Added the cellrenderertext class. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxcellrenderer.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-06-03 14:39:23 UTC (rev 2519) +++ sandbox/david/4x/Makefile 2008-06-04 14:02:22 UTC (rev 2520) @@ -84,7 +84,8 @@ grxtoolbar.o \ grxtoolitem.o \ grxtoolbutton.o \ - grxmenutoolbutton.o + grxmenutoolbutton.o \ + grxcellrenderer.o # Build the shared library @@ -210,8 +211,11 @@ grxmenutoolbutton.o: grxmenutoolbutton.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxmenutoolbutton.cpp +grxcellrenderer.o: grxcellrenderer.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxcellrenderer.cpp + clean: rm *.so *.o Added: sandbox/david/4x/grxcellrenderer.cpp =================================================================== --- sandbox/david/4x/grxcellrenderer.cpp (rev 0) +++ sandbox/david/4x/grxcellrenderer.cpp 2008-06-04 14:02:22 UTC (rev 2520) @@ -0,0 +1,135 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + +static void signal_func_2(GtkCellRenderer *renderer, + gchar *arg1, + gchar *arg2, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(renderer), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxObjectPtr tempobj1 = context->NewStringFromAsciiz(arg2);; + RexxObjectPtr tempobj2 = context->NewStringFromAsciiz(arg2);; + context->SendMessage2(rxobj, ((cbcb *)data)->signal_name, tempobj1, tempobj2); + context->DetachThread(); + return; +} + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create a renderer object. + * + * @param child The child item + * + * @param pos The position + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxCellRendererTextNew, // Object_method name + OSELF, self) // Self +{ + GtkCellRenderer *myRenderer; + + myRenderer = gtk_cell_renderer_text_new(); + context->SetObjectVariable("!POINTER", context->NewPointer(myRenderer)); + g_object_set_data(G_OBJECT(myRenderer), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxCellRendererTextSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "edited") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_edited"; + g_signal_connect(G_OBJECT(myWidget), "edited", + G_CALLBACK(signal_func_2), cblock); + return context->True(); + } + return context->False(); +} + Property changes on: sandbox/david/4x/grxcellrenderer.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-06-03 14:39:23 UTC (rev 2519) +++ sandbox/david/4x/rexxgtk.cls 2008-06-04 14:02:22 UTC (rev 2520) @@ -2618,8 +2618,29 @@ /*============================================================================*/ +/* Class: GtkCellRendererText */ /*============================================================================*/ + +::class GtkCellRendererText public + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxCellRendererTextNew" + +::method pointer +expose !pointer +return !pointer + +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxCellRendererTextSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_edited +return + + /*============================================================================*/ +/*============================================================================*/ +/*============================================================================*/ /* These are classes and routines specific to Glib. */ /*============================================================================*/ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-06-03 14:39:23 UTC (rev 2519) +++ sandbox/david/4x/rexxgtk.cpp 2008-06-04 14:02:22 UTC (rev 2520) @@ -816,6 +816,8 @@ REXX_METHOD(GrxMenuToolButtonGetMenu, GrxMenuToolButtonGetMenu), REXX_METHOD(GrxMenuToolButtonSetArrowTooltip, GrxMenuToolButtonSetArrowTooltip), REXX_METHOD(GrxMenuToolButtonSignalConnect, GrxMenuToolButtonSignalConnect), + REXX_METHOD(GrxCellRendererTextNew, GrxCellRendererTextNew), + REXX_METHOD(GrxCellRendererTextSignalConnect, GrxCellRendererTextSignalConnect), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-06-03 14:39:23 UTC (rev 2519) +++ sandbox/david/4x/rexxgtk.h 2008-06-04 14:02:22 UTC (rev 2520) @@ -583,6 +583,8 @@ REXX_METHOD_PROTOTYPE(GrxMenuToolButtonGetMenu) REXX_METHOD_PROTOTYPE(GrxMenuToolButtonSetArrowTooltip) REXX_METHOD_PROTOTYPE(GrxMenuToolButtonSignalConnect) +REXX_METHOD_PROTOTYPE(GrxCellRendererTextNew) +REXX_METHOD_PROTOTYPE(GrxCellRendererTextSignalConnect) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-05 14:46:16
|
Revision: 2521 http://oorexx.svn.sourceforge.net/oorexx/?rev=2521&view=rev Author: wdashley Date: 2008-06-05 07:45:33 -0700 (Thu, 05 Jun 2008) Log Message: ----------- ArtifactID: None Comment: Implemented the balance of the CellRenderer classes. Modified Paths: -------------- sandbox/david/4x/grxcellrenderer.cpp sandbox/david/4x/grxtoolitem.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Modified: sandbox/david/4x/grxcellrenderer.cpp =================================================================== --- sandbox/david/4x/grxcellrenderer.cpp 2008-06-04 14:02:22 UTC (rev 2520) +++ sandbox/david/4x/grxcellrenderer.cpp 2008-06-05 14:45:33 UTC (rev 2521) @@ -57,6 +57,34 @@ /* Private Functions */ /*============================================================================*/ +static void signal_func_0(GtkCellRenderer *renderer, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(renderer), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + context->SendMessage0(rxobj, ((cbcb *)data)->signal_name); + context->DetachThread(); + return; +} + +static void signal_func_1(GtkCellRenderer *renderer, + gchar *arg1, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(renderer), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + RexxObjectPtr tempobj1 = context->NewStringFromAsciiz(arg1);; + context->SendMessage1(rxobj, ((cbcb *)data)->signal_name, tempobj1); + context->DetachThread(); + return; +} + static void signal_func_2(GtkCellRenderer *renderer, gchar *arg1, gchar *arg2, @@ -65,7 +93,6 @@ cbcb *cblock = (cbcb *)data; RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(renderer), "OORXOBJECT"); RexxThreadContext *context; - gboolean retc; cblock->instance->AttachThread(&context); RexxObjectPtr tempobj1 = context->NewStringFromAsciiz(arg2);; @@ -75,22 +102,122 @@ return; } +static void signal_func_2a(GtkCellRenderer *renderer, + GtkCellEditable *arg1, + gchar *arg2, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(renderer), "OORXOBJECT"); + RexxThreadContext *context; + cblock->instance->AttachThread(&context); + RexxObjectPtr tempobj1 = (RexxObjectPtr)g_object_get_data(G_OBJECT(arg1), "OORXOBJECT"); + RexxObjectPtr tempobj2 = context->NewStringFromAsciiz(arg2);; + context->SendMessage2(rxobj, ((cbcb *)data)->signal_name, tempobj1, tempobj2); + context->DetachThread(); + return; +} + +static void signal_func_4(GtkCellRenderer *renderer, + gchar *arg1, + gint arg2, + gint arg3, + guint arg4, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(renderer), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = context->NewStringFromAsciiz(arg1); + context->ArrayPut(arr, tempobj, 1); + tempobj = context->NumberToObject((wholenumber_t)arg2);; + context->ArrayPut(arr, tempobj, 2); + tempobj = context->NumberToObject((wholenumber_t)arg3);; + context->ArrayPut(arr, tempobj, 3); + tempobj = context->UnsignedNumberToObject((size_t)arg4);; + context->ArrayPut(arr, tempobj, 4); + context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->DetachThread(); + return; +} + + /*============================================================================*/ /* Public Functions */ /*============================================================================*/ /** - * Method: init + * Method: set_fixed_size * - * Create a renderer object. + * Sets a fixed size for the renderer object. * - * @param child The child item + * @param width The width * - * @param pos The position + * @param height The height * * @return Zero **/ +RexxMethod2(int, // Return type + GrxCellRendererSetFixedSize, // Object_method name + int, width, // Width + int, height) // Height +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkCellRenderer *myWidget = (GtkCellRenderer *)context->PointerValue(rxptr); + + gtk_cell_renderer_set_fixed_size(myWidget, width, height); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxCellRendererSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "editing_canceled") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_editing_canceled"; + g_signal_connect(G_OBJECT(myWidget), "editing-canceled", + G_CALLBACK(signal_func_0), cblock); + return context->True(); + } + else if (strcmp(name, "editing_started") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_editing_started"; + g_signal_connect(G_OBJECT(myWidget), "editing-started", + G_CALLBACK(signal_func_2a), cblock); + return context->True(); + } + return context->False(); +} + +/** + * Method: init + * + * Create a cell renderer text object. + * + * @return Zero + **/ RexxMethod1(int, // Return type GrxCellRendererTextNew, // Object_method name OSELF, self) // Self @@ -130,6 +257,275 @@ G_CALLBACK(signal_func_2), cblock); return context->True(); } - return context->False(); + return context->SendSuperMessage("signal_connect", args); } +/** + * Method: init + * + * Create a cell renderer pixbuf object. + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxCellRendererPixbufNew, // Object_method name + OSELF, self) // Self +{ + GtkCellRenderer *myRenderer; + + myRenderer = gtk_cell_renderer_pixbuf_new(); + context->SetObjectVariable("!POINTER", context->NewPointer(myRenderer)); + g_object_set_data(G_OBJECT(myRenderer), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: init + * + * Create a cell renderer progress object. + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxCellRendererProgressNew, // Object_method name + OSELF, self) // Self +{ + GtkCellRenderer *myRenderer; + + myRenderer = gtk_cell_renderer_progress_new(); + context->SetObjectVariable("!POINTER", context->NewPointer(myRenderer)); + g_object_set_data(G_OBJECT(myRenderer), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: init + * + * Create a cell renderer toggle object. + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxCellRendererToggleNew, // Object_method name + OSELF, self) // Self +{ + GtkCellRenderer *myRenderer; + + myRenderer = gtk_cell_renderer_toggle_new(); + context->SetObjectVariable("!POINTER", context->NewPointer(myRenderer)); + g_object_set_data(G_OBJECT(myRenderer), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: set_radio + * + * Make the toggle a radio button. + * + * @param flag The radio boolean + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxCellRendererToggleSetRadio, // Object_method name + logical_t, flag) // Radio boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkCellRendererToggle *myWidget = (GtkCellRendererToggle *)context->PointerValue(rxptr); + + gtk_cell_renderer_toggle_set_radio(myWidget, flag); + + return 0; +} + +/** + * Method: get_radio + * + * Get the toggle a radio button. + * + * @return Boolean flag + **/ +RexxMethod0(int, // Return type + GrxCellRendererToggleGetRadio) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkCellRendererToggle *myWidget = (GtkCellRendererToggle *)context->PointerValue(rxptr); + + return gtk_cell_renderer_toggle_get_radio(myWidget); +} + +/** + * Method: set_active + * + * Make the toggle active. + * + * @param flag The active boolean + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxCellRendererToggleSetActive, // Object_method name + logical_t, flag) // Radio boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkCellRendererToggle *myWidget = (GtkCellRendererToggle *)context->PointerValue(rxptr); + + gtk_cell_renderer_toggle_set_active(myWidget, flag); + + return 0; +} + +/** + * Method: get_active + * + * Get the toggle active boolean. + * + * @return Boolean flag + **/ +RexxMethod0(int, // Return type + GrxCellRendererToggleGetActive) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkCellRendererToggle *myWidget = (GtkCellRendererToggle *)context->PointerValue(rxptr); + + return gtk_cell_renderer_toggle_get_active(myWidget); +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxCellRendererToggleSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "toggled") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_toggled"; + g_signal_connect(G_OBJECT(myWidget), "toggled", + G_CALLBACK(signal_func_1), cblock); + return context->True(); + } + return context->SendSuperMessage("signal_connect", args); +} + +/** + * Method: init + * + * Create a cell renderer accel object. + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxCellRendererAccelNew, // Object_method name + OSELF, self) // Self +{ + GtkCellRenderer *myRenderer; + + myRenderer = gtk_cell_renderer_accel_new(); + context->SetObjectVariable("!POINTER", context->NewPointer(myRenderer)); + g_object_set_data(G_OBJECT(myRenderer), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxCellRendererAccelSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "accel_cleared") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_accel_cleared"; + g_signal_connect(G_OBJECT(myWidget), "accel-cleared", + G_CALLBACK(signal_func_1), cblock); + return context->True(); + } + else if (strcmp(name, "accel_edited") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_accel_edited"; + g_signal_connect(G_OBJECT(myWidget), "accel-edited", + G_CALLBACK(signal_func_4), cblock); + return context->True(); + } + return context->SendSuperMessage("signal_connect", args); +} + +/** + * Method: init + * + * Create a cell renderer combo object. + * + * @return Zero + **/ +RexxMethod1(int, // Return type + GrxCellRendererComboNew, // Object_method name + OSELF, self) // Self +{ + GtkCellRenderer *myRenderer; + + myRenderer = gtk_cell_renderer_combo_new(); + context->SetObjectVariable("!POINTER", context->NewPointer(myRenderer)); + g_object_set_data(G_OBJECT(myRenderer), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxCellRendererComboSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "changed") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_changed"; + g_signal_connect(G_OBJECT(myWidget), "changed", + G_CALLBACK(signal_func_2a), cblock); + return context->True(); + } + return context->SendSuperMessage("signal_connect", args); +} + Modified: sandbox/david/4x/grxtoolitem.cpp =================================================================== --- sandbox/david/4x/grxtoolitem.cpp 2008-06-04 14:02:22 UTC (rev 2520) +++ sandbox/david/4x/grxtoolitem.cpp 2008-06-05 14:45:33 UTC (rev 2521) @@ -100,9 +100,9 @@ RexxArrayObject arr = context->NewArray(1); RexxObjectPtr tempobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(arg1), "OORXOBJECT"); context->ArrayPut(arr, tempobj, 1); - tempobj = context->NewStringFromAsciiz(arg2);; + tempobj = context->NewStringFromAsciiz(arg2); context->ArrayPut(arr, tempobj, 2); - tempobj = context->NewStringFromAsciiz(arg3);; + tempobj = context->NewStringFromAsciiz(arg3); context->ArrayPut(arr, tempobj, 2); tempobj = context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); context->ObjectToNumber(tempobj, &retc); Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-06-04 14:02:22 UTC (rev 2520) +++ sandbox/david/4x/rexxgtk.cls 2008-06-05 14:45:33 UTC (rev 2521) @@ -2618,17 +2618,33 @@ /*============================================================================*/ +/* Class: GtkCellRenderer */ +/* Note: This is strictly a base class. It should never be instantiated on */ +/* its own. You should instantiate one of its subclasses instead. */ +/*============================================================================*/ + +::class GtkCellRenderer public + +::METHOD set_fixed_size EXTERNAL "LIBRARY rexxgtk GrxCellRendererSetFixedSize" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxCellRendererSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_editing_canceled +return + +::method signal_editing_started +return + + +/*============================================================================*/ /* Class: GtkCellRendererText */ /*============================================================================*/ -::class GtkCellRendererText public +::class GtkCellRendererText public subclass GtkCellRenderer ::METHOD init EXTERNAL "LIBRARY rexxgtk GrxCellRendererTextNew" - -::method pointer -expose !pointer -return !pointer - ::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxCellRendererTextSignalConnect" -- The following are the methods that can be connected to signals. By default @@ -2639,8 +2655,90 @@ /*============================================================================*/ +/* Class: GtkCellRendererPixbuf */ /*============================================================================*/ + +::class GtkCellRendererPixbuf public subclass GtkCellRenderer + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxCellRendererPixbufNew" + + /*============================================================================*/ +/* Class: GtkCellRendererProgress */ +/*============================================================================*/ + +::class GtkCellRendererProgress public subclass GtkCellRenderer + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxCellRendererProgressNew" + + +/*============================================================================*/ +/* Class: GtkCellRendererToggle */ +/*============================================================================*/ + +::class GtkCellRendererToggle public subclass GtkCellRenderer + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxCellRendererToggleNew" +::METHOD set_radio EXTERNAL "LIBRARY rexxgtk GrxCellRendererToggleSetRadio" +::METHOD get_radio EXTERNAL "LIBRARY rexxgtk GrxCellRendererToggleGetRadio" +::METHOD set_active EXTERNAL "LIBRARY rexxgtk GrxCellRendererToggleSetActive" +::METHOD get_active EXTERNAL "LIBRARY rexxgtk GrxCellRendererToggleGetActive" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxCellRendererToggleSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_toggled +return + + +/*============================================================================*/ +/* Class: GtkCellRendererAccel */ +/*============================================================================*/ + +::class GtkCellRendererAccel public subclass GtkCellRendererText + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxCellRendererAccelNew" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxCellRendererAccelSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_accel_cleared +return + +::method signal_accel_edited +return + + +/*============================================================================*/ +/* Class: GtkCellRendererCombo */ +/*============================================================================*/ + +::class GtkCellRendererCombo public subclass GtkCellRendererText + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxCellRendererComboNew" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxCellRendererComboSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_accel_changed +return + + +/*============================================================================*/ +/* Class: GtkCellRendererSpin */ +/*============================================================================*/ + +::class GtkCellRendererSpin public subclass GtkCellRendererText + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxCellRendererSpinNew" + + +/*============================================================================*/ +/*============================================================================*/ +/*============================================================================*/ /* These are classes and routines specific to Glib. */ /*============================================================================*/ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-06-04 14:02:22 UTC (rev 2520) +++ sandbox/david/4x/rexxgtk.cpp 2008-06-05 14:45:33 UTC (rev 2521) @@ -816,8 +816,23 @@ REXX_METHOD(GrxMenuToolButtonGetMenu, GrxMenuToolButtonGetMenu), REXX_METHOD(GrxMenuToolButtonSetArrowTooltip, GrxMenuToolButtonSetArrowTooltip), REXX_METHOD(GrxMenuToolButtonSignalConnect, GrxMenuToolButtonSignalConnect), + REXX_METHOD(GrxCellRendererSetFixedSize, GrxCellRendererSetFixedSize), + REXX_METHOD(GrxCellRendererSignalConnect, GrxCellRendererSignalConnect), REXX_METHOD(GrxCellRendererTextNew, GrxCellRendererTextNew), REXX_METHOD(GrxCellRendererTextSignalConnect, GrxCellRendererTextSignalConnect), + REXX_METHOD(GrxCellRendererPixbufNew, GrxCellRendererPixbufNew), + REXX_METHOD(GrxCellRendererProgressNew, GrxCellRendererProgressNew), + REXX_METHOD(GrxCellRendererToggleNew, GrxCellRendererToggleNew), + REXX_METHOD(GrxCellRendererToggleSetRadio, GrxCellRendererToggleSetRadio), + REXX_METHOD(GrxCellRendererToggleGetRadio, GrxCellRendererToggleGetRadio), + REXX_METHOD(GrxCellRendererToggleSetActive, GrxCellRendererToggleSetActive), + REXX_METHOD(GrxCellRendererToggleGetActive, GrxCellRendererToggleGetActive), + REXX_METHOD(GrxCellRendererToggleSignalConnect, GrxCellRendererToggleSignalConnect), + REXX_METHOD(GrxCellRendererAccelNew, GrxCellRendererAccelNew), + REXX_METHOD(GrxCellRendererAccelSignalConnect, GrxCellRendererAccelSignalConnect), + REXX_METHOD(GrxCellRendererComboNew, GrxCellRendererComboNew), + REXX_METHOD(GrxCellRendererComboSignalConnect, GrxCellRendererComboSignalConnect), + REXX_METHOD(GrxCellRendererSpinNew, GrxCellRendererSpinNew), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-06-04 14:02:22 UTC (rev 2520) +++ sandbox/david/4x/rexxgtk.h 2008-06-05 14:45:33 UTC (rev 2521) @@ -583,8 +583,23 @@ REXX_METHOD_PROTOTYPE(GrxMenuToolButtonGetMenu) REXX_METHOD_PROTOTYPE(GrxMenuToolButtonSetArrowTooltip) REXX_METHOD_PROTOTYPE(GrxMenuToolButtonSignalConnect) +REXX_METHOD_PROTOTYPE(GrxCellRendererSetFixedSize) +REXX_METHOD_PROTOTYPE(GrxCellRendererSignalConnect) REXX_METHOD_PROTOTYPE(GrxCellRendererTextNew) REXX_METHOD_PROTOTYPE(GrxCellRendererTextSignalConnect) +REXX_METHOD_PROTOTYPE(GrxCellRendererPixbufNew) +REXX_METHOD_PROTOTYPE(GrxCellRendererProgressNew) +REXX_METHOD_PROTOTYPE(GrxCellRendererToggleNew) +REXX_METHOD_PROTOTYPE(GrxCellRendererToggleSetRadio) +REXX_METHOD_PROTOTYPE(GrxCellRendererToggleGetRadio) +REXX_METHOD_PROTOTYPE(GrxCellRendererToggleSetActive) +REXX_METHOD_PROTOTYPE(GrxCellRendererToggleGetActive) +REXX_METHOD_PROTOTYPE(GrxCellRendererToggleSignalConnect) +REXX_METHOD_PROTOTYPE(GrxCellRendererAccelNew) +REXX_METHOD_PROTOTYPE(GrxCellRendererAccelSignalConnect) +REXX_METHOD_PROTOTYPE(GrxCellRendererComboNew) +REXX_METHOD_PROTOTYPE(GrxCellRendererComboSignalConnect) +REXX_METHOD_PROTOTYPE(GrxCellRendererSpinNew) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-05 19:31:30
|
Revision: 2522 http://oorexx.svn.sourceforge.net/oorexx/?rev=2522&view=rev Author: wdashley Date: 2008-06-05 12:31:34 -0700 (Thu, 05 Jun 2008) Log Message: ----------- ArtifactID: None Comment: Added the treeview and treeviewcolumn classes. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/grxmenutoolbutton.cpp sandbox/david/4x/grxtoolbar.cpp sandbox/david/4x/grxtoolbutton.cpp sandbox/david/4x/grxtoolitem.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxtreeview.cpp sandbox/david/4x/grxtreeviewcolumn.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-06-05 14:45:33 UTC (rev 2521) +++ sandbox/david/4x/Makefile 2008-06-05 19:31:34 UTC (rev 2522) @@ -85,7 +85,9 @@ grxtoolitem.o \ grxtoolbutton.o \ grxmenutoolbutton.o \ - grxcellrenderer.o + grxcellrenderer.o \ + grxtreeview.o \ + grxtreeviewcolumn.o # Build the shared library @@ -214,8 +216,14 @@ grxcellrenderer.o: grxcellrenderer.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxcellrenderer.cpp +grxtreeview.o: grxtreeview.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxtreeview.cpp +grxtreeviewcolumn.o: grxtreeviewcolumn.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxtreeviewcolumn.cpp + + clean: rm *.so *.o Modified: sandbox/david/4x/grxmenutoolbutton.cpp =================================================================== --- sandbox/david/4x/grxmenutoolbutton.cpp 2008-06-05 14:45:33 UTC (rev 2521) +++ sandbox/david/4x/grxmenutoolbutton.cpp 2008-06-05 19:31:34 UTC (rev 2522) @@ -197,6 +197,6 @@ G_CALLBACK(signal_func_0), cblock); return context->True(); } - return context->False(); + return context->SendSuperMessage("signal_connect", args); } Modified: sandbox/david/4x/grxtoolbar.cpp =================================================================== --- sandbox/david/4x/grxtoolbar.cpp 2008-06-05 14:45:33 UTC (rev 2521) +++ sandbox/david/4x/grxtoolbar.cpp 2008-06-05 19:31:34 UTC (rev 2522) @@ -1085,6 +1085,6 @@ G_CALLBACK(signal_func_1b), cblock); return context->True(); } - return context->False(); + return context->SendSuperMessage("signal_connect", args); } Modified: sandbox/david/4x/grxtoolbutton.cpp =================================================================== --- sandbox/david/4x/grxtoolbutton.cpp 2008-06-05 14:45:33 UTC (rev 2521) +++ sandbox/david/4x/grxtoolbutton.cpp 2008-06-05 19:31:34 UTC (rev 2522) @@ -356,7 +356,7 @@ G_CALLBACK(signal_func_0), cblock); return context->True(); } - return context->False(); + return context->SendSuperMessage("signal_connect", args); } /** @@ -383,7 +383,7 @@ /** * Method: set_draw * - * Sets the fraw flag. + * Sets the draw flag. * * @param flag The draw boolean * Modified: sandbox/david/4x/grxtoolitem.cpp =================================================================== --- sandbox/david/4x/grxtoolitem.cpp 2008-06-05 14:45:33 UTC (rev 2521) +++ sandbox/david/4x/grxtoolitem.cpp 2008-06-05 19:31:34 UTC (rev 2522) @@ -570,6 +570,6 @@ G_CALLBACK(signal_func_0a), cblock); return context->True(); } - return context->False(); + return context->SendSuperMessage("signal_connect", args); } Added: sandbox/david/4x/grxtreeview.cpp =================================================================== --- sandbox/david/4x/grxtreeview.cpp (rev 0) +++ sandbox/david/4x/grxtreeview.cpp 2008-06-05 19:31:34 UTC (rev 2522) @@ -0,0 +1,442 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + +static void signal_func_0(GtkWidget *treeview, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(treeview), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + context->SendMessage0(rxobj, ((cbcb *)data)->signal_name); + context->DetachThread(); + return; +} + +static gboolean signal_func_0a(GtkWidget *treeview, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(treeview), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxObjectPtr tempobj = context->SendMessage0(rxobj, ((cbcb *)data)->signal_name); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + +static gboolean signal_func_1(GtkWidget *treeview, + gboolean arg1, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(treeview), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = context->NumberToObject((wholenumber_t)arg1); + context->ArrayPut(arr, tempobj, 1); + tempobj = context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + +static gboolean signal_func_2(GtkWidget *treeview, + int arg1, + int arg2, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(treeview), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = context->NumberToObject((wholenumber_t)arg1); + context->ArrayPut(arr, tempobj, 1); + tempobj = context->NumberToObject((wholenumber_t)arg2); + context->ArrayPut(arr, tempobj, 2); + tempobj = context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + +static void signal_func_2a(GtkWidget *treeview, + GtkTreePath *arg1, + GtkTreeViewColumn *arg2, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(treeview), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(arg1), "OORXOBJECT"); + context->ArrayPut(arr, tempobj, 1); + tempobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(arg2), "OORXOBJECT"); + context->ArrayPut(arr, tempobj, 2); + context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->DetachThread(); + return; +} + +static gboolean signal_func_2b(GtkWidget *treeview, + GtkTreePath *arg1, + GtkTreeViewColumn *arg2, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(treeview), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(arg1), "OORXOBJECT"); + context->ArrayPut(arr, tempobj, 1); + tempobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(arg2), "OORXOBJECT"); + context->ArrayPut(arr, tempobj, 2); + tempobj = context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + +static gboolean signal_func_3(GtkWidget *treeview, + gboolean arg1, + gboolean arg2, + gboolean arg3, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(treeview), "OORXOBJECT"); + RexxThreadContext *context; + gboolean retc; + + cblock->instance->AttachThread(&context); + RexxArrayObject arr = context->NewArray(1); + RexxObjectPtr tempobj = context->NumberToObject((wholenumber_t)arg1); + context->ArrayPut(arr, tempobj, 1); + tempobj = context->NumberToObject((wholenumber_t)arg2); + context->ArrayPut(arr, tempobj, 2); + tempobj = context->NumberToObject((wholenumber_t)arg3); + context->ArrayPut(arr, tempobj, 3); + tempobj = context->SendMessage(rxobj, ((cbcb *)data)->signal_name, arr); + context->ObjectToNumber(tempobj, &retc); + context->DetachThread(); + return retc; +} + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create an tree view. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxTreeViewNew, // Object_method name + OSELF, self) // Self +{ + GtkWidget *treeview; + + treeview = gtk_tree_view_new(); + + context->SetObjectVariable("!POINTER", context->NewPointer(treeview)); + g_object_set_data(G_OBJECT(treeview), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: append_column + * + * Append a column to the tree view. + * + * @param rxobj The column + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxTreeViewAppendColumn, // Object_method name + RexxObjectPtr, rxobj) // Column object +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeView *myWidget = (GtkTreeView *)context->PointerValue(rxptr); + RexxPointerObject objptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkTreeViewColumn *colWidget = (GtkTreeViewColumn *)context->PointerValue(objptr); + + gtk_tree_view_append_column(myWidget, colWidget); + + return 0; +} + +/** + * Method: remove_column + * + * Remove a column from the tree view. + * + * @param rxobj The column + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxTreeViewRemoveColumn, // Object_method name + RexxObjectPtr, rxobj) // Column object +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeView *myWidget = (GtkTreeView *)context->PointerValue(rxptr); + RexxPointerObject objptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkTreeViewColumn *colWidget = (GtkTreeViewColumn *)context->PointerValue(objptr); + + gtk_tree_view_remove_column(myWidget, colWidget); + + return 0; +} + +/** + * Method: insert_column + * + * Insert a column to the tree view. + * + * @param rxobj The column + * + * @param pos The position + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxTreeViewInsertColumn, // Object_method name + RexxObjectPtr, rxobj, // Column object + int, pos) // Position +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeView *myWidget = (GtkTreeView *)context->PointerValue(rxptr); + RexxPointerObject objptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkTreeViewColumn *colWidget = (GtkTreeViewColumn *)context->PointerValue(objptr); + + gtk_tree_view_insert_column(myWidget, colWidget, pos); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxTreeViewSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "columns_changed") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_columns_changed"; + g_signal_connect(G_OBJECT(myWidget), "columns-changed", + G_CALLBACK(signal_func_0), cblock); + return context->True(); + } + else if (strcmp(name, "cursor_changed") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_cursor_changed"; + g_signal_connect(G_OBJECT(myWidget), "cursor-changed", + G_CALLBACK(signal_func_0), cblock); + return context->True(); + } + else if (strcmp(name, "expand_collapse_cursor_row") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_expand_collapse_cursor_row"; + g_signal_connect(G_OBJECT(myWidget), "expand-collapse-cursor-row", + G_CALLBACK(signal_func_0), cblock); + return context->True(); + } + else if (strcmp(name, "move_cursor") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_move_cursor"; + g_signal_connect(G_OBJECT(myWidget), "move-cursor", + G_CALLBACK(signal_func_2), cblock); + return context->True(); + } + else if (strcmp(name, "row_activated") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_row_activated"; + g_signal_connect(G_OBJECT(myWidget), "row-activated", + G_CALLBACK(signal_func_2a), cblock); + return context->True(); + } + else if (strcmp(name, "row_collapsed") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_row_collapsed"; + g_signal_connect(G_OBJECT(myWidget), "row-collapsed", + G_CALLBACK(signal_func_2a), cblock); + return context->True(); + } + else if (strcmp(name, "row_expanded") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_row_expanded"; + g_signal_connect(G_OBJECT(myWidget), "row-expanded", + G_CALLBACK(signal_func_2a), cblock); + return context->True(); + } + else if (strcmp(name, "select_all") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_select_all"; + g_signal_connect(G_OBJECT(myWidget), "select-all", + G_CALLBACK(signal_func_0a), cblock); + return context->True(); + } + else if (strcmp(name, "select_cursor_parent") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_select_cursor_parent"; + g_signal_connect(G_OBJECT(myWidget), "select-cursor-parent", + G_CALLBACK(signal_func_0a), cblock); + return context->True(); + } + else if (strcmp(name, "select_cursor_row") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_select_cursor_row"; + g_signal_connect(G_OBJECT(myWidget), "select-cursor-row", + G_CALLBACK(signal_func_1), cblock); + return context->True(); + } + else if (strcmp(name, "set_scroll_adjustments") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_set_scroll_adjustments"; + g_signal_connect(G_OBJECT(myWidget), "set-scroll-adjustments", + G_CALLBACK(signal_func_2a), cblock); + return context->True(); + } + else if (strcmp(name, "start_interactive_search") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_start_interactive_search"; + g_signal_connect(G_OBJECT(myWidget), "start-interactive-search", + G_CALLBACK(signal_func_0a), cblock); + return context->True(); + } + else if (strcmp(name, "test_collapse_row") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_test_collapse_row"; + g_signal_connect(G_OBJECT(myWidget), "test-collapse-row", + G_CALLBACK(signal_func_2b), cblock); + return context->True(); + } + else if (strcmp(name, "test_expand_row") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_test_expand_row"; + g_signal_connect(G_OBJECT(myWidget), "test-expand-row", + G_CALLBACK(signal_func_2b), cblock); + return context->True(); + } + else if (strcmp(name, "toggle_cursor_row") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_toggle_cursor_row"; + g_signal_connect(G_OBJECT(myWidget), "toggle-cursor-row", + G_CALLBACK(signal_func_0a), cblock); + return context->True(); + } + else if (strcmp(name, "unselect_all") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_unselect_all"; + g_signal_connect(G_OBJECT(myWidget), "unselect-all", + G_CALLBACK(signal_func_0a), cblock); + return context->True(); + } + return context->SendSuperMessage("signal_connect", args); +} + Property changes on: sandbox/david/4x/grxtreeview.cpp ___________________________________________________________________ Name: svn:eol-style + native Added: sandbox/david/4x/grxtreeviewcolumn.cpp =================================================================== --- sandbox/david/4x/grxtreeviewcolumn.cpp (rev 0) +++ sandbox/david/4x/grxtreeviewcolumn.cpp 2008-06-05 19:31:34 UTC (rev 2522) @@ -0,0 +1,237 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + +static void signal_func_0(GtkWidget *treeviewcol, + gpointer data) +{ + cbcb *cblock = (cbcb *)data; + RexxObjectPtr rxobj = (RexxObjectPtr)g_object_get_data(G_OBJECT(treeviewcol), "OORXOBJECT"); + RexxThreadContext *context; + + cblock->instance->AttachThread(&context); + context->SendMessage0(rxobj, ((cbcb *)data)->signal_name); + context->DetachThread(); + return; +} + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create an tree view column. + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxTreeViewColumnNew, // Object_method name + OSELF, self) // Self +{ + GtkTreeViewColumn *treeviewcol; + + treeviewcol = gtk_tree_view_column_new(); + + context->SetObjectVariable("!POINTER", context->NewPointer(treeviewcol)); + g_object_set_data(G_OBJECT(treeviewcol), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: set_title + * + * Set the title of a tree view column. + * + * @param title The title + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxTreeViewColumnSetTitle, // Object_method name + CSTRING, title) // Title +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeViewColumn *myWidget = (GtkTreeViewColumn *)context->PointerValue(rxptr); + + gtk_tree_view_column_set_title(myWidget, title); + + return 0; +} + +/** + * Method: get_title + * + * Get the title of a tree view column. + * + * @return Zero. + **/ +RexxMethod0(CSTRING, // Return type + GrxTreeViewColumnGetTitle) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeViewColumn *myWidget = (GtkTreeViewColumn *)context->PointerValue(rxptr); + + return gtk_tree_view_column_get_title(myWidget); +} + +/** + * Method: pack_start + * + * Pack the tree view column. + * + * @param flag The expand boolean + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxTreeViewColumnPackStart, // Object_method name + RexxObjectPtr, rxobj, // Renderer + logical_t, flag) // Expand boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeViewColumn *myWidget = (GtkTreeViewColumn *)context->PointerValue(rxptr); + RexxPointerObject renptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkCellRenderer *renWidget = (GtkCellRenderer *)context->PointerValue(renptr); + + gtk_tree_view_column_pack_start(myWidget, renWidget, flag); + + return 0; +} + +/** + * Method: pack_end + * + * Pack the tree view column. + * + * @param flag The expand boolean + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxTreeViewColumnPackEnd, // Object_method name + RexxObjectPtr, rxobj, // Renderer + logical_t, flag) // Expand boolean +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeViewColumn *myWidget = (GtkTreeViewColumn *)context->PointerValue(rxptr); + RexxPointerObject renptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkCellRenderer *renWidget = (GtkCellRenderer *)context->PointerValue(renptr); + + gtk_tree_view_column_pack_end(myWidget, renWidget, flag); + + return 0; +} + +/** + * Method: set_attribute + * + * Set an attribute of a tree view column. + * + * @param flag The expand boolean + * + * @return Zero. + **/ +RexxMethod3(int, // Return type + GrxTreeViewColumnSetAttribute, // Object_method name + RexxObjectPtr, rxobj, // Renderer + CSTRING, attr, // Attribute + int, col) // Column +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeViewColumn *myWidget = (GtkTreeViewColumn *)context->PointerValue(rxptr); + RexxPointerObject renptr = (RexxPointerObject)context->SendMessage0(rxobj, "POINTER"); + GtkCellRenderer *renWidget = (GtkCellRenderer *)context->PointerValue(renptr); + + gtk_tree_view_column_set_attributes(myWidget, renWidget, attr, col, NULL); + + return 0; +} + +/** + * Method: signal_connect + * + * Connect a signal to an ooRexx method. + * + * @param name The signal name + * + * @return Zero + **/ +RexxMethod2(RexxObjectPtr, // Return type + GrxTreeViewColumnSignalConnect, // Object_method name + CSTRING, name, // Signal name + ARGLIST, args) // The whole argument list as an array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkWidget *myWidget = (GtkWidget *)context->PointerValue(rxptr); + cbcb *cblock; + + if (strcmp(name, "columns_clicked") == 0) { + cblock = (cbcb *)malloc(sizeof(cbcb)); + cblock->instance = context->threadContext->instance; + cblock->signal_name = "signal_clicked"; + g_signal_connect(G_OBJECT(myWidget), "clicked", + G_CALLBACK(signal_func_0), cblock); + return context->True(); + } + return context->False(); +} + Property changes on: sandbox/david/4x/grxtreeviewcolumn.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-06-05 14:45:33 UTC (rev 2521) +++ sandbox/david/4x/rexxgtk.cls 2008-06-05 19:31:34 UTC (rev 2522) @@ -2563,7 +2563,7 @@ /*============================================================================*/ -/* Class: GtkToolButton */ +/* Class: GtkSeparatorToolButton */ /*============================================================================*/ ::class GtkSeparatorToolItem public subclass GtkToolItem @@ -2737,8 +2737,103 @@ /*============================================================================*/ +/* Class: GtkTreeView */ /*============================================================================*/ + +::class GtkTreeView public subclass GtkContainer + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxTreeViewNew" +::METHOD append_column EXTERNAL "LIBRARY rexxgtk GrxTreeViewAppendColumn" +::METHOD insert_column EXTERNAL "LIBRARY rexxgtk GrxTreeViewInsertColumn" +::METHOD remove_column EXTERNAL "LIBRARY rexxgtk GrxTreeViewRemoveColumn" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxTreeViewSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_columns_changed +return + +::method signal_cursor_changed +return + +::method signal_expand_collapse_cursor_row +return .false + +::method signal_move_cursor +return .false + +::method signal_row_activated +return + +::method signal_row_collapsed +return + +::method signal_row_expanded +return + +::method signal_select_all +return .false + +::method signal_select_cursor_parent +return .false + +::method signal_select_cursor_row +return .false + +::method signal_set_scroll_adjustments +return + +::method signal_start_interactive_search +return .false + +::method signal_test_collapse_row +return .false + +::method signal_test_expand_row +return .false + +::method signal_toggle_cursor_row +return .false + +::method signal_unselect_all +return .false + + /*============================================================================*/ +/* Class: GtkTreeViewColumn */ +/*============================================================================*/ + +::class GtkTreeViewColumn public + +::METHOD new_with_attributes class +use arg title, renderer +obj = .GtkTreeViewColumn~new() +obj~set_title(title) +obj~pack_start(renderer, .false) +do i = 3 to arg() by 2 + obj~set_attribute(renderer, arg(i), arg(i + 1)) + end +return obj + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxTreeViewColumnNew" +::METHOD set_title EXTERNAL "LIBRARY rexxgtk GrxTreeViewColumnSetTitle" +::METHOD get_title EXTERNAL "LIBRARY rexxgtk GrxTreeViewColumnGetTitle" +::METHOD pack_start EXTERNAL "LIBRARY rexxgtk GrxTreeViewColumnPackStart" +::METHOD pack_end EXTERNAL "LIBRARY rexxgtk GrxTreeViewColumnPackEnd" +::METHOD set_attribute EXTERNAL "LIBRARY rexxgtk GrxTreeViewColumnSetAttribute" +::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxTreeViewColumnSignalConnect" + +-- The following are the methods that can be connected to signals. By default +-- they do nothing. + +::method signal_clicked +return + + +/*============================================================================*/ +/*============================================================================*/ +/*============================================================================*/ /* These are classes and routines specific to Glib. */ /*============================================================================*/ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-06-05 14:45:33 UTC (rev 2521) +++ sandbox/david/4x/rexxgtk.cpp 2008-06-05 19:31:34 UTC (rev 2522) @@ -833,6 +833,18 @@ REXX_METHOD(GrxCellRendererComboNew, GrxCellRendererComboNew), REXX_METHOD(GrxCellRendererComboSignalConnect, GrxCellRendererComboSignalConnect), REXX_METHOD(GrxCellRendererSpinNew, GrxCellRendererSpinNew), + REXX_METHOD(GrxTreeViewNew, GrxTreeViewNew), + REXX_METHOD(GrxTreeViewAppendColumn, GrxTreeViewAppendColumn), + REXX_METHOD(GrxTreeViewInsertColumn, GrxTreeViewInsertColumn), + REXX_METHOD(GrxTreeViewRemoveColumn, GrxTreeViewRemoveColumn), + REXX_METHOD(GrxTreeViewSignalConnect, GrxTreeViewSignalConnect), + REXX_METHOD(GrxTreeViewColumnNew, GrxTreeViewColumnNew), + REXX_METHOD(GrxTreeViewColumnSetTitle, GrxTreeViewColumnSetTitle), + REXX_METHOD(GrxTreeViewColumnGetTitle, GrxTreeViewColumnGetTitle), + REXX_METHOD(GrxTreeViewColumnPackStart, GrxTreeViewColumnPackStart), + REXX_METHOD(GrxTreeViewColumnPackEnd, GrxTreeViewColumnPackEnd), + REXX_METHOD(GrxTreeViewColumnSetAttribute, GrxTreeViewColumnSetAttribute), + REXX_METHOD(GrxTreeViewColumnSignalConnect, GrxTreeViewColumnSignalConnect), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-06-05 14:45:33 UTC (rev 2521) +++ sandbox/david/4x/rexxgtk.h 2008-06-05 19:31:34 UTC (rev 2522) @@ -600,6 +600,18 @@ REXX_METHOD_PROTOTYPE(GrxCellRendererComboNew) REXX_METHOD_PROTOTYPE(GrxCellRendererComboSignalConnect) REXX_METHOD_PROTOTYPE(GrxCellRendererSpinNew) +REXX_METHOD_PROTOTYPE(GrxTreeViewNew) +REXX_METHOD_PROTOTYPE(GrxTreeViewAppendColumn) +REXX_METHOD_PROTOTYPE(GrxTreeViewInsertColumn) +REXX_METHOD_PROTOTYPE(GrxTreeViewRemoveColumn) +REXX_METHOD_PROTOTYPE(GrxTreeViewSignalConnect) +REXX_METHOD_PROTOTYPE(GrxTreeViewColumnNew) +REXX_METHOD_PROTOTYPE(GrxTreeViewColumnSetTitle) +REXX_METHOD_PROTOTYPE(GrxTreeViewColumnGetTitle) +REXX_METHOD_PROTOTYPE(GrxTreeViewColumnPackStart) +REXX_METHOD_PROTOTYPE(GrxTreeViewColumnPackEnd) +REXX_METHOD_PROTOTYPE(GrxTreeViewColumnSetAttribute) +REXX_METHOD_PROTOTYPE(GrxTreeViewColumnSignalConnect) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-07 20:36:56
|
Revision: 2524 http://oorexx.svn.sourceforge.net/oorexx/?rev=2524&view=rev Author: wdashley Date: 2008-06-07 13:36:57 -0700 (Sat, 07 Jun 2008) Log Message: ----------- ArtifactID: None Comment: Added test8-1 and a new method to the treeview class. Modified Paths: -------------- sandbox/david/4x/grxliststore.cpp sandbox/david/4x/grxtreeview.cpp sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/test8-1.rex Modified: sandbox/david/4x/grxliststore.cpp =================================================================== --- sandbox/david/4x/grxliststore.cpp 2008-06-05 19:50:09 UTC (rev 2523) +++ sandbox/david/4x/grxliststore.cpp 2008-06-07 20:36:57 UTC (rev 2524) @@ -136,7 +136,7 @@ int i, col; const char *val; - for (i = 3; i <= members; i += 2) { + for (i = 2; i <= members; i += 2) { context->ObjectToNumber(context->ArrayAt(args, i), &col); val = context->StringData((RexxStringObject)context->ArrayAt(args, i - 1)); gtk_list_store_set_value(lstore, iter, col, (GValue *)val); Modified: sandbox/david/4x/grxtreeview.cpp =================================================================== --- sandbox/david/4x/grxtreeview.cpp 2008-06-05 19:50:09 UTC (rev 2523) +++ sandbox/david/4x/grxtreeview.cpp 2008-06-07 20:36:57 UTC (rev 2524) @@ -292,6 +292,29 @@ } /** + * Method: set_model + * + * Set the model for the tree. + * + * @param model The model object + * + * @return Zero. + **/ +RexxMethod1(int, // Return type + GrxTreeViewSetModel, // Object_method name + RexxObjectPtr, model) // Column object +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeView *myWidget = (GtkTreeView *)context->PointerValue(rxptr); + RexxPointerObject objptr = (RexxPointerObject)context->SendMessage0(model, "POINTER"); + GtkTreeModel *modelWidget = (GtkTreeModel *)context->PointerValue(objptr); + + gtk_tree_view_set_model(myWidget, modelWidget); + + return 0; +} + +/** * Method: signal_connect * * Connect a signal to an ooRexx method. Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-06-05 19:50:09 UTC (rev 2523) +++ sandbox/david/4x/rexxgtk.cpp 2008-06-07 20:36:57 UTC (rev 2524) @@ -837,6 +837,7 @@ REXX_METHOD(GrxTreeViewAppendColumn, GrxTreeViewAppendColumn), REXX_METHOD(GrxTreeViewInsertColumn, GrxTreeViewInsertColumn), REXX_METHOD(GrxTreeViewRemoveColumn, GrxTreeViewRemoveColumn), + REXX_METHOD(GrxTreeViewSetModel, GrxTreeViewSetModel), REXX_METHOD(GrxTreeViewSignalConnect, GrxTreeViewSignalConnect), REXX_METHOD(GrxTreeViewColumnNew, GrxTreeViewColumnNew), REXX_METHOD(GrxTreeViewColumnSetTitle, GrxTreeViewColumnSetTitle), Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-06-05 19:50:09 UTC (rev 2523) +++ sandbox/david/4x/rexxgtk.h 2008-06-07 20:36:57 UTC (rev 2524) @@ -604,6 +604,7 @@ REXX_METHOD_PROTOTYPE(GrxTreeViewAppendColumn) REXX_METHOD_PROTOTYPE(GrxTreeViewInsertColumn) REXX_METHOD_PROTOTYPE(GrxTreeViewRemoveColumn) +REXX_METHOD_PROTOTYPE(GrxTreeViewSetModel) REXX_METHOD_PROTOTYPE(GrxTreeViewSignalConnect) REXX_METHOD_PROTOTYPE(GrxTreeViewColumnNew) REXX_METHOD_PROTOTYPE(GrxTreeViewColumnSetTitle) Added: sandbox/david/4x/test8-1.rex =================================================================== --- sandbox/david/4x/test8-1.rex (rev 0) +++ sandbox/david/4x/test8-1.rex 2008-06-07 20:36:57 UTC (rev 2524) @@ -0,0 +1,122 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 8-1 +-- Foundations of GTK+ Development +-- by Andrew Krause + +BUY_IT = 0 +QUANTITY = 1 +PRODUCT = 2 +COLUMNS = 3 + +list = .array~new(1) +list[1] = .GroceryItem~new(.true, 1, 'Paper Towels') +list[2] = .GroceryItem~new(.true, 2, 'Bread') +list[3] = .GroceryItem~new(.false, 1, 'Butter') +list[4] = .GroceryItem~new(.true, 1, 'Milk') +list[5] = .GroceryItem~new(.false, 3, 'Chips') +list[6] = .GroceryItem~new(.true, 4, 'Soda') + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Grocery List') +window~signal_connect('destroy') +window~set_border_width(10) +window~set_size_request(250, 175) + +treeview = .GtkTreeview~new() +call setup_tree_view treeview + +store = .GtkListStore~new(.gtk~G_TYPE_BOOLEAN, .gtk~G_TYPE_INT, .gtk~G_TYPE_STRING) + +do item over list + iter = store~append() + store~set_value(iter, BUY_IT, item~buy. QUANTITY, item~quantity,, + PRODUCT, item~product) + end + +treeview~set_model(store) + +scrolled_win = .GtkScrolledWindow~new(.nil, .nil) +scrolled_win_set+policy(.gtk~GTK_POLICY_AUTOMATIC, gtk~GTK_POLICY_AUTOMATIC) + +scrolled_win~add(treeview) +window~add(scrolled_win) +window~show_all() + +call gtk_main +return + +::requires 'rexxgtk.cls' + +::routine setup_tree_view +use strict arg treeview + +renderer = .GtkCellRendererTextView~new() +column = .GtkTreeViewColumn~new_with_attributes('Buy', renderer, 'text', BUY_IT) +treeview~append(column) + +renderer = .GtkCellRendererTextView~new() +column = .GtkTreeViewColumn~new_with_attributes('Count', renderer, 'text', QUANTITY) +treeview~append(column) + +renderer = .GtkCellRendererTextView~new() +column = .GtkTreeViewColumn~new_with_attributes('Product', renderer, 'text', PRODUCT) +treeview~append(column) +return + +::class GroceryItem + +::attribute buy +::attribute quantity +::attribute product + +::method init +use strict arg self~buy, self~quantity, self~product +return + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + Property changes on: sandbox/david/4x/test8-1.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-12 15:45:00
|
Revision: 2533 http://oorexx.svn.sourceforge.net/oorexx/?rev=2533&view=rev Author: wdashley Date: 2008-06-12 08:44:26 -0700 (Thu, 12 Jun 2008) Log Message: ----------- ArtifactID: None CommentL Added the treestore class. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/grxtreestore.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-06-12 00:25:25 UTC (rev 2532) +++ sandbox/david/4x/Makefile 2008-06-12 15:44:26 UTC (rev 2533) @@ -87,7 +87,8 @@ grxmenutoolbutton.o \ grxcellrenderer.o \ grxtreeview.o \ - grxtreeviewcolumn.o + grxtreeviewcolumn.o \ + grxtreestore.o # Build the shared library @@ -222,8 +223,11 @@ grxtreeviewcolumn.o: grxtreeviewcolumn.cpp rexxgtk.h gcc -c $(GRXCFLAGS) grxtreeviewcolumn.cpp +grxtreestore.o: grxtreestore.cpp rexxgtk.h + gcc -c $(GRXCFLAGS) grxtreestore.cpp + clean: rm *.so *.o Added: sandbox/david/4x/grxtreestore.cpp =================================================================== --- sandbox/david/4x/grxtreestore.cpp (rev 0) +++ sandbox/david/4x/grxtreestore.cpp 2008-06-12 15:44:26 UTC (rev 2533) @@ -0,0 +1,145 @@ +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +/* include the linux headers and our local stuff */ +#include "rexxgtk.h" + + +/*----------------------------------------------------------------------------*/ +/* Global variables */ +/*----------------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------------*/ +/* Local Definitions */ +/*----------------------------------------------------------------------------*/ + + +/*============================================================================*/ +/* Private Functions */ +/*============================================================================*/ + + +/*============================================================================*/ +/* Public Functions */ +/*============================================================================*/ + +/** + * Method: init + * + * Create a tree store. + * + * @param args The argument list + * + * @return Zero. + **/ +RexxMethod2(int, // Return type + GrxTreeStoretNew, // Object_method name + OSELF, self, // Self + ARGLIST, args) // Array of column types +{ + GtkTreeStore *tstore; + size_t members = context->ArraySize(args); + gint *types[members]; + + if (members) { + for (int i = 0; i < members; i++) { + context->ObjectToNumber(context->ArrayAt(args, i), types[i]); + } + tstore = (GtkTreeStore *)gtk_tree_store_newv(members, (GType *)types); + } + context->SetObjectVariable("!POINTER", context->NewPointer(tstore)); + g_object_set_data(G_OBJECT(tstore), "OORXOBJECT", self); + + return 0; +} + +/** + * Method: append + * + * Append a new row + * + * @return Row iterator + **/ +RexxMethod0(RexxObjectPtr, // Return type + GrxTreeStoreAppend) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeStore *tstore = (GtkTreeStore *)context->PointerValue(rxptr); + GtkTreeIter *iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter)); + + gtk_tree_store_append(tstore, iter, NULL); + + return (RexxObjectPtr)context->NewPointer(iter); +} + +/** + * Method: set_value + * + * Set the value in a column. + * + * @param iter The iterator + * + * @param val The value + * + * @return Zero + **/ +RexxMethod2(int, // Return type + GrxTreeStoreSetValue, // Object_method name + RexxObjectPtr, rxiter, // Row iterator + ARGLIST, args) // Argument array +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeStore *tstore = (GtkTreeStore *)context->PointerValue(rxptr); + GtkTreeIter *iter = (GtkTreeIter *)context->PointerValue((RexxPointerObject)rxiter); + size_t members = context->ArraySize(args); + int i, col; + const char *name; + + for (i = 2; i <= members; i += 2) { + context->ObjectToNumber(context->ArrayAt(args, i), &col); + name = context->StringData((RexxStringObject)context->ArrayAt(args, i + 1)); + gtk_tree_store_set_value(tstore, iter, col, (GValue *)name); + } + + return 0; +} + Property changes on: sandbox/david/4x/grxtreestore.cpp ___________________________________________________________________ Name: svn:eol-style + native Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-06-12 00:25:25 UTC (rev 2532) +++ sandbox/david/4x/rexxgtk.cls 2008-06-12 15:44:26 UTC (rev 2533) @@ -2837,8 +2837,23 @@ /*============================================================================*/ +/* Class: GtkTreeStore */ /*============================================================================*/ + +::class GtkTreeStore public + +::METHOD init EXTERNAL "LIBRARY rexxgtk GrxTreeStoreNew" +::METHOD append EXTERNAL "LIBRARY rexxgtk GrxTreeStoreAppend" +::METHOD set EXTERNAL "LIBRARY rexxgtk GrxTreeStoreSetValue" + +::method pointer +expose !pointer +return !pointer + + /*============================================================================*/ +/*============================================================================*/ +/*============================================================================*/ /* These are classes and routines specific to Glib. */ /*============================================================================*/ /*============================================================================*/ Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-06-12 00:25:25 UTC (rev 2532) +++ sandbox/david/4x/rexxgtk.cpp 2008-06-12 15:44:26 UTC (rev 2533) @@ -846,6 +846,9 @@ REXX_METHOD(GrxTreeViewColumnPackEnd, GrxTreeViewColumnPackEnd), REXX_METHOD(GrxTreeViewColumnSetAttribute, GrxTreeViewColumnSetAttribute), REXX_METHOD(GrxTreeViewColumnSignalConnect, GrxTreeViewColumnSignalConnect), + REXX_METHOD(GrxTreeStoreNew, GrxTreeStoreNew), + REXX_METHOD(GrxTreeStoreAppend, GrxTreeStoreAppend), + REXX_METHOD(GrxTreeStoreSetValue, GrxTreeStoreSetValue), REXX_LAST_METHOD() }; Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-06-12 00:25:25 UTC (rev 2532) +++ sandbox/david/4x/rexxgtk.h 2008-06-12 15:44:26 UTC (rev 2533) @@ -613,6 +613,9 @@ REXX_METHOD_PROTOTYPE(GrxTreeViewColumnPackEnd) REXX_METHOD_PROTOTYPE(GrxTreeViewColumnSetAttribute) REXX_METHOD_PROTOTYPE(GrxTreeViewColumnSignalConnect) +REXX_METHOD_PROTOTYPE(GrxTreeStoreNew) +REXX_METHOD_PROTOTYPE(GrxTreeStoreAppend) +REXX_METHOD_PROTOTYPE(GrxTreeStoreSetValue) #endif /* REXXGTK_H */ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-15 17:56:17
|
Revision: 2539 http://oorexx.svn.sourceforge.net/oorexx/?rev=2539&view=rev Author: wdashley Date: 2008-06-15 10:56:08 -0700 (Sun, 15 Jun 2008) Log Message: ----------- ArtifactID: None Comment: Fixed the liststore classes. Modified Paths: -------------- sandbox/david/4x/grxliststore.cpp sandbox/david/4x/grxtreestore.cpp Modified: sandbox/david/4x/grxliststore.cpp =================================================================== --- sandbox/david/4x/grxliststore.cpp 2008-06-13 14:32:05 UTC (rev 2538) +++ sandbox/david/4x/grxliststore.cpp 2008-06-15 17:56:08 UTC (rev 2539) @@ -78,8 +78,8 @@ { GtkListStore *lstore; size_t members = context->ArraySize(args); - gint *types[members]; + gint **types = (gint **)malloc(sizeof(int) * members); if (members) { for (int i = 0; i < members; i++) { context->ObjectToNumber(context->ArrayAt(args, i), types[i]); @@ -88,6 +88,7 @@ } context->SetObjectVariable("!POINTER", context->NewPointer(lstore)); g_object_set_data(G_OBJECT(lstore), "OORXOBJECT", self); + context->SetObjectVariable("!COLTYPES", context->NewPointer(types)); return 0; } @@ -132,14 +133,62 @@ RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); GtkListStore *lstore = (GtkListStore *)context->PointerValue(rxptr); GtkTreeIter *iter = (GtkTreeIter *)context->PointerValue((RexxPointerObject)rxiter); + rxptr = (RexxPointerObject)context->GetObjectVariable("!COLTYPES"); + gint **types = (gint **)context->PointerValue(rxptr); size_t members = context->ArraySize(args); - int i, col; + int i, col, ival; + unsigned int uival; + long long ival64; + unsigned long long uival64; + float fval; + double dval; const char *val; for (i = 2; i <= members; i += 2) { context->ObjectToNumber(context->ArrayAt(args, i), &col); - val = context->StringData((RexxStringObject)context->ArrayAt(args, i - 1)); - gtk_list_store_set_value(lstore, iter, col, (GValue *)val); + switch (*types[col]) { + case G_TYPE_POINTER: + case G_TYPE_STRING: + case G_TYPE_OBJECT: + val = context->StringData((RexxStringObject)context->ArrayAt(args, i - 1)); + gtk_list_store_set_value(lstore, iter, col, (GValue *)val); + break; + case G_TYPE_INT: + case G_TYPE_BOOLEAN: + case G_TYPE_LONG: + case G_TYPE_ENUM: + case G_TYPE_FLAGS: + context->ObjectToNumber((RexxStringObject)context->ArrayAt(args, i - 1), &ival); + gtk_list_store_set_value(lstore, iter, col, (GValue *)&ival); + break; + case G_TYPE_UINT: + case G_TYPE_ULONG: + context->ObjectToUnsignedNumber((RexxStringObject)context->ArrayAt(args, i - 1), &uival); + gtk_list_store_set_value(lstore, iter, col, (GValue *)&uival); + break; + case G_TYPE_INT64: + context->ObjectToInt64((RexxStringObject)context->ArrayAt(args, i - 1), &ival64); + gtk_list_store_set_value(lstore, iter, col, (GValue *)&ival64); + break; + case G_TYPE_UINT64: + context->ObjectToUnsignedInt64((RexxStringObject)context->ArrayAt(args, i - 1), &uival64); + gtk_list_store_set_value(lstore, iter, col, (GValue *)&uival64); + break; + case G_TYPE_DOUBLE: + context->ObjectToDouble((RexxStringObject)context->ArrayAt(args, i - 1), &dval); + gtk_list_store_set_value(lstore, iter, col, (GValue *)&dval); + break; + case G_TYPE_CHAR: + context->ObjectToNumber((RexxStringObject)context->ArrayAt(args, i - 1), &ival); + gtk_list_store_set_value(lstore, iter, col, (GValue *)&ival); + break; + case G_TYPE_UCHAR: + context->ObjectToUnsignedNumber((RexxStringObject)context->ArrayAt(args, i - 1), &uival); + gtk_list_store_set_value(lstore, iter, col, (GValue *)&uival); + break; + default: + break; + } } return 0; Modified: sandbox/david/4x/grxtreestore.cpp =================================================================== --- sandbox/david/4x/grxtreestore.cpp 2008-06-13 14:32:05 UTC (rev 2538) +++ sandbox/david/4x/grxtreestore.cpp 2008-06-15 17:56:08 UTC (rev 2539) @@ -78,8 +78,8 @@ { GtkTreeStore *tstore; size_t members = context->ArraySize(args); - gint *types[members]; + gint **types = (gint **)malloc(sizeof(int) * members); if (members) { for (int i = 0; i < members; i++) { context->ObjectToNumber(context->ArrayAt(args, i), types[i]); @@ -88,6 +88,7 @@ } context->SetObjectVariable("!POINTER", context->NewPointer(tstore)); g_object_set_data(G_OBJECT(tstore), "OORXOBJECT", self); + context->SetObjectVariable("!COLTYPES", context->NewPointer(types)); return 0; } @@ -130,14 +131,62 @@ RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); GtkTreeStore *tstore = (GtkTreeStore *)context->PointerValue(rxptr); GtkTreeIter *iter = (GtkTreeIter *)context->PointerValue((RexxPointerObject)rxiter); + rxptr = (RexxPointerObject)context->GetObjectVariable("!COLTYPES"); + gint **types = (gint **)context->PointerValue(rxptr); size_t members = context->ArraySize(args); - int i, col; - const char *name; + int i, col, ival; + unsigned int uival; + long long ival64; + unsigned long long uival64; + float fval; + double dval; + const char *val; for (i = 2; i <= members; i += 2) { context->ObjectToNumber(context->ArrayAt(args, i), &col); - name = context->StringData((RexxStringObject)context->ArrayAt(args, i + 1)); - gtk_tree_store_set_value(tstore, iter, col, (GValue *)name); + switch (*types[col]) { + case G_TYPE_POINTER: + case G_TYPE_STRING: + case G_TYPE_OBJECT: + val = context->StringData((RexxStringObject)context->ArrayAt(args, i - 1)); + gtk_tree_store_set_value(tstore, iter, col, (GValue *)val); + break; + case G_TYPE_INT: + case G_TYPE_BOOLEAN: + case G_TYPE_LONG: + case G_TYPE_ENUM: + case G_TYPE_FLAGS: + context->ObjectToNumber((RexxStringObject)context->ArrayAt(args, i - 1), &ival); + gtk_tree_store_set_value(tstore, iter, col, (GValue *)&ival); + break; + case G_TYPE_UINT: + case G_TYPE_ULONG: + context->ObjectToUnsignedNumber((RexxStringObject)context->ArrayAt(args, i - 1), &uival); + gtk_tree_store_set_value(tstore, iter, col, (GValue *)&uival); + break; + case G_TYPE_INT64: + context->ObjectToInt64((RexxStringObject)context->ArrayAt(args, i - 1), &ival64); + gtk_tree_store_set_value(tstore, iter, col, (GValue *)&ival64); + break; + case G_TYPE_UINT64: + context->ObjectToUnsignedInt64((RexxStringObject)context->ArrayAt(args, i - 1), &uival64); + gtk_tree_store_set_value(tstore, iter, col, (GValue *)&uival64); + break; + case G_TYPE_DOUBLE: + context->ObjectToDouble((RexxStringObject)context->ArrayAt(args, i - 1), &dval); + gtk_tree_store_set_value(tstore, iter, col, (GValue *)&dval); + break; + case G_TYPE_CHAR: + context->ObjectToNumber((RexxStringObject)context->ArrayAt(args, i - 1), &ival); + gtk_tree_store_set_value(tstore, iter, col, (GValue *)&ival); + break; + case G_TYPE_UCHAR: + context->ObjectToUnsignedNumber((RexxStringObject)context->ArrayAt(args, i - 1), &uival); + gtk_tree_store_set_value(tstore, iter, col, (GValue *)&uival); + break; + default: + break; + } } return 0; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-06-18 14:29:56
|
Revision: 2548 http://oorexx.svn.sourceforge.net/oorexx/?rev=2548&view=rev Author: wdashley Date: 2008-06-18 07:29:41 -0700 (Wed, 18 Jun 2008) Log Message: ----------- ArtifactID: None Comment: Small addition to the treeview class and a new test. Modified Paths: -------------- sandbox/david/4x/grxtreestore.cpp sandbox/david/4x/grxtreeview.cpp sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp sandbox/david/4x/rexxgtk.h Added Paths: ----------- sandbox/david/4x/test8-2.rex Modified: sandbox/david/4x/grxtreestore.cpp =================================================================== --- sandbox/david/4x/grxtreestore.cpp 2008-06-17 21:37:17 UTC (rev 2547) +++ sandbox/david/4x/grxtreestore.cpp 2008-06-18 14:29:41 UTC (rev 2548) @@ -98,16 +98,20 @@ * * Append a new row * + * @param args The parent object iter + * * @return Row iterator **/ -RexxMethod0(RexxObjectPtr, // Return type - GrxTreeStoreAppend) // Object_method name +RexxMethod1(RexxObjectPtr, // Return type + GrxTreeStoreAppend, // Object_method name + RexxObjectPtr, parent) // Parent object { RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); GtkTreeStore *tstore = (GtkTreeStore *)context->PointerValue(rxptr); + GtkTreeIter *piter = (GtkTreeIter *)context->PointerValue((RexxPointerObject)parent); GtkTreeIter *iter = (GtkTreeIter *)malloc(sizeof(GtkTreeIter)); - gtk_tree_store_append(tstore, iter, NULL); + gtk_tree_store_append(tstore, iter, piter); return (RexxObjectPtr)context->NewPointer(iter); } Modified: sandbox/david/4x/grxtreeview.cpp =================================================================== --- sandbox/david/4x/grxtreeview.cpp 2008-06-17 21:37:17 UTC (rev 2547) +++ sandbox/david/4x/grxtreeview.cpp 2008-06-18 14:29:41 UTC (rev 2548) @@ -315,6 +315,24 @@ } /** + * Method: expand_all + * + * Expand all levels of the tree. + * + * @return Zero. + **/ +RexxMethod0(int, // Return type + GrxTreeViewExpandAll) // Object_method name +{ + RexxPointerObject rxptr = (RexxPointerObject)context->GetObjectVariable("!POINTER"); + GtkTreeView *myWidget = (GtkTreeView *)context->PointerValue(rxptr); + + gtk_tree_view_expand_all(myWidget); + + return 0; +} + +/** * Method: signal_connect * * Connect a signal to an ooRexx method. Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-06-17 21:37:17 UTC (rev 2547) +++ sandbox/david/4x/rexxgtk.cls 2008-06-18 14:29:41 UTC (rev 2548) @@ -2746,6 +2746,8 @@ ::METHOD append_column EXTERNAL "LIBRARY rexxgtk GrxTreeViewAppendColumn" ::METHOD insert_column EXTERNAL "LIBRARY rexxgtk GrxTreeViewInsertColumn" ::METHOD remove_column EXTERNAL "LIBRARY rexxgtk GrxTreeViewRemoveColumn" +::METHOD set_model EXTERNAL "LIBRARY rexxgtk GrxTreeViewSetModel" +::METHOD expand_all EXTERNAL "LIBRARY rexxgtk GrxTreeViewExpandAll" ::METHOD signal_connect EXTERNAL "LIBRARY rexxgtk GrxTreeViewSignalConnect" -- The following are the methods that can be connected to signals. By default Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-06-17 21:37:17 UTC (rev 2547) +++ sandbox/david/4x/rexxgtk.cpp 2008-06-18 14:29:41 UTC (rev 2548) @@ -838,6 +838,7 @@ REXX_METHOD(GrxTreeViewInsertColumn, GrxTreeViewInsertColumn), REXX_METHOD(GrxTreeViewRemoveColumn, GrxTreeViewRemoveColumn), REXX_METHOD(GrxTreeViewSetModel, GrxTreeViewSetModel), + REXX_METHOD(GrxTreeViewExpandAll, GrxTreeViewExpandAll), REXX_METHOD(GrxTreeViewSignalConnect, GrxTreeViewSignalConnect), REXX_METHOD(GrxTreeViewColumnNew, GrxTreeViewColumnNew), REXX_METHOD(GrxTreeViewColumnSetTitle, GrxTreeViewColumnSetTitle), Modified: sandbox/david/4x/rexxgtk.h =================================================================== --- sandbox/david/4x/rexxgtk.h 2008-06-17 21:37:17 UTC (rev 2547) +++ sandbox/david/4x/rexxgtk.h 2008-06-18 14:29:41 UTC (rev 2548) @@ -605,6 +605,7 @@ REXX_METHOD_PROTOTYPE(GrxTreeViewInsertColumn) REXX_METHOD_PROTOTYPE(GrxTreeViewRemoveColumn) REXX_METHOD_PROTOTYPE(GrxTreeViewSetModel) +REXX_METHOD_PROTOTYPE(GrxTreeViewExpandAll) REXX_METHOD_PROTOTYPE(GrxTreeViewSignalConnect) REXX_METHOD_PROTOTYPE(GrxTreeViewColumnNew) REXX_METHOD_PROTOTYPE(GrxTreeViewColumnSetTitle) Added: sandbox/david/4x/test8-2.rex =================================================================== --- sandbox/david/4x/test8-2.rex (rev 0) +++ sandbox/david/4x/test8-2.rex 2008-06-18 14:29:41 UTC (rev 2548) @@ -0,0 +1,145 @@ +#!/usr/bin/rexx +/*----------------------------------------------------------------------------*/ +/* */ +/* Copyright (c) 2007-2008 Rexx Language Association. All rights reserved. */ +/* */ +/* This program and the accompanying materials are made available under */ +/* the terms of the Common Public License v1.0 which accompanies this */ +/* distribution. A copy is also available at the following address: */ +/* http://www.oorexx.org/license.html */ +/* */ +/* Redistribution and use in source and binary forms, with or */ +/* without modification, are permitted provided that the following */ +/* conditions are met: */ +/* */ +/* Redistributions of source code must retain the above copyright */ +/* notice, this list of conditions and the following disclaimer. */ +/* Redistributions in binary form must reproduce the above copyright */ +/* notice, this list of conditions and the following disclaimer in */ +/* the documentation and/or other materials provided with the distribution. */ +/* */ +/* Neither the name of Rexx Language Association nor the names */ +/* of its contributors may be used to endorse or promote products */ +/* derived from this software without specific prior written permission. */ +/* */ +/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */ +/* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */ +/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */ +/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */ +/* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */ +/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */ +/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */ +/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */ +/* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */ +/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */ +/* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +/* */ +/* Authors; */ +/* W. David Ashley <da...@us...> */ +/* */ +/*----------------------------------------------------------------------------*/ + + +-- Derived from Listing 8-2 +-- Foundations of GTK+ Development +-- by Andrew Krause + +BUY_IT = 0 +QUANTITY = 1 +PRODUCT = 2 +COLUMNS = 3 + +PRODUCT_CATEGORY = 0 +PRODUCT_CHILD = 1 + +list = .array~new(1) +list[1] = .GroceryItem~new(PRODUCT_CATEGORY, .true, 0, 'Cleaning Supplies') +list[2] = .GroceryItem~new(PRODUCT_CHILD, .true, 1, 'Paper Towels') +list[3] = .GroceryItem~new(PRODUCT_CHILD, .true, 3, 'Toilet Paper') +list[4] = .GroceryItem~new(PRODUCT_CATEGORY, .true, 0, 'Food') +list[5] = .GroceryItem~new(PRODUCT_CHILD, .true, 2, 'Bread') +list[6] = .GroceryItem~new(PRODUCT_CHILD, .false, 1, 'Butter') +list[7] = .GroceryItem~new(PRODUCT_CHILD, .true, 1, 'Milk') +list[8] = .GroceryItem~new(PRODUCT_CHILD, .false, 3, 'Chips') +list[9] = .GroceryItem~new(PRODUCT_CHILD, .true, 4, 'Soda') + +window = .myMainWindow~new(.gtk~GTK_WINDOW_TOPLEVEL) +window~set_title('Grocery List') +window~signal_connect('destroy') +window~set_border_width(10) +window~set_size_request(275, 300) + +treeview = .GtkTreeview~new() +call setup_tree_view treeview + +store = .GtkTreeStore~new(.gtk~G_TYPE_BOOLEAN, .gtk~G_TYPE_INT, .gtk~G_TYPE_STRING) + +do i = 1 to store~items + if store[i]~product_type = PRODUCT_CATEGORY then do + j = i + 1 + do while j <= store~items & store[j]~product_type <> PRODUCT_CATEGORY + if store[j]~buy then do + store[i]~quantity += store[j]~quantity + end + end + iter = store~append(.nil) + store~set_value(iter, BUY_IT, store[i]~buy. QUANTITY, store[i]~quantity,, + PRODUCT, store[i]~product) + end + else do + child = store~append(iter) + store~set_value(child, BUY_IT, store[i]~buy. QUANTITY, store[i]~quantity,, + PRODUCT, store[i]~product) + end + end + +treeview~set_model(store) + +treeview~set_model(store) +treeview~expand_all() + +scrolled_win = .GtkScrolledWindow~new(.nil, .nil) +scrolled_win_set+policy(.gtk~GTK_POLICY_AUTOMATIC, gtk~GTK_POLICY_AUTOMATIC) + +scrolled_win~add(treeview) +window~add(scrolled_win) +window~show_all() + +call gtk_main +return + +::requires 'rexxgtk.cls' + +::routine setup_tree_view +use strict arg treeview + +renderer = .GtkCellRendererTextView~new() +column = .GtkTreeViewColumn~new_with_attributes('Buy', renderer, 'text', BUY_IT) +treeview~append(column) + +renderer = .GtkCellRendererTextView~new() +column = .GtkTreeViewColumn~new_with_attributes('Count', renderer, 'text', QUANTITY) +treeview~append(column) + +renderer = .GtkCellRendererTextView~new() +column = .GtkTreeViewColumn~new_with_attributes('Product', renderer, 'text', PRODUCT) +treeview~append(column) +return + +::class GroceryItem + +::attribute product_type +::attribute buy +::attribute quantity +::attribute product + +::method init +use strict arg self~product_type, self~buy, self~quantity, self~product +return + +::class myMainWindow subclass GtkWindow + +::method signal_destroy +call gtk_main_quit +return + Property changes on: sandbox/david/4x/test8-2.rex ___________________________________________________________________ Name: svn:executable + * Name: svn:eol-style + native This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <wda...@us...> - 2008-07-06 18:48:16
|
Revision: 2677 http://oorexx.svn.sourceforge.net/oorexx/?rev=2677&view=rev Author: wdashley Date: 2008-07-06 11:48:25 -0700 (Sun, 06 Jul 2008) Log Message: ----------- ArtifactID: None Comment: Small cleanup of some code. Modified Paths: -------------- sandbox/david/4x/Makefile sandbox/david/4x/rexxgtk.cls sandbox/david/4x/rexxgtk.cpp Modified: sandbox/david/4x/Makefile =================================================================== --- sandbox/david/4x/Makefile 2008-07-06 15:44:06 UTC (rev 2676) +++ sandbox/david/4x/Makefile 2008-07-06 18:48:25 UTC (rev 2677) @@ -44,8 +44,8 @@ GRXCFLAGS = `pkg-config --cflags gtk+-2.0 gdk-2.0 glib-2.0 gthread-2.0` \ -fPIC -DVMAJOR=$(VMAJOR) \ -DVMINOR=$(VMINOR) -DVREL=$(VREL) \ - -I/home/dashley/ad/svn/sandbox/rick/opt/api \ - -I/home/dashley/ad/svn/sandbox/rick/opt/api/platform/unix + -I/home/dashley/ad/svn/oorexx/interpreter-3.x/trunk/api \ + -I/home/dashley/ad/svn/oorexx/interpreter-3.x/trunk/api/platform/unix OBJECTS = rexxgtk.o \ grxwidget.o \ grxwindow.o \ Modified: sandbox/david/4x/rexxgtk.cls =================================================================== --- sandbox/david/4x/rexxgtk.cls 2008-07-06 15:44:06 UTC (rev 2676) +++ sandbox/david/4x/rexxgtk.cls 2008-07-06 18:48:25 UTC (rev 2677) @@ -76,8 +76,8 @@ /*============================================================================*/ /* Class: GTK */ -/* Note: This class should never be instatiated. It is here just provided */ -/* a container for a host of GTK constants. */ +/* Note: This class should never be instatiated. It is here just as a */ +/* container for a host of GTK constants. */ /*============================================================================*/ ::class gtk public @@ -1409,7 +1409,7 @@ ::METHOD signal_connect use strict arg event --- first try the GtkFileChooser class hiearchy first +-- first try the inherited GtkFileChooser class hiearchy first if self~signal_connect:.GtkFileChooser(event) = .true then return .true -- now try the standard hiearchy return self~signal_connect_p @@ -2195,8 +2195,8 @@ self~init_6args(value, upper, lower, step, page, pagesz) return -::METHOD init_1args private EXTERNAL "LIBRARY rexxgtk GrxAdjustmentNew" -::METHOD init_6args private EXTERNAL "LIBRARY rexxgtk GrxAdjustmentNewFromPtr" +::METHOD init_1args private EXTERNAL "LIBRARY rexxgtk GrxAdjustmentNewFromPtr" +::METHOD init_6args private EXTERNAL "LIBRARY rexxgtk GrxAdjustmentNew" ::method pointer expose !pointer Modified: sandbox/david/4x/rexxgtk.cpp =================================================================== --- sandbox/david/4x/rexxgtk.cpp 2008-07-06 15:44:06 UTC (rev 2676) +++ sandbox/david/4x/rexxgtk.cpp 2008-07-06 18:48:25 UTC (rev 2677) @@ -46,7 +46,7 @@ /* Global variables */ /*----------------------------------------------------------------------------*/ -char * rexxgtk_argv[] = {"gtxrxdlg", "\0"}; +char * rexxgtk_argv[] = {"rexxgtk", "\0"}; int rexxgtk_argc = 1; @@ -107,7 +107,6 @@ gdk_threads_init(); gtk_set_locale (); gtk_init (&rexxgtk_argc, &argv); -// grxInitEventQueue(); return rc; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |