int gui_calls_manager_init(SphoneManager *manager)
{
g_calls_manager.manager=manager;
g_calls_manager.main_window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(g_calls_manager.main_window),"Active Calls");
gtk_window_set_deletable(GTK_WINDOW(g_calls_manager.main_window),FALSE);
gtk_window_set_default_size(GTK_WINDOW(g_calls_manager.main_window),400,220);
GtkWidget *v1=gtk_vbox_new(FALSE,0);
GtkWidget *s = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (s),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
g_calls_manager.dials_view = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(g_calls_manager.dials_view),FALSE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("Photo", renderer, "pixbuf", GUI_CALLS_COLUMN_PHOTO, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", GUI_CALLS_COLUMN_DESC, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", GUI_CALLS_COLUMN_STATUS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(g_calls_manager.dials_view), column);
g_calls_manager.dials_store = gtk_list_store_new(5, G_TYPE_STRING, G_TYPE_STRING, SPHONE_TYPE_CALL, G_TYPE_STRING, GDK_TYPE_PIXBUF);
gtk_tree_view_set_model(GTK_TREE_VIEW(g_calls_manager.dials_view), GTK_TREE_MODEL(g_calls_manager.dials_store));
GtkWidget *h1=gtk_hbox_new(FALSE, 0);
GtkWidget *h2=gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(s), g_calls_manager.dials_view);
gtk_container_add(GTK_CONTAINER(v1), s);
gtk_box_pack_start(GTK_BOX(v1), h1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(v1), h2, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(g_calls_manager.main_window), v1);
gtk_widget_show_all(v1);
g_calls_manager.answer_button=gtk_button_new_with_label("\nAnswer\n");
g_calls_manager.answer_waiting_button=gtk_button_new_with_label("\nAnswer\n");
g_calls_manager.activate_button=gtk_button_new_with_label("\nActivate\n");
g_calls_manager.hangup_button=gtk_button_new_with_label("\nHangup\n");
g_calls_manager.mute_button=gtk_button_new_with_label("\nMute ringing\n");
g_calls_manager.speaker_button=gtk_button_new_with_label("\nSpeaker\n");
g_calls_manager.handset_button=gtk_button_new_with_label("\nHandset\n");
gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.activate_button);
gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.answer_button);
gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.answer_waiting_button);
gtk_container_add(GTK_CONTAINER(h1), g_calls_manager.hangup_button);
gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.mute_button);
gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.speaker_button);
gtk_container_add(GTK_CONTAINER(h2), g_calls_manager.handset_button);
g_signal_connect(G_OBJECT(g_calls_manager.dials_view),"cursor-changed", G_CALLBACK(gui_calls_select_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.dials_view),"row-activated", G_CALLBACK(gui_calls_double_click_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.activate_button),"clicked", G_CALLBACK(gui_calls_activate_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.answer_button),"clicked", G_CALLBACK(gui_calls_answer_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.answer_waiting_button),"clicked", G_CALLBACK(gui_calls_answer_waiting_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.hangup_button),"clicked", G_CALLBACK(gui_calls_hangup_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.mute_button),"clicked", G_CALLBACK(gui_calls_mute_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.speaker_button),"clicked", G_CALLBACK(gui_calls_speaker_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.handset_button),"clicked", G_CALLBACK(gui_calls_handset_callback),NULL);
g_signal_connect(G_OBJECT(g_calls_manager.main_window),"delete-event", G_CALLBACK(return_true),NULL);
g_signal_connect(G_OBJECT(manager),"call_added", G_CALLBACK(gui_calls_new_call_callback),NULL);
return 0;
}
static void
finish_setup (CEPageIP4 *self, gpointer unused, GError *error, gpointer user_data)
{
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self);
GtkTreeSelection *selection;
gint offset;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkListStore *store;
if (error)
return;
populate_ui (self);
/* Address column */
store = GTK_LIST_STORE (gtk_tree_view_get_model (priv->addr_list));
/* IP Address column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), self);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_ADDRESS));
g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_editing_started), store);
priv->addr_cells[COL_ADDRESS] = GTK_CELL_RENDERER (renderer);
offset = gtk_tree_view_insert_column_with_attributes (priv->addr_list,
-1, _("Address"), renderer,
"text", COL_ADDRESS,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->addr_list), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Prefix/netmask column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), self);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_PREFIX));
g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_editing_started), store);
priv->addr_cells[COL_PREFIX] = GTK_CELL_RENDERER (renderer);
offset = gtk_tree_view_insert_column_with_attributes (priv->addr_list,
-1, _("Netmask"), renderer,
"text", COL_PREFIX,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->addr_list), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Gateway column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), self);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_GATEWAY));
g_signal_connect (renderer, "editing-started", G_CALLBACK (cell_editing_started), store);
priv->addr_cells[COL_GATEWAY] = GTK_CELL_RENDERER (renderer);
offset = gtk_tree_view_insert_column_with_attributes (priv->addr_list,
-1, _("Gateway"), renderer,
"text", COL_GATEWAY,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->addr_list), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_add), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (priv->addr_delete), FALSE);
g_signal_connect (priv->addr_add, "clicked", G_CALLBACK (addr_add_clicked), self);
g_signal_connect (priv->addr_delete, "clicked", G_CALLBACK (addr_delete_clicked), priv->addr_list);
selection = gtk_tree_view_get_selection (priv->addr_list);
g_signal_connect (selection, "changed", G_CALLBACK (list_selection_changed), priv->addr_delete);
g_signal_connect_swapped (priv->dns_servers, "changed", G_CALLBACK (ce_page_changed), self);
g_signal_connect_swapped (priv->dns_searches, "changed", G_CALLBACK (ce_page_changed), self);
method_changed (priv->method, self);
g_signal_connect (priv->method, "changed", G_CALLBACK (method_changed), self);
g_signal_connect_swapped (priv->dhcp_client_id, "changed", G_CALLBACK (ce_page_changed), self);
g_signal_connect (priv->routes_button, "clicked", G_CALLBACK (routes_button_clicked_cb), self);
}
static void
_dtv_init (DiagramTreeView *dtv)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
gint font_size;
GtkStyle *style;
/* connect the model with the view */
gtk_tree_view_set_model (GTK_TREE_VIEW (dtv), diagram_tree_model_new ());
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (dtv), TRUE);
/* the tree requires reading across rows (semantic hint) */
#if 0 /* stripe style */
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dtv), TRUE);
#endif
style = gtk_widget_get_style (GTK_WIDGET (dtv));
font_size = pango_font_description_get_size (style->font_desc);
font_size = PANGO_PIXELS (font_size);
/* first colum: name of diagram/layer/object - here is the tree */
cell = gtk_cell_renderer_text_new ();
gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (cell), 1);
g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Name"));
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width (column, font_size * 10);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "text", NAME_COLUMN);
gtk_tree_view_insert_column (GTK_TREE_VIEW (dtv), column, -1);
/* this is enough for simple name search (just typing) */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (dtv), NAME_COLUMN);
/* must have a sortable model ... */
gtk_tree_view_column_set_sort_column_id (column, NAME_COLUMN);
/* type column - show the type icon */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Type"));
/* must have fixed size, too */
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
/* without it gets zero size - not very useful! */
gtk_tree_view_column_set_min_width (column, font_size * 6);
gtk_tree_view_column_set_resizable (column, TRUE);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (column), cell,
_dtv_cell_pixbuf_func, dtv, NULL);
gtk_tree_view_insert_column (GTK_TREE_VIEW (dtv), column, -1);
gtk_tree_view_column_set_sort_column_id (column, OBJECT_COLUMN);
/* TODO: other fancy stuff */
{
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dtv));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (dtv), TRUE);
}
gtk_widget_set_has_tooltip (GTK_WIDGET (dtv), TRUE);
_dtv_create_popup_menu (dtv);
}
/**
* vik_trw_layer_waypoint_list_internal:
* @dialog: The dialog to create the widgets in
* @waypoints_and_layers: The list of waypoints (and it's layer) to be shown
* @show_layer_names: Show the layer names that each waypoint belongs to
*
* Create a table of waypoints with corresponding waypoint information
* This table does not support being actively updated
*/
static void vik_trw_layer_waypoint_list_internal ( GtkWidget *dialog,
GList *waypoints_and_layers,
gboolean show_layer_names )
{
if ( !waypoints_and_layers )
return;
// It's simple storing the gdouble values in the tree store as the sort works automatically
// Then apply specific cell data formatting (rather default double is to 6 decimal places!)
// However not storing any doubles for waypoints ATM
// TODO: Consider adding the waypoint icon into this store for display in the list
GtkTreeStore *store = gtk_tree_store_new ( WPT_LIST_COLS,
G_TYPE_STRING, // 0: Layer Name
G_TYPE_STRING, // 1: Waypoint Name
G_TYPE_STRING, // 2: Date
G_TYPE_BOOLEAN, // 3: Visible
G_TYPE_STRING, // 4: Comment
G_TYPE_INT, // 5: Height
GDK_TYPE_PIXBUF, // 6: Symbol Icon
G_TYPE_POINTER, // 7: TrackWaypoint Layer pointer
G_TYPE_POINTER ); // 8: Waypoint pointer
//gtk_tree_selection_set_select_function ( gtk_tree_view_get_selection (GTK_TREE_VIEW(vt)), vik_treeview_selection_filter, vt, NULL );
vik_units_height_t height_units = a_vik_get_units_height ();
//GList *gl = get_waypoints_and_layers_cb ( vl, user_data );
//g_list_foreach ( waypoints_and_layers, (GFunc) trw_layer_waypoint_list_add, store );
GList *gl = waypoints_and_layers;
while ( gl ) {
trw_layer_waypoint_list_add ( (vik_trw_waypoint_list_t*)gl->data, store, height_units );
gl = g_list_next ( gl );
}
GtkWidget *view = gtk_tree_view_new();
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
GtkTreeViewColumn *column;
GtkTreeViewColumn *sort_by_column;
gint column_runner = 0;
if ( show_layer_names ) {
// Insert column for the layer name when viewing multi layers
column = my_new_column_text ( _("Layer"), renderer, view, column_runner++ );
g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_expand ( column, TRUE );
// remember the layer column so we can sort by it later
sort_by_column = column;
}
else
column_runner++;
column = my_new_column_text ( _("Name"), renderer, view, column_runner++ );
gtk_tree_view_column_set_expand ( column, TRUE );
if ( !show_layer_names )
// remember the name column so we can sort by it later
sort_by_column = column;
column = my_new_column_text ( _("Date"), renderer, view, column_runner++ );
gtk_tree_view_column_set_resizable ( column, TRUE );
GtkCellRenderer *renderer_toggle = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ( _("Visible"), renderer_toggle, "active", column_runner, NULL );
gtk_tree_view_column_set_sort_column_id ( column, column_runner );
gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column );
column_runner++;
column = my_new_column_text ( _("Comment"), renderer, view, column_runner++ );
gtk_tree_view_column_set_expand ( column, TRUE );
if ( height_units == VIK_UNITS_HEIGHT_FEET )
(void)my_new_column_text ( _("Max Height\n(Feet)"), renderer, view, column_runner++ );
else
(void)my_new_column_text ( _("Max Height\n(Metres)"), renderer, view, column_runner++ );
GtkCellRenderer *renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
g_object_set (G_OBJECT (renderer_pixbuf), "xalign", 0.5, NULL);
column = gtk_tree_view_column_new_with_attributes ( _("Symbol"), renderer_pixbuf, "pixbuf", column_runner++, NULL );
// Special sort required for pixbufs
gtk_tree_sortable_set_sort_func ( GTK_TREE_SORTABLE(store), column_runner, sort_pixbuf_compare_func, NULL, NULL );
gtk_tree_view_column_set_sort_column_id ( column, column_runner );
gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column );
gtk_tree_view_set_model ( GTK_TREE_VIEW(view), GTK_TREE_MODEL(store) );
gtk_tree_selection_set_mode ( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE );
gtk_tree_view_set_rules_hint ( GTK_TREE_VIEW(view), TRUE );
g_object_unref(store);
GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
gtk_container_add ( GTK_CONTAINER(scrolledwindow), view );
g_object_set ( view, "has-tooltip", TRUE, NULL);
g_signal_connect ( view, "query-tooltip", G_CALLBACK (trw_layer_waypoint_tooltip_cb), NULL );
//g_signal_connect ( gtk_tree_view_get_selection (GTK_TREE_VIEW(view)), "changed", G_CALLBACK(trw_layer_waypoint_select_cb), view );
g_signal_connect ( view, "popup-menu", G_CALLBACK(trw_layer_waypoint_menu_popup), waypoints_and_layers );
g_signal_connect ( view, "button-press-event", G_CALLBACK(trw_layer_waypoint_button_pressed), waypoints_and_layers );
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolledwindow, TRUE, TRUE, 0);
// Set ordering of the initial view by one of the name columns
gtk_tree_view_column_clicked ( sort_by_column );
// Ensure a reasonable number of items are shown
// TODO: may be save window size, column order, sorted by between invocations.
gtk_window_set_default_size ( GTK_WINDOW(dialog), show_layer_names ? 700 : 500, 400 );
}
gint gui_contact_open_by_dial(const gchar *dial)
{
debug("gui_contact_open_by_dial\n");
store_contact_struct *contact=NULL;
store_contact_match(&contact,dial);
if(!contact)
return -1;
store_contact_load_details(contact);
GtkWidget *window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
if(contact->name)
gtk_window_set_title(GTK_WINDOW(window),contact->name);
else
gtk_window_set_title(GTK_WINDOW(window),"<Unknown>");
gtk_window_set_default_size(GTK_WINDOW(window),400,220);
GtkWidget *notebook=gtk_notebook_new();
GtkWidget *v1=gtk_vbox_new(FALSE,0);
GtkWidget *title_bar=gtk_hbox_new(FALSE,0);
GdkPixbuf *pixbuf=NULL;
if(contact->name==NULL && contact->picture==NULL)
pixbuf=utils_get_photo_unknown();
else if(contact->picture==NULL)
pixbuf=utils_get_photo_default();
else
pixbuf=utils_get_photo(contact->picture);
GtkWidget *picture=gtk_image_new_from_pixbuf(pixbuf);
GtkWidget *name;
if(contact->name){
name=gtk_label_new (contact->name);
}else{
name=gtk_label_new ("<Unknown>");
}
gtk_box_pack_start(GTK_BOX(title_bar), picture, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(title_bar), name, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(v1), title_bar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(v1), gtk_hseparator_new(), FALSE, FALSE, 5);
GList *dials=contact->dials;
debug("Dials %p\n",dials);
while(dials){
gchar *dial=((store_dial_struct*)dials->data)->dial;
GtkWidget *label=gtk_label_new(dial);
GtkWidget *button_sms=gtk_button_new ();
GtkWidget *button_voice=gtk_button_new ();
GtkWidget *h_dial=gtk_hbox_new(FALSE,0);
GtkWidget *sms=gtk_image_new_from_pixbuf(utils_get_icon("sms.png"));
GtkWidget *voice=gtk_image_new_from_pixbuf(utils_get_icon("voice.png"));
g_signal_connect(G_OBJECT(button_sms),"clicked", G_CALLBACK(gui_contact_send_sms_callback),label);
g_signal_connect(G_OBJECT(button_voice),"clicked", G_CALLBACK(gui_contact_dial_callback),label);
gtk_container_add (GTK_CONTAINER(button_sms),sms);
gtk_container_add (GTK_CONTAINER(button_voice),voice);
gtk_misc_set_alignment(GTK_MISC(label),0,0.5);
debug("gui_contact_open_by_dial add dial %d\n",dial);
gtk_box_pack_start(GTK_BOX(h_dial), label, TRUE, TRUE, 20);
gtk_box_pack_start(GTK_BOX(h_dial), button_sms, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(h_dial), button_voice, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(v1), h_dial, FALSE, FALSE, 0);
dials=g_list_next(dials);
}
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Details"));
// Call history
GtkWidget *scroll;
GtkWidget *calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_STATUS, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Duration", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_DURACTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
//g_signal_connect_after(G_OBJECT(g_gui_calls.dials_view),"cursor-changed", G_CALLBACK(gui_dialer_book_click_callback),NULL);
SphoneStoreTreeModel *calls;
if(contact->name!=NULL){ // known contact
gchar contactid[20];
sprintf(contactid,"%d",contact->id);
debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID query='%s'\n",contactid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID, contactid);
}else{
gchar dialid[20];
sprintf(dialid,"%d",store_dial_get_id(dial));
debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID query='%s'\n",dialid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID, dialid);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),scroll,gtk_label_new("Calls"));
// SMS history
v1=gtk_vbox_new(FALSE,0);
calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Text", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_SMS_TEXT, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
GtkWidget *sms_content=gtk_label_new (NULL);
gtk_label_set_selectable(GTK_LABEL(sms_content), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(sms_content), TRUE);
g_signal_connect_after(G_OBJECT(calls_view),"cursor-changed", G_CALLBACK(gui_contact_sms_selected_callback),sms_content);
if(contact->name!=NULL){ // known contact
gchar contactid[20];
sprintf(contactid,"%d",contact->id);
debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID query='%s'\n",contactid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID, contactid);
}else{
gchar dialid[20];
sprintf(dialid,"%d",store_dial_get_id(dial));
debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID query='%s'\n",dialid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID, dialid);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_container_add (GTK_CONTAINER(v1),scroll);
gtk_container_add (GTK_CONTAINER(v1),sms_content);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Messages"));
gtk_container_add(GTK_CONTAINER(window),notebook);
gtk_widget_show_all(window);
store_contact_free(contact);
return 0;
}
void
gnc_ab_initial_druid(void)
{
ABInitialInfo *info;
GladeXML *xml;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
gint component_id;
info = g_new0(ABInitialInfo, 1);
xml = gnc_glade_xml_new("aqbanking.glade", "AqBanking Init Druid");
info->window = glade_xml_get_widget(xml, "AqBanking Init Druid");
g_object_set_data_full(G_OBJECT(info->window), "xml", xml, g_object_unref);
glade_xml_signal_autoconnect_full(xml, gnc_glade_autoconnect_full_func,
info);
info->druid = glade_xml_get_widget(xml, "ab_init_druid");
gnc_druid_set_colors(GNOME_DRUID(info->druid));
info->api = gnc_AB_BANKING_new();
info->deferred_info = NULL;
info->gnc_hash = NULL;
info->match_page_prepared = FALSE;
info->account_view =
GTK_TREE_VIEW(glade_xml_get_widget(xml, "account_page_view"));
info->account_store = gtk_list_store_new(NUM_ACCOUNT_LIST_COLS,
G_TYPE_INT, G_TYPE_STRING,
G_TYPE_POINTER, G_TYPE_STRING,
G_TYPE_BOOLEAN);
gtk_tree_view_set_model(info->account_view,
GTK_TREE_MODEL(info->account_store));
g_object_unref(info->account_store);
column = gtk_tree_view_column_new_with_attributes(
_("Online Banking Account Name"), gtk_cell_renderer_text_new(),
"text", ACCOUNT_LIST_COL_AB_NAME, (gchar*) NULL);
gtk_tree_view_append_column(info->account_view, column);
column = gtk_tree_view_column_new_with_attributes(
_("GnuCash Account Name"), gtk_cell_renderer_text_new(),
"text", ACCOUNT_LIST_COL_GNC_NAME, (gchar*) NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(info->account_view, column);
column = gtk_tree_view_column_new_with_attributes(
_("New?"), gtk_cell_renderer_toggle_new(),
"active", ACCOUNT_LIST_COL_CHECKED, (gchar*) NULL);
gtk_tree_view_append_column(info->account_view, column);
selection = gtk_tree_view_get_selection(info->account_view);
g_signal_connect(selection, "changed",
G_CALLBACK(account_list_changed_cb), info);
component_id = gnc_register_gui_component(DRUID_AB_INITIAL_CM_CLASS,
NULL, cm_close_handler, info);
gnc_gui_component_set_session(component_id, gnc_get_current_session());
gtk_widget_show(info->window);
}
static void
impl_constructed (GObject *object)
{
RBPodcastAddDialog *dialog;
GtkBuilder *builder;
GtkWidget *widget;
GtkWidget *paned;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
RBEntryView *episodes;
RBShellPlayer *shell_player;
RhythmDBQuery *query;
RhythmDBQueryModel *query_model;
const char *episode_strings[3];
RB_CHAIN_GOBJECT_METHOD (rb_podcast_add_dialog_parent_class, constructed, object);
dialog = RB_PODCAST_ADD_DIALOG (object);
g_object_get (dialog->priv->podcast_mgr, "db", &dialog->priv->db, NULL);
builder = rb_builder_load ("podcast-add-dialog.ui", NULL);
dialog->priv->info_bar_message = gtk_label_new ("");
dialog->priv->info_bar = gtk_info_bar_new ();
g_object_set (dialog->priv->info_bar, "spacing", 0, NULL);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar))),
dialog->priv->info_bar_message);
gtk_widget_set_no_show_all (dialog->priv->info_bar, TRUE);
gtk_box_pack_start (GTK_BOX (dialog), dialog->priv->info_bar, FALSE, FALSE, 0);
gtk_widget_show (dialog->priv->info_bar_message);
dialog->priv->subscribe_button = GTK_WIDGET (gtk_builder_get_object (builder, "subscribe-button"));
g_signal_connect_object (dialog->priv->subscribe_button, "clicked", G_CALLBACK (subscribe_clicked_cb), dialog, 0);
gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE);
dialog->priv->feed_view = GTK_WIDGET (gtk_builder_get_object (builder, "feed-view"));
g_signal_connect (dialog->priv->feed_view, "row-activated", G_CALLBACK (feed_activated_cb), dialog);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)),
"changed",
G_CALLBACK (feed_selection_changed_cb),
dialog);
dialog->priv->search_entry = rb_search_entry_new (FALSE);
gtk_widget_set_size_request (GTK_WIDGET (dialog->priv->search_entry), 400, -1);
g_object_set (dialog->priv->search_entry,"explicit-mode", TRUE, NULL);
g_signal_connect (dialog->priv->search_entry, "search", G_CALLBACK (search_cb), dialog);
g_signal_connect (dialog->priv->search_entry, "activate", G_CALLBACK (search_cb), dialog);
gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "search-entry-box")),
GTK_WIDGET (dialog->priv->search_entry));
g_signal_connect (gtk_builder_get_object (builder, "close-button"),
"clicked",
G_CALLBACK (close_clicked_cb),
dialog);
dialog->priv->feed_model = gtk_list_store_new (7,
G_TYPE_STRING, /* name */
G_TYPE_STRING, /* author */
GDK_TYPE_PIXBUF, /* image */
G_TYPE_FILE, /* image file */
G_TYPE_INT, /* episode count */
G_TYPE_POINTER, /* RBPodcastChannel */
G_TYPE_ULONG); /* date */
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->feed_view), GTK_TREE_MODEL (dialog->priv->feed_model));
column = gtk_tree_view_column_new_with_attributes (_("Title"), gtk_cell_renderer_pixbuf_new (), "pixbuf", FEED_COLUMN_IMAGE, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer, "text", FEED_COLUMN_TITLE, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", FEED_COLUMN_AUTHOR, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Episodes"), renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer, episode_count_column_cell_data_func, NULL, NULL);
episode_strings[0] = "0000";
episode_strings[1] = _("Episodes");
episode_strings[2] = NULL;
rb_set_tree_view_column_fixed_width (dialog->priv->feed_view, column, renderer, episode_strings, 6);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast-add-dialog"));
gtk_box_pack_start (GTK_BOX (dialog), widget, TRUE, TRUE, 0);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dialog->priv->feed_view), TRUE);
/* set up episode view */
g_object_get (dialog->priv->shell, "shell-player", &shell_player, NULL);
episodes = rb_entry_view_new (dialog->priv->db, G_OBJECT (shell_player), TRUE, FALSE);
g_object_unref (shell_player);
g_signal_connect (episodes, "entry-activated", G_CALLBACK (episode_entry_activated_cb), dialog);
/* date column */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
{
const char *sample_strings[3];
sample_strings[0] = _("Date");
sample_strings[1] = rb_entry_view_get_time_date_column_sample ();
sample_strings[2] = NULL;
rb_entry_view_set_fixed_column_width (episodes, column, renderer, sample_strings);
}
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc) podcast_post_date_cell_data_func,
dialog, NULL);
rb_entry_view_append_column_custom (episodes, column,
_("Date"), "Date",
(GCompareDataFunc) podcast_post_date_sort_func,
0, NULL);
rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_TITLE, TRUE);
rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_DURATION, TRUE);
rb_entry_view_set_sorting_order (RB_ENTRY_VIEW (episodes), "Date", GTK_SORT_DESCENDING);
g_signal_connect (episodes,
"notify::sort-order",
G_CALLBACK (episodes_sort_changed_cb),
dialog);
query = rhythmdb_query_parse (dialog->priv->db,
RHYTHMDB_QUERY_PROP_EQUALS,
RHYTHMDB_PROP_TYPE,
RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH,
RHYTHMDB_QUERY_END);
query_model = rhythmdb_query_model_new_empty (dialog->priv->db);
rb_entry_view_set_model (episodes, query_model);
rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (query_model), query);
rhythmdb_query_free (query);
g_object_unref (query_model);
paned = GTK_WIDGET (gtk_builder_get_object (builder, "paned"));
g_signal_connect (paned, "size-allocate", G_CALLBACK (paned_size_allocate_cb), dialog);
gtk_paned_pack2 (GTK_PANED (paned),
GTK_WIDGET (episodes),
TRUE,
FALSE);
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_unref (builder);
}
SeahorseKeyManagerStore*
seahorse_key_manager_store_new (GcrCollection *collection,
GtkTreeView *view,
SeahorsePredicate *pred,
GSettings *settings)
{
SeahorseKeyManagerStore *self;
GtkTreeViewColumn *col;
SeahorseCollection *filtered;
GtkCellRenderer *renderer;
gchar *sort_by;
guint last;
filtered = seahorse_collection_new_for_predicate (collection, pred, NULL);
pred->custom = on_filter_visible;
self = g_object_new (SEAHORSE_TYPE_KEY_MANAGER_STORE,
"collection", filtered,
"settings", settings,
"mode", GCR_COLLECTION_MODEL_LIST,
NULL);
pred->custom_target = self;
g_object_unref (filtered);
last = gcr_collection_model_set_columns (GCR_COLLECTION_MODEL (self), columns);
g_return_val_if_fail (last == N_COLS, NULL);
/* The sorted model is the top level model */
gtk_tree_view_set_model (view, GTK_TREE_MODEL (self));
/* add the icon column */
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "stock-size", GTK_ICON_SIZE_DND, NULL);
g_object_set (renderer, "ypad", 6, NULL);
g_object_set (renderer, "yalign", 0.0, NULL);
col = gtk_tree_view_column_new_with_attributes ("", renderer, "gicon", COL_ICON, NULL);
gtk_tree_view_column_set_resizable (col, FALSE);
gtk_tree_view_append_column (view, col);
/* Name column */
col = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer,
"ypad", 6,
"yalign", 0.0,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL);
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_set_attributes (col, renderer,
"markup", COL_MARKUP,
NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer,
"ypad", 6,
"xpad", 3,
"yalign", 0.0,
"xalign", 1.0,
"scale", PANGO_SCALE_SMALL,
"alignment", PANGO_ALIGN_RIGHT,
NULL);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_set_attributes (col, renderer,
"markup", COL_DESCRIPTION,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_column_set_expand (col, TRUE);
gtk_tree_view_append_column (view, col);
gtk_tree_view_column_set_sort_column_id (col, COL_LABEL);
/* Use predicate to figure out which columns to add */
if (SEAHORSE_IS_COLLECTION (collection))
pred = seahorse_collection_get_predicate (SEAHORSE_COLLECTION (collection));
else
pred = NULL;
/* Also watch for sort-changed on the store */
g_signal_connect (self, "sort-column-changed", G_CALLBACK (on_sort_column_changed), self);
/* Update sort order in case the sorted column was added */
if ((sort_by = g_settings_get_string (settings, "sort-by")) != NULL) {
set_sort_to (self, sort_by);
g_free (sort_by);
}
gtk_tree_view_set_enable_search (view, FALSE);
gtk_tree_view_set_show_expanders (view, FALSE);
gtk_tree_view_set_rules_hint (view, TRUE);
gtk_tree_view_set_headers_visible (view, FALSE);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self), COL_LABEL,
GTK_SORT_ASCENDING);
/* Tree drag */
egg_tree_multi_drag_add_drag_support (view);
g_signal_connect (G_OBJECT (view), "drag_data_get", G_CALLBACK (drag_data_get), self);
g_signal_connect (G_OBJECT (view), "drag_begin", G_CALLBACK (drag_begin), self);
g_signal_connect (G_OBJECT (view), "drag_end", G_CALLBACK (drag_end), self);
gtk_drag_source_set (GTK_WIDGET (view), GDK_BUTTON1_MASK,
store_targets, G_N_ELEMENTS (store_targets), GDK_ACTION_COPY);
return self;
}
extern "C" int addToGui(gpointer data)
{
plugData* plugdata=(plugData*)data;
GtkTreeViewColumn* column;
GtkTreeModel* model=NULL;
GtkCellRenderer* renderer;
GtkTreeIter iter;
GtkWidget* menu;
setTextDomain(true,plugdata);
menu=gtk_menu_item_get_submenu((GtkMenuItem*)plugdata->mlist.menuView);
hideMenu=gtk_menu_item_new_with_label(gettext("Hide Browser"));
g_signal_connect(G_OBJECT(hideMenu),"activate",G_CALLBACK(toggleBrowser),plugdata);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),hideMenu);
gtk_widget_show_all(plugdata->mlist.menuView);
store=gtk_tree_store_new(NUM_COLUMNS,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING);
addFolderContents("/",&iter,true);
model=GTK_TREE_MODEL(store);
treeview=gtk_tree_view_new_with_model(model);
gtk_tree_view_set_enable_tree_lines((GtkTreeView*)treeview,true);
scrollbox=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrollbox,GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrollbox),(GtkWidget*)treeview);
gtk_box_pack_start((GtkBox*)plugdata->leftUserBox,scrollbox,true,true,0);
gtk_widget_show_all(plugdata->leftUserBox);
gtk_widget_set_size_request((GtkWidget*)scrollbox,100,-1);
//pixbuf
renderer=gtk_cell_renderer_pixbuf_new();
column=gtk_tree_view_column_new_with_attributes("path",renderer,"pixbuf",COLUMN_PIXBUF,NULL);
gtk_tree_view_column_set_resizable(column,false);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column((GtkTreeView*)treeview,column);
gtk_tree_view_column_set_spacing(column,0);
gtk_tree_view_column_set_expand(column,false);
//colom file
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(NULL,renderer,"text",COLUMN_FILENAME,NULL);
gtk_tree_view_column_set_resizable(column,true);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column((GtkTreeView*)treeview,column);
gtk_tree_view_column_set_expand(column,true);
gtk_tree_view_column_set_spacing(column,0);
gtk_tree_view_set_headers_visible((GtkTreeView*)treeview,false);
g_signal_connect(treeview,"row-expanded",G_CALLBACK(expandRow),column);
g_signal_connect(treeview,"row-collapsed",G_CALLBACK(collapseRow),column);
g_signal_connect(treeview,"row-activated",G_CALLBACK(onRowActivated),NULL);
leftBox=(GtkWidget*)plugdata->leftUserBox;
doStartUpCheck(plugdata);
showHideBrowser(plugdata,true);
if(showing==true)
showSide(true);
else
hideSide(true);
setTextDomain(false,plugdata);
return(0);
}
static void
gb_book_links_construct (GbBookLinks *self)
{
GbBookLinksPrivate *priv;
GtkWidget *swindow;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
priv = self->priv;
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow),
GTK_SHADOW_IN);
/* Create tree view */
priv->tree_view = gtk_tree_view_new ();
gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (priv->tree_view), TRUE);
g_signal_connect_swapped (priv->tree_view, "row-activated",
G_CALLBACK (schedule_emit_link_activated), self);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (priv->tree_view), 20);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_container_add (GTK_CONTAINER (swindow), priv->tree_view);
gtk_box_pack_start (GTK_BOX (self), swindow, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (self));
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), column);
renderer = (GtkCellRenderer *)
g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
"ellipsize", PANGO_ELLIPSIZE_END,
"weight", PANGO_WEIGHT_BOLD,
"xpad", 10,
NULL);
gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, TRUE);
gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
"markup", BOOK_LINKS_COLUMN_MARKUP,
NULL);
renderer = gd_styled_text_renderer_new ();
gd_styled_text_renderer_add_class (GD_STYLED_TEXT_RENDERER (renderer), "dim-label");
g_object_set (renderer,
"max-width-chars", 12,
"scale", PANGO_SCALE_SMALL,
"xalign", 1.0,
"xpad", 10,
NULL);
gtk_tree_view_column_pack_end (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE);
/*
gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
"text", BOOK_LINKS_COLUMN_LABEL,
NULL);
*/
priv->model = (GtkTreeModel *)gtk_list_store_new (BOOK_LINKS_COLUMN_N,
G_TYPE_STRING,
G_TYPE_STRING);
}
static void
add_columns (gint n_columns)
{
gint i;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
for (i = 0; i < n_columns; i++)
{
YadColumn *col = (YadColumn *) g_slist_nth_data (options.list_data.columns, i);
if (i == options.list_data.hide_column - 1 || col->type == YAD_COLUMN_HIDDEN ||
i == fore_col || i == back_col || i == font_col)
continue;
switch (col->type)
{
case YAD_COLUMN_CHECK:
case YAD_COLUMN_RADIO:
renderer = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes (col->name, renderer, "active", i, NULL);
if (back_col != -1)
gtk_tree_view_column_add_attribute (column, renderer, "cell-background", back_col);
if (col->type == YAD_COLUMN_RADIO)
{
gtk_cell_renderer_toggle_set_radio (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE);
g_signal_connect (renderer, "toggled", G_CALLBACK (rtoggled_cb), NULL);
}
else
g_signal_connect (renderer, "toggled", G_CALLBACK (toggled_cb), NULL);
break;
case YAD_COLUMN_IMAGE:
renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new_with_attributes (col->name, renderer, "pixbuf", i, NULL);
if (back_col != -1)
gtk_tree_view_column_add_attribute (column, renderer, "cell-background", back_col);
break;
case YAD_COLUMN_NUM:
case YAD_COLUMN_FLOAT:
renderer = gtk_cell_renderer_text_new ();
if (options.common_data.editable)
{
g_object_set (G_OBJECT (renderer), "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited_cb), NULL);
}
column = gtk_tree_view_column_new_with_attributes (col->name, renderer, "text", i, NULL);
if (fore_col != -1)
gtk_tree_view_column_add_attribute (column, renderer, "foreground", fore_col);
if (back_col != -1)
gtk_tree_view_column_add_attribute (column, renderer, "cell-background", back_col);
if (font_col != -1)
gtk_tree_view_column_add_attribute (column, renderer, "font", font_col);
gtk_tree_view_column_set_sort_column_id (column, i);
gtk_tree_view_column_set_resizable (column, TRUE);
break;
default:
renderer = gtk_cell_renderer_text_new ();
if (options.common_data.editable)
{
g_object_set (G_OBJECT (renderer), "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited_cb), NULL);
}
if (options.data.no_markup)
column = gtk_tree_view_column_new_with_attributes (col->name, renderer, "text", i, NULL);
else
column = gtk_tree_view_column_new_with_attributes (col->name, renderer, "markup", i, NULL);
g_object_set (G_OBJECT (renderer), "ellipsize", options.list_data.ellipsize, NULL);
if (fore_col != -1)
gtk_tree_view_column_add_attribute (column, renderer, "foreground", fore_col);
if (back_col != -1)
gtk_tree_view_column_add_attribute (column, renderer, "cell-background", back_col);
if (font_col != -1)
gtk_tree_view_column_add_attribute (column, renderer, "font", font_col);
gtk_tree_view_column_set_sort_column_id (column, i);
gtk_tree_view_column_set_resizable (column, TRUE);
break;
}
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (i));
gtk_tree_view_append_column (GTK_TREE_VIEW (list_view), column);
gtk_tree_view_column_set_clickable (column, options.list_data.clickable);
if (col->type != YAD_COLUMN_CHECK && col->type != YAD_COLUMN_IMAGE)
{
if (i == options.list_data.expand_column - 1 || options.list_data.expand_column == 0)
gtk_tree_view_column_set_expand (column, TRUE);
}
}
if (options.list_data.checkbox && !options.list_data.search_column)
options.list_data.search_column += 1;
if (options.list_data.search_column <= n_columns)
{
options.list_data.search_column -= 1;
gtk_tree_view_set_search_column (GTK_TREE_VIEW (list_view), options.list_data.search_column);
}
}
static void _camera_import_dialog_new(_camera_import_dialog_t *data)
{
data->dialog = gtk_dialog_new_with_buttons(_("import images from camera"), NULL, GTK_DIALOG_MODAL,
_("cancel"), GTK_RESPONSE_NONE, C_("camera import", "import"),
GTK_RESPONSE_ACCEPT, NULL);
gtk_window_set_default_size(GTK_WINDOW(data->dialog), 100, 600);
gtk_window_set_transient_for(GTK_WINDOW(data->dialog), GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)));
GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(data->dialog));
// List - setup store
data->store = gtk_list_store_new(2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
// IMPORT PAGE
data->import.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(data->import.page), 5);
// Top info
data->import.info = gtk_label_new(_("please wait while prefetching thumbnails of images from camera..."));
gtk_label_set_single_line_mode(GTK_LABEL(data->import.info), FALSE);
gtk_widget_set_halign(data->import.info, GTK_ALIGN_START);
gtk_box_pack_start(GTK_BOX(data->import.page), data->import.info, FALSE, FALSE, 0);
// jobcode
data->import.jobname
= _camera_import_gconf_widget(data, _("jobcode"), "plugins/capture/camera/import/jobcode");
gtk_box_pack_start(GTK_BOX(data->import.page), GTK_WIDGET(data->import.jobname->widget), FALSE, FALSE, 0);
// Create the treview with list model data store
data->import.treeview = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview), GTK_POLICY_NEVER,
GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new());
GtkTreeView *treeview = GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview)));
GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new();
GtkTreeViewColumn *column
= gtk_tree_view_column_new_with_attributes(_("thumbnail"), renderer, "pixbuf", 0, (char *)NULL);
gtk_tree_view_append_column(treeview, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("storage file"), renderer, "text", 1, (char *)NULL);
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_expand(column, TRUE);
GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(data->store));
gtk_tree_view_set_headers_visible(treeview, FALSE);
gtk_box_pack_start(GTK_BOX(data->import.page), data->import.treeview, TRUE, TRUE, 0);
// SETTINGS PAGE
data->settings.page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(data->settings.page), 5);
// general settings
gtk_box_pack_start(GTK_BOX(data->settings.page), gtk_label_new(_("general")), FALSE, FALSE, 0);
// ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
data->settings.general.ignore_jpeg = gtk_check_button_new_with_label(_("ignore JPEG files"));
gtk_widget_set_tooltip_text(data->settings.general.ignore_jpeg,
_("do not load files with an extension of .jpg or .jpeg. this can be useful when there are "
"raw+JPEG in a directory."));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->settings.general.ignore_jpeg),
dt_conf_get_bool("ui_last/import_ignore_jpegs"));
gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(data->settings.general.ignore_jpeg), "clicked",
G_CALLBACK(_check_button_callback), data);
GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
data->settings.general.date_override = gtk_check_button_new_with_label(_("override today's date"));
gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_override, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(data->settings.general.date_override,
_("check this, if you want to override the timestamp used when expanding variables:\n$(YEAR), "
"$(MONTH), $(DAY),\n$(HOUR), $(MINUTE), $(SECONDS)"));
data->settings.general.date_entry = gtk_entry_new();
gtk_widget_set_sensitive(data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
data->settings.general.date_override)));
gtk_box_pack_start(GTK_BOX(hbox), data->settings.general.date_entry, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(data->settings.general.date_override), "clicked",
G_CALLBACK(_check_button_callback), data);
gtk_box_pack_start(GTK_BOX(data->settings.page), hbox, FALSE, FALSE, 0);
// THE NOTEBOOK
data->notebook = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->import.page, gtk_label_new(_("images")));
gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook), data->settings.page, gtk_label_new(_("settings")));
// end
gtk_box_pack_start(GTK_BOX(content), data->notebook, TRUE, TRUE, 0);
// gtk_widget_set_size_request(content, DT_PIXEL_APPLY_DPI(400), DT_PIXEL_APPLY_DPI(400));
}
static GtkWidget *
ignore_treeview_new (GtkWidget *box)
{
GtkListStore *store;
GtkWidget *view;
GtkTreeViewColumn *col;
GtkCellRenderer *render;
int col_id;
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
g_return_val_if_fail (store != NULL, NULL);
view = gtkutil_treeview_new (box, GTK_TREE_MODEL (store),
NULL,
MASK_COLUMN, _("Mask"),
CHAN_COLUMN, _("Channel"),
PRIV_COLUMN, _("Private"),
NOTICE_COLUMN, _("Notice"),
CTCP_COLUMN, _("CTCP"),
DCC_COLUMN, _("DCC"),
INVITE_COLUMN, _("Invite"),
UNIGNORE_COLUMN, _("Unignore"),
-1);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (view), 0), TRUE);
/* attach to signals and customise columns */
for (col_id=0; (col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), col_id));
col_id++)
{
GList *list = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (col));
GList *tmp;
for (tmp = list; tmp; tmp = tmp->next)
{
render = static_cast<GtkCellRenderer*>(tmp->data);
if (col_id > 0) /* it's a toggle button column */
{
g_signal_connect (render, "toggled", G_CALLBACK (option_toggled),
GINT_TO_POINTER (col_id));
} else /* mask column */
{
g_object_set (G_OBJECT (render), "editable", TRUE, NULL);
g_signal_connect (render, "edited", G_CALLBACK (mask_edited), NULL);
/* make this column sortable */
gtk_tree_view_column_set_sort_column_id (col, col_id);
gtk_tree_view_column_set_min_width (col, 272);
}
/* centre titles */
gtk_tree_view_column_set_alignment (col, 0.5);
}
g_list_free (list);
}
gtk_widget_show (view);
return view;
}
static void
ft_manager_build_ui (EmpathyFTManager *manager)
{
GtkBuilder *gui;
GtkTreeView *view;
GtkListStore *liststore;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gchar *filename;
EmpathyFTManagerPriv *priv = GET_PRIV (manager);
filename = empathy_file_lookup ("empathy-ft-manager.ui", "src");
gui = empathy_builder_get_file (filename,
"ft_manager_dialog", &priv->window,
"ft_list", &priv->treeview,
"clear_button", &priv->clear_button,
"open_button", &priv->open_button,
"abort_button", &priv->abort_button,
NULL);
g_free (filename);
empathy_builder_connect (gui, manager,
"ft_manager_dialog", "destroy", ft_manager_destroy_cb,
"ft_manager_dialog", "response", ft_manager_response_cb,
"ft_manager_dialog", "delete-event", ft_manager_delete_event_cb,
"ft_manager_dialog", "key-press-event", ft_manager_key_press_event_cb,
NULL);
empathy_builder_unref_and_keep_widget (gui, priv->window);
/* Window geometry. */
empathy_geometry_bind (GTK_WINDOW (priv->window), "ft-manager");
/* Setup the tree view */
view = GTK_TREE_VIEW (priv->treeview);
selection = gtk_tree_view_get_selection (view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed",
G_CALLBACK (ft_manager_selection_changed), manager);
gtk_tree_view_set_headers_visible (view, TRUE);
gtk_tree_view_set_enable_search (view, FALSE);
/* Setup the model */
liststore = gtk_list_store_new (5,
G_TYPE_INT, /* percent */
G_TYPE_ICON, /* icon */
G_TYPE_STRING, /* message */
G_TYPE_STRING, /* remaining */
G_TYPE_OBJECT); /* ft_handler */
gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore));
priv->model = GTK_TREE_MODEL (liststore);
g_object_unref (liststore);
/* Progress column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("%"));
gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT);
gtk_tree_view_insert_column (view, column, -1);
renderer = gtk_cell_renderer_progress_new ();
g_object_set (renderer, "xalign", 0.5, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer,
ft_manager_progress_cell_data_func, NULL, NULL);
/* Icon and filename column*/
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("File"));
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE);
gtk_tree_view_column_set_spacing (column, 3);
gtk_tree_view_insert_column (view, column, -1);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "xpad", 3,
"stock-size", GTK_ICON_SIZE_DND, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"gicon", COL_ICON, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COL_MESSAGE, NULL);
/* Remaining time column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Remaining"));
gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING);
gtk_tree_view_insert_column (view, column, -1);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.5, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COL_REMAINING, NULL);
/* clear button should be sensitive only if there are completed/cancelled
* handlers in the store.
*/
gtk_widget_set_sensitive (priv->clear_button, FALSE);
}
/* favorites_init */
static Favorites * _favorites_init(BrowserPluginHelper * helper)
{
Favorites * favorites;
GtkIconTheme * icontheme;
gint size;
GtkWidget * widget;
GtkToolItem * toolitem;
GtkTreeModel * model;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
GtkTreeSelection * treesel;
GError * error = NULL;
if((favorites = object_new(sizeof(*favorites))) == NULL)
return NULL;
favorites->helper = helper;
favorites->mime = helper->get_mime(helper->browser);
favorites->selection = NULL;
icontheme = gtk_icon_theme_get_default();
gtk_icon_size_lookup(GTK_ICON_SIZE_BUTTON, &size, &size);
favorites->folder = gtk_icon_theme_load_icon(icontheme, "stock_folder",
size, GTK_ICON_LOOKUP_USE_BUILTIN, &error);
if(favorites->folder == NULL)
{
helper->error(helper->browser, error->message, 1);
g_error_free(error);
}
favorites->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
favorites->store = gtk_list_store_new(FC_COUNT, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_STRING);
model = gtk_tree_model_filter_new(GTK_TREE_MODEL(favorites->store),
NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),
_favorites_on_filter_visible, NULL, NULL);
favorites->view = gtk_tree_view_new_with_model(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(favorites->view),
FALSE);
/* columns */
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
"pixbuf", FC_ICON, NULL);
gtk_tree_view_column_set_expand(column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(favorites->view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
"text", FC_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(favorites->view), column);
/* selection */
treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(favorites->view));
gtk_tree_selection_set_mode(treesel, GTK_SELECTION_SINGLE);
/* signals */
g_signal_connect(favorites->view, "row-activated", G_CALLBACK(
_favorites_on_row_activated), favorites);
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_container_add(GTK_CONTAINER(widget), favorites->view);
#else
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(widget),
favorites->view);
#endif
gtk_box_pack_start(GTK_BOX(favorites->widget), widget, TRUE, TRUE, 0);
/* lower toolbar */
widget = gtk_toolbar_new();
gtk_toolbar_set_icon_size(GTK_TOOLBAR(widget), GTK_ICON_SIZE_MENU);
gtk_toolbar_set_style(GTK_TOOLBAR(widget), GTK_TOOLBAR_ICONS);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_ADD);
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem),
_("Add to bookmarks"));
#endif
g_signal_connect_swapped(toolitem, "clicked", G_CALLBACK(
_favorites_on_add), favorites);
gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_REMOVE);
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem),
_("Remove from bookmarks"));
#endif
g_signal_connect_swapped(toolitem, "clicked", G_CALLBACK(
_favorites_on_remove), favorites);
gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1);
gtk_box_pack_start(GTK_BOX(favorites->widget), widget, FALSE, TRUE, 0);
gtk_widget_show_all(favorites->widget);
return favorites;
}
static void
gnc_find_account_dialog_create (GtkWidget *parent, FindAccountDialog *facc_dialog)
{
GtkWidget *dialog;
GtkBuilder *builder;
GtkTreeSelection *selection;
GtkTreeViewColumn *tree_column;
GtkCellRenderer *cr;
ENTER(" ");
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-find-account.glade", "list-store");
gnc_builder_add_from_file (builder, "dialog-find-account.glade", "Find Account Dialog");
dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Find Account Dialog"));
facc_dialog->dialog = dialog;
facc_dialog->session = gnc_get_current_session();
/* parent */
if (parent != NULL)
{
facc_dialog->parent = parent;
gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(parent));
}
else
facc_dialog->parent = NULL;
/* Connect the radio buttons...*/
facc_dialog->radio_root = GTK_WIDGET(gtk_builder_get_object (builder, "radio-root"));
facc_dialog->radio_subroot = GTK_WIDGET(gtk_builder_get_object (builder, "radio-subroot"));
facc_dialog->filter_text_entry = GTK_WIDGET(gtk_builder_get_object (builder, "filter-text-entry"));
facc_dialog->sub_label = GTK_WIDGET(gtk_builder_get_object (builder, "sub-label"));
facc_dialog->radio_hbox = GTK_WIDGET(gtk_builder_get_object (builder, "hbox-radio"));
facc_dialog->filter_button = GTK_WIDGET(gtk_builder_get_object (builder, "filter-button"));
g_signal_connect (facc_dialog->filter_button, "clicked",
G_CALLBACK(filter_button_cb), (gpointer)facc_dialog);
facc_dialog->view = GTK_WIDGET(gtk_builder_get_object (builder, "treeview"));
g_signal_connect (facc_dialog->view, "row-activated",
G_CALLBACK(row_double_clicked), (gpointer)facc_dialog);
/* Enable alternative line colors */
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(facc_dialog->view), TRUE);
/* default to 'close' button */
gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(facc_dialog->view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
/* Need to add pixbuf renderers here to get the xalign to work. */
tree_column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (tree_column, _("Place Holder"));
gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column);
gtk_tree_view_column_set_alignment (tree_column, 0.5);
gtk_tree_view_column_set_expand (tree_column, TRUE);
cr = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start (tree_column, cr, TRUE);
// connect 'active' and set 'xalign' property of the cell renderer
gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", PLACE_HOLDER, NULL);
gtk_cell_renderer_set_alignment (cr, 0.5, 0.5);
tree_column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (tree_column, _("Hidden"));
gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column);
gtk_tree_view_column_set_alignment (tree_column, 0.5);
gtk_tree_view_column_set_expand (tree_column, TRUE);
cr = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start (tree_column, cr, TRUE);
// connect 'active' and set 'xalign' property of the cell renderer
gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", HIDDEN, NULL);
gtk_cell_renderer_set_alignment (cr, 0.5, 0.5);
tree_column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (tree_column, _("Not Used"));
gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column);
gtk_tree_view_column_set_alignment (tree_column, 0.5);
gtk_tree_view_column_set_expand (tree_column, TRUE);
cr = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start (tree_column, cr, TRUE);
// connect 'active' and set 'xalign' property of the cell renderer
gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", NOT_USED, NULL);
gtk_cell_renderer_set_alignment (cr, 0.5, 0.5);
tree_column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (tree_column, _("Balance Zero"));
gtk_tree_view_append_column (GTK_TREE_VIEW(facc_dialog->view), tree_column);
gtk_tree_view_column_set_alignment (tree_column, 0.5);
gtk_tree_view_column_set_expand (tree_column, TRUE);
cr = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start (tree_column, cr, TRUE);
// connect 'active' and set 'xalign' property of the cell renderer
gtk_tree_view_column_set_attributes (tree_column, cr, "stock-id", BAL_ZERO, NULL);
gtk_cell_renderer_set_alignment (cr, 0.5, 0.5);
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, facc_dialog);
g_object_unref (G_OBJECT(builder));
gnc_restore_window_size (GNC_PREFS_GROUP, GTK_WINDOW(facc_dialog->dialog));
if (facc_dialog->account != NULL)
{
const gchar *sub_label_start = _("Search from ");
gchar *sub_full_name = gnc_account_get_full_name (facc_dialog->account);
gchar *sub_label;
sub_label = g_strconcat (sub_label_start, sub_full_name, NULL);
gtk_button_set_label (GTK_BUTTON(facc_dialog->radio_subroot), sub_label);
g_free (sub_full_name);
g_free (sub_label);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(facc_dialog->radio_subroot), TRUE);
gtk_widget_show_all (facc_dialog->radio_hbox);
}
else
gtk_widget_hide_all (facc_dialog->radio_hbox);
// Set the filter to Wildcard
gtk_entry_set_text (GTK_ENTRY(facc_dialog->filter_text_entry), "");
get_account_info (facc_dialog);
LEAVE(" ");
}
int
fe_dcc_open_recv_win (int passive)
{
GtkWidget *radio, *table, *vbox, *bbox, *view, *exp, *detailbox;
GtkListStore *store;
GSList *group;
if (dccfwin.window)
{
if (!passive)
mg_bring_tofront (dccfwin.window);
return TRUE;
}
dccfwin.window = mg_create_generic_tab ("Transfers", _(DISPLAY_NAME": Uploads and Downloads"),
FALSE, TRUE, close_dcc_file_window, NULL,
win_width, win_height, &vbox, 0);
gtkutil_destroy_on_esc (dccfwin.window);
gtk_container_set_border_width (GTK_CONTAINER (dccfwin.window), 3);
gtk_box_set_spacing (GTK_BOX (vbox), 3);
store = gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER, GDK_TYPE_COLOR);
view = gtkutil_treeview_new (vbox, GTK_TREE_MODEL (store), NULL, -1);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
/* Up/Down Icon column */
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), -1, NULL,
gtk_cell_renderer_pixbuf_new (),
"pixbuf", COL_TYPE, NULL);
dcc_add_column (view, COL_STATUS, COL_COLOR, _("Status"), FALSE);
dcc_add_column (view, COL_FILE, COL_COLOR, _("File"), FALSE);
dcc_add_column (view, COL_SIZE, COL_COLOR, _("Size"), TRUE);
dcc_add_column (view, COL_POS, COL_COLOR, _("Position"), TRUE);
dcc_add_column (view, COL_PERC, COL_COLOR, "%", TRUE);
dcc_add_column (view, COL_SPEED, COL_COLOR, "KB/s", TRUE);
dcc_add_column (view, COL_ETA, COL_COLOR, _("ETA"), FALSE);
dcc_add_column (view, COL_NICK, COL_COLOR, _("Nick"), FALSE);
gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (view), COL_FILE), TRUE);
gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (view), COL_NICK), TRUE);
dccfwin.list = view;
dccfwin.store = store;
dccfwin.sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
view_mode = VIEW_BOTH;
gtk_tree_selection_set_mode (dccfwin.sel, GTK_SELECTION_MULTIPLE);
if (!prefs.hex_gui_tab_utils)
g_signal_connect (G_OBJECT (dccfwin.window), "configure_event",
G_CALLBACK (dcc_configure_cb), 0);
g_signal_connect (G_OBJECT (dccfwin.sel), "changed",
G_CALLBACK (dcc_row_cb), NULL);
/* double click */
g_signal_connect (G_OBJECT (view), "row-activated",
G_CALLBACK (dcc_dclick_cb), NULL);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 16);
gtk_box_pack_start (GTK_BOX (vbox), table, 0, 0, 0);
radio = gtk_radio_button_new_with_mnemonic (NULL, _("Both"));
g_signal_connect (G_OBJECT (radio), "toggled",
G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_BOTH));
gtk_table_attach (GTK_TABLE (table), radio, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
radio = gtk_radio_button_new_with_mnemonic (group, _("Uploads"));
g_signal_connect (G_OBJECT (radio), "toggled",
G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_UPLOAD));
gtk_table_attach (GTK_TABLE (table), radio, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
radio = gtk_radio_button_new_with_mnemonic (group, _("Downloads"));
g_signal_connect (G_OBJECT (radio), "toggled",
G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_DOWNLOAD));
gtk_table_attach (GTK_TABLE (table), radio, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
exp = gtk_expander_new (_("Details"));
gtk_table_attach (GTK_TABLE (table), exp, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
detailbox = gtk_table_new (3, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (detailbox), 6);
gtk_table_set_row_spacings (GTK_TABLE (detailbox), 2);
gtk_container_set_border_width (GTK_CONTAINER (detailbox), 6);
g_signal_connect (G_OBJECT (exp), "activate",
G_CALLBACK (dcc_exp_cb), detailbox);
gtk_table_attach (GTK_TABLE (table), detailbox, 0, 4, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
dccfwin.file_label = dcc_detail_label (_("File:"), detailbox, 0);
dccfwin.address_label = dcc_detail_label (_("Address:"), detailbox, 1);
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 2);
dccfwin.abort_button = gtkutil_button (bbox, GTK_STOCK_CANCEL, 0, abort_clicked, 0, _("Abort"));
dccfwin.accept_button = gtkutil_button (bbox, GTK_STOCK_APPLY, 0, accept_clicked, 0, _("Accept"));
dccfwin.resume_button = gtkutil_button (bbox, GTK_STOCK_REFRESH, 0, resume_clicked, 0, _("Resume"));
dccfwin.clear_button = gtkutil_button (bbox, GTK_STOCK_CLEAR, 0, clear_completed, 0, _("Clear"));
dccfwin.open_button = gtkutil_button (bbox, 0, 0, browse_dcc_folder, 0, _("Open Folder..."));
gtk_widget_set_sensitive (dccfwin.accept_button, FALSE);
gtk_widget_set_sensitive (dccfwin.resume_button, FALSE);
gtk_widget_set_sensitive (dccfwin.abort_button, FALSE);
dcc_fill_window (3);
gtk_widget_show_all (dccfwin.window);
gtk_widget_hide (detailbox);
return FALSE;
}
static GtkWidget *create_window(void)
{
// Basic window
stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title
gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
// Horizontal layout of banner and controls
stwidgets.hlayout = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout);
// banner
{
GdkPixbuf *pixbuf = load_banner();
stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref((gpointer)pixbuf);
}
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0);
// Vertical layout of tab control and start+cancel buttons
stwidgets.vlayout = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0);
// Tab control
stwidgets.tabs = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4);
// layout table of config page
stwidgets.configtlayout = gtk_table_new(6, 3, FALSE);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout);
// 3D video mode LabelText
stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, 0, 4, 0);
// 3D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, 0, 4, 0);
// Fullscreen checkbox
stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, 0, 4, 0);
stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen");
gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0);
#ifdef POLYMER
// Polymer checkbox
stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer");
gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0);
#endif
// Input devices LabelText
stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, 0, 4, 0);
// Input devices combo
{
GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING);
GtkCellRenderer *cell;
stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2, GTK_EXPAND | GTK_FILL, 0, 4, 0);
// Custom mod LabelText
stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, 0, 4, 7);
// Custom mod combo
{
GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING);
GtkCellRenderer *cell;
stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3, GTK_EXPAND | GTK_FILL, 0, 4, 7);
// Empty horizontal layout
stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, 0, GTK_EXPAND | GTK_FILL, 4, 0);
// Autoload checkbox
stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, 0, 2, 2);
// Always show config checkbox
stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, 0, 2, 2);
// Configuration tab
stwidgets.configtab = gtk_label_new("Configuration");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab);
// Game data layout
stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4);
// Game data field LabelText
stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:");
gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5);
// Game data scrollable area
stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN);
// Game data list
{
GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING);
stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL);
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col);
col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL);
gtk_tree_view_column_set_min_width(col, 64);
gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col);
}
gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE);
// Game tab
stwidgets.gametab = gtk_label_new("Game");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab);
// Messages scrollable area
stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
// Messages text area
stwidgets.messagestext = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext);
gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
// Messages tab
stwidgets.messagestab = gtk_label_new("Messages");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab);
// Dialogue box buttons layout
stwidgets.buttons = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3);
gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END);
// Cancel button
stwidgets.cancelbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT);
stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign);
stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout);
stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0);
stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel");
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0);
// Start button
stwidgets.startbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT);
gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton);
stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign);
stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout);
stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0);
stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start");
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0);
// Wire up the signals
g_signal_connect((gpointer) stwidgets.startwin, "delete_event",
G_CALLBACK(on_startwin_delete_event),
NULL);
g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed",
G_CALLBACK(on_vmode3dcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled",
G_CALLBACK(on_fullscreencheck_toggled),
NULL);
#ifdef POLYMER
g_signal_connect((gpointer) stwidgets.polymercheck, "toggled",
G_CALLBACK(on_polymercheck_toggled),
NULL);
#endif
g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed",
G_CALLBACK(on_inputdevcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.custommodcombo, "changed",
G_CALLBACK(on_custommodcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled",
G_CALLBACK(on_autoloadcheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled",
G_CALLBACK(on_alwaysshowcheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked",
G_CALLBACK(on_cancelbutton_clicked),
NULL);
g_signal_connect((gpointer) stwidgets.startbutton, "clicked",
G_CALLBACK(on_startbutton_clicked),
NULL);
{
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
g_signal_connect((gpointer) sel, "changed",
G_CALLBACK(on_gamelist_selection_changed),
NULL);
}
// Associate labels with their controls
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist);
return stwidgets.startwin;
}
PrefabSelector::PrefabSelector () :
_widget(gtk_vbox_new(FALSE, 2)), _store(gtk_tree_store_new(PREFAB_STORE_SIZE, G_TYPE_STRING, G_TYPE_STRING,
GDK_TYPE_PIXBUF, G_TYPE_STRING)),
_fileFiltered(gtk_tree_model_filter_new(GTK_TREE_MODEL(_store), NULL)), _fileSorted(
GTK_TREE_MODEL(gtk_tree_model_sort_new_with_model(_fileFiltered))), _view(
GTK_TREE_VIEW(gtk_tree_view_new_with_model(_fileSorted)))
{
std::string fullpath = GlobalRegistry().get(RKEY_APP_PATH) + "prefabs/";
_selectedSelectionStrategy = PREFAB_SELECT_EXTEND;
GtkWidget* scr = gtk_scrolled_window_new(0, 0);
gtk_box_pack_start(GTK_BOX(_widget), scr, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scr), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scr), GTK_SHADOW_IN);
{
gtk_tree_view_set_enable_search(_view, TRUE);
gtk_tree_view_set_search_column(_view, PREFAB_SHORTNAME);
gtk_tree_view_set_headers_visible(_view, TRUE);
gtk_tree_view_set_headers_clickable(_view, TRUE);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_grid_lines(_view, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
#endif
g_signal_connect(G_OBJECT(_view), "button_press_event", G_CALLBACK(callbackButtonPress), this);
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Prefab"));
gtk_tree_view_column_set_expand(column, FALSE);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, PREFAB_SHORTNAME);
gtk_tree_view_append_column(_view, column);
GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_renderer_set_fixed_size(imageRenderer, 128, -1);
gtk_tree_view_column_pack_start(column, imageRenderer, false);
gtk_tree_view_column_add_attribute(column, imageRenderer, "pixbuf", PREFAB_IMAGE);
GtkCellRenderer* nameRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(column, nameRenderer, false);
gtk_tree_view_column_add_attribute(column, nameRenderer, "markup", PREFAB_DESCRIPTION);
}
gtk_container_add(GTK_CONTAINER(scr), GTK_WIDGET(_view));
g_object_unref(G_OBJECT(_store));
}
GtkWidget* hboxFooter = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(_widget), hboxFooter, FALSE, TRUE, 0);
{
// options
GtkWidget* vboxOptions = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxOptions, FALSE, TRUE, 0);
GtkRadioButton* radioExtendSelection =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(NULL, _("Extend current selection")));
gtk_widget_ref(GTK_WIDGET(radioExtendSelection));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioExtendSelection), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioExtendSelection), "handler", gint_to_pointer(
g_signal_connect(radioExtendSelection,
"toggled", G_CALLBACK(callbackSelectionOptionToggleExtend), this)));
GtkRadioButton
* radioUnselect =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioExtendSelection, _("Deselect before insert")));
gtk_widget_ref(GTK_WIDGET(radioUnselect));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioUnselect), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioUnselect), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioUnselect),
"toggled", G_CALLBACK(callbackSelectionOptionToggleUnselect), this)));
GtkRadioButton
* radioReplace =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioUnselect, _("Replace current selection")));
gtk_widget_ref(GTK_WIDGET(radioReplace));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioReplace), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioReplace), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioReplace),
"toggled", G_CALLBACK(callbackSelectionOptionToggleReplace), this)));
}
{
//search entry, connect to file filter
GtkWidget* vboxSearch = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxSearch, FALSE, TRUE, 3);
GtkWidget *searchEntry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vboxSearch), searchEntry, FALSE, TRUE, 3);
gtk_widget_show(searchEntry);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(_fileFiltered),
(GtkTreeModelFilterVisibleFunc) callbackFilterFiles, this, NULL);
g_signal_connect(G_OBJECT(searchEntry), "changed", G_CALLBACK(callbackRefilter), NULL);
_filterEntry = GTK_ENTRY(searchEntry);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_search_entry(_view, _filterEntry);
#endif
}
/* fill prefab store with data */
Directory_forEach(fullpath, LoadPrefabDirectoryFunctor(fullpath, "", NULL, _store));
Directory_forEach(fullpath, MatchFileExtension<LoadPrefabFileFunctor> ("map", LoadPrefabFileFunctor("", NULL, _store)));
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(_fileFiltered));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(_fileSorted), PREFAB_SHORTNAME, GTK_SORT_ASCENDING);
}
static void
auth_methods_setup (GtkBuilder *builder, GHashTable *hash)
{
GtkWidget *widget;
GtkListStore *store;
GtkTreeIter iter;
const char *value;
gboolean allowed;
gboolean use_mppe = FALSE;
GtkCellRendererToggle *check_renderer;
GtkCellRenderer *text_renderer;
GtkTreeViewColumn *column;
gint offset;
gboolean mschap_state = TRUE;
gboolean mschap2_state = TRUE;
store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_UINT, G_TYPE_BOOLEAN);
/* Check for MPPE */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REQUIRE_MPPE);
if (value && !strcmp (value, "yes"))
use_mppe = TRUE;
/* Or MPPE-128 */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REQUIRE_MPPE_128);
if (value && !strcmp (value, "yes"))
use_mppe = TRUE;
/* Or MPPE-40 */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REQUIRE_MPPE_40);
if (value && !strcmp (value, "yes"))
use_mppe = TRUE;
/* PAP */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_PAP);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
if (use_mppe)
allowed = FALSE;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("PAP"),
COL_VALUE, allowed,
COL_TAG, TAG_PAP,
COL_SENSITIVE, !use_mppe,
-1);
/* CHAP */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_CHAP);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
if (use_mppe)
allowed = FALSE;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("CHAP"),
COL_VALUE, allowed,
COL_TAG, TAG_CHAP,
COL_SENSITIVE, !use_mppe,
-1);
/* MSCHAP */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_MSCHAP);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
mschap_state = allowed;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("MSCHAP"),
COL_VALUE, allowed,
COL_TAG, TAG_MSCHAP,
COL_SENSITIVE, TRUE,
-1);
/* MSCHAPv2 */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_MSCHAPV2);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
mschap2_state = allowed;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("MSCHAPv2"),
COL_VALUE, allowed,
COL_TAG, TAG_MSCHAPV2,
COL_SENSITIVE, TRUE,
-1);
/* EAP */
value = g_hash_table_lookup (hash, NM_L2TP_KEY_REFUSE_EAP);
allowed = (value && !strcmp (value, "yes")) ? FALSE : TRUE;
if (use_mppe)
allowed = FALSE;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_NAME, _("EAP"),
COL_VALUE, allowed,
COL_TAG, TAG_EAP,
COL_SENSITIVE, !use_mppe,
-1);
/* Set up the tree view */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ppp_auth_methods"));
gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (store));
check_renderer = GTK_CELL_RENDERER_TOGGLE (gtk_cell_renderer_toggle_new ());
g_signal_connect (check_renderer, "toggled", G_CALLBACK (check_toggled_cb), builder);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, "", GTK_CELL_RENDERER (check_renderer),
"active", COL_VALUE,
"sensitive", COL_SENSITIVE,
"activatable", COL_SENSITIVE,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 30);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
text_renderer = gtk_cell_renderer_text_new ();
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, "", text_renderer,
"text", COL_NAME,
"sensitive", COL_SENSITIVE,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Make sure MPPE is non-sensitive if MSCHAP and MSCHAPv2 are disabled */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ppp_use_mppe"));
if (!mschap_state && !mschap2_state) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_set_sensitive (widget, FALSE);
} else
gtk_widget_set_sensitive (widget, TRUE);
}
FeedListView *
feed_list_view_create (GtkTreeView *treeview)
{
GtkCellRenderer *titleRenderer, *countRenderer;
GtkCellRenderer *iconRenderer;
GtkTreeViewColumn *column, *column2;
GtkTreeSelection *select;
debug_enter ("feed_list_view_create");
/* Set up store */
g_assert (NULL == flv);
flv = FEED_LIST_VIEW (g_object_new (FEED_LIST_VIEW_TYPE, NULL));
flv->treeview = treeview;
flv->feedstore = gtk_tree_store_new (FS_LEN,
G_TYPE_STRING,
G_TYPE_ICON,
G_TYPE_POINTER,
G_TYPE_UINT,
G_TYPE_STRING);
gtk_tree_view_set_model (GTK_TREE_VIEW (flv->treeview), GTK_TREE_MODEL (flv->feedstore));
/* Prepare filter */
flv->filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (flv->feedstore), NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (flv->filter),
feed_list_view_filter_visible_function,
NULL,
NULL);
g_signal_connect (G_OBJECT (flv->feedstore), "row-changed",
G_CALLBACK (feed_list_view_row_changed_cb), flv);
/* we render the icon/state, the feed title and the unread count */
iconRenderer = gtk_cell_renderer_pixbuf_new ();
titleRenderer = gtk_cell_renderer_text_new ();
countRenderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_alignment (countRenderer, 1.0, 0);
column = gtk_tree_view_column_new ();
column2 = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, iconRenderer, FALSE);
gtk_tree_view_column_pack_start (column, titleRenderer, TRUE);
gtk_tree_view_column_pack_end (column2, countRenderer, FALSE);
gtk_tree_view_column_add_attribute (column, iconRenderer, "gicon", FS_ICON);
gtk_tree_view_column_add_attribute (column, titleRenderer, "markup", FS_LABEL);
gtk_tree_view_column_add_attribute (column2, countRenderer, "markup", FS_COUNT);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
gtk_tree_view_column_set_sizing (column2, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
gtk_tree_view_append_column (flv->treeview, column);
gtk_tree_view_append_column (flv->treeview, column2);
g_object_set (titleRenderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect (G_OBJECT (flv->treeview), "row-activated", G_CALLBACK (feed_list_view_row_activated_cb), flv);
g_signal_connect (G_OBJECT (flv->treeview), "key-press-event", G_CALLBACK (feed_list_view_key_press_cb), flv);
select = gtk_tree_view_get_selection (flv->treeview);
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed",
G_CALLBACK (feed_list_view_selection_changed_cb),
flv);
conf_get_bool_value (REDUCED_FEEDLIST, &flv->feedlist_reduced_unread);
if (flv->feedlist_reduced_unread)
feed_list_view_reduce_mode_changed (); /* before menu setup for reduced mode check box to be correct */
ui_dnd_setup_feedlist (flv->feedstore);
liferea_shell_update_feed_menu (TRUE, FALSE, FALSE);
liferea_shell_update_allitems_actions (FALSE, FALSE);
debug_exit ("feed_list_view_create");
return flv;
}
static void
thunar_uca_chooser_init (ThunarUcaChooser *uca_chooser)
{
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
ThunarUcaModel *uca_model;
GtkWidget *image;
GtkWidget *label;
GtkWidget *hbox;
GtkWidget *swin;
GtkWidget *vbox;
/* configure the dialog window */
gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_HELP, GTK_RESPONSE_HELP);
gtk_dialog_add_button (GTK_DIALOG (uca_chooser), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response (GTK_DIALOG (uca_chooser), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator (GTK_DIALOG (uca_chooser), FALSE);
gtk_window_set_default_size (GTK_WINDOW (uca_chooser), 500, 350);
gtk_window_set_destroy_with_parent (GTK_WINDOW (uca_chooser), TRUE);
gtk_window_set_title (GTK_WINDOW (uca_chooser), _("Custom Actions"));
hbox = gtk_hbox_new (FALSE, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DND);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
gtk_widget_show (image);
label = gtk_label_new (_("You can configure custom actions that will appear in the\n"
"file managers context menus for certain kinds of files."));
gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
gtk_widget_show (label);
hbox = gtk_hbox_new (FALSE, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (uca_chooser)->vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
swin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), swin, TRUE, TRUE, 0);
gtk_widget_show (swin);
uca_chooser->treeview = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (uca_chooser->treeview), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (uca_chooser->treeview), TRUE);
gtk_container_add (GTK_CONTAINER (swin), uca_chooser->treeview);
g_signal_connect_swapped (G_OBJECT (uca_chooser->treeview), "row-activated", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser);
gtk_widget_show (uca_chooser->treeview);
uca_model = thunar_uca_model_get_default ();
gtk_tree_view_set_model (GTK_TREE_VIEW (uca_chooser->treeview), GTK_TREE_MODEL (uca_model));
g_object_unref (G_OBJECT (uca_model));
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (uca_chooser->treeview), column);
renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "stock-size", GTK_ICON_SIZE_DND, "xpad", 2, "ypad", 2, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer, "icon-name", THUNAR_UCA_MODEL_COLUMN_ICON, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer, "markup", THUNAR_UCA_MODEL_COLUMN_STOCK_LABEL, NULL);
vbox = gtk_vbox_new (FALSE, 3);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
uca_chooser->add_button = gtk_button_new ();
gtk_widget_set_tooltip_text (uca_chooser->add_button, _("Add a new custom action."));
gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->add_button, FALSE, FALSE, 0);
g_signal_connect_swapped (G_OBJECT (uca_chooser->add_button), "clicked", G_CALLBACK (thunar_uca_chooser_add_clicked), uca_chooser);
gtk_widget_show (uca_chooser->add_button);
image = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (uca_chooser->add_button), image);
gtk_widget_show (image);
uca_chooser->edit_button = gtk_button_new ();
gtk_widget_set_tooltip_text (uca_chooser->edit_button, _("Edit the currently selected action."));
gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->edit_button, FALSE, FALSE, 0);
g_signal_connect_swapped (G_OBJECT (uca_chooser->edit_button), "clicked", G_CALLBACK (thunar_uca_chooser_edit_clicked), uca_chooser);
gtk_widget_show (uca_chooser->edit_button);
image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (uca_chooser->edit_button), image);
gtk_widget_show (image);
uca_chooser->delete_button = gtk_button_new ();
gtk_widget_set_tooltip_text (uca_chooser->delete_button, _("Delete the currently selected action."));
gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->delete_button, FALSE, FALSE, 0);
g_signal_connect_swapped (G_OBJECT (uca_chooser->delete_button), "clicked", G_CALLBACK (thunar_uca_chooser_delete_clicked), uca_chooser);
gtk_widget_show (uca_chooser->delete_button);
image = gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (uca_chooser->delete_button), image);
gtk_widget_show (image);
uca_chooser->up_button = gtk_button_new ();
gtk_widget_set_tooltip_text (uca_chooser->up_button, _("Move the currently selected action up by one row."));
gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->up_button, FALSE, FALSE, 0);
g_signal_connect_swapped (G_OBJECT (uca_chooser->up_button), "clicked", G_CALLBACK (thunar_uca_chooser_up_clicked), uca_chooser);
gtk_widget_show (uca_chooser->up_button);
image = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (uca_chooser->up_button), image);
gtk_widget_show (image);
uca_chooser->down_button = gtk_button_new ();
gtk_widget_set_tooltip_text (uca_chooser->down_button, _("Move the currently selected action down by one row."));
gtk_box_pack_start (GTK_BOX (vbox), uca_chooser->down_button, FALSE, FALSE, 0);
g_signal_connect_swapped (G_OBJECT (uca_chooser->down_button), "clicked", G_CALLBACK (thunar_uca_chooser_down_clicked), uca_chooser);
gtk_widget_show (uca_chooser->down_button);
image = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (uca_chooser->down_button), image);
gtk_widget_show (image);
/* configure the tree view selection after the buttons have been created */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (uca_chooser->treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect_swapped (G_OBJECT (selection), "changed", G_CALLBACK (thunar_uca_chooser_selection_changed), uca_chooser);
thunar_uca_chooser_selection_changed (uca_chooser, selection);
}
gint gui_history_sms(void)
{
SphoneStoreTreeModel *calls;
static GtkWidget *calls_view=NULL;
debug("gui_history_sms\n");
if(sms_window){
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_ALL, NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_window_present(GTK_WINDOW(sms_window));
return 0;
}
sms_window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(sms_window),"SMS History");
gtk_window_set_default_size(GTK_WINDOW(sms_window),600,220);
GtkWidget *v1=gtk_vbox_new(FALSE,0);
GtkWidget *scroll;
calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("", renderer, "pixbuf", SPHONE_STORE_TREE_MODEL_COLUMN_PICTURE, NULL);
gtk_tree_view_column_set_fixed_width(column,40);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Name", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_NAME, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Text", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_SMS_TEXT, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GtkWidget *sms_content=gtk_label_new (NULL);
gtk_label_set_selectable(GTK_LABEL(sms_content), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(sms_content), TRUE);
g_signal_connect_after(G_OBJECT(calls_view),"cursor-changed", G_CALLBACK(gui_contact_sms_selected_callback),sms_content);
g_signal_connect_after(G_OBJECT(calls_view),"row-activated", G_CALLBACK(gui_contact_book_double_click_callback),NULL);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
gtk_container_add (GTK_CONTAINER(v1),scroll);
gtk_container_add (GTK_CONTAINER(v1),sms_content);
gtk_container_add (GTK_CONTAINER(sms_window),v1);
g_signal_connect(G_OBJECT(sms_window),"delete-event", G_CALLBACK(gui_contact_make_null),&sms_window);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_ALL, NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_widget_show_all(sms_window);
return 0;
}
static void
import_widget_set_up_account_list (EmpathyImportWidget *self)
{
EmpathyImportWidgetPriv *priv = GET_PRIV (self);
GtkListStore *store;
GtkTreeView *view;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
priv->accounts = empathy_import_accounts_load (priv->app_id);
store = gtk_list_store_new (COL_COUNT, G_TYPE_BOOLEAN, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
GTK_TREE_MODEL (store));
g_object_unref (store);
view = GTK_TREE_VIEW (priv->treeview);
gtk_tree_view_set_headers_visible (view, TRUE);
/* Import column */
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_insert_column_with_attributes (view, -1,
/* Translators: this is the header of a treeview column */
_("Import"), cell,
"active", COL_IMPORT,
NULL);
g_signal_connect (cell, "toggled",
G_CALLBACK (import_widget_cell_toggled_cb), self);
/* Protocol column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Protocol"));
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (view, column);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "editable", FALSE, NULL);
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "text", COL_PROTOCOL);
/* Account column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Account"));
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (view, column);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "editable", FALSE, NULL);
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "text", COL_NAME);
if (priv->app_id == EMPATHY_IMPORT_APPLICATION_ALL)
{
/* Source column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Source"));
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (view, column);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell, "editable", FALSE, NULL);
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "text", COL_SOURCE);
}
import_widget_add_accounts_to_model (self);
}
static void
initialize_treeview (NMConnectionList *self)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
ConnectionTypeData *types;
GtkTreeIter iter;
char *id;
int i;
/* Model */
self->model = GTK_TREE_MODEL (gtk_tree_store_new (6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_OBJECT, G_TYPE_GTYPE, G_TYPE_INT));
/* Filter */
self->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (self->model, NULL));
gtk_tree_model_filter_set_visible_func (self->filter,
tree_model_visible_func,
self, NULL);
/* Sortable */
self->sortable = GTK_TREE_SORTABLE (gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (self->filter)));
gtk_tree_sortable_set_default_sort_func (self->sortable, NULL, NULL, NULL);
gtk_tree_sortable_set_sort_func (self->sortable, COL_TIMESTAMP, timestamp_sort_func,
self->sortable, NULL);
gtk_tree_sortable_set_sort_func (self->sortable, COL_ID, id_sort_func,
self->sortable, NULL);
gtk_tree_sortable_set_sort_column_id (self->sortable, COL_TIMESTAMP, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (self->connection_list, GTK_TREE_MODEL (self->sortable));
/* Name column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Name"),
renderer,
"markup", COL_ID,
NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, COL_ID);
g_signal_connect (column, "clicked", G_CALLBACK (column_header_clicked_cb), GINT_TO_POINTER (COL_ID));
gtk_tree_view_append_column (self->connection_list, column);
/* Last Used column */
renderer = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
"foreground", "SlateGray",
NULL);
column = gtk_tree_view_column_new_with_attributes (_("Last Used"),
renderer,
"text", COL_LAST_USED,
NULL);
gtk_tree_view_column_set_sort_column_id (column, COL_TIMESTAMP);
g_signal_connect (column, "clicked", G_CALLBACK (column_header_clicked_cb), GINT_TO_POINTER (COL_TIMESTAMP));
gtk_tree_view_append_column (self->connection_list, column);
/* Selection */
selection = gtk_tree_view_get_selection (self->connection_list);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
/* Fill in connection types */
types = get_connection_type_list ();
for (i = 0; types[i].name; i++) {
id = g_strdup_printf ("<b>%s</b>", types[i].name);
gtk_tree_store_append (GTK_TREE_STORE (self->model), &iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (self->model), &iter,
COL_ID, id,
COL_GTYPE, types[i].setting_type,
COL_ORDER, i,
-1);
g_free (id);
}
}
static void
populate_dialog (PpPPDSelectionDialog *dialog)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeView *manufacturers_treeview;
GtkTreeView *models_treeview;
GtkWidget *widget;
GtkWidget *header;
manufacturers_treeview = (GtkTreeView*)
gtk_builder_get_object (dialog->builder, "ppd-selection-manufacturers-treeview");
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_padding (renderer, 10, 0);
/* Translators: Name of column showing printer manufacturers */
column = gtk_tree_view_column_new_with_attributes (_("Manufacturer"), renderer,
"text", PPD_MANUFACTURERS_DISPLAY_NAMES_COLUMN, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
header = gtk_label_new (gtk_tree_view_column_get_title (column));
gtk_widget_set_margin_start (header, 10);
gtk_tree_view_column_set_widget (column, header);
gtk_widget_show (header);
gtk_tree_view_append_column (manufacturers_treeview, column);
models_treeview = (GtkTreeView*)
gtk_builder_get_object (dialog->builder, "ppd-selection-models-treeview");
renderer = gtk_cell_renderer_text_new ();
gtk_cell_renderer_set_padding (renderer, 10, 0);
/* Translators: Name of column showing printer drivers */
column = gtk_tree_view_column_new_with_attributes (_("Driver"), renderer,
"text", PPD_DISPLAY_NAMES_COLUMN,
NULL);
gtk_tree_view_column_set_expand (column, TRUE);
header = gtk_label_new (gtk_tree_view_column_get_title (column));
gtk_widget_set_margin_start (header, 10);
gtk_tree_view_column_set_widget (column, header);
gtk_widget_show (header);
gtk_tree_view_append_column (models_treeview, column);
g_signal_connect (gtk_tree_view_get_selection (models_treeview),
"changed", G_CALLBACK (model_selection_changed_cb), dialog);
g_signal_connect (gtk_tree_view_get_selection (manufacturers_treeview),
"changed", G_CALLBACK (manufacturer_selection_changed_cb), dialog);
gtk_widget_show_all (dialog->dialog);
if (!dialog->list)
{
widget = (GtkWidget*)
gtk_builder_get_object (dialog->builder, "ppd-spinner");
gtk_widget_show (widget);
gtk_spinner_start (GTK_SPINNER (widget));
widget = (GtkWidget*)
gtk_builder_get_object (dialog->builder, "progress-label");
gtk_widget_show (widget);
}
else
{
fill_ppds_list (dialog);
}
}
static void
setup_profile_pages (GtrPreferencesDialog *dlg)
{
GtkTreeViewColumn *name_column, *toggle_column;
GtkCellRenderer *text_renderer, *toggle_renderer;
GtkListStore *model;
model = gtk_list_store_new (PROFILE_N_COLUMNS,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (dlg->priv->profile_treeview),
GTK_TREE_MODEL (model));
g_object_unref (model);
text_renderer = gtk_cell_renderer_text_new ();
toggle_renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (toggle_renderer,
"toggled", G_CALLBACK (active_toggled_cb), dlg);
gtk_cell_renderer_toggle_set_activatable (GTK_CELL_RENDERER_TOGGLE (toggle_renderer),
TRUE);
gtk_cell_renderer_toggle_set_radio (GTK_CELL_RENDERER_TOGGLE (toggle_renderer),
TRUE);
name_column = gtk_tree_view_column_new_with_attributes (_("Profile"),
text_renderer,
"text",
PROFILE_NAME_COLUMN,
NULL);
toggle_column = gtk_tree_view_column_new_with_attributes (_("Active"),
toggle_renderer,
"active",
ACTIVE_PROFILE_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (toggle_column, TRUE);
gtk_tree_view_column_set_resizable (name_column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->profile_treeview),
name_column);
gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->profile_treeview),
toggle_column);
gtk_tree_view_column_set_expand (name_column, TRUE);
fill_profile_treeview (dlg, GTK_TREE_MODEL (model));
/* Connect the signals */
g_signal_connect (dlg->priv->add_button,
"clicked", G_CALLBACK (add_button_clicked), dlg);
g_signal_connect (dlg->priv->delete_button,
"clicked", G_CALLBACK (delete_button_clicked), dlg);
g_signal_connect (dlg->priv->edit_button,
"clicked", G_CALLBACK (edit_button_clicked), dlg);
}
/**
* empathy_irc_network_dialog_show:
* @network: the #EmpathyIrcNetwork to configure
* @parent: the parent of this dialog
*
* Display a dialog to configure a given #EmpathyIrcNetwork.
* This function is a singleton so if a configuration dialog already
* exists we use this one to edit the network.
*
* Returns: The displayed #GtkDialog
*/
GtkWidget *
empathy_irc_network_dialog_show (EmpathyIrcNetwork *network,
GtkWidget *parent)
{
static EmpathyIrcNetworkDialog *dialog = NULL;
GtkBuilder *gui;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkAdjustment *adjustment;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gchar *filename;
GtkWidget *sw, *toolbar;
GtkStyleContext *context;
g_return_val_if_fail (network != NULL, NULL);
if (dialog != NULL)
{
change_network (dialog, network);
gtk_window_present (GTK_WINDOW (dialog->dialog));
return dialog->dialog;
}
dialog = g_slice_new0 (EmpathyIrcNetworkDialog);
dialog->network = network;
g_object_ref (dialog->network);
filename = empathy_file_lookup ("empathy-account-widget-irc.ui",
"libempathy-gtk");
gui = empathy_builder_get_file (filename,
"irc_network_dialog", &dialog->dialog,
"button_close", &dialog->button_close,
"entry_network", &dialog->entry_network,
"combobox_charset", &dialog->combobox_charset,
"treeview_servers", &dialog->treeview_servers,
"button_add", &dialog->button_add,
"button_remove", &dialog->button_remove,
"button_up", &dialog->button_up,
"button_down", &dialog->button_down,
"scrolledwindow_network_server", &sw,
"toolbar_network_server", &toolbar,
NULL);
g_free (filename);
store = gtk_list_store_new (4, G_TYPE_OBJECT, G_TYPE_STRING,
G_TYPE_UINT, G_TYPE_BOOLEAN);
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->treeview_servers),
GTK_TREE_MODEL (store));
g_object_unref (store);
/* address */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (irc_network_dialog_address_edited_cb), dialog);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_servers),
-1, _("Server"), renderer, "text", COL_ADR,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->treeview_servers),
0);
gtk_tree_view_column_set_expand (column, TRUE);
/* port */
adjustment = (GtkAdjustment *) gtk_adjustment_new (6667, 1, G_MAXUINT16,
1, 10, 0);
renderer = gtk_cell_renderer_spin_new ();
g_object_set (renderer,
"editable", TRUE,
"adjustment", adjustment,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (irc_network_dialog_port_edited_cb), dialog);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_servers),
-1, _("Port"), renderer, "text", COL_PORT,
NULL);
/* SSL */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "activatable", TRUE, NULL);
g_signal_connect (renderer, "toggled",
G_CALLBACK (irc_network_dialog_ssl_toggled_cb), dialog);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_servers),
-1, _("SSL"), renderer, "active", COL_SSL,
NULL);
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (dialog->treeview_servers));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
/* charset */
totem_subtitle_encoding_init (GTK_COMBO_BOX (dialog->combobox_charset));
irc_network_dialog_setup (dialog);
empathy_builder_connect (gui, dialog,
"irc_network_dialog", "destroy", irc_network_dialog_destroy_cb,
"button_close", "clicked", irc_network_dialog_close_clicked_cb,
"entry_network", "focus-out-event", irc_network_dialog_network_focus_cb,
"button_add", "clicked", irc_network_dialog_button_add_clicked_cb,
"button_remove", "clicked", irc_network_dialog_button_remove_clicked_cb,
"button_up", "clicked", irc_network_dialog_button_up_clicked_cb,
"button_down", "clicked", irc_network_dialog_button_down_clicked_cb,
"combobox_charset", "changed", irc_network_dialog_combobox_charset_changed_cb,
NULL);
g_object_unref (gui);
g_object_add_weak_pointer (G_OBJECT (dialog->dialog),
(gpointer) &dialog);
g_signal_connect (selection, "changed",
G_CALLBACK (irc_network_dialog_selection_changed_cb),
dialog);
gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog),
GTK_WINDOW (parent));
gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE);
/* join the add/remove toolbar to the treeview */
context = gtk_widget_get_style_context (sw);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
context = gtk_widget_get_style_context (toolbar);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
irc_network_dialog_network_update_buttons (dialog);
gtk_widget_show_all (dialog->dialog);
return dialog->dialog;
}
static void
setup_search (GnomeControlCenter *shell)
{
GtkWidget *search_view, *widget;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GnomeControlCenterPrivate *priv = shell->priv;
g_return_if_fail (priv->store != NULL);
/* create the search filter */
priv->search_filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (priv->store),
NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->search_filter),
(GtkTreeModelFilterVisibleFunc)
model_filter_func,
priv, NULL);
/* set up the search view */
priv->search_view = search_view = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (search_view), FALSE);
gtk_tree_view_set_model (GTK_TREE_VIEW (search_view),
GTK_TREE_MODEL (priv->search_filter));
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer,
"follow-state", TRUE,
"xpad", 15,
"ypad", 10,
"stock-size", GTK_ICON_SIZE_DIALOG,
NULL);
column = gtk_tree_view_column_new_with_attributes ("Icon", renderer,
"gicon", COL_GICON,
NULL);
gtk_tree_view_column_set_expand (column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer,
"xpad", 0,
NULL);
column = gtk_tree_view_column_new_with_attributes ("Name", renderer,
"text", COL_NAME,
NULL);
gtk_tree_view_column_set_expand (column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer,
"xpad", 15,
NULL);
column = gtk_tree_view_column_new_with_attributes ("Description", renderer,
"text", COL_DESCRIPTION,
NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column);
priv->search_scrolled = W (priv->builder, "search-scrolled-window");
gtk_container_add (GTK_CONTAINER (priv->search_scrolled), search_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->search_view)),
"changed",
G_CALLBACK (on_search_selection_changed),
shell);
/* setup the search entry widget */
widget = (GtkWidget*) gtk_builder_get_object (priv->builder, "search-entry");
priv->search_entry = widget;
priv->filter_string = g_strdup ("");
g_signal_connect (widget, "changed", G_CALLBACK (search_entry_changed_cb),
shell);
g_signal_connect (widget, "key-press-event",
G_CALLBACK (search_entry_key_press_event_cb), priv);
gtk_widget_show (priv->search_view);
}
GtkWidget *
ip4_routes_dialog_new (NMSettingIP4Config *s_ip4, gboolean automatic)
{
GtkBuilder *builder;
GtkWidget *dialog, *widget, *ok_button;
GtkListStore *store;
GtkTreeIter model_iter;
GtkTreeSelection *selection;
gint offset;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
int i;
GSList *renderers = NULL;
GError* error = NULL;
/* Initialize temporary storage vars */
g_free (last_edited);
last_edited = NULL;
last_path = NULL;
g_free (last_path);
last_column = -1;
builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (builder, UIDIR "/ce-ip4-routes.ui", &error)) {
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
return NULL;
}
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_routes_dialog"));
if (!dialog) {
g_warning ("%s: Couldn't load ip4 routes dialog from .ui file.", __func__);
g_object_unref (builder);
return NULL;
}
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
g_object_set_data_full (G_OBJECT (dialog), "builder",
builder, (GDestroyNotify) g_object_unref);
ok_button = GTK_WIDGET (gtk_builder_get_object (builder, "ok_button"));
store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
/* Add existing routes */
for (i = 0; i < nm_setting_ip4_config_get_num_routes (s_ip4); i++) {
NMIP4Route *route = nm_setting_ip4_config_get_route (s_ip4, i);
struct in_addr tmp_addr;
char ip_string[INET_ADDRSTRLEN];
char *tmp;
if (!route) {
g_warning ("%s: empty IP4 route structure!", __func__);
continue;
}
gtk_list_store_append (store, &model_iter);
tmp_addr.s_addr = nm_ip4_route_get_dest (route);;
if (inet_ntop (AF_INET, &tmp_addr, &ip_string[0], sizeof (ip_string)))
gtk_list_store_set (store, &model_iter, COL_ADDRESS, ip_string, -1);
tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip4_route_get_prefix (route));
if (inet_ntop (AF_INET, &tmp_addr, &ip_string[0], sizeof (ip_string)))
gtk_list_store_set (store, &model_iter, COL_PREFIX, ip_string, -1);
tmp_addr.s_addr = nm_ip4_route_get_next_hop (route);
if (tmp_addr.s_addr && inet_ntop (AF_INET, &tmp_addr, &ip_string[0], sizeof (ip_string)))
gtk_list_store_set (store, &model_iter, COL_NEXT_HOP, ip_string, -1);
if (nm_ip4_route_get_metric (route)) {
tmp = g_strdup_printf ("%d", nm_ip4_route_get_metric (route));
gtk_list_store_set (store, &model_iter, COL_METRIC, tmp, -1);
g_free (tmp);
}
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_routes"));
gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (store));
g_object_unref (store);
/* IP Address column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_ADDRESS));
g_signal_connect (renderer, "editing-started", G_CALLBACK (ip4_cell_editing_started), ok_button);
g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder);
renderers = g_slist_append (renderers, renderer);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, _("Address"), renderer,
"text", COL_ADDRESS,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Prefix column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_PREFIX));
g_signal_connect (renderer, "editing-started", G_CALLBACK (ip4_cell_editing_started), ok_button);
g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder);
renderers = g_slist_append (renderers, renderer);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, _("Netmask"), renderer,
"text", COL_PREFIX,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Gateway column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_NEXT_HOP));
g_signal_connect (renderer, "editing-started", G_CALLBACK (ip4_cell_editing_started), ok_button);
g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder);
renderers = g_slist_append (renderers, renderer);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, _("Gateway"), renderer,
"text", COL_NEXT_HOP,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Metric column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_METRIC));
g_signal_connect (renderer, "editing-started", G_CALLBACK (uint_cell_editing_started), ok_button);
g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder);
renderers = g_slist_append (renderers, renderer);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, _("Metric"), renderer,
"text", COL_METRIC,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
g_object_set_data_full (G_OBJECT (dialog), "renderers", renderers, (GDestroyNotify) g_slist_free);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
g_signal_connect (selection, "changed",
G_CALLBACK (list_selection_changed),
GTK_WIDGET (gtk_builder_get_object (builder, "ip4_route_delete_button")));
g_signal_connect (widget, "button-press-event", G_CALLBACK (tree_view_button_pressed_cb), builder);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_route_add_button"));
gtk_widget_set_sensitive (widget, TRUE);
g_signal_connect (widget, "clicked", G_CALLBACK (route_add_clicked), builder);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_route_delete_button"));
gtk_widget_set_sensitive (widget, FALSE);
g_signal_connect (widget, "clicked", G_CALLBACK (route_delete_clicked), builder);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_ignore_auto_routes"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
nm_setting_ip4_config_get_ignore_auto_routes (s_ip4));
gtk_widget_set_sensitive (widget, automatic);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_never_default"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
nm_setting_ip4_config_get_never_default (s_ip4));
/* Update initial validity */
validate (dialog);
return dialog;
}
