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); }