static void
impl_MateComponent_Listener_event (PortableServer_Servant servant,
const CORBA_char *event_name,
const CORBA_any *args,
CORBA_Environment *ev)
{
MateComponentListener *listener;
listener = MATECOMPONENT_LISTENER (matecomponent_object_from_servant (servant));
matecomponent_object_ref (MATECOMPONENT_OBJECT (listener));
if (listener->priv->event_callback)
matecomponent_closure_invoke (
listener->priv->event_callback,
G_TYPE_NONE,
MATECOMPONENT_TYPE_LISTENER, listener,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE, event_name,
MATECOMPONENT_TYPE_STATIC_CORBA_ANY, args,
MATECOMPONENT_TYPE_STATIC_CORBA_EXCEPTION, ev,
G_TYPE_INVALID);
g_signal_emit (G_OBJECT (listener),
signals [EVENT_NOTIFY], 0,
event_name, args, ev);
matecomponent_object_unref (MATECOMPONENT_OBJECT (listener));
}
static void
simple_tests (void)
{
MateComponentControl *control;
GtkWidget *widget = gtk_button_new_with_label ("Foo");
control = matecomponent_control_new (widget);
matecomponent_object_unref (MATECOMPONENT_OBJECT (control));
control = matecomponent_control_new (gtk_entry_new ());
matecomponent_object_unref (MATECOMPONENT_OBJECT (control));
}
/**
* matecomponent_event_source_notify_listeners:
* @event_source: the Event Source that will emit the event.
* @event_name: Name of the event being emitted
* @opt_value: A CORBA_any value that contains the data that is passed
* to interested clients, or NULL for an empty value
* @opt_ev: A CORBA_Environment where a failure code can be returned, can be NULL.
*
* This will notify all clients that have registered with this EventSource
* (through the addListener or addListenerWithMask methods) of the availability
* of the event named @event_name. The @value CORBA::any value is passed to
* all listeners.
*
* @event_name can not contain comma separators, as commas are used to
* separate the various event names.
*/
void
matecomponent_event_source_notify_listeners (MateComponentEventSource *event_source,
const char *event_name,
const CORBA_any *opt_value,
CORBA_Environment *opt_ev)
{
GSList *l, *notify;
CORBA_Environment *ev, temp_ev;
const MateComponentArg *my_value;
g_return_if_fail (MATECOMPONENT_IS_EVENT_SOURCE (event_source));
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
if (!opt_value)
my_value = matecomponent_arg_new (MATECOMPONENT_ARG_NULL);
else
my_value = opt_value;
notify = NULL;
for (l = event_source->priv->listeners; l; l = l->next) {
ListenerDesc *desc = (ListenerDesc *) l->data;
if (desc->event_masks == NULL ||
event_match (event_name, desc->event_masks)) {
notify = g_slist_prepend (
notify,
CORBA_Object_duplicate (desc->listener, ev));
}
}
matecomponent_object_ref (MATECOMPONENT_OBJECT (event_source));
for (l = notify; l; l = l->next) {
MateComponent_Listener_event (l->data, event_name, my_value, ev);
CORBA_Object_release (l->data, ev);
}
matecomponent_object_unref (MATECOMPONENT_OBJECT (event_source));
g_slist_free (notify);
if (!opt_ev)
CORBA_exception_free (ev);
if (!opt_value)
matecomponent_arg_release ((MateComponentArg *) my_value);
}
/**
* matecomponent_control_get_remote_ui_container:
* @control: A MateComponentControl object which is associated with a remote
* ControlFrame.
* @opt_ev: an optional exception environment
*
* Returns: The MateComponent_UIContainer CORBA server for the remote MateComponentControlFrame.
*/
MateComponent_UIContainer
matecomponent_control_get_remote_ui_container (MateComponentControl *control,
CORBA_Environment *opt_ev)
{
CORBA_Environment tmp_ev, *ev;
MateComponent_UIContainer ui_container;
g_return_val_if_fail (MATECOMPONENT_IS_CONTROL (control), CORBA_OBJECT_NIL);
g_return_val_if_fail (control->priv->frame != CORBA_OBJECT_NIL,
CORBA_OBJECT_NIL);
if (!opt_ev) {
CORBA_exception_init (&tmp_ev);
ev = &tmp_ev;
} else
ev = opt_ev;
ui_container = MateComponent_ControlFrame_getUIContainer (control->priv->frame, ev);
matecomponent_object_check_env (MATECOMPONENT_OBJECT (control), control->priv->frame, ev);
if (MATECOMPONENT_EX (ev))
ui_container = CORBA_OBJECT_NIL;
if (!opt_ev)
CORBA_exception_free (&tmp_ev);
return ui_container;
}
GList *
matecomponent_zoomable_frame_get_preferred_zoom_level_names (MateComponentZoomableFrame *zoomable_frame)
{
CORBA_Environment ev;
MateComponent_ZoomLevelNameList *zoom_level_names;
GList *list = NULL;
int i;
g_return_val_if_fail (MATECOMPONENT_IS_ZOOMABLE_FRAME (zoomable_frame), NULL);
CORBA_exception_init (&ev);
zoom_level_names = MateComponent_Zoomable__get_preferredLevelNames (
zoomable_frame->priv->zoomable, &ev);
if (MATECOMPONENT_EX (&ev)) {
matecomponent_object_check_env (MATECOMPONENT_OBJECT (zoomable_frame),
zoomable_frame->priv->zoomable, &ev);
CORBA_exception_free (&ev);
return NULL;
}
CORBA_exception_free (&ev);
if (zoom_level_names == CORBA_OBJECT_NIL)
return NULL;
for (i = 0; i < zoom_level_names->_length; i++)
list = g_list_prepend (list, g_strdup (zoom_level_names->_buffer [i]));
CORBA_free (zoom_level_names);
return g_list_reverse (list);
}
static void
mate_panel_applet_frame_matecomponent_finalize (GObject *object)
{
MatePanelAppletFrameMateComponent *frame = MATE_PANEL_APPLET_FRAME_MATECOMPONENT (object);
if (frame->priv->control) {
/* do this before unref'ing every matecomponent stuff since it looks
* like we can receive some events when unref'ing them */
MateCORBA_small_unlisten_for_broken (frame->priv->control,
G_CALLBACK (mate_panel_applet_frame_matecomponent_applet_broken));
matecomponent_object_release_unref (frame->priv->control, NULL);
frame->priv->control = CORBA_OBJECT_NIL;
}
if (frame->priv->property_bag)
matecomponent_object_release_unref (
frame->priv->property_bag, NULL);
if (frame->priv->applet_shell)
matecomponent_object_release_unref (
frame->priv->applet_shell, NULL);
if (frame->priv->ui_component)
matecomponent_object_unref (
MATECOMPONENT_OBJECT (frame->priv->ui_component));
G_OBJECT_CLASS (mate_panel_applet_frame_matecomponent_parent_class)->finalize (object);
}
/**
* matecomponent_stream_cache_create:
* @cs: a reference to the stream we want to cache
* @opt_ev: an optional environment
*
* Returns a new MateComponentStream object
*/
MateComponentObject *
matecomponent_stream_cache_create (MateComponent_Stream cs,
CORBA_Environment *opt_ev)
{
MateComponentStreamCache *stream;
CORBA_Environment ev, *my_ev;
matecomponent_return_val_if_fail (cs != NULL, NULL, opt_ev);
if (!(stream = g_object_new (matecomponent_stream_cache_get_type (), NULL))) {
if (opt_ev)
matecomponent_exception_set (opt_ev, ex_MateComponent_Storage_IOError);
return NULL;
}
if (!opt_ev) {
CORBA_exception_init (&ev);
my_ev = &ev;
} else
my_ev = opt_ev;
stream->priv->cs = matecomponent_object_dup_ref (cs, my_ev);
if (MATECOMPONENT_EX (my_ev)) {
if (!opt_ev)
CORBA_exception_free (&ev);
matecomponent_object_unref (MATECOMPONENT_OBJECT (stream));
return NULL;
}
if (!opt_ev)
CORBA_exception_free (&ev);
return (MateComponentObject *) stream;
}
/**
* matecomponent_zoomable_frame_bind_to_zoomable:
* @zoomable_frame: A MateComponentZoomableFrame object.
* @zoomable: The CORBA object for the MateComponentZoomable embedded
* in this MateComponentZoomableFrame.
*
* Associates @zoomable with this @zoomable_frame.
*/
void
matecomponent_zoomable_frame_bind_to_zoomable (MateComponentZoomableFrame *zoomable_frame,
MateComponent_Zoomable zoomable,
CORBA_Environment *opt_ev)
{
CORBA_Environment *ev, temp_ev;
g_return_if_fail (zoomable != CORBA_OBJECT_NIL);
g_return_if_fail (MATECOMPONENT_IS_ZOOMABLE_FRAME (zoomable_frame));
if (zoomable_frame->priv->zoomable != CORBA_OBJECT_NIL)
CORBA_Object_release (zoomable_frame->priv->zoomable, NULL);
zoomable_frame->priv->zoomable = CORBA_Object_duplicate (zoomable, NULL);
if (!opt_ev) {
CORBA_exception_init (&temp_ev);
ev = &temp_ev;
} else
ev = opt_ev;
MateComponent_Zoomable_setFrame (zoomable, MATECOMPONENT_OBJREF (zoomable_frame), ev);
if (MATECOMPONENT_EX (ev))
matecomponent_object_check_env (MATECOMPONENT_OBJECT (zoomable_frame), zoomable, ev);
if (!opt_ev)
CORBA_exception_free (&temp_ev);
}
MateComponentObject *
matecomponent_foreign_object_new (CORBA_Object corba_objref)
{
MateComponentObject *object;
CORBA_Environment ev[1];
g_return_val_if_fail (corba_objref != CORBA_OBJECT_NIL, NULL);
CORBA_exception_init (ev);
if (!CORBA_Object_is_a (corba_objref, "IDL:MateComponent/Unknown:1.0", ev)) {
if (ev->_major != CORBA_NO_EXCEPTION) {
char *text = matecomponent_exception_get_text (ev);
g_warning ("CORBA_Object_is_a: %s", text);
g_free (text);
} else
g_warning ("matecomponent_foreign_object_new: corba_objref"
" doesn't have interface MateComponent::Unknown");
object = NULL;
} else {
object = MATECOMPONENT_OBJECT (g_object_new (MATECOMPONENT_TYPE_FOREIGN_OBJECT, NULL));
object->corba_objref = CORBA_Object_duplicate (corba_objref, NULL);
matecomponent_running_context_add_object_T (object->corba_objref);
}
CORBA_exception_free (ev);
return object;
}
MateComponent_Listener
matecomponent_event_source_client_add_listener_full (MateComponent_Unknown object,
GClosure *event_callback,
const char *opt_mask,
CORBA_Environment *opt_ev)
{
MateComponentListener *listener = NULL;
MateComponent_Listener corba_listener = CORBA_OBJECT_NIL;
MateComponent_Unknown es;
CORBA_Environment *ev, temp_ev;
g_return_val_if_fail (event_callback != NULL, CORBA_OBJECT_NIL);
if (!opt_ev) {
ev = &temp_ev;
CORBA_exception_init (ev);
} else
ev = opt_ev;
es = MateComponent_Unknown_queryInterface (object,
"IDL:MateComponent/EventSource:1.0", ev);
if (MATECOMPONENT_EX (ev) || !es)
goto add_listener_end;
if (!(listener = matecomponent_listener_new_closure (event_callback)))
goto add_listener_end;
corba_listener = MATECOMPONENT_OBJREF (listener);
if (opt_mask)
MateComponent_EventSource_addListenerWithMask (
es, corba_listener, opt_mask, ev);
else
MateComponent_EventSource_addListener (
es, corba_listener, ev);
corba_listener = CORBA_Object_duplicate (corba_listener, ev);
matecomponent_object_unref (MATECOMPONENT_OBJECT (listener));
matecomponent_object_release_unref (es, ev);
add_listener_end:
if (!opt_ev) {
if (MATECOMPONENT_EX (ev)) {
char *text = matecomponent_exception_get_text (ev);
g_warning ("add_listener failed '%s'", text);
g_free (text);
}
CORBA_exception_free (ev);
}
return corba_listener;
}
/**
* matecomponent_canvas_component_factory_new:
* @item_factory: A callback invoke when the container activates the object.
* @user_data: User data pointer.
*
* Returns: The object to be passed into matecomponent_generic_factory_main.
*/
MateComponentObject *matecomponent_canvas_component_factory_new(
MateItemCreator item_factory, void *user_data)
{
MateComponentCanvasComponentFactory *factory;
factory = g_object_new (MATECOMPONENT_CANVAS_COMPONENT_FACTORY_TYPE, NULL);
factory->priv->item_creator = item_factory;
factory->priv->item_creator_data = user_data;
return MATECOMPONENT_OBJECT(factory);
}
void
matecomponent_control_set_popup_ui_container (MateComponentControl *control,
MateComponentUIContainer *ui_container)
{
g_return_if_fail (MATECOMPONENT_IS_CONTROL (control));
g_return_if_fail (MATECOMPONENT_IS_UI_CONTAINER (ui_container));
g_assert (control->priv->popup_ui_container == NULL);
control->priv->popup_ui_container = matecomponent_object_ref (
MATECOMPONENT_OBJECT (ui_container));
}
static void
control_frame_connection_died_cb (gpointer connection,
gpointer user_data)
{
MateComponentControl *control = MATECOMPONENT_CONTROL (user_data);
g_return_if_fail (control != NULL);
matecomponent_control_disconnected (control);
dbgprintf ("The remote control frame died unexpectedly");
matecomponent_object_unref (MATECOMPONENT_OBJECT (control));
}
void
matecomponent_zoomable_frame_set_zoom_level (MateComponentZoomableFrame *zoomable_frame, float zoom_level)
{
CORBA_Environment ev;
g_return_if_fail (MATECOMPONENT_IS_ZOOMABLE_FRAME (zoomable_frame));
CORBA_exception_init (&ev);
MateComponent_Zoomable_setLevel (zoomable_frame->priv->zoomable, zoom_level, &ev);
matecomponent_object_check_env (MATECOMPONENT_OBJECT (zoomable_frame),
zoomable_frame->priv->zoomable, &ev);
CORBA_exception_free (&ev);
}
static void
matecomponent_event_source_finalize (GObject *object)
{
MateComponentEventSourcePrivate *priv;
priv = MATECOMPONENT_EVENT_SOURCE (object)->priv;
/* in case of strange re-enterancy */
matecomponent_event_source_destroy (MATECOMPONENT_OBJECT (object));
g_free (priv);
matecomponent_event_source_parent_class->finalize (object);
}
/**
* matecomponent_property_control_construct:
* @property_control: A MateComponentPropertyControl object.
* @event_source: A MateComponentEventSource object that will be aggregated onto the
* property control.
* @get_fn: Creation routine.
* @closure: Data passed to closure routine.
*
* Initialises the MateComponentPropertyControl object.
*
* Returns: The newly constructed MateComponentPropertyControl.
*/
MateComponentPropertyControl *
matecomponent_property_control_construct (MateComponentPropertyControl *property_control,
MateComponentEventSource *event_source,
MateComponentPropertyControlGetControlFn get_fn,
int num_pages,
void *closure)
{
MateComponentPropertyControlPrivate *priv;
g_return_val_if_fail (MATECOMPONENT_IS_EVENT_SOURCE (event_source), NULL);
g_return_val_if_fail (MATECOMPONENT_IS_PROPERTY_CONTROL (property_control), NULL);
priv = property_control->priv;
priv->get_fn = get_fn;
priv->page_count = num_pages;
priv->closure = closure;
priv->event_source = event_source;
matecomponent_object_add_interface (MATECOMPONENT_OBJECT (property_control),
MATECOMPONENT_OBJECT (priv->event_source));
return property_control;
}
void
matecomponent_zoomable_frame_zoom_to_default (MateComponentZoomableFrame *zoomable_frame)
{
CORBA_Environment ev;
g_return_if_fail (MATECOMPONENT_IS_ZOOMABLE_FRAME (zoomable_frame));
g_return_if_fail (zoomable_frame->priv->zoomable != CORBA_OBJECT_NIL);
CORBA_exception_init (&ev);
MateComponent_Zoomable_zoomDefault (zoomable_frame->priv->zoomable, &ev);
matecomponent_object_check_env (MATECOMPONENT_OBJECT (zoomable_frame),
zoomable_frame->priv->zoomable, &ev);
CORBA_exception_free (&ev);
}
MateComponentObject *
matecomponent_running_context_new (void)
{
if (matecomponent_running_context) {
matecomponent_object_ref (matecomponent_running_context);
return matecomponent_running_context;
}
matecomponent_running_context = g_object_new (
matecomponent_running_context_get_type (), NULL);
matecomponent_running_event_source = matecomponent_event_source_new ();
matecomponent_running_context_ignore_object (
MATECOMPONENT_OBJREF (matecomponent_running_event_source));
matecomponent_event_source_ignore_listeners (matecomponent_running_event_source);
matecomponent_object_add_interface (MATECOMPONENT_OBJECT (matecomponent_running_context),
MATECOMPONENT_OBJECT (matecomponent_running_event_source));
g_signal_connect (G_OBJECT (matecomponent_running_context),
"destroy", G_CALLBACK (check_destroy), NULL);
return matecomponent_running_context;
}
void
matecomponent_control_set_ui_component (MateComponentControl *control,
MateComponentUIComponent *component)
{
g_return_if_fail (MATECOMPONENT_IS_CONTROL (control));
g_return_if_fail (component == NULL ||
MATECOMPONENT_IS_UI_COMPONENT (component));
if (component == control->priv->ui_component)
return;
if (control->priv->ui_component) {
matecomponent_ui_component_unset_container (control->priv->ui_component, NULL);
matecomponent_object_unref (MATECOMPONENT_OBJECT (control->priv->ui_component));
}
control->priv->ui_component = matecomponent_object_ref ((MateComponentObject *) component);
}
static void
xfapplet_unload_applet (XfAppletPlugin *xap)
{
if (xap->prop_bag) {
matecomponent_object_release_unref (xap->prop_bag, NULL);
xap->prop_bag = CORBA_OBJECT_NIL;
}
if (xap->uic) {
matecomponent_object_unref (MATECOMPONENT_OBJECT (xap->uic));
xap->uic = NULL;
}
if (xap->object) {
MateCORBA_small_unlisten_for_broken (xap->object, G_CALLBACK (xfapplet_connection_broken));
CORBA_Object_release (xap->object, NULL);
xap->object = CORBA_OBJECT_NIL;
}
}
float
matecomponent_zoomable_frame_get_max_zoom_level (MateComponentZoomableFrame *zoomable_frame)
{
CORBA_Environment ev;
float retval;
g_return_val_if_fail (MATECOMPONENT_IS_ZOOMABLE_FRAME (zoomable_frame), 0.0);
g_return_val_if_fail (zoomable_frame->priv->zoomable != CORBA_OBJECT_NIL, 0.0);
CORBA_exception_init (&ev);
retval = MateComponent_Zoomable__get_maxLevel (zoomable_frame->priv->zoomable, &ev);
if (MATECOMPONENT_EX (&ev))
retval = 0.0;
matecomponent_object_check_env (MATECOMPONENT_OBJECT (zoomable_frame),
zoomable_frame->priv->zoomable, &ev);
CORBA_exception_free (&ev);
return retval;
}
gboolean
matecomponent_zoomable_frame_is_continuous (MateComponentZoomableFrame *zoomable_frame)
{
CORBA_Environment ev;
gboolean retval;
g_return_val_if_fail (MATECOMPONENT_IS_ZOOMABLE_FRAME (zoomable_frame), FALSE);
g_return_val_if_fail (zoomable_frame->priv->zoomable != CORBA_OBJECT_NIL, FALSE);
CORBA_exception_init (&ev);
retval = MateComponent_Zoomable__get_isContinuous (zoomable_frame->priv->zoomable, &ev);
if (MATECOMPONENT_EX (&ev))
retval = FALSE;
matecomponent_object_check_env (MATECOMPONENT_OBJECT (zoomable_frame),
zoomable_frame->priv->zoomable, &ev);
CORBA_exception_free (&ev);
return retval;
}
/**
* matecomponent_control_activate_notify:
* @control: A #MateComponentControl object which is bound
* to a remote ControlFrame.
* @activated: Whether or not @control has been activated.
* @opt_ev: An optional exception environment
*
* Notifies the remote ControlFrame which is associated with
* @control that @control has been activated/deactivated.
*/
void
matecomponent_control_activate_notify (MateComponentControl *control,
gboolean activated,
CORBA_Environment *opt_ev)
{
CORBA_Environment *ev, tmp_ev;
g_return_if_fail (MATECOMPONENT_IS_CONTROL (control));
g_return_if_fail (control->priv->frame != CORBA_OBJECT_NIL);
if (!opt_ev) {
CORBA_exception_init (&tmp_ev);
ev = &tmp_ev;
} else
ev = opt_ev;
MateComponent_ControlFrame_notifyActivated (control->priv->frame, activated, ev);
matecomponent_object_check_env (MATECOMPONENT_OBJECT (control), control->priv->frame, ev);
if (!opt_ev)
CORBA_exception_free (&tmp_ev);
}
static void
create_frame (Test *test, gboolean fake_remote)
{
MateComponent_Control control;
control = MATECOMPONENT_OBJREF (test->control);
/* if (fake_remote)
control = MateCORBA_objref_get_proxy (control);*/
test->matecomponent_widget = matecomponent_widget_new_control_from_objref (
control, CORBA_OBJECT_NIL);
matecomponent_object_unref (MATECOMPONENT_OBJECT (test->control));
gtk_widget_show (test->matecomponent_widget);
test->frame = matecomponent_widget_get_control_frame (
MATECOMPONENT_WIDGET (test->matecomponent_widget));
test->socket = matecomponent_control_frame_get_socket (test->frame);
g_object_add_weak_pointer (G_OBJECT (test->frame),
(gpointer *) &test->frame);
g_object_add_weak_pointer (G_OBJECT (test->socket),
(gpointer *) &test->socket);
g_object_add_weak_pointer (G_OBJECT (test->matecomponent_widget),
(gpointer *) &test->matecomponent_widget);
}
MateComponentObject *
circle_control_new (CommonData *com)
{
MateComponentPropertyBag *pb;
MateComponentControl *control;
GParamSpec **pspecs;
guint n_pspecs;
GtkWidget *button, *frame, *spin, *hbox, *spin_label;
GtkObject *adj;
GSList **list = &com->list;
GSList *li;
ObjectData *object = NULL;
frame = gtk_frame_new("Circle");
hbox = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(frame), hbox);
button = gtk_button_new();
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
spin_label = gtk_label_new ("Speed:");
gtk_box_pack_start (GTK_BOX (hbox), spin_label, FALSE, FALSE, 0);
adj = gtk_adjustment_new(100.0, 0.0, 1000.0, 1.0, 10.0, 0.0);
g_signal_connect(adj, "value_changed", G_CALLBACK(set_speed), com);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 0.0, 0);
gtk_box_pack_start (GTK_BOX (hbox), spin, FALSE, FALSE, 0);
gtk_widget_show_all(frame);
control = matecomponent_control_new (frame);
pb = matecomponent_property_bag_new (NULL, NULL, NULL);
matecomponent_control_set_properties (control, MATECOMPONENT_OBJREF (pb), NULL);
matecomponent_object_unref (MATECOMPONENT_OBJECT (pb));
g_signal_connect(button, "clicked", G_CALLBACK(on_press), com);
pspecs = g_object_class_list_properties (
G_OBJECT_GET_CLASS (button), &n_pspecs);
matecomponent_property_bag_map_params (
pb, G_OBJECT (button), (const GParamSpec **)pspecs, n_pspecs);
g_free (pspecs);
matecomponent_control_life_instrument (control);
li = g_slist_last(*list);
if (li)
{
object = li->data;
}
if (!object || object->button)
{
object = g_new0(ObjectData, 1);
*list = g_slist_append(*list, object);
}
object->button = button;
object->adj = GTK_ADJUSTMENT(adj);
update_button(object, com);
set_speed(GTK_ADJUSTMENT(adj), com);
return MATECOMPONENT_OBJECT (control);
}
MateComponentObject *
matecomponent_entry_control_new (void)
{
MateComponentPropertyBag *pb;
MateComponentControl *control;
GtkWidget *entry;
GParamSpec **pspecs;
guint n_pspecs;
GtkWidget *box;
int i;
/* Create the control. */
box = gtk_vbox_new (FALSE, 0);
for (i = 0; i < 3; i++) {
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (box), entry, FALSE, FALSE, 0);
gtk_widget_show (entry);
}
gtk_widget_show (box);
#ifdef USE_SCROLLED
{
GtkWidget *canvas, *scrolled;
MateCanvasItem *item;
canvas = mate_canvas_new ();
gtk_widget_show (canvas);
item = mate_canvas_item_new (
mate_canvas_root (MATE_CANVAS (canvas)),
MATE_TYPE_CANVAS_WIDGET,
"x", 0.0, "y", 0.0, "width", 100.0,
"height", 100.0, "widget", box, NULL);
mate_canvas_item_show (item);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (
GTK_CONTAINER (scrolled), canvas);
gtk_widget_show (scrolled);
control = matecomponent_control_new (scrolled);
}
#else
control = matecomponent_control_new (box);
#endif
pb = matecomponent_property_bag_new (NULL, NULL, NULL);
matecomponent_control_set_properties (control, MATECOMPONENT_OBJREF (pb), NULL);
matecomponent_object_unref (MATECOMPONENT_OBJECT (pb));
g_signal_connect (
GTK_OBJECT (entry), "activate",
G_CALLBACK (activate_cb), control);
pspecs = g_object_class_list_properties (
G_OBJECT_GET_CLASS (entry), &n_pspecs);
matecomponent_property_bag_map_params (
pb, G_OBJECT (entry), (const GParamSpec **)pspecs, n_pspecs);
g_free (pspecs);
matecomponent_control_life_instrument (control);
return MATECOMPONENT_OBJECT (control);
}
