GtkWidget *
gmdb_prefs_new()
{
GtkWidget *prefswin, *button;
GtkWidget *entry;
gchar *str;
/* load the interface */
prefswin_xml = glade_xml_new(GMDB_GLADEDIR "gmdb-prefs.glade", NULL, NULL);
/* connect the signals in the interface */
glade_xml_signal_autoconnect(prefswin_xml);
entry = glade_xml_get_widget (prefswin_xml, "maxrows_entry");
button = glade_xml_get_widget (prefswin_xml, "cancel_button");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gmdb_prefs_cancel_cb), prefswin_xml);
button = glade_xml_get_widget (prefswin_xml, "ok_button");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gmdb_prefs_save_cb), prefswin_xml);
button = glade_xml_get_widget (prefswin_xml, "help_button");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gmdb_prefs_help_cb), prefswin_xml);
str = gnome_config_get_string("/gmdb/prefs/maxrows");
if (!str || !strlen(str)) {
str = "1000";
gnome_config_set_string("/gmdb/prefs/maxrows", str);
gnome_config_sync();
}
gtk_entry_set_text(GTK_ENTRY(entry), str);
prefswin = glade_xml_get_widget (prefswin_xml, "prefs_dialog");
return prefswin;
}
/*
** Load and set up GUI with libglade
*/
GtkWidget *InitTestMEdWindow( void )
{
GtkWidget *win=NULL, *frame=NULL;
GladeXML *xml=NULL;
char *rootnode=NULL; // This is probably never needed
errormsg(MAPDEBUG1,"InitTestMEdWindow: Entered");
glade_init();
errormsg(MAPDEBUG4,"InitTestMEdWindow: glade_init done");
xml = glade_xml_new(TESTMAPEDITFILE, rootnode);
errormsg(MAPDEBUG4,"InitTestMEdWindow: glade_xml_new done");
if (!xml) {
g_warning("something bad happened while creating the interface");
CloseAll();
exit(20);
}
if (rootnode) // Probably never needed
{
GtkWidget *wid = glade_xml_get_widget(xml, rootnode);
if (!GTK_IS_WINDOW(wid))
{
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
errormsg(MAPDEBUG3,"InitTestMEdWindow: win=%x",win);
gtk_signal_connect(GTK_OBJECT(win), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_container_set_border_width(GTK_CONTAINER(win), 5);
frame = gtk_frame_new(NULL);
gtk_container_set_border_width(GTK_CONTAINER(frame), 5);
gtk_container_add(GTK_CONTAINER(win), frame);
gtk_widget_show(frame);
gtk_container_add(GTK_CONTAINER(frame), wid);
gtk_widget_show(win);
}
else win=wid;
}
// Connect signals
errormsg(MAPDEBUG3,"InitTestMEdWindow: win=%x",win);
glade_xml_signal_autoconnect(xml);
gtk_object_unref(GTK_OBJECT(xml));
errormsg(MAPDEBUG3,"InitTestMEdWindow: win=%x now!",win);
errormsg(MAPDEBUG1,"InitTestMEdWindow: Finished succesfully");
return win; // Problem: We never get a window pointer ?
}
/*!
\brief hides a tab
\param widget is the widget clicked to get this to come up
\param data is the index to the tab to hide
\return TRUE on success
*/
G_MODULE_EXPORT gboolean hide_tab(GtkWidget *widget, gpointer data)
{
GtkWidget *child;
GtkWidget *label;
GtkWidget *notebook;
GtkWidget *item = NULL;
GladeXML *main_xml = NULL;
extern GdkColor red;
extern GdkColor black;
gint index = (GINT)data;
gint total = (GINT)DATA_GET(global_data,"notebook_rows");
gint i = 0;
gboolean hidden = FALSE;
gint *hidden_list;
ENTER();
main_xml = (GladeXML *)DATA_GET(global_data,"main_xml");
hidden_list = (gboolean *)DATA_GET(global_data,"hidden_list");
notebook = glade_xml_get_widget(main_xml,"toplevel_notebook");
child = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),index);
label = gtk_notebook_get_tab_label(GTK_NOTEBOOK(notebook),child);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
{
gtk_widget_hide(child);
gtk_widget_hide(label);
hidden_list[index] = TRUE;
}
else
{
gtk_widget_show(child);
gtk_widget_show(label);
hidden_list[index] = FALSE;
}
for (i=0;i<total;i++)
{
if (hidden_list[i])
hidden = TRUE;
}
item = lookup_widget("show_tab_visibility_menuitem");
if (hidden)
gtk_widget_modify_text(gtk_bin_get_child(GTK_BIN(item)),GTK_STATE_NORMAL,&red);
else
gtk_widget_modify_text(gtk_bin_get_child(GTK_BIN(item)),GTK_STATE_NORMAL,&black);
EXIT();
return TRUE;
}
CEPage *
ce_page_wireless_new (NMConnection *connection, GtkWindow *parent_window, GError **error)
{
CEPageWireless *self;
CEPageWirelessPrivate *priv;
CEPage *parent;
g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
self = CE_PAGE_WIRELESS (g_object_new (CE_TYPE_PAGE_WIRELESS,
CE_PAGE_CONNECTION, connection,
CE_PAGE_PARENT_WINDOW, parent_window,
NULL));
parent = CE_PAGE (self);
parent->xml = glade_xml_new (GLADEDIR "/ce-page-wireless.glade", "WirelessPage", NULL);
if (!parent->xml) {
g_set_error (error, 0, 0, "%s", _("Could not load WiFi user interface."));
g_object_unref (self);
return NULL;
}
parent->page = glade_xml_get_widget (parent->xml, "WirelessPage");
if (!parent->page) {
g_set_error (error, 0, 0, "%s", _("Could not load WiFi user interface."));
g_object_unref (self);
return NULL;
}
g_object_ref_sink (parent->page);
parent->title = g_strdup (_("Wireless"));
wireless_private_init (self);
priv = CE_PAGE_WIRELESS_GET_PRIVATE (self);
priv->setting = (NMSettingWireless *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRELESS);
if (!priv->setting) {
priv->setting = NM_SETTING_WIRELESS (nm_setting_wireless_new ());
nm_connection_add_setting (connection, NM_SETTING (priv->setting));
}
g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL);
if (!ce_page_initialize (parent, NULL, error)) {
g_object_unref (self);
return NULL;
}
return CE_PAGE (self);
}
void
on_rescue_button_clicked (GtkButton *button,
gpointer user_data)
{
GtkWidget *window;
rescue_glade = glade_xml_new("check.glade", "media_select");
glade_xml_signal_autoconnect(rescue_glade);
/* Ask the user to insert the media */
window = glade_xml_get_widget(rescue_glade, "media_select");
on_cdrom_radio_toggled(NULL, NULL);
gtk_widget_show(window);
}
static gboolean
data_table_init (GnmDialogDataTable *state, WBCGtk *wbcg)
{
GtkTable *table;
state->gui = gnm_glade_xml_new (GO_CMD_CONTEXT (wbcg),
"data-table.glade", NULL, NULL);
if (state->gui == NULL)
return TRUE;
state->dialog = glade_xml_get_widget (state->gui, "DataTable");
table = GTK_TABLE (glade_xml_get_widget (state->gui, "table"));
state->row_entry = init_entry (state, "row-entry");
state->col_entry = init_entry (state, "col-entry");
g_signal_connect (G_OBJECT (state->dialog), "response",
G_CALLBACK (cb_data_table_response), state);
gnumeric_init_help_button (
glade_xml_get_widget (state->gui, "help"),
GNUMERIC_HELP_LINK_DATA_TABLE);
/* a candidate for merging into attach guru */
gnumeric_keyed_dialog (state->wbcg, GTK_WINDOW (state->dialog),
DIALOG_DATA_TABLE_KEY);
go_gtk_nonmodal_dialog (wbcg_toplevel (state->wbcg),
GTK_WINDOW (state->dialog));
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify)cb_data_table_destroy);
gtk_widget_show_all (GTK_WIDGET (state->dialog));
return FALSE;
}
void
empathy_account_widget_add_forget_button (McAccount *account,
GladeXML *glade,
const gchar *button,
const gchar *entry)
{
GtkWidget *button_forget;
GtkWidget *entry_password;
gchar *password = NULL;
button_forget = glade_xml_get_widget (glade, button);
entry_password = glade_xml_get_widget (glade, entry);
mc_account_get_param_string (account, "password", &password);
gtk_widget_set_sensitive (button_forget, !G_STR_EMPTY (password));
g_free (password);
g_signal_connect (button_forget, "clicked",
G_CALLBACK (account_widget_forget_clicked_cb),
entry_password);
g_signal_connect (entry_password, "changed",
G_CALLBACK (account_widget_password_changed_cb),
button_forget);
}
/* Visit the next location in the history list. */
void
on_forward_clicked (GtkToolButton *item)
{
GtkWidget *treeview;
GString *str;
if (history_pos + 1 < history->len)
{
history_pos++;
treeview = glade_xml_get_widget (xml, "treeview");
str = g_string_new ((gchar*) g_ptr_array_index (history, history_pos));
parse_location (str);
populate_tree_model (GTK_WIDGET (treeview));
}
}
int
gmdb_export_get_quote(GladeXML *xml)
{
GtkWidget *combo;
int need_quote = 0;
gchar *str;
combo = glade_xml_get_widget(xml, "quote_combo");
str = (gchar *) gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry));
if (!strcmp(str,ALWAYS)) { need_quote = 1; }
else if (!strcmp(str,NEVER)) { need_quote = 0; }
else if (!strcmp(str,AUTOMAT)) { need_quote = -1; }
return need_quote;
}
void SetCursolPosition(const gchar *entry_name, const gint position)
{
GtkWidget *entry = NULL;
entry = glade_xml_get_widget(g_cngplp_xml, entry_name);
if(entry != NULL){
if(-1 == position){
const gint num = GTK_ENTRY(entry)->text_length;
gtk_editable_set_position(GTK_EDITABLE(entry), num);
}else{
gtk_editable_delete_text(GTK_EDITABLE(entry), position, -1);
gtk_editable_set_position(GTK_EDITABLE(entry), position);
}
}
}
void ShowFunctionWidget(const FuncInfo *funclist)
{
FuncInfo *func = funclist;
ShowWidgetInfo* show_widgets = NULL;
GtkWidget *widget = NULL;
while(func != NULL){
show_widgets = func->show_widget_list;
while(show_widgets != NULL){
widget = glade_xml_get_widget(g_cngplp_xml, show_widgets->name);
gtk_widget_show(widget);
show_widgets = show_widgets->next;
}
func = func->next;
}
}
void
gimmix_lyrics_plugin_init (void)
{
char *cpath = NULL;
lyrics_textview = glade_xml_get_widget (xml, "lyrics_textview");
g_signal_connect (G_OBJECT(glade_xml_get_widget(xml,"lyrics_get_btn")),
"clicked",
G_CALLBACK(cb_gimmix_lyrics_get_btn_clicked),
NULL);
/* check if .gimmix/lyrics exists */
cpath = cfg_get_path_to_config_file (LYRICS_DIR);
g_mkdir_with_parents (cpath, 00755);
g_free (cpath);
lyrics_dir = cfg_get_path_to_config_file (LYRICS_DIR);
/* initialize mutex */
l_mutex = g_mutex_new ();
return;
}
int handle_message_box(GladeXML* g_glade_xml, GtkLayout* screen, int init)
{
char* message = get_string();
if (init)
{
g_message_window = glade_xml_get_widget(g_glade_xml,
"message_window");
g_assert(g_message_window);
set_nil_draw_focus(g_message_window);
if(screen) gtk_layout_put(screen, g_message_window, 0, 0);
g_message_label = glade_xml_get_widget(g_glade_xml,
"message_label");
g_assert(g_message_label);
GUI_BRANCH(g_glade_xml, on_okbutton1_clicked);
}
gtk_label_set_text(GTK_LABEL(g_message_label), message);
g_free(message);
gui_center(g_message_window, screen);
return TRUE;
}
static StyleSheetDialog *
gnc_style_sheet_select_dialog_create(void)
{
StyleSheetDialog * ss = g_new0(StyleSheetDialog, 1);
GladeXML * xml;
GtkCellRenderer * renderer;
GtkTreeSelection * selection;
xml = gnc_glade_xml_new ("report.glade", "Select Style Sheet Dialog");
ss->toplevel = glade_xml_get_widget (xml, "Select Style Sheet Dialog");
ss->list_view = GTK_TREE_VIEW(glade_xml_get_widget (xml, "style_sheet_list_view"));
ss->list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER);
gtk_tree_view_set_model(ss->list_view, GTK_TREE_MODEL(ss->list_store));
g_object_unref(ss->list_store);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(ss->list_view, -1,
_("Style Sheet Name"), renderer,
"text", COLUMN_NAME,
NULL);
selection = gtk_tree_view_get_selection (ss->list_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect(ss->toplevel, "response",
G_CALLBACK(gnc_style_sheet_select_dialog_response_cb), ss);
g_signal_connect(ss->list_view, "event-after",
G_CALLBACK(gnc_style_sheet_select_dialog_event_cb), ss);
gnc_style_sheet_select_dialog_fill(ss);
gtk_widget_show_all(ss->toplevel);
return ss;
}
/***********************************************************
* Function: // main
* Description: // 入口函数
***********************************************************/
int main( int argc, char *argv[] )
{
gtk_init( &argc, &argv ); // 初始化GTK+库
GladeXML *ui; // 声明GladeXML类型变量
ui = glade_xml_new( "xms_apitest.glade", NULL, NULL ); // 创建GladeXML对象
GtkWidget *window; // 声明GtkWidget类型变量
window = glade_xml_get_widget( ui, "main_dialog" );
// 从GladeXML对象获得GtkWidget界面构件
GtkWidget *label;
label = glade_xml_get_widget( ui, "label1" );
gtk_label_set_label( GTK_LABEL( label ), "Hello World!" );
text_view = glade_xml_get_widget (ui, "textview1");
// 修改界面构件的属性
gtk_widget_show_all( window ); // 显示window内的所有构件
glade_xml_signal_autoconnect( ui ); // 连接GladeXML对象所有已定义信号
InitSystem( ); //初始化系统
gtk_main( ); // 开始GTK+主循环
return 0;
}
static void
eds_stop_button_clicked (GtkButton *button,
PlannerPlugin *plugin)
{
GtkProgressBar *progress = GTK_PROGRESS_BAR
(glade_xml_get_widget (plugin->priv->glade, "progressbar"));
g_message ("Cancelling the query: %s", plugin->priv->current_query_id);
plugin->priv->queries_cancelled =
g_list_append (plugin->priv->queries_cancelled,
g_strdup (plugin->priv->current_query_id));
gtk_progress_bar_set_text (progress,_("Query cancelled."));
eds_plugin_busy (plugin, FALSE);
}
static void
eds_group_selected (GtkComboBox *select_group,
PlannerPlugin *plugin)
{
GtkTreeIter iter;
PlannerPluginPriv *priv = plugin->priv;
ESourceGroup *group;
gtk_widget_set_sensitive (glade_xml_get_widget (priv->glade, "search_box"), TRUE);
if (gtk_combo_box_get_active_iter (select_group, &iter)) {
gtk_tree_model_get (priv->groups_model, &iter, COL_GROUP_OBJECT, &group, -1);
eds_load_resources (group, plugin, "");
}
}
void SwapTableItemText(int max, int rowA, int rowB)
{
GtkTreeView *table = (GtkTreeView *)glade_xml_get_widget(windowXML, "table");
GtkListStore *store = (GtkListStore *)gtk_tree_view_get_model(table);
GtkTreeModel *model = gtk_tree_view_get_model(table);
GtkTreeIter iter, iterA, iterB;
gtk_tree_model_get_iter_first(model, &iter);
for (int i=0; i<max; i++) {
if (rowA == i) iterA = iter;
if (rowB == i) iterB = iter;
}
gtk_list_store_swap(store, &iterA, &iterB);
}
void btnTVFilterApply_clicked_cb(GtkWidget * widget, gpointer user_data)
{
/* GTK_RESPONSE_OK = -5,
GTK_RESPONSE_CANCEL = -6,
GTK_RESPONSE_CLOSE = -7,
GTK_RESPONSE_YES = -8,
GTK_RESPONSE_NO = -9,
GTK_RESPONSE_APPLY = -10,
GTK_RESPONSE_HELP = -11 */
gtk_dialog_response((GtkDialog *)
glade_xml_get_widget(xml, "dlgTVFilter"),
GTK_RESPONSE_OK);
}
/*
Display popup menu (right click)
*/
static GtkWidget* display_popup_menu(void)
{
GladeXML *xml;
GtkWidget *menu;
xml = glade_xml_new
(tilp_paths_build_glade("dbg_regs-2.glade"), "dbgregs_popup",
PACKAGE);
if (!xml)
g_error(_("%s: GUI loading failed !\n"), __FILE__);
glade_xml_signal_autoconnect(xml);
menu = glade_xml_get_widget(xml, "dbgregs_popup");
return menu;
}
/*!
\param value La cadena que imprimimos.
\param xml Un puntero al GladeXML que define la ventana.
*/
static void salida_imprimir(const char *value, GladeXML *xml) {
if(value) {
GtkWidget* texto;
GString *valor = g_string_new("");
GtkTextIter iter;
GtkTextBuffer * buffer;
g_string_sprintf(valor, "%s\n", (char *)value);
texto = glade_xml_get_widget(xml, "txt_salida");
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(texto));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, -1);
gtk_text_buffer_insert(buffer, &iter, valor->str, -1);
g_string_free(valor, TRUE);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(texto), &iter, 0.0, FALSE, 1.0, 1.0);
}
}
void
preferences_show (void)
{
if (dialog == NULL)
{
glade_xml = glade_xml_new(g_build_filename(MINBAR_DATADIR,GLADE_MAIN_INTERFACE,NULL), NULL, NULL);
glade_xml_signal_autoconnect(glade_xml);
dialog = glade_xml_get_widget(glade_xml, "editcity");
setup_dialog();
update_widgets();
}
gtk_window_present(GTK_WINDOW(dialog));
}
static void
update_toggles (GtkWidget * dialog)
{
usbUpdate ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(glade_xml_get_widget (xml, "c0")),
((buffer[0] & (1 << 0)) ?
PSG_ACTIVE (TRUE)
: PSG_ACTIVE (FALSE)));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(glade_xml_get_widget (xml, "c1")),
((buffer[0] & (1 << 1)) ?
PSG_ACTIVE (TRUE)
: PSG_ACTIVE (FALSE)));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(glade_xml_get_widget (xml, "c2")),
((buffer[0] & (1 << 2)) ?
PSG_ACTIVE (TRUE)
: PSG_ACTIVE (FALSE)));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(glade_xml_get_widget (xml, "c3")),
((buffer[0] & (1 << 3)) ?
PSG_ACTIVE (TRUE)
: PSG_ACTIVE (FALSE)));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(glade_xml_get_widget (xml, "c4")),
((buffer[0] & (1 << 4)) ?
PSG_ACTIVE (TRUE)
: PSG_ACTIVE (FALSE)));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(glade_xml_get_widget (xml, "c5")),
((buffer[0] & (1 << 5)) ?
PSG_ACTIVE (TRUE)
: PSG_ACTIVE (FALSE)));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(glade_xml_get_widget (xml, "c6")),
((buffer[0] & (1 << 6)) ?
PSG_ACTIVE (TRUE)
: PSG_ACTIVE (FALSE)));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(glade_xml_get_widget (xml, "c7")),
((buffer[0] & (1 << 7)) ?
PSG_ACTIVE (TRUE)
: PSG_ACTIVE (FALSE)));
}
GLADE_CALLBACK void
on_file_open_activate(GtkWidget *w, gpointer userdata)
{
_log.debug("on_file_open_activate\n");
if (open_window == 0)
{
GladeXML *xml;
xml = ui_load_tree("open");
open_window = glade_xml_get_widget(xml, "open");
}
gtk_widget_show(open_window);
}
static gboolean
validate (EAPMethod *parent)
{
NMSetting8021xCKFormat format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN;
GtkWidget *widget;
const char *password, *identity;
widget = glade_xml_get_widget (parent->xml, "eap_tls_identity_entry");
g_assert (widget);
identity = gtk_entry_get_text (GTK_ENTRY (widget));
if (!identity || !strlen (identity))
return FALSE;
if (!eap_method_validate_filepicker (parent->xml, "eap_tls_ca_cert_button", TYPE_CA_CERT, NULL, NULL))
return FALSE;
widget = glade_xml_get_widget (parent->xml, "eap_tls_private_key_password_entry");
g_assert (widget);
password = gtk_entry_get_text (GTK_ENTRY (widget));
if (!password || !strlen (password))
return FALSE;
if (!eap_method_validate_filepicker (parent->xml,
"eap_tls_private_key_button",
TYPE_PRIVATE_KEY,
password,
&format))
return FALSE;
if (format != NM_SETTING_802_1X_CK_FORMAT_PKCS12) {
if (!eap_method_validate_filepicker (parent->xml, "eap_tls_user_cert_button", TYPE_CLIENT_CERT, NULL, NULL))
return FALSE;
}
return TRUE;
}
static void
private_key_picker_helper (EAPMethod *parent, const char *filename, gboolean changed)
{
NMSetting8021x *setting;
NMSetting8021xCKType cert_type = NM_SETTING_802_1X_CK_TYPE_UNKNOWN;
const char *password;
GtkWidget *widget;
widget = glade_xml_get_widget (parent->xml, "eap_tls_private_key_password_entry");
g_assert (widget);
password = gtk_entry_get_text (GTK_ENTRY (widget));
setting = (NMSetting8021x *) nm_setting_802_1x_new ();
nm_setting_802_1x_set_private_key_from_file (setting, filename, password, &cert_type, NULL);
g_object_unref (setting);
/* With PKCS#12, the client cert must be the same as the private key */
widget = glade_xml_get_widget (parent->xml, "eap_tls_user_cert_button");
if (cert_type == NM_SETTING_802_1X_CK_TYPE_PKCS12) {
gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (widget));
gtk_widget_set_sensitive (widget, FALSE);
} else if (changed)
gtk_widget_set_sensitive (widget, TRUE);
}
gint dbgentry_display_dbox(void)
{
GladeXML *xml;
GtkWidget *dbox;
GtkWidget *data;
gint result;
xml = glade_xml_new
(tilp_paths_build_glade("dbg_entry-2.glade"), "dbgentry_dbox",
PACKAGE);
if (!xml)
g_error(_("%s: GUI loading failed!\n"), __FILE__);
glade_xml_signal_autoconnect(xml);
dbox = glade_xml_get_widget(xml, "dbgentry_dbox");
//gtk_window_resize(GTK_WINDOW(dbox), 320, 240);
data = glade_xml_get_widget(xml, "treeview1");
ctree_create(data);
ctree_populate(data);
result = gtk_dialog_run(GTK_DIALOG(dbox));
switch (result)
{
case GTK_RESPONSE_OK:
ctree_get_selection();
dbgbkpts_refresh_window();
break;
default:
break;
}
gtk_widget_destroy(dbox);
return 0;
}
static void
setup_locations_dialog()
{
GladeXML *xml = glade_xml;
g_signal_connect(locations_dialog, "delete_event",
G_CALLBACK(locations_delete_event), NULL);
g_signal_connect(locations_dialog, "response",
G_CALLBACK(locations_response), NULL);
GtkTreeStore *model;
/*GtkTreeSelection *selection;*/
GtkWidget *scrolled_window;
GtkTreeViewColumn *column;
GtkCellRenderer *cell_renderer;
/*WeatherLocation *current_location;*/
scrolled_window = (GtkWidget*) glade_xml_get_widget(xml, "location_list_scroll");
model = gtk_tree_store_new (GWEATHER_XML_NUM_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER);
locations_widgets->tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (locations_widgets->tree), FALSE);
/* Add a colum for the locations */
cell_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("not used", cell_renderer,
"text", GWEATHER_XML_COL_LOC, NULL);
gtk_tree_view_append_column ((GtkTreeView *)locations_widgets->tree, column);
gtk_tree_view_set_expander_column (GTK_TREE_VIEW (locations_widgets->tree), column);
gtk_container_add (GTK_CONTAINER (scrolled_window), locations_widgets->tree);
gtk_widget_show (locations_widgets->tree);
gtk_widget_show (scrolled_window);
/* current_location = weather_location_clone (gw_applet->gweather_pref.location);*/
/* load locations from xml file */
if (gweather_xml_load_locations ((GtkTreeView *)locations_widgets->tree, NULL))
{
GtkWidget *d;
d = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("Failed to load the Locations XML "
"database. Please report this as "
"a bug."));
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (d);
}
}
void funcion_error(const char *nombre, const char *modulo, const char *textos) {
if(xml && nombre && textos && modulo) {
GString *valor = g_string_new("");
g_string_sprintf(valor, "%s [%s]: %s\n", strdup(nombre), strdup(modulo), strdup(textos));
// Sacar la salida por pantalla hace fácil redirigir el resultado de depuración
// a un archivo de texto: pipeline --timer=500 vision.xml > vision.log
printf("%s", valor->str);
GtkWidget* texto = glade_xml_get_widget(xml, "txt_error");
GtkTextIter iter;
GtkTextBuffer * buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(texto));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, -1);
gtk_text_buffer_insert(buffer, &iter, valor->str, -1);
g_string_free(valor, TRUE);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(texto), &iter, 0.0, FALSE, 1.0, 1.0);
}
}
void explorer_force_pause (Explorer *self)
{
/* Force rendering to pause now, but keep note of its original state
* so that explorer_restore_pause() can undo this as necessary.
*/
GtkCheckMenuItem *paused = GTK_CHECK_MENU_ITEM(glade_xml_get_widget(self->xml, "pause_menu"));
gboolean original_state = gtk_check_menu_item_get_active(paused);
gtk_check_menu_item_set_active(paused, TRUE);
/* Now, on_pause_rendering_toggle just disabled unpause_on_restore since
* typically only a user changes the pause_menu state. We want to turn
* that back on if we just paused it and originally it was unpaused,
* so that explorer_restore_pause() does the Right Thing (tm).
*/
self->unpause_on_restore = !original_state;
}
