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