void gtkhash_properties_list_update_hash_func_names(struct page_s *page)
{
GtkTreeModel *model = gtkhash_properties_list_get_model(page);
GtkTreeIter iter;
if (!gtk_tree_model_get_iter_first(model, &iter))
return;
GtkListStore *store = gtkhash_properties_list_get_store(page);
const bool hmac = gtk_toggle_button_get_active(page->togglebutton_hmac);
do {
int id;
gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
if (!page->funcs[id].hmac_supported)
continue;
if (hmac) {
char *name = g_strdup_printf("HMAC-%s",
page->funcs[id].name);
gtk_list_store_set(store, &iter, COL_HASH_FUNC, name, -1);
g_free(name);
} else {
gtk_list_store_set(store, &iter, COL_HASH_FUNC,
page->funcs[id].name, -1);
}
// Digest is invalid now, so clear it
gtk_list_store_set(store, &iter, COL_DIGEST, "", -1);
} while (gtk_tree_model_iter_next(model, &iter));
gtk_tree_view_columns_autosize(page->treeview);
}
/*
** update the archive name everytime it changes
*/
static void defarchive_rename(GtkWidget *widget, gpointer user_data)
{
struct defarchive_data *data;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *txt;
Archive *item;
DB( g_print("(defarchive) rename\n") );
data = g_object_get_data(G_OBJECT(gtk_widget_get_ancestor(widget, GTK_TYPE_WINDOW)), "inst_data");
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(data->LV_arc));
//if true there is a selected node
if (gtk_tree_selection_get_selected(selection, &model, &iter))
{
gtk_tree_model_get(model, &iter, LST_DEFARC_DATAS, &item, -1);
DB( g_print(" -> %s\n", item->wording) );
txt = (gchar *)gtk_entry_get_text(GTK_ENTRY(data->ST_word));
// ignore if entry is empty
if (txt && *txt)
{
g_free(item->wording);
item->wording = g_strdup(txt);
}
gtk_tree_view_columns_autosize (GTK_TREE_VIEW(data->LV_arc));
}
}
static void
on_tv_row_expanded (GtkTreeView *treeview,
GtkTreeIter *arg1,
GtkTreePath *arg2,
gpointer data)
{
gtk_tree_view_columns_autosize (treeview);
}
void
parasite_widget_tree_scan(ParasiteWidgetTree *widget_tree,
GtkWidget *window)
{
gtk_tree_store_clear(widget_tree->priv->model);
append_widget(widget_tree->priv->model, window, NULL);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(widget_tree));
}
static void
manufacturer_selection_changed_cb (GtkTreeSelection *selection,
gpointer user_data)
{
PpPPDSelectionDialog *dialog = (PpPPDSelectionDialog *) user_data;
GtkListStore *store;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeView *models_treeview;
gchar *manufacturer_name = NULL;
gint i, index;
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_tree_model_get (model, &iter,
PPD_MANUFACTURERS_NAMES_COLUMN, &manufacturer_name,
-1);
}
if (manufacturer_name)
{
index = -1;
for (i = 0; i < dialog->list->num_of_manufacturers; i++)
{
if (g_strcmp0 (manufacturer_name,
dialog->list->manufacturers[i]->manufacturer_name) == 0)
{
index = i;
break;
}
}
if (index >= 0)
{
models_treeview = (GtkTreeView*)
gtk_builder_get_object (dialog->builder, "ppd-selection-models-treeview");
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
for (i = 0; i < dialog->list->manufacturers[index]->num_of_ppds; i++)
{
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
PPD_NAMES_COLUMN, dialog->list->manufacturers[index]->ppds[i]->ppd_name,
PPD_DISPLAY_NAMES_COLUMN, dialog->list->manufacturers[index]->ppds[i]->ppd_display_name,
-1);
}
gtk_tree_view_set_model (models_treeview, GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_tree_view_columns_autosize (models_treeview);
}
g_free (manufacturer_name);
}
}
void gtkhash_properties_list_refilter(struct page_s *page)
{
GtkTreeModelFilter *filter = gtkhash_properties_list_get_filter(page);
gtk_tree_model_filter_refilter(filter);
bool active = gtk_check_menu_item_get_active(page->menuitem_show_funcs);
GtkTreeViewColumn *col = gtk_tree_view_get_column(page->treeview, 0);
gtk_tree_view_column_set_visible(col, active);
gtk_tree_view_columns_autosize(page->treeview);
}
static void
fm_list_view_zoom_level_changed (FMDirectoryView *view)
{
/* set the new "size" for the icon renderer */
g_object_set (G_OBJECT (view->icon_renderer), "size", marlin_zoom_level_to_icon_size (view->zoom_level), "zoom-level", view->zoom_level, NULL);
gint xpad, ypad;
gtk_cell_renderer_get_padding (view->icon_renderer, &xpad, &ypad);
gtk_cell_renderer_set_fixed_size (view->icon_renderer,
marlin_zoom_level_to_icon_size (view->zoom_level) + 2 * xpad,
marlin_zoom_level_to_icon_size (view->zoom_level) + 2 * ypad);
gtk_tree_view_columns_autosize (FM_LIST_VIEW (view)->tree);
}
void gtkhash_properties_list_clear_digests(struct page_s *page)
{
GtkTreeModel *model = gtkhash_properties_list_get_model(page);
GtkTreeIter iter;
if (!gtk_tree_model_get_iter_first(model, &iter))
return;
GtkListStore *store = gtkhash_properties_list_get_store(page);
do {
gtk_list_store_set(store, &iter, COL_DIGEST, "", -1);
} while (gtk_tree_model_iter_next(model, &iter));
gtk_tree_view_columns_autosize(page->treeview);
}
static void
info_selected(GtkTreeSelection * ts, gpointer data)
{
ShellInfoTree *info = (ShellInfoTree *) data;
GtkTreeModel *model = GTK_TREE_MODEL(info->model);
GtkTreeIter parent;
gchar *datacol;
if (!gtk_tree_selection_get_selected(ts, &model, &parent))
return;
gtk_tree_model_get(model, &parent, INFO_TREE_COL_DATA, &datacol, -1);
info_selected_show_extra(datacol);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW
(shell->moreinfo->view));
}
void playlist_widget_append( PlaylistWidget *wgt,
const gchar *name,
const gchar *uri )
{
GtkTreeIter iter;
gtk_list_store_append(wgt->list_store, &iter);
gtk_list_store_set
(wgt->list_store, &iter, PLAYLIST_NAME_COLUMN, name, -1);
gtk_list_store_set
(wgt->list_store, &iter, PLAYLIST_URI_COLUMN, uri, -1);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(wgt->tree_view));
}
void
gimp_component_editor_set_view_size (GimpComponentEditor *editor,
gint view_size)
{
GtkWidget *tree_widget;
GtkStyle *tree_style;
GtkIconSize icon_size;
GtkTreeIter iter;
gboolean iter_valid;
g_return_if_fail (GIMP_IS_COMPONENT_EDITOR (editor));
g_return_if_fail (view_size > 0 &&
view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE);
tree_widget = GTK_WIDGET (editor->view);
tree_style = gtk_widget_get_style (tree_widget);
icon_size = gimp_get_icon_size (tree_widget,
GIMP_STOCK_VISIBLE,
GTK_ICON_SIZE_BUTTON,
view_size -
2 * tree_style->xthickness,
view_size -
2 * tree_style->ythickness);
g_object_set (editor->eye_cell,
"stock-size", icon_size,
NULL);
for (iter_valid = gtk_tree_model_get_iter_first (editor->model, &iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (editor->model, &iter))
{
GimpViewRenderer *renderer;
gtk_tree_model_get (editor->model, &iter,
COLUMN_RENDERER, &renderer,
-1);
gimp_view_renderer_set_size (renderer, view_size, 1);
g_object_unref (renderer);
}
editor->view_size = view_size;
gtk_tree_view_columns_autosize (editor->view);
}
static void
render_column(HybridInfo *info)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* expander columns */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(info->treeview), column);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(info->treeview), column);
/* main column */
column = gtk_tree_view_column_new ();
gtk_tree_view_append_column(GTK_TREE_VIEW(info->treeview), column);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(info->treeview));
/* name */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"markup", HYBRID_INFO_NAME_COLUMN,
NULL);
g_object_set(renderer, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(renderer, "wrap-width",120, NULL);
/* value */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"markup", HYBRID_INFO_VALUE_COLUMN,
"visible", HYBRID_INFO_VALUE_COLUMN_VISIBLE,
NULL);
g_object_set(renderer, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(renderer, "wrap-width",250, NULL);
/* pixbuf */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"pixbuf", HYBRID_INFO_PIXBUF_COLUMN,
"visible", HYBRID_INFO_PIXBUF_COLUMN_VISIBLE,
NULL);
}
void gtkhash_properties_list_update_digests(struct page_s *page)
{
GtkTreeModel *model = gtkhash_properties_list_get_model(page);
GtkListStore *store = gtkhash_properties_list_get_store(page);
GtkTreeIter iter;
if (!gtk_tree_model_get_iter_first(model, &iter))
return;
do {
int id;
gtk_tree_model_get(model, &iter, COL_ID, &id, -1);
const char *digest = gtkhash_hash_func_get_digest(
&page->hash_file.funcs[id], DIGEST_FORMAT_HEX_LOWER);
gtk_list_store_set(store, &iter, COL_DIGEST, digest, -1);
} while (gtk_tree_model_iter_next(model, &iter));
gtk_tree_view_columns_autosize(page->treeview);
}
void playlist_widget_remove(PlaylistWidget *wgt, gint pos)
{
GtkTreeIter iter;
gboolean rc;
rc = gtk_tree_model_get_iter_first
(GTK_TREE_MODEL(wgt->list_store), &iter);
while(rc && --pos >= 0)
{
rc = gtk_tree_model_iter_next
(GTK_TREE_MODEL(wgt->list_store), &iter);
}
if(rc)
{
gtk_list_store_remove(wgt->list_store, &iter);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(wgt->tree_view));
}
}
static void
populate_selected_list (SelectUI *sui,
GList *selected_songs)
{
GList * llist;
GjaySong * s;
gchar * artist, * title;
gchar bpm[20];
GtkTreeIter iter;
gtk_list_store_clear (GTK_LIST_STORE(sui->list_store));
for (llist = g_list_first(selected_songs);
llist;
llist = g_list_next(llist)) {
s = (GjaySong *) llist->data;
assert(s);
if (s->artist)
artist = s->artist;
else
artist = NULL;
if (s->title && strlen(s->title) > 1)
title = s->title;
else
title = s->fname;
if (s->no_data)
sprintf(bpm, "?");
else if (s->bpm_undef)
sprintf(bpm, "Unsure");
else
sprintf(bpm, "%3.2f", s->bpm);
song_set_freq_pixbuf(s);
gtk_list_store_append (GTK_LIST_STORE(sui->list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE(sui->list_store), &iter,
ARTIST_COLUMN, artist,
TITLE_COLUMN, title,
FREQ_COLUMN, s->freq_pixbuf,
BPM_COLUMN, bpm,
-1);
}
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(sui->dir_tree));
}
static void
get_account_info (FindAccountDialog *facc_dialog)
{
Account *root;
GList *accts;
GList *ptr;
gchar *filter_text;
gboolean radio_root;
/* Get the state of the root radio button */
radio_root = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(facc_dialog->radio_root));
/* Get list of Accounts */
if ((facc_dialog->account == NULL) || (radio_root == TRUE))
root = gnc_book_get_root_account (gnc_get_current_book());
else
root = facc_dialog->account;
accts = gnc_account_get_descendants_sorted (root);
filter_text = g_ascii_strdown (gtk_entry_get_text (GTK_ENTRY(facc_dialog->filter_text_entry)), -1);
/* Go through list of accounts */
for (ptr = accts; ptr; ptr = g_list_next (ptr))
{
Account *acc = ptr->data;
gchar *full_name = gnc_account_get_full_name (acc);
gchar *match_string = g_ascii_strdown (full_name, -1);
if ((g_strcmp0 (filter_text, "") == 0) || (g_strrstr (match_string, filter_text) != NULL))
fill_model (facc_dialog, acc);
g_free (match_string);
g_free (full_name);
}
g_free (filter_text);
g_list_free (accts);
gtk_tree_view_columns_autosize (GTK_TREE_VIEW(facc_dialog->view));
}
void RevertDialog::on_chapter_changed()
{
// Load the revisions.
listview_clear_strings(treeviewrevisions, store);
ustring chapterdirectory = project_data_directory_chapter(project, book_get(), chapter_get());
ustring path = project_data_filename_chapter(project, book_get(), chapter_get(), false);
path = gw_path_get_basename(path);
seconds = snapshots_get_seconds (project, book_get(), chapter_get());
vector <ustring> lines;
for (unsigned int i = 0; i < seconds.size(); i++) {
lines.push_back(date_time_seconds_human_readable(seconds[i], false));
}
listview_set_strings(treeviewrevisions, store, lines);
// Autosize columns.
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(treeviewrevisions));
// No revision loaded yet.
revisionloaded = false;
// Take action defined by radio button.
on_radiobutton (NULL);
}
static void
show_macros_list (MCData *mc)
{
MCPrefsDialog *dialog;
GtkTreeIter iter;
GSList *l;
dialog = &mc->prefs_dialog;
gtk_list_store_clear (dialog->macros_store);
for (l = mc->preferences.macros; l; l = l->next) {
MCMacro *macro = l->data;
gtk_list_store_append (dialog->macros_store, &iter);
gtk_list_store_set (dialog->macros_store, &iter,
COLUMN_PATTERN, macro->pattern,
COLUMN_COMMAND, macro->command,
-1);
}
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (dialog->macros_tree));
}
int
mug_msg_list_view_query (MugMsgListView * self, const char *query)
{
MugMsgListViewPrivate *priv;
gboolean rv;
g_return_val_if_fail (MUG_IS_MSG_LIST_VIEW (self), FALSE);
priv = MUG_MSG_LIST_VIEW_GET_PRIVATE (self);
gtk_list_store_clear (priv->_store);
g_free (priv->_query);
priv->_query = query ? g_strdup (query) : NULL;
if (!query)
return TRUE;
rv = update_model (priv->_store, priv->_xpath, query, self);
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (self));
return rv;
}
/* sortcolidx == -1 means 'sortcolidx = colidx' */
static void
append_col (GtkTreeView * treeview, const char *label, int colidx,
int sortcolidx, gint maxwidth)
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END,
NULL);
col = gtk_tree_view_column_new_with_attributes (label, renderer, "text",
colidx, NULL);
g_object_set (G_OBJECT (col), "resizable", TRUE, NULL);
gtk_tree_view_column_set_sort_indicator (col, TRUE);
if (sortcolidx == -1)
sortcolidx = colidx;
gtk_tree_view_column_set_sort_column_id (col, sortcolidx);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
if (maxwidth) {
gtk_tree_view_column_set_fixed_width (col, maxwidth);
gtk_tree_view_column_set_expand (col, FALSE);
} else
gtk_tree_view_column_set_expand (col, TRUE);
gtk_tree_view_column_set_cell_data_func (col, renderer,
(GtkTreeCellDataFunc)
treecell_func, NULL, NULL);
gtk_tree_view_append_column (treeview, col);
gtk_tree_view_columns_autosize (treeview);
gtk_tree_view_set_fixed_height_mode (treeview, TRUE);
}
SIGNAL_CALLBACK gboolean search_tools_search(GtkEntry* entry, GdkEventKey* event, SearchTools* self) {
if( event->keyval==GDK_KEY_Return || event->keyval==GDK_KEY_KP_Enter ) {
const gchar* text = gtk_entry_get_text(entry);
gtk_tree_view_set_model(self->result_view, 0);
clear_search_results(self);
if( gtk_toggle_button_get_active(self->search_option_in_current_file) )
search_in_current_file(text, self);
else if( gtk_toggle_button_get_active(self->search_option_in_opened_files) )
search_in_opened_files(text, self);
else if( gtk_toggle_button_get_active(self->search_option_in_current_file_dir) )
search_in_current_file_dir(text, self);
fill_search_results_list(self);
gtk_tree_view_set_model(self->result_view, GTK_TREE_MODEL(self->result_store));
gtk_tree_view_columns_autosize(self->result_view);
return TRUE;
}
return FALSE;
}
void
gimp_action_view_set_filter (GimpActionView *view,
const gchar *filter)
{
GtkTreeSelection *sel;
GtkTreeModel *filtered_model;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean iter_valid;
GtkTreeRowReference *selected_row = NULL;
g_return_if_fail (GIMP_IS_ACTION_VIEW (view));
filtered_model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filtered_model));
if (filter && ! strlen (filter))
filter = NULL;
g_free (view->filter);
view->filter = NULL;
if (filter)
view->filter = g_utf8_casefold (filter, -1);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
if (gtk_tree_selection_get_selected (sel, NULL, &iter))
{
GtkTreePath *path = gtk_tree_model_get_path (filtered_model, &iter);
selected_row = gtk_tree_row_reference_new (filtered_model, path);
}
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &iter))
{
GtkTreeIter child_iter;
gboolean child_valid;
gint n_children = 0;
for (child_valid = gtk_tree_model_iter_children (model, &child_iter,
&iter);
child_valid;
child_valid = gtk_tree_model_iter_next (model, &child_iter))
{
gboolean visible = TRUE;
if (view->filter)
{
gchar *label;
gchar *name;
gtk_tree_model_get (model, &child_iter,
GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, &label,
GIMP_ACTION_VIEW_COLUMN_NAME, &name,
-1);
visible = label && name && (strstr (label, view->filter) != NULL ||
strstr (name, view->filter) != NULL);
g_free (label);
g_free (name);
}
gtk_tree_store_set (GTK_TREE_STORE (model), &child_iter,
GIMP_ACTION_VIEW_COLUMN_VISIBLE, visible,
-1);
if (visible)
n_children++;
}
gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
GIMP_ACTION_VIEW_COLUMN_VISIBLE, n_children > 0,
-1);
}
if (view->filter)
gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
else
gtk_tree_view_collapse_all (GTK_TREE_VIEW (view));
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (view));
if (selected_row)
{
if (gtk_tree_row_reference_valid (selected_row))
{
GtkTreePath *path = gtk_tree_row_reference_get_path (selected_row);
gimp_action_view_select_path (view, path);
gtk_tree_path_free (path);
}
gtk_tree_row_reference_free (selected_row);
}
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
GOptionContext *context;
GConfClient *gconf_client;
GtkWidget *widget;
GtkTreeSelection *selection;
GtkEntryCompletion *completion;
UniqueApp *unique_app;
gboolean ret;
guint retval;
guint xid = 0;
GError *error = NULL;
const GOptionEntry options[] = {
{ "filter", 'f', 0, G_OPTION_ARG_STRING, &filter,
/* TRANSLATORS: preset the GtktextBox with this filter text */
N_("Set the filter to this value"), NULL },
{ "parent-window", 'p', 0, G_OPTION_ARG_INT, &xid,
/* TRANSLATORS: we can make this modal (stay on top of) another window */
_("Set the parent window to make this modal"), NULL },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
if (! g_thread_supported ())
g_thread_init (NULL);
g_type_init ();
gtk_init (&argc, &argv);
context = g_option_context_new (NULL);
g_option_context_set_summary (context, _("Software Log Viewer"));
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, egg_debug_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
/* are we running privileged */
ret = gpk_check_privileged_user (_("Log viewer"), TRUE);
if (!ret)
return 1;
/* are we already activated? */
unique_app = unique_app_new ("org.freedesktop.PackageKit.LogViewer", NULL);
if (unique_app_is_running (unique_app)) {
egg_debug ("You have another instance running. This program will now close");
unique_app_send_message (unique_app, UNIQUE_ACTIVATE, NULL);
goto unique_out;
}
g_signal_connect (unique_app, "message-received",
G_CALLBACK (gpk_log_message_received_cb), NULL);
/* add application specific icons to search path */
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (),
GPK_DATA G_DIR_SEPARATOR_S "icons");
client = pk_client_new ();
g_object_set (client,
"background", FALSE,
NULL);
/* get UI */
builder = gtk_builder_new ();
retval = gtk_builder_add_from_file (builder, GPK_DATA "/gpk-log.ui", &error);
if (retval == 0) {
egg_warning ("failed to load ui: %s", error->message);
g_error_free (error);
goto out_build;
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_simple"));
gtk_window_set_icon_name (GTK_WINDOW (widget), GPK_ICON_SOFTWARE_LOG);
/* set a size, if the screen allows */
gpk_window_set_size_request (GTK_WINDOW (widget), 900, 300);
/* if command line arguments are set, then setup UI */
if (filter != NULL) {
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
gtk_entry_set_text (GTK_ENTRY(widget), filter);
}
/* Get the main window quit */
g_signal_connect_swapped (widget, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_close"));
g_signal_connect_swapped (widget, "clicked", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_grab_default (widget);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_help"));
g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_help_cb), NULL);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_refresh"));
g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_refresh_cb), NULL);
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_filter"));
g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_filter_cb), NULL);
/* hit enter in the search box for filter */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
g_signal_connect (widget, "activate", G_CALLBACK (gpk_log_button_filter_cb), NULL);
/* autocompletion can be turned off as it's slow */
gconf_client = gconf_client_get_default ();
ret = gconf_client_get_bool (gconf_client, GPK_CONF_AUTOCOMPLETE, NULL);
if (ret) {
/* create the completion object */
completion = gpk_package_entry_completion_new ();
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
gtk_entry_set_completion (GTK_ENTRY (widget), completion);
g_object_unref (completion);
} else {
/* use search as you type */
g_signal_connect (widget, "key-release-event", G_CALLBACK (gpk_log_entry_filter_cb), NULL);
}
g_object_unref (gconf_client);
/* create list stores */
list_store = gtk_list_store_new (GPK_LOG_COLUMN_LAST, 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_STRING, G_TYPE_BOOLEAN);
/* create transaction_id tree view */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "treeview_simple"));
gtk_tree_view_set_model (GTK_TREE_VIEW (widget),
GTK_TREE_MODEL (list_store));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
g_signal_connect (selection, "changed",
G_CALLBACK (gpk_log_treeview_clicked_cb), NULL);
/* add columns to the tree view */
pk_treeview_add_general_columns (GTK_TREE_VIEW (widget));
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (widget));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store),
GPK_LOG_COLUMN_TIMESPEC, GTK_SORT_DESCENDING);
/* show */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_simple"));
gtk_widget_show (widget);
/* set the parent window if it is specified */
if (xid != 0) {
egg_debug ("Setting xid %i", xid);
gpk_window_set_parent_xid (GTK_WINDOW (widget), xid);
}
/* get the update list */
gpk_log_refresh ();
gtk_main ();
out_build:
g_object_unref (builder);
g_object_unref (list_store);
g_object_unref (client);
g_free (transaction_id);
g_free (filter);
if (transactions != NULL)
g_ptr_array_unref (transactions);
unique_out:
g_object_unref (unique_app);
return 0;
}
/*
* on row collapsed handler
*/
void on_row_collapsed (GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path, gpointer user_data)
{
/* autosize tree view columns */
gtk_tree_view_columns_autosize (GTK_TREE_VIEW(tree_view));
}
EXPORT gboolean lookuptables_configurator(GtkWidget *widget, gpointer data)
{
static gboolean ltc_created = FALSE;
static GtkWidget * lookuptables_config_window = NULL;
extern Firmware_Details *firmware;
GtkListStore *store = NULL;
GtkTreeStore *combostore = NULL;
GtkTreeIter iter;
GtkTreeIter per_iter;
GtkTreeIter sys_iter;
GtkCellRenderer *renderer = NULL;
GtkTreeViewColumn *column = NULL;
GtkWidget * vbox = NULL;
GtkWidget * tree = NULL;
GtkWidget * frame = NULL;
ListElement *element = NULL;
ConfigFile *cfgfile = NULL;
GArray *classes = NULL;
GList *p_list = NULL;
GList *s_list = NULL;
guint i = 0;
gchar * tmpbuf = NULL;
gchar ** vector = NULL;
gchar ** tmpvector = NULL;
if ((ltc_created) && (ltc_visible))
return TRUE;
if ((ltc_created) && (!ltc_visible))
{
gtk_widget_show_all(lookuptables_config_window);
return TRUE;
}
else /* i.e. NOT created, build it */
{
lookuptables_config_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(lookuptables_config_window),_("MegaTunix LookupTables"));
gtk_window_set_default_size(GTK_WINDOW(lookuptables_config_window),300,200);
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(lookuptables_config_window),vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox),5);
g_signal_connect(G_OBJECT(lookuptables_config_window),"delete_event", G_CALLBACK(lookuptables_configurator_hide),NULL);
ltc_created = TRUE;
ltc_visible = TRUE;
frame = gtk_frame_new("MegaTunix LookupTables");
gtk_box_pack_start (GTK_BOX(vbox),frame,FALSE,TRUE,5);
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(frame),vbox);
store = gtk_list_store_new(N_COLS, /* total cols */
G_TYPE_STRING, /* int name */
G_TYPE_STRING, /* filename combo*/
G_TYPE_BOOLEAN,/* View/Edit */
G_TYPE_BOOLEAN); /* change */
combostore = gtk_tree_store_new(1,G_TYPE_STRING);/* lookuptable filename */
gtk_tree_store_append(combostore,&per_iter,NULL);
gtk_tree_store_append(combostore,&sys_iter,NULL);
gtk_tree_store_set(combostore,&per_iter,
0,"Personal", -1);
gtk_tree_store_set(combostore,&sys_iter,
0,"System", -1);
vector = get_files(g_strdup(LOOKUPTABLES_DATA_DIR),g_strdup("inc"),&classes);
for (i=0;i<g_strv_length(vector);i++)
{
tmpvector = g_strsplit(vector[i],PSEP,-1);
if (g_array_index(classes,FileClass,i) == PERSONAL)
{
element = g_new0(ListElement, 1);
element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
p_list = g_list_append(p_list,element);
}
if (g_array_index(classes,FileClass,i) == SYSTEM)
{
element = g_new0(ListElement, 1);
element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
s_list = g_list_append(s_list,element);
}
g_strfreev(tmpvector);
}
g_strfreev(vector);
g_array_free(classes,TRUE);
p_list = g_list_sort(p_list,list_sort);
s_list = g_list_sort(s_list,list_sort);
for (i=0;i<g_list_length(p_list);i++)
{
gtk_tree_store_append(combostore,&iter,&per_iter);
element = g_list_nth_data(p_list,i);
gtk_tree_store_set(combostore,&iter,
0,element->name,
-1);
}
for (i=0;i<g_list_length(s_list);i++)
{
gtk_tree_store_append(combostore,&iter,&sys_iter);
element = g_list_nth_data(s_list,i);
gtk_tree_store_set(combostore,&iter,
0,element->name,
-1);
}
g_list_foreach(p_list,free_element,NULL);
g_list_foreach(s_list,free_element,NULL);
g_list_free(p_list);
g_list_free(s_list);
cfgfile = cfg_open_file(firmware->profile_filename);
if (!cfgfile)
return FALSE;
cfg_read_string(cfgfile,"lookuptables","tables",&tmpbuf);
vector = g_strsplit(tmpbuf,",",-1);
g_free(tmpbuf);
for (i=0;i<g_strv_length(vector);i++)
{
cfg_read_string(cfgfile,"lookuptables",vector[i],&tmpbuf);
gtk_list_store_append(store,&iter);
gtk_list_store_set(store,&iter,
INTERNAL_NAME_COL,vector[i],
FILENAME_COL,tmpbuf,
VIEW_EDIT_COL,FALSE,
-1);
g_free(tmpbuf);
}
g_strfreev(vector);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree),TRUE);
gtk_box_pack_start(GTK_BOX(vbox),tree,TRUE,TRUE,0);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Internal Name",renderer,"text",INTERNAL_NAME_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
renderer = gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(renderer),"editable",TRUE,"model",combostore,"text-column",0,"style",PANGO_STYLE_ITALIC,NULL);
g_signal_connect(G_OBJECT(renderer),"edited", G_CALLBACK(lookuptable_change),store);
column = gtk_tree_view_column_new_with_attributes("Table Filename",renderer,"text",FILENAME_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
/* renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes("View/Edit",renderer,"active",VIEW_EDIT_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
*/
gtk_widget_show_all (lookuptables_config_window);
gtk_tree_view_columns_autosize( GTK_TREE_VIEW(tree));
return TRUE;
}
}
static void
module_selected(GtkTreeSelection * ts, gpointer data)
{
ShellTree *shelltree = shell->tree;
GtkTreeModel *model = GTK_TREE_MODEL(shelltree->model);
GtkTreeIter parent;
ShellModuleEntry *entry;
static ShellModuleEntry *current = NULL;
static gboolean updating = FALSE;
if (updating)
return;
updating = TRUE;
/* Gets the currently selected item on the left-side TreeView; if there is no
selection, silently return */
if (!gtk_tree_selection_get_selected(ts, &model, &parent))
return;
/* Mark the currently selected module as "unselected"; this is used to kill the
update timeout. */
if (current)
current->selected = FALSE;
/* Get the current selection and shows its related info */
gtk_tree_model_get(model, &parent, TREE_COL_DATA, &entry, -1);
if (entry && entry->func && !entry->selected) {
shell_status_set_enabled(TRUE);
shell_status_update("Updating...");
entry->selected = TRUE;
shell->selected = entry;
module_selected_show_info(entry, FALSE);
info_selected_show_extra(NULL); /* clears the more info store */
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(shell->info->view));
/* urgh. why don't GTK do this when the model is cleared? */
gtk_range_set_value(GTK_RANGE(GTK_SCROLLED_WINDOW(shell->info->scroll)->vscrollbar), 0.0);
gtk_range_set_value(GTK_RANGE(GTK_SCROLLED_WINDOW(shell->info->scroll)->hscrollbar), 0.0);
gtk_range_set_value(GTK_RANGE(GTK_SCROLLED_WINDOW(shell->moreinfo->scroll)->vscrollbar), 0.0);
gtk_range_set_value(GTK_RANGE(GTK_SCROLLED_WINDOW(shell->moreinfo->scroll)->hscrollbar), 0.0);
shell_status_update("Done.");
shell_status_set_enabled(FALSE);
gchar *tmp = g_strdup_printf("%s - System Information", entry->name);
gtk_window_set_title(GTK_WINDOW(shell->window), tmp);
g_free(tmp);
shell_action_set_enabled("RefreshAction", entry->reloadfunc ? TRUE : FALSE);
} else {
gtk_window_set_title(GTK_WINDOW(shell->window), "System Information");
shell_action_set_enabled("RefreshAction", FALSE);
gtk_tree_store_clear(GTK_TREE_STORE(shell->info->model));
set_view_type(SHELL_VIEW_NORMAL);
}
current = entry;
updating = FALSE;
}
static void
add_response (GtkWidget *window,
int id,
MCData *mc)
{
MCPrefsDialog *dialog;
dialog = &mc->prefs_dialog;
switch (id) {
case GTK_RESPONSE_OK: {
const char *pattern;
const char *command;
GtkTreeIter iter;
const char *error_message = NULL;
pattern = gtk_entry_get_text (GTK_ENTRY (dialog->pattern_entry));
command = gtk_entry_get_text (GTK_ENTRY (dialog->command_entry));
if (!pattern || !pattern [0])
error_message = _("You must specify a pattern");
if (!command || !command [0])
error_message = error_message != NULL ?
_("You must specify a pattern and a command") :
_("You must specify a command");
if (!error_message && duplicate_pattern (mc, pattern))
error_message = _("You may not specify duplicate patterns");
if (error_message) {
GtkWidget *error_dialog;
error_dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
error_message);
g_signal_connect (error_dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
gtk_window_set_resizable (GTK_WINDOW (error_dialog), FALSE);
gtk_widget_show_all (error_dialog);
return;
}
gtk_widget_hide (window);
gtk_list_store_append (dialog->macros_store, &iter);
gtk_list_store_set (dialog->macros_store, &iter,
COLUMN_PATTERN, pattern,
COLUMN_COMMAND, command,
-1);
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (dialog->macros_tree));
gtk_editable_delete_text (GTK_EDITABLE (dialog->pattern_entry), 0, -1);
gtk_editable_delete_text (GTK_EDITABLE (dialog->command_entry), 0, -1);
save_macros_to_mateconf (mc);
}
break;
case GTK_RESPONSE_HELP:
show_help_section (GTK_WINDOW (window), "command-line-prefs-2");
break;
case GTK_RESPONSE_CLOSE:
default:
gtk_editable_delete_text (GTK_EDITABLE (dialog->pattern_entry), 0, -1);
gtk_editable_delete_text (GTK_EDITABLE (dialog->command_entry), 0, -1);
gtk_widget_hide (window);
break;
}
}
/**
* gpk_log_startup_cb:
**/
static void
gpk_log_startup_cb (GtkApplication *application, gpointer user_data)
{
gboolean ret;
GError *error = NULL;
GSettings *settings;
GtkEntryCompletion *completion;
GtkTreeSelection *selection;
GtkWidget *widget;
GtkWindow *window;
guint retval;
client = pk_client_new ();
g_object_set (client,
"background", FALSE,
NULL);
/* get UI */
builder = gtk_builder_new ();
retval = gtk_builder_add_from_file (builder, GPK_DATA "/pi-gpk-log.ui", &error);
if (retval == 0) {
g_warning ("failed to load ui: %s", error->message);
g_error_free (error);
goto out;
}
window = GTK_WINDOW (gtk_builder_get_object (builder, "dialog_simple"));
gtk_window_set_icon_name (window, GPK_ICON_SOFTWARE_LOG);
gtk_window_set_application (window, application);
/* set a size, as the screen allows */
gpk_window_set_size_request (window, 1200, 1200);
/* if command line arguments are set, then setup UI */
if (filter != NULL) {
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
gtk_entry_set_text (GTK_ENTRY(widget), filter);
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_close"));
g_signal_connect (widget, "clicked",
G_CALLBACK (gpk_log_button_close_cb), application);
gtk_widget_grab_default (widget);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_refresh"));
g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_refresh_cb), NULL);
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_filter"));
g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_filter_cb), NULL);
/* hit enter in the search box for filter */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
g_signal_connect (widget, "activate", G_CALLBACK (gpk_log_button_filter_cb), NULL);
/* autocompletion can be turned off as it's slow */
settings = g_settings_new (GPK_SETTINGS_SCHEMA);
ret = g_settings_get_boolean (settings, GPK_SETTINGS_AUTOCOMPLETE);
if (ret) {
/* create the completion object */
completion = gpk_package_entry_completion_new ();
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
gtk_entry_set_completion (GTK_ENTRY (widget), completion);
g_object_unref (completion);
} else {
/* use search as you type */
g_signal_connect (widget, "key-release-event", G_CALLBACK (gpk_log_entry_filter_cb), NULL);
}
g_object_unref (settings);
/* create list stores */
list_store = gtk_list_store_new (GPK_LOG_COLUMN_LAST, 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_STRING, G_TYPE_BOOLEAN);
/* create transaction_id tree view */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "treeview_simple"));
gtk_tree_view_set_model (GTK_TREE_VIEW (widget),
GTK_TREE_MODEL (list_store));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
g_signal_connect (selection, "changed",
G_CALLBACK (gpk_log_treeview_clicked_cb), NULL);
/* add columns to the tree view */
pk_treeview_add_general_columns (GTK_TREE_VIEW (widget));
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (widget));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store),
GPK_LOG_COLUMN_TIMESPEC, GTK_SORT_DESCENDING);
/* show */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_simple"));
gtk_widget_show (widget);
/* set the parent window if it is specified */
if (xid != 0) {
g_debug ("Setting xid %i", xid);
gpk_window_set_parent_xid (GTK_WINDOW (widget), xid);
}
/* get the update list */
gpk_log_refresh ();
out:
g_object_unref (list_store);
g_object_unref (client);
g_free (transaction_id);
g_free (filter);
if (transactions != NULL)
g_ptr_array_unref (transactions);
}
/****************************************************************
...
*****************************************************************/
static void create_meswin_dialog(void)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
GtkWidget *view, *sw, *cmd, *notebook;
if (gui_gtk2_split_bottom_notebook) {
notebook = right_notebook;
} else {
notebook = bottom_notebook;
}
gui_dialog_new(&meswin_shell, GTK_NOTEBOOK(notebook), NULL);
gui_dialog_set_title(meswin_shell, _("Messages"));
meswin_store = gtk_list_store_new(3, G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_INT);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(meswin_shell->vbox), sw, TRUE, TRUE, 0);
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(meswin_store));
meswin_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
g_object_unref(meswin_store);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(view));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(NULL, renderer,
"text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_column_set_cell_data_func(col, renderer,
meswin_cell_data_func, NULL, NULL);
gtk_container_add(GTK_CONTAINER(sw), view);
g_signal_connect(meswin_selection, "changed",
G_CALLBACK(meswin_selection_callback), NULL);
g_signal_connect(view, "row_activated",
G_CALLBACK(meswin_row_activated_callback), NULL);
g_signal_connect(view, "button-press-event",
G_CALLBACK(meswin_button_press_callback), NULL);
if (gui_gtk2_show_message_window_buttons) {
cmd = gui_dialog_add_stockbutton(meswin_shell, GTK_STOCK_JUMP_TO,
_("Goto _Location"), CMD_GOTO);
gtk_widget_set_sensitive(cmd, FALSE);
cmd = gui_dialog_add_stockbutton(meswin_shell, GTK_STOCK_ZOOM_IN,
_("Inspect _City"), CMD_POPCITY);
gtk_widget_set_sensitive(cmd, FALSE);
}
gui_dialog_add_button(meswin_shell, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gui_dialog_response_set_callback(meswin_shell, meswin_response_callback);
gui_dialog_set_default_size(meswin_shell, 520, 300);
gui_dialog_show_all(meswin_shell);
}
void prefs_dialog_open(SensorsApplet *sensors_applet) {
gchar *header_text;
PrefsDialog *prefs_dialog;
DisplayMode display_mode;
g_assert(sensors_applet->prefs_dialog == NULL);
/* while prefs dialog is open, stop the updating of sensors so
* we don't get any race conditions due to concurrent updates
* of the labels, values and icons linked lists etc. */
if (sensors_applet->timeout_id != 0) {
if (g_source_remove(sensors_applet->timeout_id)) {
sensors_applet->timeout_id = 0;
}
}
sensors_applet->prefs_dialog = g_new0(PrefsDialog, 1);
prefs_dialog = sensors_applet->prefs_dialog;
prefs_dialog->sensors_applet = sensors_applet;
prefs_dialog->dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(_("Sensors Applet Preferences"),
NULL,
GTK_DIALOG_MODAL,
GTK_STOCK_HELP,
GTK_RESPONSE_HELP,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL));
g_object_set(prefs_dialog->dialog,
"border-width", 12,
"default-width", 480,
"default-height", 350,
NULL);
gtk_box_set_homogeneous(GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), FALSE);
gtk_box_set_spacing(GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), 5);
g_signal_connect(prefs_dialog->dialog,
"response", G_CALLBACK(prefs_dialog_response),
sensors_applet);
g_signal_connect_swapped(prefs_dialog->dialog,
"delete-event", G_CALLBACK(prefs_dialog_close),
sensors_applet);
g_signal_connect_swapped(prefs_dialog->dialog,
"destroy", G_CALLBACK(prefs_dialog_close),
sensors_applet);
/* if no SensorsList's have been created, this is because
we haven't been able to access any sensors */
if (sensors_applet->sensors == NULL) {
GtkWidget *label;
label = gtk_label_new(_("No sensors found!"));
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)), label, TRUE, TRUE, 0);
return;
}
header_text = g_markup_printf_escaped("<b>%s</b>", _("Display"));
prefs_dialog->display_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
prefs_dialog->display_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_text_new());
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("label with value"));
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("icon with value"));
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("value only"));
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("icon only"));
gtk_combo_box_text_append_text(prefs_dialog->display_mode_combo_box, _("graph only"));
display_mode = g_settings_get_int(sensors_applet->settings, DISPLAY_MODE);
gtk_combo_box_set_active(prefs_dialog->display_mode_combo_box, display_mode);
g_signal_connect(prefs_dialog->display_mode_combo_box,
"changed",
G_CALLBACK(prefs_dialog_display_mode_changed),
prefs_dialog);
/* use spaces in label to indent */
prefs_dialog->display_mode_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("_Display sensors in panel as"),
"mnemonic-widget", prefs_dialog->display_mode_combo_box,
"xalign", 0.0,
NULL);
prefs_dialog->layout_mode_combo_box = GTK_COMBO_BOX(gtk_combo_box_text_new());
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_combo_box),
(display_mode != DISPLAY_ICON) &&
(display_mode != DISPLAY_VALUE) &&
(display_mode != DISPLAY_GRAPH));
gtk_combo_box_text_append_text(prefs_dialog->layout_mode_combo_box, _("beside labels / icons"));
gtk_combo_box_text_append_text(prefs_dialog->layout_mode_combo_box, _("below labels / icons"));
gtk_combo_box_set_active(prefs_dialog->layout_mode_combo_box, g_settings_get_int(sensors_applet->settings, LAYOUT_MODE));
g_signal_connect(prefs_dialog->layout_mode_combo_box,
"changed",
G_CALLBACK(prefs_dialog_layout_mode_changed),
prefs_dialog);
prefs_dialog->layout_mode_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Preferred _position of sensor values"),
"mnemonic-widget", prefs_dialog->layout_mode_combo_box,
"xalign", 0.0,
NULL);
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_label),
(display_mode != DISPLAY_ICON) &&
(display_mode != DISPLAY_VALUE) &&
(display_mode != DISPLAY_GRAPH));
prefs_dialog->temperature_scale_combo_box = GTK_COMBO_BOX(gtk_combo_box_text_new());
gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Kelvin"));
gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Celsius"));
gtk_combo_box_text_append_text(prefs_dialog->temperature_scale_combo_box, _("Fahrenheit"));
gtk_combo_box_set_active(prefs_dialog->temperature_scale_combo_box, g_settings_get_int(sensors_applet->settings, TEMPERATURE_SCALE));
g_signal_connect(prefs_dialog->temperature_scale_combo_box,
"changed",
G_CALLBACK(prefs_dialog_temperature_scale_changed),
prefs_dialog);
prefs_dialog->temperature_scale_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("_Temperature scale"),
"mnemonic-widget", prefs_dialog->temperature_scale_combo_box,
"xalign", 0.0,
NULL);
prefs_dialog->graph_size_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", (gdouble)g_settings_get_int(sensors_applet->settings, GRAPH_SIZE),
"lower", 1.0,
"upper", 100.0,
"step-increment", 1.0,
"page-increment", 10.0,
"page-size", 0.0,
NULL);
prefs_dialog->graph_size_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", prefs_dialog->graph_size_adjust,
"climb-rate", 1.0,
"digits", 0,
"value", (gdouble)g_settings_get_int(sensors_applet->settings, GRAPH_SIZE),
"width-chars", 4,
NULL);
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_spinbutton),
(display_mode == DISPLAY_GRAPH));
prefs_dialog->graph_size_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Graph _size (pixels)"),
"mnemonic-widget", prefs_dialog->graph_size_spinbutton,
"xalign", 0.0,
NULL);
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_label),
(display_mode == DISPLAY_GRAPH));
g_signal_connect(prefs_dialog->graph_size_spinbutton, "value-changed",
G_CALLBACK(prefs_dialog_graph_size_changed),
prefs_dialog);
header_text = g_markup_printf_escaped("<b>%s</b>", _("Update"));
prefs_dialog->update_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
prefs_dialog->timeout_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 2.0,
"lower", 1.5,
"upper", 10.0,
"step-increment", 0.5,
"page-increment", 1.0,
"page-size", 0.0,
NULL);
prefs_dialog->timeout_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", prefs_dialog->timeout_adjust,
"climb-rate", 0.5,
"digits", 1,
"value", (gdouble) g_settings_get_int(sensors_applet->settings, TIMEOUT) / 1000.0,
"width-chars", 4,
NULL);
prefs_dialog->timeout_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Update _interval (secs)"),
"mnemonic-widget", prefs_dialog->timeout_spinbutton,
"xalign", 0.0,
NULL);
g_signal_connect(prefs_dialog->timeout_spinbutton, "value-changed",
G_CALLBACK(prefs_dialog_timeout_changed),
prefs_dialog);
#ifdef HAVE_LIBNOTIFY
header_text = g_markup_printf_escaped("<b>%s</b>", _("Notifications"));
prefs_dialog->notifications_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
prefs_dialog->display_notifications = g_object_new(GTK_TYPE_CHECK_BUTTON,
"use-underline", TRUE,
"label", _("Display _notifications"),
NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prefs_dialog->display_notifications),
g_settings_get_boolean(sensors_applet->settings,
DISPLAY_NOTIFICATIONS));
g_signal_connect(prefs_dialog->display_notifications,
"toggled",
G_CALLBACK(prefs_dialog_display_notifications_toggled),
prefs_dialog);
#endif
/* SIZE AND LAYOUT */
/* keep all widgets same size */
prefs_dialog->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget(prefs_dialog->size_group,
GTK_WIDGET(prefs_dialog->display_mode_combo_box));
gtk_size_group_add_widget(prefs_dialog->size_group,
GTK_WIDGET(prefs_dialog->layout_mode_combo_box));
gtk_size_group_add_widget(prefs_dialog->size_group,
GTK_WIDGET(prefs_dialog->temperature_scale_combo_box));
gtk_size_group_add_widget(prefs_dialog->size_group,
GTK_WIDGET(prefs_dialog->timeout_spinbutton));
g_object_unref(prefs_dialog->size_group);
prefs_dialog->globals_table = g_object_new(GTK_TYPE_TABLE,
"homogeneous", FALSE,
"n-columns", 3,
#ifdef HAVE_LIBNOTIFY
"n-rows", 9,
#else
"n-rows", 7,
#endif
"row-spacing", 6,
"column-spacing", 12,
NULL);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->display_header),
0, 2,
0, 1,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->display_mode_label),
1, 2,
1, 2,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->display_mode_combo_box),
2, 3,
1, 2,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->layout_mode_label),
1, 2,
2, 3,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->layout_mode_combo_box),
2, 3,
2, 3,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->graph_size_label),
1, 2,
3, 4,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->graph_size_spinbutton),
2, 3,
3, 4,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->temperature_scale_label),
1, 2,
4, 5,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->temperature_scale_combo_box),
2, 3,
4, 5,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->update_header),
0, 2,
5, 6,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->timeout_label),
1, 2,
6, 7,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->timeout_spinbutton),
2, 3,
6, 7,
GTK_FILL,
GTK_FILL,
0,
0);
#ifdef HAVE_LIBNOTIFY
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->notifications_header),
0, 2,
7, 8,
GTK_FILL,
GTK_FILL,
0,
0);
gtk_table_attach(prefs_dialog->globals_table,
GTK_WIDGET(prefs_dialog->display_notifications),
1, 2,
8, 9,
GTK_FILL,
GTK_FILL,
0,
0);
#endif
prefs_dialog->view = g_object_new(GTK_TYPE_TREE_VIEW,
"model", GTK_TREE_MODEL(sensors_applet->sensors),
"rules-hint", TRUE,
"reorderable", FALSE,
"enable-search", TRUE,
"search-column", LABEL_COLUMN,
NULL);
/* get double clicks on rows - do same as configure sensor
* button clicks */
g_signal_connect(prefs_dialog->view, "row-activated",
G_CALLBACK(prefs_dialog_row_activated),
prefs_dialog);
prefs_dialog->id_renderer = gtk_cell_renderer_text_new();
prefs_dialog->label_renderer = gtk_cell_renderer_text_new();
g_object_set(prefs_dialog->label_renderer,
"editable", TRUE,
NULL);
g_signal_connect(prefs_dialog->label_renderer, "edited",
G_CALLBACK(prefs_dialog_sensor_name_changed),
prefs_dialog);
prefs_dialog->enable_renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(prefs_dialog->enable_renderer, "toggled",
G_CALLBACK(prefs_dialog_sensor_toggled),
prefs_dialog);
prefs_dialog->icon_renderer = gtk_cell_renderer_pixbuf_new();
prefs_dialog->id_column = gtk_tree_view_column_new_with_attributes(_("Sensor"),
prefs_dialog->id_renderer,
"text", ID_COLUMN,
NULL);
gtk_tree_view_column_set_min_width(prefs_dialog->id_column, 90);
prefs_dialog->label_column = gtk_tree_view_column_new_with_attributes(_("Label"),
prefs_dialog->label_renderer,
"text", LABEL_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
gtk_tree_view_column_set_min_width(prefs_dialog->label_column, 100);
/* create the tooltip */
gtk_widget_set_tooltip_text(GTK_WIDGET(prefs_dialog->view),
_("Labels can be edited directly by clicking on them."));
prefs_dialog->enable_column = gtk_tree_view_column_new_with_attributes(_("Enabled"),
prefs_dialog->enable_renderer,
"active", ENABLE_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
prefs_dialog->icon_column = gtk_tree_view_column_new_with_attributes(_("Icon"),
prefs_dialog->icon_renderer,
"pixbuf", ICON_PIXBUF_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
gtk_tree_view_append_column(prefs_dialog->view,
prefs_dialog->id_column);
gtk_tree_view_append_column(prefs_dialog->view,
prefs_dialog->icon_column);
gtk_tree_view_append_column(prefs_dialog->view,
prefs_dialog->label_column);
gtk_tree_view_append_column(prefs_dialog->view,
prefs_dialog->enable_column);
gtk_tree_view_columns_autosize(prefs_dialog->view);
prefs_dialog->scrolled_window = g_object_new(GTK_TYPE_SCROLLED_WINDOW,
"hadjustment", NULL,
"height-request", 200,
"hscrollbar-policy", GTK_POLICY_AUTOMATIC,
"vadjustment",NULL,
"vscrollbar-policy", GTK_POLICY_AUTOMATIC,
NULL);
gtk_container_add(GTK_CONTAINER(prefs_dialog->scrolled_window), GTK_WIDGET(prefs_dialog->view));
/* GtkTree Selection */
sensors_applet->selection = gtk_tree_view_get_selection(prefs_dialog->view);
/* allow user to only select one row at a time at most */
gtk_tree_selection_set_mode(sensors_applet->selection, GTK_SELECTION_SINGLE);
/* when selection is changed, make sure sensor_config button is
activated */
/* Create buttons for user to interact with sensors tree */
prefs_dialog->sensor_up_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_UP));
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE);
g_signal_connect(prefs_dialog->sensor_up_button, "clicked",
G_CALLBACK(prefs_dialog_sensor_up_button_clicked),
prefs_dialog);
prefs_dialog->sensor_down_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_GO_DOWN));
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE);
g_signal_connect(prefs_dialog->sensor_down_button, "clicked",
G_CALLBACK(prefs_dialog_sensor_down_button_clicked),
prefs_dialog);
prefs_dialog->buttons_box = GTK_VBUTTON_BOX(gtk_vbutton_box_new());
gtk_button_box_set_layout(GTK_BUTTON_BOX(prefs_dialog->buttons_box),
GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_up_button), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(prefs_dialog->buttons_box), GTK_WIDGET(prefs_dialog->sensor_down_button), FALSE, FALSE, 0);
prefs_dialog->sensors_hbox = g_object_new(GTK_TYPE_HBOX,
"border-width", 5,
"homogeneous", FALSE,
"spacing", 5,
NULL);
gtk_box_pack_start(prefs_dialog->sensors_hbox,
GTK_WIDGET(prefs_dialog->scrolled_window),
TRUE, TRUE, 0); /* make sure window takes
* up most of room */
gtk_box_pack_start(prefs_dialog->sensors_hbox,
GTK_WIDGET(prefs_dialog->buttons_box),
FALSE, FALSE, 0);
/* Sensor Config button */
/* initially make button insensitive until user selects a row
from the sensors tree */
prefs_dialog->sensor_config_button = GTK_BUTTON(gtk_button_new_from_stock(GTK_STOCK_PROPERTIES));
g_object_set(prefs_dialog->sensor_config_button,
"sensitive", FALSE,
NULL);
g_signal_connect(sensors_applet->selection,
"changed",
G_CALLBACK(prefs_dialog_selection_changed),
prefs_dialog);
/* pass selection to signal handler so we can give user a
sensors_applet->prefs_dialog with the selected rows alarm
value and enable */
g_signal_connect(prefs_dialog->sensor_config_button, "clicked",
G_CALLBACK(prefs_dialog_sensor_config_button_clicked),
prefs_dialog);
prefs_dialog->sensor_config_hbox = g_object_new(GTK_TYPE_HBOX,
"border-width", 5,
"homogeneous", FALSE,
"spacing", 0,
NULL);
gtk_box_pack_end(prefs_dialog->sensor_config_hbox,
GTK_WIDGET(prefs_dialog->sensor_config_button),
FALSE, FALSE, 0);
/* pack sensors_vbox */
prefs_dialog->sensors_vbox = g_object_new(GTK_TYPE_VBOX,
"border-width", 5,
"homogeneous", FALSE,
"spacing", 0,
NULL);
gtk_box_pack_start(prefs_dialog->sensors_vbox,
GTK_WIDGET(prefs_dialog->sensors_hbox),
TRUE, TRUE, 0);
gtk_box_pack_start(prefs_dialog->sensors_vbox,
GTK_WIDGET(prefs_dialog->sensor_config_hbox),
FALSE, FALSE, 0);
prefs_dialog->globals_alignment = g_object_new(GTK_TYPE_ALIGNMENT,
"xalign", 0.5,
"yalign", 0.0,
"top-padding", 12,
"left-padding", 12,
"bottom-padding", 12,
"right-padding", 12,
NULL);
gtk_container_add(GTK_CONTAINER(prefs_dialog->globals_alignment),
GTK_WIDGET(prefs_dialog->globals_table));
prefs_dialog->notebook = g_object_new(GTK_TYPE_NOTEBOOK,
NULL);
gtk_notebook_append_page(prefs_dialog->notebook,
GTK_WIDGET(prefs_dialog->globals_alignment),
gtk_label_new(_("General Options")));
gtk_notebook_append_page(prefs_dialog->notebook,
GTK_WIDGET(prefs_dialog->sensors_vbox),
gtk_label_new(_("Sensors")));
/* pack notebook into prefs_dialog */
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area (prefs_dialog->dialog)),
GTK_WIDGET(prefs_dialog->notebook), TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(prefs_dialog->dialog));
}
