static void action_changed (GtkComboBox *combo, UmPasswordDialog *um) { gint active; active = gtk_combo_box_get_active (combo); if (active == 0) { gtk_widget_set_sensitive (um->password_entry, TRUE); gtk_widget_set_sensitive (um->generate_button, TRUE); gtk_widget_set_has_tooltip (um->generate_button, TRUE); gtk_widget_set_sensitive (um->verify_entry, TRUE); gtk_widget_set_sensitive (um->old_password_entry, TRUE); gtk_widget_set_sensitive (um->normal_hint_entry, TRUE); gtk_widget_set_sensitive (um->normal_hint_label, TRUE); gtk_widget_set_sensitive (um->strength_indicator_label, TRUE); gtk_widget_set_sensitive (um->show_password_button, TRUE); update_sensitivity (um); } else { gtk_widget_set_sensitive (um->password_entry, FALSE); gtk_widget_set_sensitive (um->generate_button, FALSE); gtk_widget_set_has_tooltip (um->generate_button, FALSE); gtk_widget_set_sensitive (um->verify_entry, FALSE); gtk_widget_set_sensitive (um->old_password_entry, FALSE); gtk_widget_set_sensitive (um->normal_hint_entry, FALSE); gtk_widget_set_sensitive (um->normal_hint_label, FALSE); gtk_widget_set_sensitive (um->strength_indicator_label, FALSE); gtk_widget_set_sensitive (um->show_password_button, FALSE); gtk_widget_set_sensitive (um->ok_button, TRUE); } }
int main(int argc, char *argv[]) { gtk_init(&argc, &argv); GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL); GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_add(GTK_CONTAINER(window), vbox); GtkWidget *button = gtk_button_new_with_label("Button"); gtk_widget_set_has_tooltip(GTK_WIDGET(button), TRUE); g_signal_connect(button, "query-tooltip", G_CALLBACK(on_query_tooltip), "Button with advanced Tooltip"); gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 0); GtkWidget *label = gtk_label_new("Label"); gtk_widget_set_has_tooltip(GTK_WIDGET(label), TRUE); g_signal_connect(label, "query-tooltip", G_CALLBACK(on_query_tooltip), "Label with advanced Tooltip"); gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0); GtkWidget *entry = gtk_entry_new(); gtk_widget_set_has_tooltip(GTK_WIDGET(entry), TRUE); g_signal_connect(entry, "query-tooltip", G_CALLBACK(on_query_tooltip), "Entry with advanced Tooltip"); gtk_box_pack_start(GTK_BOX(vbox), entry, TRUE, TRUE, 0); gtk_widget_show_all(window); gtk_main(); return 0; }
void setup_tooltip_with_embedded_icon (GtkWidget *widget, const gchar *text, const gchar *placeholder, GIcon *icon) { IconShapeData *data; data = g_object_get_data (G_OBJECT (widget), "icon-shape-data"); if (data) { gtk_widget_set_has_tooltip (widget, FALSE); g_signal_handler_disconnect (widget, data->query_id); g_object_set_data (G_OBJECT (widget), "icon-shape-data", NULL); g_object_set_data (G_OBJECT (widget), "tooltip-label", NULL); } if (!placeholder) { gtk_widget_set_tooltip_text (widget, text); return; } data = icon_shape_data_new (text, placeholder, icon); g_object_set_data_full (G_OBJECT (widget), "icon-shape-data", data, icon_shape_data_free); gtk_widget_set_has_tooltip (widget, TRUE); data->query_id = g_signal_connect (widget, "query-tooltip", G_CALLBACK (query_unlock_tooltip), NULL); }
void e_buffer_tagger_disconnect (GtkTextView *textview) { GtkTextBuffer *buffer; GtkTextTagTable *tag_table; GtkTextTag *tag; g_return_if_fail (textview != NULL); g_return_if_fail (GTK_IS_TEXT_VIEW (textview)); buffer = gtk_text_view_get_buffer (textview); tag_table = gtk_text_buffer_get_tag_table (buffer); tag = gtk_text_tag_table_lookup (tag_table, E_BUFFER_TAGGER_LINK_TAG); /* if tag is not there, then it is not connected, thus claim */ g_return_if_fail (tag != NULL); gtk_text_tag_table_remove (tag_table, tag); set_state (buffer, E_BUFFER_TAGGER_STATE_NONE); g_signal_handlers_disconnect_by_func (buffer, G_CALLBACK (buffer_insert_text), NULL); g_signal_handlers_disconnect_by_func (buffer, G_CALLBACK (buffer_delete_range), NULL); g_signal_handlers_disconnect_by_func (buffer, G_CALLBACK (buffer_cursor_position), NULL); gtk_widget_set_has_tooltip (GTK_WIDGET (textview), FALSE); g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_query_tooltip), NULL); g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_key_press_event), NULL); g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_event_after), NULL); g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_motion_notify_event), NULL); g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_visibility_notify_event), NULL); }
ClockLocationTile * clock_location_tile_new (ClockLocation *loc, ClockFaceSize size) { ClockLocationTile *this; ClockLocationTilePrivate *priv; this = g_object_new (CLOCK_LOCATION_TILE_TYPE, NULL); priv = PRIVATE (this); priv->location = g_object_ref (loc); priv->size = size; clock_location_tile_fill (this); update_weather_icon (loc, clock_location_get_weather_info (loc), this); gtk_widget_set_has_tooltip (priv->weather_icon, TRUE); g_signal_connect (priv->weather_icon, "query-tooltip", G_CALLBACK (weather_tooltip), this); priv->location_weather_updated_id = g_signal_connect (G_OBJECT (loc), "weather-updated", G_CALLBACK (update_weather_icon), this); return this; }
/** @brief set label and tip for existing button @a button This does not affect the button's "default" label @param button the button widget to be updated @param type 0-based index into labels array @return */ void e2_button_set_indexed_text (GtkWidget *button, E2_ButtonText type) { if (type >= 0 && type < (sizeof(defined_button_labels)/sizeof(defined_button_labels[0]))) { e2_button_set_label (button, defined_button_labels[type]); if (defined_button_tips[type] != NULL) { e2_widget_set_safetip (button, defined_button_tips[type]); } else { #ifdef USE_GTK2_12TIPS gtk_widget_set_has_tooltip (button, FALSE); #else GtkTooltipsData *tdata = gtk_tooltips_data_get (button); if (tdata != NULL) { g_free (tdata->tip_text); tdata->tip_text = NULL; g_free (tdata->tip_private); tdata->tip_private = NULL; } #endif } } }
static void pgd_text_buffer_selection_changed (GtkTextBuffer *buffer, GParamSpec *pspec, GtkWidget *textview) { gtk_widget_set_has_tooltip (textview, gtk_text_buffer_get_has_selection (buffer)); }
static gint gtk_icon_entry_leave_notify (GtkWidget *widget, GdkEventCrossing *event) { GtkIconEntry *entry; GtkIconEntryPrivate *priv; int i; entry = GTK_ICON_ENTRY (widget); priv = GTK_ICON_ENTRY_GET_PRIVATE (entry); for (i = 0; i < MAX_ICONS; i++) { if (event->window == priv->icons[i].window) { if (gtk_icon_entry_get_icon_highlight (entry, i)) { priv->icons[i].hovered = FALSE; gtk_widget_set_has_tooltip (widget, FALSE); gtk_widget_queue_draw (widget); break; } } } return FALSE; }
/* Creates GtkStatusIcon and tooltip */ void launcher_create_icon (launcher_core_s *launcher_core, char *image, char *text) { launcher_core->icon = (GtkWidget *) gtk_status_icon_new_from_pixbuf (create_pixbuf(image)); gtk_status_icon_set_tooltip_text(GTK_STATUS_ICON(launcher_core->icon), text); gtk_widget_set_has_tooltip(launcher_core->window, TRUE); }
void tree_view_set_tooltip_column(GtkTreeView *tree_view, gint column) { g_signal_connect(tree_view, "query-tooltip", G_CALLBACK(tree_view_set_tooltip_query_cb), GINT_TO_POINTER(column)); gtk_widget_set_has_tooltip(GTK_WIDGET(tree_view), TRUE); }
void tooltip_attach(GeanyEditor *editor) { if (option_editor_tooltips) { gtk_widget_set_has_tooltip(GTK_WIDGET(editor->sci), TRUE); g_signal_connect(editor->sci, "query-tooltip", G_CALLBACK(on_query_tooltip), editor); } }
void e_buffer_tagger_connect (GtkTextView *textview) { GtkTextBuffer *buffer; GtkTextTagTable *tag_table; GtkTextTag *tag; init_magic_links (); g_return_if_fail (textview != NULL); g_return_if_fail (GTK_IS_TEXT_VIEW (textview)); buffer = gtk_text_view_get_buffer (textview); tag_table = gtk_text_buffer_get_tag_table (buffer); tag = gtk_text_tag_table_lookup (tag_table, E_BUFFER_TAGGER_LINK_TAG); /* if tag is there already, then it is connected, thus claim */ g_return_if_fail (tag == NULL); gtk_text_buffer_create_tag ( buffer, E_BUFFER_TAGGER_LINK_TAG, "foreground", "blue", "underline", PANGO_UNDERLINE_SINGLE, NULL); set_state (buffer, E_BUFFER_TAGGER_STATE_NONE); g_signal_connect ( buffer, "insert-text", G_CALLBACK (buffer_insert_text), NULL); g_signal_connect ( buffer, "delete-range", G_CALLBACK (buffer_delete_range), NULL); g_signal_connect ( buffer, "notify::cursor-position", G_CALLBACK (buffer_cursor_position), NULL); gtk_widget_set_has_tooltip (GTK_WIDGET (textview), TRUE); g_signal_connect ( textview, "query-tooltip", G_CALLBACK (textview_query_tooltip), NULL); g_signal_connect ( textview, "key-press-event", G_CALLBACK (textview_key_press_event), NULL); g_signal_connect ( textview, "event-after", G_CALLBACK (textview_event_after), NULL); g_signal_connect ( textview, "motion-notify-event", G_CALLBACK (textview_motion_notify_event), NULL); g_signal_connect ( textview, "visibility-notify-event", G_CALLBACK (textview_visibility_notify_event), NULL); }
static void generate_clicked (GtkButton *button, UmPasswordDialog *um) { gtk_menu_popup (GTK_MENU (um->generate_menu), NULL, NULL, (GtkMenuPositionFunc) popup_menu_below_button, um->generate_button, 0, gtk_get_current_event_time ()); gtk_widget_set_has_tooltip (um->generate_button, FALSE); }
static void anaconda_disk_overview_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { AnacondaDiskOverview *widget = ANACONDA_DISK_OVERVIEW(object); AnacondaDiskOverviewPrivate *priv = widget->priv; switch(prop_id) { case PROP_DESCRIPTION: { char *markup = g_markup_printf_escaped("<span weight='bold' size='large'>%s</span>", g_value_get_string(value)); gtk_label_set_markup(GTK_LABEL(priv->description_label), markup); g_free(markup); break; } case PROP_KIND: if (widget->priv->kind) g_free(widget->priv->kind); widget->priv->kind = g_strdup(g_value_get_string(value)); set_icon(widget, widget->priv->kind); gtk_grid_attach(GTK_GRID(widget->priv->grid), widget->priv->kind_icon, 0, 1, 3, 1); break; case PROP_FREE: { char *markup = g_markup_printf_escaped("<span size='large'>%s</span>", g_value_get_string(value)); gtk_label_set_markup(GTK_LABEL(priv->free_label), markup); g_free(markup); break; } case PROP_CAPACITY: { char *markup = g_markup_printf_escaped("<span size='large'>%s</span>", g_value_get_string(value)); gtk_label_set_markup(GTK_LABEL(priv->capacity_label), markup); g_free(markup); break; } case PROP_NAME: { char *markup = g_markup_printf_escaped("<span size='large'>%s</span>", g_value_get_string(value)); gtk_label_set_markup(GTK_LABEL(priv->name_label), markup); g_free(markup); break; } case PROP_POPUP_INFO: { if (!strcmp(g_value_get_string(value), "")) gtk_widget_set_has_tooltip(GTK_WIDGET(widget), FALSE); else { gtk_widget_set_tooltip_text(GTK_WIDGET(widget), g_value_get_string(value)); break; } } } }
static void assign_tooltip_from_action(GtkWidget* widget) { GtkAction* action; const gchar * tooltip; action = gtk_activatable_get_related_action(GTK_ACTIVATABLE(widget)); if (!action) return; if (!gtk_activatable_get_use_action_appearance(GTK_ACTIVATABLE(widget))) return; tooltip = gtk_action_get_tooltip(action); if (tooltip) { gtk_widget_set_tooltip_text(widget, tooltip); gtk_widget_set_has_tooltip(widget, TRUE); } else { gtk_widget_set_has_tooltip(widget, FALSE); } }
void tooltip_remove(GeanyEditor *editor) { GtkWidget *widget = GTK_WIDGET(editor->sci); if (gtk_widget_get_has_tooltip(widget)) { gulong query_tooltip_id = g_signal_handler_find(widget, G_SIGNAL_MATCH_ID, g_signal_lookup("query-tooltip", GTK_TYPE_WIDGET), 0, NULL, NULL, NULL); if (query_tooltip_id) g_signal_handler_disconnect(widget, query_tooltip_id); gtk_widget_set_has_tooltip(widget, FALSE); } }
static void gctt_init (GncCombott *combott) { GtkWidget *hbox; GtkWidget *label; GtkWidget *arrow; GtkWidget *button; GtkWidget *sep; GncCombottPrivate *priv = GNC_COMBOTT_GET_PRIVATE (combott); priv->active = 0; priv->text_col = 0; priv->tip_col = 1; hbox = gtk_hbox_new(FALSE, 0); arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT); gtk_box_pack_end (GTK_BOX (hbox), arrow, FALSE, FALSE, 0); sep = gtk_vseparator_new(); gtk_box_pack_end (GTK_BOX (hbox), sep, FALSE, FALSE, 0); label = gtk_label_new(NULL); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); priv->label = label; button = gtk_button_new(); gtk_container_add(GTK_CONTAINER(button), GTK_WIDGET(hbox)); priv->button = button; gtk_container_add(GTK_CONTAINER(combott), GTK_WIDGET(button)); g_signal_connect (button, "event", G_CALLBACK (button_press_cb), combott); gtk_widget_set_has_tooltip (GTK_WIDGET(combott), TRUE); g_signal_connect(G_OBJECT(combott), "query-tooltip", G_CALLBACK(which_tooltip_cb), combott); g_signal_connect(G_OBJECT(combott), "size-allocate", G_CALLBACK(button_getsize_cb), combott); gtk_widget_show(GTK_WIDGET(priv->button)); }
/****************************************************************************\ * gnc_reconcile_view_new * * creates the account tree * * * * Args: account - the account to use in filling up the splits. * * type - the type of view, RECLIST_DEBIT or RECLIST_CREDIT * * statement_date - date of statement * * Returns: the account tree widget, or NULL if there was a problem. * \****************************************************************************/ static void gnc_reconcile_view_construct (GNCReconcileView *view, Query *query) { GNCQueryView *qview = GNC_QUERY_VIEW (view); GtkTreeViewColumn *col; GtkTreeSelection *selection; GList *renderers; GtkCellRenderer *cr0; gboolean inv_sort = FALSE; if (view->view_type == RECLIST_CREDIT) inv_sort = TRUE; /* Construct the view */ gnc_query_view_construct (qview, view->column_list, query); gnc_query_view_set_numerics (qview, TRUE, inv_sort); /* Set the description field to have spare space, REC_DESC -1 to allow for the pointer model column at 0 */ col = gtk_tree_view_get_column (GTK_TREE_VIEW (qview), (REC_DESC - 1)); gtk_tree_view_column_set_expand (col, TRUE); /* Get the renderer of the description column and set ellipsize value */ renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col)); cr0 = g_list_nth_data (renderers, 0); g_list_free (renderers); g_object_set (cr0, "ellipsize", PANGO_ELLIPSIZE_END, NULL ); gtk_widget_set_has_tooltip (GTK_WIDGET (qview), TRUE); /* Set the selection method */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (qview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); /* Now set up the signals for the QueryView */ g_signal_connect (G_OBJECT (qview), "column_toggled", G_CALLBACK (gnc_reconcile_view_line_toggled), view); g_signal_connect (G_OBJECT (qview), "double_click_entry", G_CALLBACK (gnc_reconcile_view_double_click_entry), view); g_signal_connect (G_OBJECT (qview), "row_selected", G_CALLBACK (gnc_reconcile_view_row_selected), view); g_signal_connect (G_OBJECT (qview), "key_press_event", G_CALLBACK (gnc_reconcile_view_key_press_cb), view); g_signal_connect (G_OBJECT (qview), "query-tooltip", G_CALLBACK (gnc_reconcile_view_tooltip_cb), view); }
GtkWidget* create_window (void) { GtkWidget *window; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_resize(GTK_WINDOW(window),800,600); view = gtk_source_view_new(); GtkWidget *scroll = gtk_scrolled_window_new(NULL,NULL); gtk_container_add(GTK_CONTAINER(scroll),view); gtk_container_add(GTK_CONTAINER(window),scroll); gtk_widget_set_has_tooltip(view,TRUE); g_signal_connect(view, "key-release-event", G_CALLBACK(key_press), NULL); g_signal_connect(window, "destroy", G_CALLBACK(destroy_cb), NULL); return window; }
void init_editor(GtkWidget *box) { //エディタ部分の外観の設定 GtkWidget *notebook = gtk_notebook_new(); scroll_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); buffer = gtk_source_buffer_new(NULL); view = gtk_source_view_new_with_buffer(buffer); set_file_name(""); name_label = gtk_label_new("編集中のファイル"); gtk_container_add(GTK_CONTAINER(scroll_window), view); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scroll_window, name_label); gtk_widget_set_has_tooltip(view, TRUE); gtk_widget_grab_focus(view); set_style(); gtk_box_pack_start(GTK_BOX(box), notebook, TRUE, TRUE, 0); //エディタ部分の動作の初期設定 gtk_source_buffer_set_highlight_matching_brackets(buffer, FALSE); gtk_widget_modify_font(view, pango_font_description_from_string(font_name)); gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(view), state & width_mask); if (state & wrap_mask) { gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_CHAR); } else { gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_NONE); } if (state & line_mask) { gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), TRUE); } else { gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), FALSE); } if (state & highlight_mask) { gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), TRUE); } else { gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), FALSE); } if (state & space_mask) { gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), TRUE); } else { gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), FALSE); } }
static GtkWidget * create_view_box (EmpathyRosterModel *model, gboolean show_offline, gboolean show_groups) { GtkWidget *view, *scrolled, *box, *search; box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); view = empathy_roster_view_new (model); g_signal_connect (view, "individual-activated", G_CALLBACK (individual_activated_cb), NULL); g_signal_connect (view, "popup-individual-menu", G_CALLBACK (popup_individual_menu_cb), NULL); g_signal_connect (view, "notify::empty", G_CALLBACK (empty_cb), NULL); g_signal_connect (view, "individual-tooltip", G_CALLBACK (individual_tooltip_cb), NULL); gtk_widget_set_has_tooltip (view, TRUE); empathy_roster_view_show_offline (EMPATHY_ROSTER_VIEW (view), show_offline); empathy_roster_view_show_groups (EMPATHY_ROSTER_VIEW (view), show_groups); search = tpaw_live_search_new (view); empathy_roster_view_set_live_search (EMPATHY_ROSTER_VIEW (view), TPAW_LIVE_SEARCH (search)); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (scrolled), view); gtk_box_pack_start (GTK_BOX (box), search, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box), scrolled, TRUE, TRUE, 0); return box; }
static void settings_changed_cb (GSettings *settings, const gchar *key, GpMenuButtonApplet *menu_button) { GpMenuButtonAppletPrivate *priv; priv = gp_menu_button_applet_get_instance_private (menu_button); if (g_strcmp0 (key, "custom-icon") == 0) { update_icon (menu_button); } else if (g_strcmp0 (key, "menu-path") == 0) { update_menu (menu_button); update_icon (menu_button); } else if (g_strcmp0 (key, "show-arrow") == 0) { gboolean show_arrow; show_arrow = g_settings_get_boolean (priv->settings, "show-arrow"); gtk_widget_set_visible (priv->image, show_arrow); } else if (g_strcmp0 (key, "tooltip") == 0) { gchar *tooltip; gboolean enable_tooltips; tooltip = g_settings_get_string (priv->settings, "tooltip"); gtk_widget_set_tooltip_text (priv->button, *tooltip != '\0' ? tooltip : NULL); g_free (tooltip); g_object_get (menu_button, "enable-tooltips", &enable_tooltips, NULL); gtk_widget_set_has_tooltip (priv->button, enable_tooltips); } }
static void contact_list_view_set_list_features (EmpathyContactListView *view, EmpathyContactListFeatureFlags features) { EmpathyContactListViewPriv *priv = GET_PRIV (view); gboolean has_tooltip; g_return_if_fail (EMPATHY_IS_CONTACT_LIST_VIEW (view)); priv->list_features = features; /* Update DnD source/dest */ if (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DRAG) { gtk_drag_source_set (GTK_WIDGET (view), GDK_BUTTON1_MASK, drag_types_source, G_N_ELEMENTS (drag_types_source), GDK_ACTION_MOVE | GDK_ACTION_COPY); } else { gtk_drag_source_unset (GTK_WIDGET (view)); } if (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DROP) { gtk_drag_dest_set (GTK_WIDGET (view), GTK_DEST_DEFAULT_ALL, drag_types_dest, G_N_ELEMENTS (drag_types_dest), GDK_ACTION_MOVE | GDK_ACTION_COPY); } else { /* FIXME: URI could still be droped depending on FT feature */ gtk_drag_dest_unset (GTK_WIDGET (view)); } /* Update has-tooltip */ has_tooltip = (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_TOOLTIP) != 0; gtk_widget_set_has_tooltip (GTK_WIDGET (view), has_tooltip); }
static void fill_sample_table(DrMrUi* ui, int samples, char** names,GtkWidget** gain_sliders, GtkWidget** pan_sliders) { int row = 0; int col = 0; int si; gchar buf[64]; int rows = (samples/ui->cols); if (samples % ui->cols != 0) rows++; gtk_table_resize(ui->sample_table,rows,ui->cols); switch (ui->startSamp) { case 1: // bottom left row = rows-1; break; case 2: // top right col = ui->cols-1; break; case 3: // bottom right row = rows-1; col = ui->cols-1; break; } for(si = 0;si<samples;si++) { GtkWidget *frame,*hbox,*gain_vbox,*pan_vbox; GtkWidget* gain_slider; GtkWidget* pan_slider; GtkWidget* gain_label; GtkWidget* pan_label; gboolean slide_expand; snprintf(buf,64,"<b>%s</b> (%i)",names[si],si); frame = gtk_frame_new(buf); gtk_label_set_use_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))),true); gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_OUT); hbox = gtk_hbox_new(false,0); #ifdef NO_NKNOB gain_slider = gtk_vscale_new_with_range(GAIN_MIN,6.0,1.0); gtk_scale_set_value_pos(GTK_SCALE(gain_slider),GTK_POS_BOTTOM); gtk_scale_set_digits(GTK_SCALE(gain_slider),1); gtk_scale_add_mark(GTK_SCALE(gain_slider),0.0,GTK_POS_RIGHT,"0 dB"); // Hrmm, -inf label is at top in ardour for some reason //gtk_scale_add_mark(GTK_SCALE(gain_slider),GAIN_MIN,GTK_POS_RIGHT,"-inf"); gtk_range_set_inverted(GTK_RANGE(gain_slider),true); slide_expand = true; #else gain_slider = n_knob_new_with_range(0.0,GAIN_MIN,6.0,1.0); n_knob_set_load_prefix(N_KNOB(gain_slider),ui->bundle_path); gtk_widget_set_has_tooltip(gain_slider,TRUE); slide_expand = false; #endif g_object_set_qdata (G_OBJECT(gain_slider),ui->gain_quark,GINT_TO_POINTER(si)); if (gain_sliders) gain_sliders[si] = gain_slider; if (si < 32) gtk_range_set_value(GTK_RANGE(gain_slider),ui->gain_vals[si]); else // things are gross if we have > 32 samples, what to do? gtk_range_set_value(GTK_RANGE(gain_slider),0.0); g_signal_connect(G_OBJECT(gain_slider),"change-value",G_CALLBACK(gain_callback),ui); gain_label = gtk_label_new("Gain"); gain_vbox = gtk_vbox_new(false,0); #ifdef NO_NKNOB pan_slider = gtk_hscale_new_with_range(-1.0,1.0,0.1); gtk_scale_add_mark(GTK_SCALE(pan_slider),0.0,GTK_POS_TOP,NULL); #else pan_slider = n_knob_new_with_range(0.0,-1.0,1.0,0.1); n_knob_set_load_prefix(N_KNOB(pan_slider),ui->bundle_path); gtk_widget_set_has_tooltip(pan_slider,TRUE); #endif if (pan_sliders) pan_sliders[si] = pan_slider; if (si < 32) gtk_range_set_value(GTK_RANGE(pan_slider),ui->pan_vals[si]); else gtk_range_set_value(GTK_RANGE(pan_slider),0); g_object_set_qdata (G_OBJECT(pan_slider),ui->pan_quark,GINT_TO_POINTER(si)); g_signal_connect(G_OBJECT(pan_slider),"change-value",G_CALLBACK(pan_callback),ui); pan_label = gtk_label_new("Pan"); pan_vbox = gtk_vbox_new(false,0); gtk_box_pack_start(GTK_BOX(gain_vbox),gain_slider,slide_expand,slide_expand,0); gtk_box_pack_start(GTK_BOX(gain_vbox),gain_label,false,false,0); gtk_box_pack_start(GTK_BOX(pan_vbox),pan_slider,slide_expand,slide_expand,0); gtk_box_pack_start(GTK_BOX(pan_vbox),pan_label,false,false,0); gtk_box_pack_start(GTK_BOX(hbox),gain_vbox,true,true,0); gtk_box_pack_start(GTK_BOX(hbox),pan_vbox,true,true,0); gtk_container_add(GTK_CONTAINER(frame),hbox); gtk_table_attach_defaults(ui->sample_table,frame,col,col+1,row,row+1); if (ui->startSamp > 1) { col--; if (col < 0) { if (ui->startSamp == 2) row++; else row--; col = ui->cols-1; } } else { col++; if (col >= ui->cols) { if (ui->startSamp == 0) row++; else row--; col = 0; } } } gtk_widget_queue_resize(GTK_WIDGET(ui->sample_table)); }
ItemListView * item_list_view_create (GtkWidget *window) { ItemListView *ilv; GtkCellRenderer *renderer; GtkTreeViewColumn *column, *headline_column; GtkTreeSelection *select; GtkWidget *ilscrolledwindow; ilv = g_object_new (ITEM_LIST_VIEW_TYPE, NULL); ilscrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (ilscrolledwindow); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (ilscrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (ilscrolledwindow), GTK_SHADOW_IN); ilv->priv->treeview = GTK_TREE_VIEW (gtk_tree_view_new ()); gtk_container_add (GTK_CONTAINER (ilscrolledwindow), GTK_WIDGET (ilv->priv->treeview)); gtk_widget_show (GTK_WIDGET (ilv->priv->treeview)); gtk_widget_set_name (GTK_WIDGET (ilv->priv->treeview), "itemlist"); gtk_tree_view_set_rules_hint (ilv->priv->treeview, TRUE); g_object_set_data (G_OBJECT (window), "itemlist", ilv->priv->treeview); item_list_view_set_tree_store (ilv, item_list_view_create_tree_store ()); renderer = gtk_cell_renderer_pixbuf_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer, "pixbuf", IS_STATEICON, NULL); gtk_tree_view_append_column (ilv->priv->treeview, column); gtk_tree_view_column_set_sort_column_id (column, IS_STATE); renderer = gtk_cell_renderer_pixbuf_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer, "pixbuf", IS_ENCICON, NULL); gtk_tree_view_append_column (ilv->priv->treeview, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Date"), renderer, "text", IS_TIME_STR, "weight", ITEMSTORE_UNREAD, NULL); gtk_tree_view_append_column (ilv->priv->treeview, column); gtk_tree_view_column_set_sort_column_id(column, IS_TIME); g_object_set (column, "resizable", TRUE, NULL); renderer = gtk_cell_renderer_pixbuf_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer, "pixbuf", IS_FAVICON, NULL); gtk_tree_view_column_set_sort_column_id (column, IS_SOURCE); gtk_tree_view_append_column (ilv->priv->treeview, column); renderer = gtk_cell_renderer_text_new (); headline_column = gtk_tree_view_column_new_with_attributes (_("Headline"), renderer, "text", IS_LABEL, "weight", ITEMSTORE_UNREAD, "xalign", ITEMSTORE_ALIGN, NULL); gtk_tree_view_append_column (ilv->priv->treeview, headline_column); gtk_tree_view_column_set_sort_column_id (headline_column, IS_LABEL); g_object_set (headline_column, "resizable", TRUE, NULL); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); /* And connect signals */ g_signal_connect (G_OBJECT (ilv->priv->treeview), "button_press_event", G_CALLBACK (on_item_list_view_button_press_event), ilv); g_signal_connect (G_OBJECT (ilv->priv->treeview), "row_activated", G_CALLBACK (on_Itemlist_row_activated), ilv); g_signal_connect (G_OBJECT (ilv->priv->treeview), "key-press-event", G_CALLBACK (on_item_list_view_key_press_event), ilv); g_signal_connect (G_OBJECT (ilv->priv->treeview), "popup_menu", G_CALLBACK (on_item_list_view_popup_menu), ilv); gtk_widget_set_has_tooltip (GTK_WIDGET (ilv->priv->treeview), TRUE); g_signal_connect (G_OBJECT (ilv->priv->treeview), "query-tooltip", G_CALLBACK (on_item_list_view_query_tooltip), headline_column); /* Setup the selection handler */ select = gtk_tree_view_get_selection (ilv->priv->treeview); gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (on_itemlist_selection_changed), ilv); return ilv; }
gboolean yatla_layout_load_layout (YatlaLayout* self, YatlaSidebar* sidebar, const gchar* list_name) { gboolean result = FALSE; Block4Data* _data4_; YatlaSidebar* _tmp0_ = NULL; YatlaSidebar* _tmp1_ = NULL; const gchar* _tmp2_ = NULL; gchar* _tmp3_ = NULL; const gchar* _tmp4_ = NULL; gchar* _tmp5_ = NULL; GtkBox* _tmp6_ = NULL; const gchar* _tmp7_ = NULL; GtkLabel* _tmp8_ = NULL; GtkLabel* _tmp9_ = NULL; GtkLabel* _tmp10_ = NULL; GtkLabel* _tmp11_ = NULL; const gchar* _tmp12_ = NULL; gchar* _tmp13_ = NULL; gchar* _tmp14_ = NULL; GtkBox* _tmp15_ = NULL; GtkLabel* _tmp16_ = NULL; GtkBox* _tmp17_ = NULL; GtkEntry* _tmp18_ = NULL; GtkEntry* _tmp19_ = NULL; GtkEntry* _tmp20_ = NULL; GtkBox* _tmp21_ = NULL; GtkEntry* _tmp22_ = NULL; GtkBox* _tmp23_ = NULL; gint list_index = 0; YatlaSidebar* _tmp24_ = NULL; GList* _tmp25_ = NULL; gint task_index = 0; guint the_longest_task = 0U; GtkBox* _tmp122_ = NULL; GtkBox* _tmp123_ = NULL; GtkBox* _tmp124_ = NULL; guint _tmp125_ = 0U; GeeTreeMap* _tmp126_ = NULL; GeeCollection* _tmp127_ = NULL; GeeCollection* _tmp128_ = NULL; GeeCollection* _tmp129_ = NULL; gint _tmp130_ = 0; gint _tmp131_ = 0; GtkEntry* _tmp132_ = NULL; GeeMapIterator* map_iterator = NULL; GeeTreeMap* _tmp133_ = NULL; GeeMapIterator* _tmp134_ = NULL; g_return_val_if_fail (self != NULL, FALSE); g_return_val_if_fail (sidebar != NULL, FALSE); g_return_val_if_fail (list_name != NULL, FALSE); _data4_ = g_slice_new0 (Block4Data); _data4_->_ref_count_ = 1; _data4_->self = g_object_ref (self); _tmp0_ = sidebar; _tmp1_ = _g_object_ref0 (_tmp0_); _g_object_unref0 (_data4_->sidebar); _data4_->sidebar = _tmp1_; _tmp2_ = list_name; _tmp3_ = g_strdup (_tmp2_); _g_free0 (_data4_->list_name); _data4_->list_name = _tmp3_; _tmp4_ = _data4_->list_name; _tmp5_ = g_strdup (_tmp4_); _g_free0 (self->_name); self->_name = _tmp5_; _tmp6_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); g_object_ref_sink (_tmp6_); _g_object_unref0 (self->_top_box1); self->_top_box1 = _tmp6_; _tmp7_ = _data4_->list_name; _tmp8_ = (GtkLabel*) gtk_label_new (_tmp7_); g_object_ref_sink (_tmp8_); _g_object_unref0 (self->_list_name); self->_list_name = _tmp8_; _tmp9_ = self->_list_name; gtk_label_set_use_markup (_tmp9_, TRUE); _tmp10_ = self->_list_name; _tmp11_ = self->_list_name; _tmp12_ = gtk_label_get_text (_tmp11_); _tmp13_ = g_strdup_printf ("<span font='14'><b>%s</b></span>", _tmp12_); _tmp14_ = _tmp13_; gtk_label_set_markup (_tmp10_, _tmp14_); _g_free0 (_tmp14_); _tmp15_ = self->_top_box1; _tmp16_ = self->_list_name; gtk_box_pack_start (_tmp15_, (GtkWidget*) _tmp16_, TRUE, TRUE, (guint) 0); _tmp17_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); g_object_ref_sink (_tmp17_); _g_object_unref0 (self->_top_box2); self->_top_box2 = _tmp17_; _tmp18_ = (GtkEntry*) gtk_entry_new (); g_object_ref_sink (_tmp18_); _g_object_unref0 (self->new_task_entry); self->new_task_entry = _tmp18_; _tmp19_ = self->new_task_entry; gtk_entry_set_placeholder_text (_tmp19_, "Add new task"); _tmp20_ = self->new_task_entry; gtk_entry_set_icon_from_stock (_tmp20_, GTK_ENTRY_ICON_SECONDARY, "gtk-edit"); _tmp21_ = self->_top_box2; _tmp22_ = self->new_task_entry; gtk_box_pack_start (_tmp21_, (GtkWidget*) _tmp22_, TRUE, TRUE, (guint) 0); _tmp23_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 10); g_object_ref_sink (_tmp23_); _g_object_unref0 (self->_tasks_box); self->_tasks_box = _tmp23_; list_index = 0; _tmp24_ = _data4_->sidebar; _tmp25_ = _tmp24_->sidebar_list; { GList* list_collection = NULL; GList* list_it = NULL; list_collection = _tmp25_; for (list_it = list_collection; list_it != NULL; list_it = list_it->next) { YatlaList* _tmp26_ = NULL; YatlaList* list = NULL; _tmp26_ = _g_object_ref0 ((YatlaList*) list_it->data); list = _tmp26_; { YatlaList* _tmp27_ = NULL; const gchar* _tmp28_ = NULL; const gchar* _tmp29_ = NULL; const gchar* _tmp30_ = NULL; gint _tmp31_ = 0; _tmp27_ = list; _tmp28_ = yatla_list_get_name (_tmp27_); _tmp29_ = _tmp28_; _tmp30_ = _data4_->list_name; if (g_strcmp0 (_tmp29_, _tmp30_) == 0) { _g_object_unref0 (list); break; } _tmp31_ = list_index; list_index = _tmp31_ + 1; _g_object_unref0 (list); } } } task_index = 0; the_longest_task = (guint) 0; while (TRUE) { Block5Data* _data5_; gint _tmp32_ = 0; YatlaSidebar* _tmp33_ = NULL; GList* _tmp34_ = NULL; gint _tmp35_ = 0; gconstpointer _tmp36_ = NULL; guint _tmp37_ = 0U; guint _tmp38_ = 0U; gint task_id = 0; YatlaSidebar* _tmp39_ = NULL; GList* _tmp40_ = NULL; gint _tmp41_ = 0; gconstpointer _tmp42_ = NULL; GList* _tmp43_ = NULL; gint _tmp44_ = 0; gconstpointer _tmp45_ = NULL; gint _tmp46_ = 0; gint _tmp47_ = 0; gchar* task_name = NULL; YatlaSidebar* _tmp48_ = NULL; GList* _tmp49_ = NULL; gint _tmp50_ = 0; gconstpointer _tmp51_ = NULL; GList* _tmp52_ = NULL; gint _tmp53_ = 0; gconstpointer _tmp54_ = NULL; const gchar* _tmp55_ = NULL; const gchar* _tmp56_ = NULL; gchar* _tmp57_ = NULL; YatlaSidebar* _tmp58_ = NULL; GList* _tmp59_ = NULL; gint _tmp60_ = 0; gconstpointer _tmp61_ = NULL; GList* _tmp62_ = NULL; gint _tmp63_ = 0; gconstpointer _tmp64_ = NULL; const gchar* _tmp65_ = NULL; const gchar* _tmp66_ = NULL; gchar* _tmp67_ = NULL; GDateTime* task_date = NULL; YatlaSidebar* _tmp68_ = NULL; GList* _tmp69_ = NULL; gint _tmp70_ = 0; gconstpointer _tmp71_ = NULL; GList* _tmp72_ = NULL; gint _tmp73_ = 0; gconstpointer _tmp74_ = NULL; GDateTime* _tmp75_ = NULL; GDateTime* _tmp76_ = NULL; gboolean task_is_done = FALSE; YatlaSidebar* _tmp87_ = NULL; GList* _tmp88_ = NULL; gint _tmp89_ = 0; gconstpointer _tmp90_ = NULL; GList* _tmp91_ = NULL; gint _tmp92_ = 0; gconstpointer _tmp93_ = NULL; gboolean _tmp94_ = FALSE; gboolean _tmp95_ = FALSE; YatlaTask* task = NULL; const gchar* _tmp96_ = NULL; const gchar* _tmp97_ = NULL; GDateTime* _tmp98_ = NULL; gboolean _tmp99_ = FALSE; YatlaTask* _tmp100_ = NULL; YatlaTask* _tmp101_ = NULL; gint _tmp102_ = 0; const gchar* _tmp103_ = NULL; gint _tmp104_ = 0; gint _tmp105_ = 0; guint _tmp106_ = 0U; GtkCheckButton* checkBox = NULL; const gchar* _tmp110_ = NULL; GtkCheckButton* _tmp111_ = NULL; GtkCheckButton* _tmp112_ = NULL; gboolean _tmp113_ = FALSE; GtkCheckButton* _tmp114_ = NULL; GtkCheckButton* _tmp115_ = NULL; GeeTreeMap* _tmp116_ = NULL; YatlaTask* _tmp117_ = NULL; GtkCheckButton* _tmp118_ = NULL; GtkBox* _tmp119_ = NULL; GtkCheckButton* _tmp120_ = NULL; gint _tmp121_ = 0; _data5_ = g_slice_new0 (Block5Data); _data5_->_ref_count_ = 1; _data5_->_data4_ = block4_data_ref (_data4_); _tmp32_ = task_index; _tmp33_ = _data4_->sidebar; _tmp34_ = _tmp33_->sidebar_list; _tmp35_ = list_index; _tmp36_ = g_list_nth_data (_tmp34_, (guint) _tmp35_); _tmp37_ = yatla_list_get_size ((YatlaList*) _tmp36_); _tmp38_ = _tmp37_; if (!(((guint) _tmp32_) != _tmp38_)) { block5_data_unref (_data5_); _data5_ = NULL; break; } _tmp39_ = _data4_->sidebar; _tmp40_ = _tmp39_->sidebar_list; _tmp41_ = list_index; _tmp42_ = g_list_nth_data (_tmp40_, (guint) _tmp41_); _tmp43_ = ((YatlaList*) _tmp42_)->tasks; _tmp44_ = task_index; _tmp45_ = g_list_nth_data (_tmp43_, (guint) _tmp44_); _tmp46_ = yatla_task_get_id ((YatlaTask*) _tmp45_); _tmp47_ = _tmp46_; task_id = _tmp47_; _tmp48_ = _data4_->sidebar; _tmp49_ = _tmp48_->sidebar_list; _tmp50_ = list_index; _tmp51_ = g_list_nth_data (_tmp49_, (guint) _tmp50_); _tmp52_ = ((YatlaList*) _tmp51_)->tasks; _tmp53_ = task_index; _tmp54_ = g_list_nth_data (_tmp52_, (guint) _tmp53_); _tmp55_ = yatla_task_get_name ((YatlaTask*) _tmp54_); _tmp56_ = _tmp55_; _tmp57_ = g_strdup (_tmp56_); task_name = _tmp57_; _tmp58_ = _data4_->sidebar; _tmp59_ = _tmp58_->sidebar_list; _tmp60_ = list_index; _tmp61_ = g_list_nth_data (_tmp59_, (guint) _tmp60_); _tmp62_ = ((YatlaList*) _tmp61_)->tasks; _tmp63_ = task_index; _tmp64_ = g_list_nth_data (_tmp62_, (guint) _tmp63_); _tmp65_ = yatla_task_get_note ((YatlaTask*) _tmp64_); _tmp66_ = _tmp65_; _tmp67_ = g_strdup (_tmp66_); _data5_->task_note = _tmp67_; _tmp68_ = _data4_->sidebar; _tmp69_ = _tmp68_->sidebar_list; _tmp70_ = list_index; _tmp71_ = g_list_nth_data (_tmp69_, (guint) _tmp70_); _tmp72_ = ((YatlaList*) _tmp71_)->tasks; _tmp73_ = task_index; _tmp74_ = g_list_nth_data (_tmp72_, (guint) _tmp73_); _tmp75_ = yatla_task_get_date ((YatlaTask*) _tmp74_); _tmp76_ = _tmp75_; if (_tmp76_ != NULL) { YatlaSidebar* _tmp77_ = NULL; GList* _tmp78_ = NULL; gint _tmp79_ = 0; gconstpointer _tmp80_ = NULL; GList* _tmp81_ = NULL; gint _tmp82_ = 0; gconstpointer _tmp83_ = NULL; GDateTime* _tmp84_ = NULL; GDateTime* _tmp85_ = NULL; GDateTime* _tmp86_ = NULL; _tmp77_ = _data4_->sidebar; _tmp78_ = _tmp77_->sidebar_list; _tmp79_ = list_index; _tmp80_ = g_list_nth_data (_tmp78_, (guint) _tmp79_); _tmp81_ = ((YatlaList*) _tmp80_)->tasks; _tmp82_ = task_index; _tmp83_ = g_list_nth_data (_tmp81_, (guint) _tmp82_); _tmp84_ = yatla_task_get_date ((YatlaTask*) _tmp83_); _tmp85_ = _tmp84_; _tmp86_ = _g_date_time_ref0 (_tmp85_); _g_date_time_unref0 (task_date); task_date = _tmp86_; } else { _g_date_time_unref0 (task_date); task_date = NULL; } _tmp87_ = _data4_->sidebar; _tmp88_ = _tmp87_->sidebar_list; _tmp89_ = list_index; _tmp90_ = g_list_nth_data (_tmp88_, (guint) _tmp89_); _tmp91_ = ((YatlaList*) _tmp90_)->tasks; _tmp92_ = task_index; _tmp93_ = g_list_nth_data (_tmp91_, (guint) _tmp92_); _tmp94_ = yatla_task_get_is_done ((YatlaTask*) _tmp93_); _tmp95_ = _tmp94_; task_is_done = _tmp95_; _tmp96_ = task_name; _tmp97_ = _data5_->task_note; _tmp98_ = task_date; _tmp99_ = task_is_done; _tmp100_ = yatla_task_new (_tmp96_, _tmp97_, _tmp98_, _tmp99_); task = _tmp100_; _tmp101_ = task; _tmp102_ = task_id; yatla_task_set_id (_tmp101_, _tmp102_); _tmp103_ = task_name; _tmp104_ = strlen (_tmp103_); _tmp105_ = _tmp104_; _tmp106_ = the_longest_task; if (((guint) _tmp105_) > _tmp106_) { const gchar* _tmp107_ = NULL; gint _tmp108_ = 0; gint _tmp109_ = 0; _tmp107_ = task_name; _tmp108_ = strlen (_tmp107_); _tmp109_ = _tmp108_; the_longest_task = (guint) _tmp109_; } _tmp110_ = task_name; _tmp111_ = (GtkCheckButton*) gtk_check_button_new_with_label (_tmp110_); g_object_ref_sink (_tmp111_); checkBox = _tmp111_; _tmp112_ = checkBox; _tmp113_ = task_is_done; gtk_toggle_button_set_active ((GtkToggleButton*) _tmp112_, _tmp113_); _tmp114_ = checkBox; gtk_widget_set_has_tooltip ((GtkWidget*) _tmp114_, TRUE); _tmp115_ = checkBox; g_signal_connect_data ((GtkWidget*) _tmp115_, "query-tooltip", (GCallback) ____lambda4__gtk_widget_query_tooltip, block5_data_ref (_data5_), (GClosureNotify) block5_data_unref, 0); _tmp116_ = self->tasks; _tmp117_ = task; _tmp118_ = checkBox; gee_abstract_map_set ((GeeAbstractMap*) _tmp116_, _tmp117_, _tmp118_); _tmp119_ = self->_tasks_box; _tmp120_ = checkBox; gtk_box_pack_start (_tmp119_, (GtkWidget*) _tmp120_, TRUE, TRUE, (guint) 0); _tmp121_ = task_index; task_index = _tmp121_ + 1; _g_object_unref0 (checkBox); _g_object_unref0 (task); _g_date_time_unref0 (task_date); _g_free0 (task_name); block5_data_unref (_data5_); _data5_ = NULL; } _tmp122_ = self->_top_box1; gtk_layout_put ((GtkLayout*) self, (GtkWidget*) _tmp122_, 25, 20); _tmp123_ = self->_top_box2; gtk_layout_put ((GtkLayout*) self, (GtkWidget*) _tmp123_, 20, 40); _tmp124_ = self->_tasks_box; gtk_layout_put ((GtkLayout*) self, (GtkWidget*) _tmp124_, 20, 100); _tmp125_ = the_longest_task; g_object_set ((GtkLayout*) self, "width", 65 + (_tmp125_ * 7), NULL); _tmp126_ = self->tasks; _tmp127_ = gee_abstract_map_get_values ((GeeMap*) _tmp126_); _tmp128_ = _tmp127_; _tmp129_ = _tmp128_; _tmp130_ = gee_collection_get_size (_tmp129_); _tmp131_ = _tmp130_; g_object_set ((GtkLayout*) self, "height", (guint) (100 + (_tmp131_ * 30)), NULL); _g_object_unref0 (_tmp129_); gtk_widget_show_all ((GtkWidget*) self); _tmp132_ = self->new_task_entry; g_signal_connect_data (_tmp132_, "icon-press", (GCallback) ___lambda5__gtk_entry_icon_press, block4_data_ref (_data4_), (GClosureNotify) block4_data_unref, 0); _tmp133_ = self->tasks; _tmp134_ = gee_abstract_map_map_iterator ((GeeAbstractMap*) _tmp133_); map_iterator = _tmp134_; while (TRUE) { Block6Data* _data6_; GeeMapIterator* _tmp135_ = NULL; gboolean _tmp136_ = FALSE; GeeMapIterator* _tmp137_ = NULL; gpointer _tmp138_ = NULL; GeeMapIterator* _tmp139_ = NULL; gpointer _tmp140_ = NULL; GtkCheckButton* _tmp141_ = NULL; _data6_ = g_slice_new0 (Block6Data); _data6_->_ref_count_ = 1; _data6_->_data4_ = block4_data_ref (_data4_); _tmp135_ = map_iterator; _tmp136_ = gee_map_iterator_next (_tmp135_); if (!_tmp136_) { block6_data_unref (_data6_); _data6_ = NULL; break; } _tmp137_ = map_iterator; _tmp138_ = gee_map_iterator_get_value (_tmp137_); _data6_->checkBox = (GtkCheckButton*) _tmp138_; _tmp139_ = map_iterator; _tmp140_ = gee_map_iterator_get_key (_tmp139_); _data6_->task = (YatlaTask*) _tmp140_; _tmp141_ = _data6_->checkBox; g_signal_connect_data ((GObject*) _tmp141_, "notify::active", (GCallback) ____lambda11__g_object_notify, block6_data_ref (_data6_), (GClosureNotify) block6_data_unref, 0); block6_data_unref (_data6_); _data6_ = NULL; } result = TRUE; _g_object_unref0 (map_iterator); block4_data_unref (_data4_); _data4_ = NULL; return result; }
static void qq_mainpanel_init(QQMainPanel *panel) { GtkWidget *hbox = gtk_hbox_new(FALSE, 0); GtkWidget *box = NULL; GtkWidget *vbox = gtk_vbox_new(FALSE, 0); panel -> faceimgframe = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(hbox), panel -> faceimgframe , FALSE, FALSE, 5); panel -> status_btn = qq_statusbutton_new(); panel -> nick = gtk_label_new(""); box = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(box), panel -> status_btn, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), panel -> nick, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 2); panel -> longnick = gtk_label_new(""); panel -> longnick_entry = gtk_entry_new(); gtk_widget_set_size_request(GTK_WIDGET(panel -> longnick_entry), 0, 0); panel -> longnick_box = gtk_hbox_new(FALSE, 0); panel -> longnick_eventbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(panel -> longnick_eventbox) , panel -> longnick); gtk_box_pack_start(GTK_BOX(panel -> longnick_box) , panel -> longnick_eventbox , FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(panel -> longnick_box) , panel -> longnick_entry , FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), panel -> longnick_box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(panel), hbox, FALSE, FALSE, 10); g_signal_connect(GTK_WIDGET(panel -> longnick_eventbox) , "button-release-event" , G_CALLBACK(lnick_release_cb), panel); g_signal_connect(GTK_WIDGET(panel -> longnick_eventbox) , "enter-notify-event" , G_CALLBACK(lnick_enter_cb), panel); g_signal_connect(GTK_WIDGET(panel -> longnick_eventbox) , "leave-notify-event" , G_CALLBACK(lnick_leave_cb), panel); g_signal_connect(GTK_WIDGET(panel -> longnick_entry) , "focus-out-event" , G_CALLBACK(lnick_focus_out_cb), panel); panel -> buddy_btn = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(panel -> buddy_btn) , this_class -> buddy_img[0]); panel -> grp_btn = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(panel -> grp_btn) , this_class -> grp_img[1]); panel -> recent_btn = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(panel -> recent_btn) , this_class -> recent_img[1]); g_signal_connect(GTK_WIDGET(panel -> buddy_btn), "button-release-event" , G_CALLBACK(btn_group_release_cb), panel); g_signal_connect(GTK_WIDGET(panel -> grp_btn), "button-release-event" , G_CALLBACK(btn_group_release_cb), panel); g_signal_connect(GTK_WIDGET(panel -> recent_btn), "button-release-event" , G_CALLBACK(btn_group_release_cb), panel); g_signal_connect(GTK_WIDGET(panel -> buddy_btn), "enter-notify-event" , G_CALLBACK(btn_group_enter_cb), panel); g_signal_connect(GTK_WIDGET(panel -> grp_btn), "enter-notify-event" , G_CALLBACK(btn_group_enter_cb), panel); g_signal_connect(GTK_WIDGET(panel -> recent_btn), "enter-notify-event" , G_CALLBACK(btn_group_enter_cb), panel); g_signal_connect(GTK_WIDGET(panel -> buddy_btn), "leave-notify-event" , G_CALLBACK(btn_group_leave_cb), panel); g_signal_connect(GTK_WIDGET(panel -> grp_btn), "leave-notify-event" , G_CALLBACK(btn_group_leave_cb), panel); g_signal_connect(GTK_WIDGET(panel -> recent_btn), "leave-notify-event" , G_CALLBACK(btn_group_leave_cb), panel); hbox = gtk_hbox_new(TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), panel -> buddy_btn, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), panel -> grp_btn, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), panel -> recent_btn, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(panel), hbox, FALSE, FALSE, 0); panel -> notebook = gtk_notebook_new(); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(panel -> notebook), FALSE); gtk_notebook_set_scrollable(GTK_NOTEBOOK(panel -> notebook), TRUE); gtk_notebook_set_show_border(GTK_NOTEBOOK(panel -> notebook), TRUE); gtk_box_pack_start(GTK_BOX(panel), panel -> notebook, TRUE, TRUE, 3); panel -> buddy_tree= qq_buddy_tree_new(); panel -> group_list = qq_buddy_list_new(); panel -> recent_list = qq_buddy_list_new(); g_signal_connect(panel -> group_list , "row-activated" , G_CALLBACK(qq_group_list_on_double_click) , NULL); gtk_widget_set_has_tooltip(panel -> group_list, TRUE); g_signal_connect(panel -> group_list, "query-tooltip" , G_CALLBACK(qq_group_list_on_show_tooltip) , NULL); GtkWidget *scrolled_win; scrolled_win= gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolled_win), panel -> buddy_tree); gtk_notebook_append_page(GTK_NOTEBOOK(panel -> notebook) , scrolled_win, NULL); scrolled_win= gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolled_win), panel -> group_list); gtk_notebook_append_page(GTK_NOTEBOOK(panel -> notebook) , scrolled_win, NULL); scrolled_win= gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolled_win), panel -> recent_list); gtk_notebook_append_page(GTK_NOTEBOOK(panel -> notebook) , scrolled_win, NULL); }
/* * init breaks tree view and return it if succesfull * arguments: * cb - callback to call on treeview double click */ gboolean bptree_init(move_to_line_cb cb) { GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; /* save double click callback */ on_break_clicked = cb; /* crete hash table for file nodes */ files = g_hash_table_new_full( g_str_hash, g_str_equal, (GDestroyNotify)g_free, (GDestroyNotify)gtk_tree_row_reference_free ); /* create tree view */ store = gtk_tree_store_new ( N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_STRING); model = GTK_TREE_MODEL(store); tree = gtk_tree_view_new_with_model (model); g_object_unref(store); /* set tree view properties */ gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), 1); gtk_widget_set_has_tooltip(GTK_WIDGET(tree), TRUE); /* multiple selection */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); /* connect signals */ g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL); g_signal_connect(G_OBJECT(tree), "row-activated", G_CALLBACK (on_row_double_click), NULL); g_signal_connect(G_OBJECT(tree), "query-tooltip", G_CALLBACK (on_query_tooltip), NULL); /* creating columns */ /* icon, file */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new(); gtk_tree_view_column_pack_end(column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_filename, NULL, NULL); /* enable for file */ renderer = cell_renderer_toggle_new (); g_signal_connect (G_OBJECT(renderer), "toggled", G_CALLBACK(on_enable_for_file), NULL); gtk_tree_view_column_pack_end(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "active", ENABLED, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_enable_for_file, NULL, NULL); /* enable breakpoint */ renderer = cell_renderer_break_icon_new (); g_signal_connect (G_OBJECT(renderer), "clicked", G_CALLBACK(on_enable_break), NULL); g_object_set(renderer, "pixbuf_enabled", (gpointer)break_pixbuf, NULL); g_object_set(renderer, "pixbuf_disabled", (gpointer)break_disabled_pixbuf, NULL); g_object_set(renderer, "pixbuf_conditional", (gpointer)break_condition_pixbuf, NULL); g_object_set(renderer, "pixbuf_file", (gpointer)break_pixbuf, NULL); gtk_tree_view_column_pack_end(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "enabled", ENABLED, "condition", CONDITION, "hitscount", HITSCOUNT, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_enable_break, NULL, NULL); gtk_tree_view_column_set_title(column, _("Location")); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); /* condition */ condition_renderer = gtk_cell_renderer_text_new (); g_object_set (condition_renderer, "editable", TRUE, NULL); g_object_set (condition_renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_signal_connect (G_OBJECT (condition_renderer), "edited", G_CALLBACK (on_condition_changed), NULL); column = gtk_tree_view_column_new_with_attributes (_("Condition"), condition_renderer, "text", CONDITION, NULL); gtk_tree_view_column_set_cell_data_func(column, condition_renderer, on_render, NULL, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); /* hits count */ hcount_renderer = gtk_cell_renderer_spin_new (); g_object_set (hcount_renderer, "adjustment", gtk_adjustment_new (0.0, 0.0, 100000.0, 1.0, 2.0, 2.0), "digits", 0, NULL); g_signal_connect (G_OBJECT (hcount_renderer), "edited", G_CALLBACK (on_hitscount_changed), NULL); column = gtk_tree_view_column_new_with_attributes (_("Hit count"), hcount_renderer, "text", HITSCOUNT, NULL); gtk_tree_view_column_set_cell_data_func(column, hcount_renderer, on_render, (gpointer)TRUE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); /* line */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Line"), renderer, "text", LINE, NULL); gtk_tree_view_column_set_visible(column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); /* Last invisible column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", LAST_VISIBLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); tab_breaks = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (tab_breaks); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tab_breaks), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (tab_breaks), GTK_SHADOW_NONE); gtk_container_add (GTK_CONTAINER (tab_breaks), tree); return TRUE; }
static void tab_panel_app_add_browser_cb (MidoriApp* app, MidoriBrowser* browser, MidoriExtension* extension) { GtkTreeStore* model; GtkWidget* treeview; GtkTreeViewColumn* column; GtkCellRenderer* renderer_pixbuf; GtkCellRenderer* renderer_text; GtkWidget* panel; GtkWidget* toolbar; gint i; /* GtkToolItem* toolitem; */ g_object_set (browser, "show-tabs", FALSE, NULL); panel = katze_object_get_object (browser, "panel"); model = gtk_tree_store_new (8, MIDORI_TYPE_VIEW, G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT, GDK_TYPE_COLOR, GDK_TYPE_COLOR); g_object_set_data (G_OBJECT (browser), "tab-panel-ext-model", model); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (treeview), FALSE); g_signal_connect (treeview, "query-tooltip", G_CALLBACK (tab_panel_treeview_query_tooltip_cb), NULL); gtk_widget_set_has_tooltip (treeview, TRUE); column = gtk_tree_view_column_new (); renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf, "pixbuf", 3, "cell-background-gdk", 6, NULL); renderer_text = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer_text, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_text, "text", 4, "ellipsize", 5, "cell-background-gdk", 6, "foreground-gdk", 7, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); column = gtk_tree_view_column_new (); renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf, "stock-id", 1, "follow-state", 2, "visible", 2, "cell-background-gdk", 6, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); g_object_connect (treeview, "signal::row-activated", midori_extension_row_activated_cb, extension, "signal::cursor-changed", midori_extension_cursor_or_row_changed_cb, extension, "signal::columns-changed", midori_extension_cursor_or_row_changed_cb, extension, "signal::button-release-event", midori_extension_button_release_event_cb, extension, "signal::key-release-event", midori_extension_key_release_event_cb, extension, "signal::popup-menu", midori_extension_popup_menu_cb, extension, NULL); gtk_widget_show (treeview); toolbar = gtk_toolbar_new (); g_object_set_data (G_OBJECT (browser), "tab-panel-ext-toolbar", toolbar); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON); gtk_widget_show (toolbar); /* TODO: Implement optional thumbnail images toolitem = gtk_toggle_tool_button_new_from_stock (STOCK_IMAGE); gtk_tool_item_set_is_important (toolitem, TRUE); g_signal_connect (toolitem, "toggled", G_CALLBACK (tab_panel_button_thumbnail_toggled_cb), notebook); gtk_widget_show (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); */ i = midori_panel_append_widget (MIDORI_PANEL (panel), treeview, STOCK_TAB_PANEL, _("Tab Panel"), toolbar); if (gtk_widget_get_visible (GTK_WIDGET (browser))) midori_panel_set_current_page (MIDORI_PANEL (panel), i); g_object_unref (panel); midori_browser_foreach (browser, (GtkCallback)tab_panel_browser_foreach_cb, treeview); g_signal_connect_after (browser, "add-tab", G_CALLBACK (tab_panel_browser_add_tab_cb), extension); g_signal_connect (browser, "remove-tab", G_CALLBACK (tab_panel_browser_remove_tab_cb), extension); g_signal_connect (browser, "notify::tab", G_CALLBACK (tab_panel_browser_notify_tab_cb), treeview); g_signal_connect (extension, "deactivate", G_CALLBACK (tab_panel_deactivate_cb), treeview); g_signal_connect (browser, "move-tab", G_CALLBACK (tab_panel_browser_move_tab_cb), NULL); }
static void gedit_documents_panel_init (GeditDocumentsPanel *panel) { GtkWidget *sw; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeSelection *selection; GIcon *icon; gedit_debug (DEBUG_PANEL); panel->priv = GEDIT_DOCUMENTS_PANEL_GET_PRIVATE (panel); panel->priv->adding_tab = FALSE; panel->priv->is_reodering = FALSE; gtk_orientable_set_orientation (GTK_ORIENTABLE (panel), GTK_ORIENTATION_VERTICAL); /* Create the scrolled window */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (sw); gtk_box_pack_start (GTK_BOX (panel), sw, TRUE, TRUE, 0); /* Create the empty model */ panel->priv->model = GTK_TREE_MODEL (gtk_tree_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_OBJECT)); /* Create the treeview */ panel->priv->treeview = gtk_tree_view_new_with_model (panel->priv->model); g_object_unref (G_OBJECT (panel->priv->model)); gtk_container_add (GTK_CONTAINER (sw), panel->priv->treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (panel->priv->treeview), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (panel->priv->treeview), FALSE); /* TODO */ gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (panel->priv->treeview), FALSE); gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (panel->priv->treeview), 18); /* Disable search because each time the selection is changed, the active tab is changed which focuses the view, and thus would remove the search entry, rendering it useless */ gtk_tree_view_set_enable_search (GTK_TREE_VIEW (panel->priv->treeview), FALSE); /* Disable focus so it doesn't steal focus each time from the view */ gtk_widget_set_can_focus (panel->priv->treeview, FALSE); gtk_widget_set_has_tooltip (panel->priv->treeview, TRUE); gtk_widget_show (panel->priv->treeview); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Documents")); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_add_attribute (column, cell, "pixbuf", PIXBUF_COLUMN); gtk_tree_view_column_set_cell_data_func (column, cell, (GtkTreeCellDataFunc)pixbuf_data_func, panel, NULL); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_add_attribute (column, cell, "markup", NAME_COLUMN); gtk_tree_view_append_column (GTK_TREE_VIEW (panel->priv->treeview), column); cell = gedit_cell_renderer_button_new (); icon = g_themed_icon_new_with_default_fallbacks ("window-close-symbolic"); g_object_set (cell, "gicon", icon, NULL); g_object_unref (icon); gtk_tree_view_column_pack_end (column, cell, FALSE); g_signal_connect (cell, "clicked", G_CALLBACK (close_button_clicked), panel); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (panel->priv->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); panel->priv->selection_changed_handler_id = g_signal_connect (selection, "changed", G_CALLBACK (treeview_selection_changed), panel); g_signal_connect (panel->priv->treeview, "button-press-event", G_CALLBACK (panel_button_press_event), panel); g_signal_connect (panel->priv->treeview, "query-tooltip", G_CALLBACK (treeview_query_tooltip), panel); /* g_signal_connect (panel->priv->model, "row-inserted", G_CALLBACK (treeview_row_inserted), panel);*/ }