JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1set_1default
(
JNIEnv* env,
jclass cls,
jlong _self,
jlong _defaultWidget
)
{
GtkWindow* self;
GtkWidget* defaultWidget;
// convert parameter self
self = (GtkWindow*) _self;
// convert parameter defaultWidget
defaultWidget = (GtkWidget*) _defaultWidget;
// call function
gtk_window_set_default(self, defaultWidget);
// cleanup parameter self
// cleanup parameter defaultWidget
}
void
html_diag_finish(Thtml_diag * dg, GCallback ok_func)
{
GtkWidget *align, *hbox;
align = gtk_alignment_new(0.5, 1.0, 1.0, 0.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(align), 12, 0, 0, 0);
#if GTK_CHECK_VERSION(3,0,0)
hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
hbox = gtk_hbutton_box_new();
#endif
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 12);
gtk_container_add(GTK_CONTAINER(align), hbox);
dg->obut = bf_stock_ok_button(ok_func, dg);
dg->cbut = bf_stock_cancel_button(G_CALLBACK(html_diag_cancel_clicked_cb), dg);
gtk_box_pack_start(GTK_BOX(hbox), dg->cbut, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), dg->obut, FALSE, FALSE, 0);
gtk_window_set_default(GTK_WINDOW(dg->dialog), dg->obut);
gtk_box_pack_start(GTK_BOX(dg->vbox), align, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(dg->dialog));
}
static void
contacts_edit_pane_hide (ContactsData *data)
{
GtkWidget *widget;
GtkWindow *window;
/* All changed are instant-apply, so just remove the edit components
* and switch back to main view.
*/
window = GTK_WINDOW (data->ui->main_window);
widget = data->ui->edit_table;
gtk_container_foreach (GTK_CONTAINER (widget),
(GtkCallback)contacts_remove_edit_widgets_cb,
widget);
if ((widget = data->ui->contact_menu))
gtk_widget_hide (widget);
if ((widget = data->ui->contacts_menu))
gtk_widget_show (widget);
widget = data->ui->main_notebook;
gtk_notebook_set_current_page (GTK_NOTEBOOK (widget), 0);
gtk_window_set_title (window, _("Contacts"));
contacts_set_available_options (data, TRUE, TRUE, TRUE);
if (data->ui->edit_button)
gtk_window_set_default (window, data->ui->edit_button);
if ((widget = data->ui->search_entry) && GTK_WIDGET_VISIBLE (widget))
gtk_window_set_focus (window, data->ui->search_entry);
}
void
empathy_contact_information_dialog_show (EmpathyContact *contact,
GtkWindow *parent)
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *contact_widget;
GList *l;
g_return_if_fail (EMPATHY_IS_CONTACT (contact));
l = g_list_find_custom (information_dialogs,
contact,
(GCompareFunc) contact_dialogs_find);
if (l) {
gtk_window_present (GTK_WINDOW (l->data));
return;
}
/* Create dialog */
dialog = gtk_dialog_new ();
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (dialog),
empathy_contact_get_name (contact));
/* Close button */
button = gtk_button_new_with_label (GTK_STOCK_CLOSE);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
button,
GTK_RESPONSE_CLOSE);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_window_set_default (GTK_WINDOW (dialog), button);
gtk_widget_show (button);
/* Contact info widget */
contact_widget = empathy_contact_widget_new (contact,
EMPATHY_CONTACT_WIDGET_SHOW_LOCATION |
EMPATHY_CONTACT_WIDGET_EDIT_NONE);
gtk_container_set_border_width (GTK_CONTAINER (contact_widget), 8);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
contact_widget,
TRUE, TRUE, 0);
gtk_widget_show (contact_widget);
g_object_set_data (G_OBJECT (dialog), "contact_widget", contact_widget);
information_dialogs = g_list_prepend (information_dialogs, dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (contact_dialogs_response_cb),
&information_dialogs);
if (parent) {
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
}
gtk_widget_show (dialog);
}
GtkWidget *
applet_mobile_password_dialog_new (NMDevice *device,
NMConnection *connection,
GtkEntry **out_secret_entry)
{
GtkDialog *dialog;
GtkWidget *w;
GtkBox *box;
char *dev_str;
NMSettingConnection *s_con;
char *tmp;
const char *id;
dialog = GTK_DIALOG (gtk_dialog_new ());
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_window_set_title (GTK_WINDOW (dialog), _("Mobile broadband network password"));
w = gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
w = gtk_dialog_add_button (dialog, GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default (GTK_WINDOW (dialog), w);
s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION));
id = nm_setting_connection_get_id (s_con);
g_assert (id);
tmp = g_strdup_printf (_("A password is required to connect to '%s'."), id);
w = gtk_label_new (tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (dialog->vbox), w, TRUE, TRUE, 0);
dev_str = g_strdup_printf ("<b>%s</b>", utils_get_device_description (device));
w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (w), dev_str);
g_free (dev_str);
gtk_box_pack_start (GTK_BOX (dialog->vbox), w, TRUE, TRUE, 0);
w = gtk_alignment_new (0.5, 0.5, 0, 1.0);
gtk_box_pack_start (GTK_BOX (dialog->vbox), w, TRUE, TRUE, 0);
box = GTK_BOX (gtk_hbox_new (FALSE, 6));
gtk_container_set_border_width (GTK_CONTAINER (box), 6);
gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (box));
gtk_box_pack_start (box, gtk_label_new (_("Password:")), FALSE, FALSE, 0);
w = gtk_entry_new ();
*out_secret_entry = GTK_ENTRY (w);
gtk_entry_set_activates_default (GTK_ENTRY (w), TRUE);
gtk_box_pack_start (box, w, FALSE, FALSE, 0);
gtk_widget_show_all (dialog->vbox);
return GTK_WIDGET (dialog);
}
void
empathy_contact_personal_dialog_show (GtkWindow *parent)
{
GtkWidget *button;
GtkWidget *contact_widget;
if (personal_dialog) {
gtk_window_present (GTK_WINDOW (personal_dialog));
return;
}
/* Create dialog */
personal_dialog = gtk_dialog_new ();
gtk_dialog_set_has_separator (GTK_DIALOG (personal_dialog), FALSE);
gtk_window_set_resizable (GTK_WINDOW (personal_dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (personal_dialog), _("Personal Information"));
/* Close button */
button = gtk_button_new_with_label (GTK_STOCK_CLOSE);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (personal_dialog),
button,
GTK_RESPONSE_CLOSE);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_window_set_default (GTK_WINDOW (personal_dialog), button);
gtk_widget_show (button);
/* Contact info widget */
contact_widget = empathy_contact_widget_new (NULL,
EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT |
EMPATHY_CONTACT_WIDGET_EDIT_ALIAS |
EMPATHY_CONTACT_WIDGET_EDIT_AVATAR);
gtk_container_set_border_width (GTK_CONTAINER (contact_widget), 8);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (personal_dialog)->vbox),
contact_widget,
TRUE, TRUE, 0);
empathy_contact_widget_set_account_filter (contact_widget,
empathy_account_chooser_filter_is_connected, NULL);
gtk_widget_show (contact_widget);
g_signal_connect (personal_dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_object_add_weak_pointer (G_OBJECT (personal_dialog),
(gpointer) &personal_dialog);
if (parent) {
gtk_window_set_transient_for (GTK_WINDOW (personal_dialog), parent);
}
gtk_widget_show (personal_dialog);
}
void gui_set_state(const enum gui_state_e state)
{
g_assert(GUI_STATE_IS_VALID(state));
gui_priv.state = state;
if (gui_get_view() == GUI_VIEW_TEXT)
return;
const bool busy = (state == GUI_STATE_BUSY);
gtk_widget_set_visible(GTK_WIDGET(gui.button_hash), !busy);
gtk_widget_set_visible(GTK_WIDGET(gui.button_stop), busy);
gtk_progress_bar_set_fraction(gui.progressbar, 0.0);
gtk_widget_set_visible(GTK_WIDGET(gui.progressbar), busy);
gtk_widget_set_sensitive(GTK_WIDGET(gui.hbox_input), !busy);
gtk_widget_set_sensitive(GTK_WIDGET(gui.hbox_output), !busy);
gtk_widget_set_sensitive(GTK_WIDGET(gui.toolbar), !busy);
gtk_widget_set_sensitive(GTK_WIDGET(gui.treeview), !busy);
gtk_widget_set_sensitive(GTK_WIDGET(gui.radiomenuitem_text), !busy);
gtk_widget_set_sensitive(GTK_WIDGET(gui.radiomenuitem_file), !busy);
gtk_widget_set_sensitive(GTK_WIDGET(gui.radiomenuitem_file_list), !busy);
gtk_widget_set_sensitive(GTK_WIDGET(gui.dialog_table), !busy);
gtk_widget_set_sensitive(GTK_WIDGET(gui.dialog_combobox), !busy);
if (busy) {
gtk_window_set_default(gui.window, GTK_WIDGET(gui.button_stop));
gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_save_as), false);
} else {
gtk_window_set_default(gui.window, GTK_WIDGET(gui.button_hash));
// User may already have menu open, so make sure save_as gets updated
g_signal_emit_by_name(gui.menuitem_file, "activate");
}
}
extern void usage_popup(GtkAction *action, gpointer user_data)
{
GtkWidget *table = gtk_table_new(1, 1, FALSE);
GtkWidget *label = NULL;
GtkWidget *popup = gtk_dialog_new_with_buttons(
"Usage",
GTK_WINDOW(user_data),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
char *help_msg =
"sview can be used to view and modify many of SLURM's\n"
"records.\n\n"
"Tabs are used to select the data type to work with.\n"
"Right click on the tab to select it. Left click on\n"
"the tab to control the fields of the table to be\n"
"displayed. Those fields can then be re-ordered or used\n"
"for sorting the records.\n\n"
"Left click on a record to see the compute nodes\n"
"associated with it. Right click on a record to modify\n"
"it. The colored boxes represent compute nodes associated\n"
"with each job, partition, etc. and may also selected\n"
"with right and left buttons.\n\n"
"Select 'Option' then 'Admin mode' to enable editing\n"
"of the records.\n";
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_window_set_default_size(GTK_WINDOW(popup), 200, 50);
label = gtk_label_new(help_msg);
gtk_container_set_border_width(GTK_CONTAINER(table), 10);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
table, FALSE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_widget_show_all(popup);
(void) gtk_dialog_run (GTK_DIALOG(popup));
gtk_widget_destroy(popup);
return;
}
static GtkWidget *
ask_for_pin (GtkEntry **out_secret_entry)
{
GtkDialog *dialog;
GtkWidget *w = NULL, *ok_button = NULL;
GtkBox *box = NULL, *vbox = NULL;
dialog = GTK_DIALOG (gtk_dialog_new ());
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_window_set_title (GTK_WINDOW (dialog), _("PIN code required"));
ok_button = gtk_dialog_add_button (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
ok_button = gtk_dialog_add_button (dialog, GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default (GTK_WINDOW (dialog), ok_button);
vbox = GTK_BOX (gtk_dialog_get_content_area (dialog));
w = gtk_label_new (_("PIN code is needed for the mobile broadband device"));
gtk_box_pack_start (vbox, w, TRUE, TRUE, 0);
w = gtk_alignment_new (0.5, 0.5, 0, 1.0);
gtk_box_pack_start (vbox, w, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION(3,1,6)
box = GTK_BOX (gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6));
#else
box = GTK_BOX (gtk_hbox_new (FALSE, 6));
#endif
gtk_container_set_border_width (GTK_CONTAINER (box), 6);
gtk_container_add (GTK_CONTAINER (w), GTK_WIDGET (box));
gtk_box_pack_start (box, gtk_label_new ("PIN:"), FALSE, FALSE, 0);
w = gtk_entry_new ();
*out_secret_entry = GTK_ENTRY (w);
gtk_entry_set_max_length (GTK_ENTRY (w), 8);
gtk_entry_set_width_chars (GTK_ENTRY (w), 8);
gtk_entry_set_activates_default (GTK_ENTRY (w), TRUE);
gtk_entry_set_visibility (GTK_ENTRY (w), FALSE);
gtk_box_pack_start (box, w, FALSE, FALSE, 0);
g_signal_connect (w, "changed", G_CALLBACK (pin_entry_changed), ok_button);
pin_entry_changed (GTK_EDITABLE (w), ok_button);
gtk_widget_show_all (GTK_WIDGET (vbox));
return GTK_WIDGET (dialog);
}
void html_diag_finish(Thtml_diag *dg, GtkSignalFunc ok_func) {
GtkWidget *hbox;
gtk_box_pack_start(GTK_BOX(dg->vbox), gtk_hseparator_new(), FALSE, FALSE, 12);
hbox = gtk_hbutton_box_new();
gtk_hbutton_box_set_layout_default(GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbox), 12);
dg->obut = bf_stock_ok_button(ok_func, dg);
dg->cbut = bf_stock_cancel_button(G_CALLBACK(html_diag_cancel_clicked_cb), dg);
gtk_box_pack_start(GTK_BOX(hbox),dg->cbut , FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox),dg->obut , FALSE, FALSE, 0);
gtk_window_set_default(GTK_WINDOW(dg->dialog), dg->obut);
gtk_box_pack_start(GTK_BOX(dg->vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(dg->dialog));
}
static void
thunar_location_dialog_init (ThunarLocationDialog *location_dialog)
{
GtkWidget *cancel_button;
GtkWidget *open_button;
GtkWidget *hbox;
GtkWidget *label;
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (location_dialog)->vbox), 2);
gtk_container_set_border_width (GTK_CONTAINER (location_dialog), 5);
gtk_dialog_set_has_separator (GTK_DIALOG (location_dialog), FALSE);
gtk_window_set_default_size (GTK_WINDOW (location_dialog), 350, -1);
gtk_window_set_title (GTK_WINDOW (location_dialog), _("Open Location"));
cancel_button = gtk_dialog_add_button (GTK_DIALOG (location_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
open_button = gtk_dialog_add_button (GTK_DIALOG (location_dialog), GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT);
gtk_window_set_default (GTK_WINDOW (location_dialog), open_button);
hbox = g_object_new (GTK_TYPE_HBOX,
"border-width", 5,
"spacing", 12,
NULL);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (location_dialog)->vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("_Location:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
location_dialog->entry = thunar_path_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (location_dialog->entry), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), location_dialog->entry, TRUE, TRUE, 0);
thunar_gtk_label_set_a11y_relation (GTK_LABEL (label), location_dialog->entry);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), location_dialog->entry);
gtk_widget_show (location_dialog->entry);
/* the "Open" button is only sensitive if a valid file is entered */
exo_binding_new_full (G_OBJECT (location_dialog->entry), "current-file",
G_OBJECT (open_button), "sensitive",
transform_object_to_boolean, NULL, NULL);
}
static void
gw_addvocabularywindow_constructed (GObject *object)
{
//Declarations
GwAddVocabularyWindow *window;
GwAddVocabularyWindowPrivate *priv;
//Chain the parent class
{
G_OBJECT_CLASS (gw_addvocabularywindow_parent_class)->constructed (object);
}
//Initializations
window = GW_ADDVOCABULARYWINDOW (object);
priv = window->priv;
//Set up the gtkbuilder links
priv->kanji_entry = GTK_ENTRY (gw_window_get_object (GW_WINDOW (window), "kanji_entry"));
priv->furigana_entry = GTK_ENTRY (gw_window_get_object (GW_WINDOW (window), "furigana_entry"));
priv->definitions_textview = GTK_TEXT_VIEW (gw_window_get_object (GW_WINDOW (window), "definitions_textview"));
priv->cancel_button = GTK_BUTTON (gw_window_get_object (GW_WINDOW (window), "cancel_button"));
priv->add_button = GTK_BUTTON (gw_window_get_object (GW_WINDOW (window), "add_button"));
priv->vocabulary_list_combobox = GTK_COMBO_BOX (gw_window_get_object (GW_WINDOW (window), "vocabulary_list_combobox"));
//Set up the gtk window
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_default_size (GTK_WINDOW (window), 500, 250);
gtk_window_set_icon_name (GTK_WINDOW (window), "gwaei");
gtk_window_set_title (GTK_WINDOW (window), gettext("Add Vocabulary Word..."));
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), TRUE);
gtk_window_set_skip_pager_hint (GTK_WINDOW (window), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (window), FALSE);
gtk_window_set_modal (GTK_WINDOW (window), TRUE);
gtk_window_set_default (GTK_WINDOW (window), GTK_WIDGET (priv->add_button));
gw_addvocabularywindow_init_accelerators (window);
gw_addvocabularywindow_init_combobox (window);
gw_window_unload_xml (GW_WINDOW (window));
}
extern void about_popup(GtkAction *action, gpointer user_data)
{
GtkWidget *table = gtk_table_new(1, 1, FALSE);
GtkWidget *label = NULL;
GtkWidget *popup = gtk_dialog_new_with_buttons(
"About",
GTK_WINDOW(user_data),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
char *version = NULL;
version = xstrdup_printf("SLURM Version: %s", SLURM_VERSION_STRING);
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_window_set_default_size(GTK_WINDOW(popup), 200, 50);
label = gtk_label_new(version);
xfree(version);
gtk_container_set_border_width(GTK_CONTAINER(table), 10);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
table, FALSE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_widget_show_all(popup);
(void) gtk_dialog_run (GTK_DIALOG(popup));
gtk_widget_destroy(popup);
return;
}
static void
empathy_individual_edit_dialog_init (
EmpathyIndividualEditDialog *dialog)
{
GtkWidget *button;
EmpathyIndividualEditDialogPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (
dialog, EMPATHY_TYPE_INDIVIDUAL_EDIT_DIALOG,
EmpathyIndividualEditDialogPriv);
dialog->priv = priv;
priv->individual = NULL;
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (dialog), _("Edit Contact Information"));
/* Individual widget */
priv->individual_widget = empathy_individual_widget_new (priv->individual,
EMPATHY_INDIVIDUAL_WIDGET_EDIT_ALIAS |
EMPATHY_INDIVIDUAL_WIDGET_EDIT_GROUPS |
EMPATHY_INDIVIDUAL_WIDGET_EDIT_FAVOURITE);
gtk_container_set_border_width (GTK_CONTAINER (priv->individual_widget), 8);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (
GTK_DIALOG (dialog))), priv->individual_widget, TRUE, TRUE, 0);
gtk_widget_show (priv->individual_widget);
/* Close button */
button = gtk_button_new_with_label (GTK_STOCK_CLOSE);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
GTK_RESPONSE_CLOSE);
gtk_widget_set_can_default (button, TRUE);
gtk_window_set_default (GTK_WINDOW (dialog), button);
gtk_widget_show (button);
g_signal_connect (dialog, "response",
G_CALLBACK (individual_dialogs_response_cb), &edit_dialogs);
}
/* ******************************************************************
*
*/
gint
create_route_cb (GtkWidget * widget, guint datum)
{
GtkWidget *window;
gchar *tabeltitel1[] = { "#",
_("Waypoint"), _("Latitude"), _("Longitude"), _("Distance"),
NULL
};
GtkWidget *scrwindow, *vbox, *button, *button3, *hbox, *hbox_displays, *l1;
gint i, j;
gchar *text[5], text0[20], text1[20], text2[20], text3[20];
GtkTooltips *tooltips;
route.edit = TRUE;
window = gtk_dialog_new ();
routewindow = window;
/* gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, TRUE); */
gtk_window_set_title (GTK_WINDOW (window), _("Define route"));
gtk_window_set_default_size (GTK_WINDOW (window), 320, 320);
myroutelist = gtk_clist_new_with_titles (5, tabeltitel1);
gtk_signal_connect (GTK_OBJECT (GTK_CLIST (myroutelist)),
"select-row",
GTK_SIGNAL_FUNC (setroutetarget),
GTK_OBJECT (myroutelist));
select_route_button = gtk_button_new_with_label (_("Start route"));
gtk_widget_set_sensitive (select_route_button, FALSE);
GTK_WIDGET_SET_FLAGS (select_route_button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (select_route_button), "clicked",
GTK_SIGNAL_FUNC (do_route_cb), 0);
gtk_window_set_default (GTK_WINDOW (window), select_route_button);
create_route2_button =
gtk_button_new_with_label (_("Take all WP as route"));
GTK_WIDGET_SET_FLAGS (create_route2_button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (create_route2_button), "clicked",
GTK_SIGNAL_FUNC (insertallroutepoints), 0);
button = gtk_button_new_with_label (_("Abort route"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC
(sel_routecancel_cb), GTK_OBJECT (window));
gtk_signal_connect_object (GTK_OBJECT (window),
"delete_event",
GTK_SIGNAL_FUNC
(sel_routeclose_cb), GTK_OBJECT (window));
/* button3 = gtk_button_new_with_label (_("Close")); */
button3 = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
GTK_WIDGET_SET_FLAGS (button3, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button3), "clicked",
GTK_SIGNAL_FUNC
(sel_routeclose_cb), GTK_OBJECT (window));
/* Font �ndern falls PDA-Mode und Touchscreen */
if (local_config.guimode == GUI_PDA)
{
if (onemousebutton)
{
/* Change default font throughout the widget */
PangoFontDescription *font_desc;
font_desc =
pango_font_description_from_string
("Sans 10");
gtk_widget_modify_font (myroutelist, font_desc);
pango_font_description_free (font_desc);
}
}
gtk_clist_set_column_justification (GTK_CLIST (myroutelist), 4,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_justification (GTK_CLIST (myroutelist), 0,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 0, TRUE);
gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 1, TRUE);
gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 2, TRUE);
gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 3, TRUE);
gtk_clist_set_column_auto_resize (GTK_CLIST (myroutelist), 4, TRUE);
scrwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrwindow), myroutelist);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW
(scrwindow),
(GtkPolicyType)
GTK_POLICY_AUTOMATIC,
(GtkPolicyType) GTK_POLICY_AUTOMATIC);
vbox = gtk_vbox_new (FALSE, 2);
/* gtk_container_add (GTK_CONTAINER (window), vbox); */
gtk_box_pack_start (GTK_BOX
(GTK_DIALOG (window)->vbox), vbox, TRUE, TRUE, 2);
gtk_box_pack_start (GTK_BOX (vbox), scrwindow, TRUE, TRUE, 2);
hbox = gtk_hbox_new (TRUE, 2);
hbox_displays = gtk_hbox_new (TRUE, 2);
if (!route.active)
l1 = gtk_label_new (_
("Click on waypoints list\nto add waypoints"));
else
l1 = gtk_label_new (_
("Click on list item\nto select next waypoint"));
gtk_box_pack_start (GTK_BOX (vbox), l1, FALSE, FALSE, 2);
/* gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2); */
gtk_box_pack_start (GTK_BOX
(GTK_DIALOG (window)->action_area),
hbox, TRUE, TRUE, 2);
gtk_box_pack_start (GTK_BOX (hbox), select_route_button, TRUE, TRUE,
2);
gtk_box_pack_start (GTK_BOX (hbox), create_route2_button, TRUE, TRUE,
2);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
gtk_box_pack_start (GTK_BOX (vbox), hbox_displays, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (hbox), button3, TRUE, TRUE, 2);
gtk_widget_set_sensitive (create_route_button, FALSE);
if (route.active)
{
gtk_widget_set_sensitive (select_route_button, FALSE);
gtk_clist_clear (GTK_CLIST (myroutelist));
for (i = 0; i < route.items; i++)
{
(routelist + i)->dist =
calcdist ((routelist + i)->lon,
(routelist + i)->lat);
text[1] = (routelist + i)->name;
g_snprintf (text0, sizeof (text0), "%d", i + 1);
g_snprintf (text1, sizeof (text1), "%8.5f",
(routelist + i)->lat);
g_snprintf (text2, sizeof (text2), "%8.5f",
(routelist + i)->lon);
g_snprintf (text3, sizeof (text3), "%9.3f",
(routelist + i)->dist);
text[0] = text0;
text[2] = text1;
text[3] = text2;
text[4] = text3;
j = gtk_clist_append (GTK_CLIST (myroutelist),
(gchar **) text);
gtk_clist_set_foreground (GTK_CLIST (myroutelist), j,
&colors.black);
}
}
else
route.items = 0;
tooltips = gtk_tooltips_new ();
gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), create_route2_button,
_
("Create a route from all waypoints. Sorted with order in file, not distance."),
NULL);
gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), select_route_button,
_
("Click here to start your journey. GpsDrive guides you through the waypoints in this list."),
NULL);
gtk_tooltips_set_tip (GTK_TOOLTIPS (tooltips), button,
_("Abort your journey"), NULL);
gtk_widget_show_all (window);
return TRUE;
}
static void
_setup_ui (OlPlayerChooser *window)
{
OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window);
gtk_container_set_border_width (GTK_CONTAINER (window), WINDOW_BORDER_SIZE);
/* Setup info widgets */
priv->info_label = GTK_LABEL (gtk_label_new (NULL));
gtk_label_set_line_wrap (priv->info_label, TRUE);
gtk_misc_set_alignment (GTK_MISC (priv->info_label), 0.0, 0.0);
priv->info_icon = GTK_IMAGE (gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO,
GTK_ICON_SIZE_DIALOG));
GtkWidget *info_box = gtk_hbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (info_box),
GTK_WIDGET (priv->info_icon),
FALSE, /* expand */
FALSE, /* fill */
0);
gtk_box_pack_start (GTK_BOX (info_box),
GTK_WIDGET (priv->info_label),
TRUE, /* expand */
TRUE, /* fill */
0);
/* Setup app choosers */
priv->page_button_panel = GTK_BOX (gtk_hbox_new (FALSE, 0));
priv->chooser_panel = GTK_BOX (gtk_hbox_new (FALSE, 0));
_new_page (window, _("Supported players"));
_new_page (window, _("All players"));
_set_apps_to_page (window,
ALL_CHOOSER_INDEX,
g_app_info_get_all_for_type ("audio/mp3"));
GtkWidget *apps_frame = gtk_frame_new (_("Choose a player to launch"));
GtkBox *page_vbox = GTK_BOX (gtk_vbox_new (FALSE, 0));
gtk_widget_show (GTK_WIDGET (page_vbox));
gtk_box_pack_start (page_vbox,
GTK_WIDGET (priv->page_button_panel),
FALSE, /* expand */
FALSE, /* fill */
0); /* padding */
gtk_box_pack_end (page_vbox,
GTK_WIDGET (priv->chooser_panel),
FALSE, /* expand */
FALSE, /* fill */
0); /* padding */
gtk_container_add (GTK_CONTAINER (apps_frame), GTK_WIDGET (page_vbox));
/* Setup custom command */
priv->custom_cmd_panel = GTK_BOX (gtk_hbox_new (FALSE, 5));
GtkWidget *cmd_label = gtk_label_new (_("Use command:"));
GtkWidget *cmd_entry = gtk_entry_new ();
priv->cmd_entry = GTK_ENTRY (cmd_entry);
gtk_entry_set_activates_default (priv->cmd_entry, TRUE);
gtk_entry_set_completion (priv->cmd_entry, _new_bin_completion ());
GtkWidget *launch_button = gtk_button_new_with_label (_("Launch"));
gtk_widget_set_can_default (launch_button, TRUE);
gtk_window_set_default (GTK_WINDOW (window), launch_button);
priv->launch_button = launch_button;
g_signal_connect (launch_button,
"clicked",
G_CALLBACK (_launch_button_clicked_cb),
window);
gtk_box_pack_start (priv->custom_cmd_panel, cmd_label, FALSE, TRUE, 0);
gtk_box_pack_start (priv->custom_cmd_panel, cmd_entry, TRUE, TRUE, 0);
gtk_box_pack_start (priv->custom_cmd_panel, launch_button, FALSE, TRUE, 0);
GtkWidget *final_hbox = gtk_hbox_new (FALSE, 0);
GtkWidget *remember_button = gtk_check_button_new_with_label (_("Remember my choice"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (remember_button), TRUE);
priv->remember_button = remember_button;
gtk_box_pack_start (GTK_BOX (final_hbox), remember_button, FALSE, TRUE, 0);
/* Setup the whole dialog */
GtkWidget *vbox = gtk_dialog_get_content_area (GTK_DIALOG (window));
gtk_box_set_spacing (GTK_BOX (vbox), 10);
gtk_box_pack_start (GTK_BOX (vbox),
info_box,
FALSE,
FALSE,
0);
gtk_box_pack_start (GTK_BOX (vbox),
apps_frame,
FALSE,
FALSE,
0);
gtk_box_pack_start (GTK_BOX (vbox),
GTK_WIDGET (priv->custom_cmd_panel),
FALSE,
TRUE,
0);
gtk_box_pack_end (GTK_BOX (vbox),
final_hbox,
FALSE,
TRUE,
0);
gtk_widget_show (vbox);
gtk_widget_show_all (info_box);
gtk_widget_show (apps_frame);
gtk_widget_show_all (GTK_WIDGET (priv->page_button_panel));
gtk_widget_show (GTK_WIDGET (priv->chooser_panel));
gtk_widget_show_all (GTK_WIDGET (priv->custom_cmd_panel));
gtk_widget_show_all (GTK_WIDGET (final_hbox));
gtk_dialog_add_button (GTK_DIALOG (window),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE);
gtk_window_set_title (GTK_WINDOW (window), _("Choose a player to launch"));
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
}
static void _admin_resv(GtkTreeModel *model, GtkTreeIter *iter, char *type)
{
resv_desc_msg_t *resv_msg = xmalloc(sizeof(resv_desc_msg_t));
reservation_name_msg_t resv_name_msg;
char *resvid = NULL;
char tmp_char[100];
char *temp = NULL;
int edit_type = 0;
int response = 0;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkWidget *popup = gtk_dialog_new_with_buttons(
type,
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
gtk_window_set_transient_for(GTK_WINDOW(popup), NULL);
gtk_tree_model_get(model, iter, SORTID_NAME, &resvid, -1);
slurm_init_resv_desc_msg(resv_msg);
memset(&resv_name_msg, 0, sizeof(reservation_name_msg_t));
resv_msg->name = xstrdup(resvid);
if (!strcasecmp("Remove Reservation", type)) {
resv_name_msg.name = resvid;
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_YES, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to remove "
"reservation %s?",
resvid);
label = gtk_label_new(tmp_char);
edit_type = EDIT_REMOVE;
} else {
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_window_set_default_size(GTK_WINDOW(popup), 200, 400);
snprintf(tmp_char, sizeof(tmp_char),
"Editing reservation %s think before you type",
resvid);
label = gtk_label_new(tmp_char);
edit_type = EDIT_EDIT;
entry = _admin_full_edit_resv(resv_msg, model, iter);
}
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, FALSE, FALSE, 0);
if (entry)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
entry, TRUE, TRUE, 0);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
switch(edit_type) {
case EDIT_REMOVE:
if (slurm_delete_reservation(&resv_name_msg)
== SLURM_SUCCESS) {
temp = g_strdup_printf(
"Reservation %s removed successfully",
resvid);
} else {
temp = g_strdup_printf(
"Problem removing reservation %s.",
resvid);
}
display_edit_note(temp);
g_free(temp);
break;
case EDIT_EDIT:
if (got_edit_signal)
goto end_it;
if (!global_send_update_msg) {
temp = g_strdup_printf("No change detected.");
} else if (slurm_update_reservation(resv_msg)
== SLURM_SUCCESS) {
temp = g_strdup_printf(
"Reservation %s updated successfully",
resvid);
} else {
temp = g_strdup_printf(
"Problem updating reservation %s.",
resvid);
}
display_edit_note(temp);
g_free(temp);
break;
default:
break;
}
}
end_it:
g_free(resvid);
global_entry_changed = 0;
slurm_free_resv_desc_msg(resv_msg);
gtk_widget_destroy(popup);
if (got_edit_signal) {
type = got_edit_signal;
got_edit_signal = NULL;
_admin_resv(model, iter, type);
xfree(type);
}
return;
}
static void _admin_front_end(GtkTreeModel *model, GtkTreeIter *iter, char *type,
char *node_list)
{
uint16_t state = (uint16_t) NO_VAL;
update_front_end_msg_t front_end_update_msg;
char *new_type = NULL, *reason = NULL;
char tmp_char[100];
char *lower;
int rc;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkWidget *popup = NULL;
if (cluster_flags & CLUSTER_FLAG_FED) {
display_fed_disabled_popup(type);
global_entry_changed = 0;
return;
}
popup = gtk_dialog_new_with_buttons(
type,
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
gtk_window_set_transient_for(GTK_WINDOW(popup), NULL);
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_YES, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
if (!strncasecmp("Drain", type, 5)) {
new_type = "DRAIN";
reason = "\n\nPlease enter reason.";
state = NODE_STATE_DRAIN;
entry = create_entry();
} else if (!strncasecmp("Resume", type, 6)) {
new_type = "RESUME";
reason = "";
state = NODE_RESUME;
}
snprintf(tmp_char, sizeof(tmp_char),
"Are you sure you want to set state of front end node %s "
"to %s?%s", node_list, new_type, reason);
label = gtk_label_new(tmp_char);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, false, false, 0);
if (entry)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
entry, true, true, 0);
gtk_widget_show_all(popup);
rc = gtk_dialog_run (GTK_DIALOG(popup));
slurm_init_update_front_end_msg(&front_end_update_msg);
if (rc == GTK_RESPONSE_OK) {
front_end_update_msg.name = node_list;
front_end_update_msg.node_state = state;
if (entry) {
front_end_update_msg.reason = xstrdup(
gtk_entry_get_text(GTK_ENTRY(entry)));
if (!front_end_update_msg.reason ||
!strlen(front_end_update_msg.reason)) {
lower = g_strdup_printf(
"You need a reason to do that.");
display_edit_note(lower);
g_free(lower);
goto end_it;
}
rc = uid_from_string(getlogin(),
&front_end_update_msg.reason_uid);
if (rc < 0)
front_end_update_msg.reason_uid = getuid();
}
rc = slurm_update_front_end(&front_end_update_msg);
if (rc == SLURM_SUCCESS) {
lower = g_strdup_printf(
"Nodes %s updated successfully.",
node_list);
display_edit_note(lower);
g_free(lower);
} else {
lower = g_strdup_printf(
"Problem updating nodes %s: %s",
node_list, slurm_strerror(rc));
display_edit_note(lower);
g_free(lower);
}
}
end_it:
global_entry_changed = 0;
xfree(front_end_update_msg.reason);
gtk_widget_destroy(popup);
if (got_edit_signal) {
type = got_edit_signal;
got_edit_signal = NULL;
_admin_front_end(model, iter, type, node_list);
xfree(type);
}
return;
}
GtkWidget *create_dir_browser(gchar * title, gchar * current_path, GtkSelectionMode mode, void (*handler) (gchar *))
{
GtkWidget *window, *scroll_win, *tree, *vbox, *bbox, *ok, *cancel,
*sep;
gchar *root_text = "/", *node_text = "dummy";
gchar *currentdir, *pos, *tpath, *tpathnew;
GtkCTreeNode *root_node, *node, *nextnode;
DirNode *dirnode;
gboolean leaf;
#ifdef _GTK2
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
// gtk_window_set_decorated(GTK_WINDOW(window), TRUE);
#else
window = gtk_window_new(GTK_WINDOW_DIALOG);
#endif
gtk_window_set_title(GTK_WINDOW(window), title);
gtk_container_border_width(GTK_CONTAINER(window), 10);
vbox = gtk_vbox_new(FALSE, 10);
gtk_container_add(GTK_CONTAINER(window), vbox);
scroll_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_usize(scroll_win, 250, 200);
gtk_box_pack_start(GTK_BOX(vbox), scroll_win, TRUE, TRUE, 0);
gtk_widget_show(scroll_win);
gtk_widget_realize(window);
if (!folder_pixmap)
{
folder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &folder_mask, NULL, folder);
ofolder_pixmap = gdk_pixmap_create_from_xpm_d(window->window, &ofolder_mask, NULL, ofolder);
}
tree = gtk_ctree_new(1, 0);
gtk_clist_set_column_auto_resize(GTK_CLIST(tree), 0, TRUE);
gtk_clist_set_selection_mode(GTK_CLIST(tree), mode);
gtk_ctree_set_line_style(GTK_CTREE(tree), GTK_CTREE_LINES_DOTTED);
gtk_signal_connect(GTK_OBJECT(tree), "tree_expand", GTK_SIGNAL_FUNC(expand_cb), NULL);
gtk_signal_connect(GTK_OBJECT(tree), "select_row", GTK_SIGNAL_FUNC(select_row_cb), NULL);
gtk_container_add(GTK_CONTAINER(scroll_win), tree);
gtk_object_set_user_data(GTK_OBJECT(tree), (gpointer) handler);
root_node = gtk_ctree_insert_node(GTK_CTREE(tree), NULL, NULL, &root_text, 4, folder_pixmap, folder_mask, ofolder_pixmap, ofolder_mask, FALSE, FALSE);
dirnode = g_malloc0(sizeof (DirNode));
dirnode->path = g_strdup("/");
gtk_ctree_node_set_row_data_full(GTK_CTREE(tree), root_node, dirnode, destroy_cb);
node = gtk_ctree_insert_node(GTK_CTREE(tree), root_node, NULL, &node_text, 4, NULL, NULL, NULL, NULL, TRUE, TRUE);
gtk_ctree_expand(GTK_CTREE(tree), root_node);
gtk_widget_show(tree);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0);
gtk_widget_show(sep);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
ok = gtk_button_new_with_label(tr("Ok"));
gtk_object_set_user_data(GTK_OBJECT(ok), window);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_window_set_default(GTK_WINDOW(window), ok);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(ok_clicked), tree);
gtk_widget_show(ok);
cancel = gtk_button_new_with_label(tr("Cancel"));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(window));
gtk_widget_show(cancel);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
gtk_widget_show(bbox);
gtk_widget_show(vbox);
if (current_path && *current_path)
{
currentdir = g_strdup(current_path);
tpath = g_strdup("/");
pos = strtok(currentdir, "/");
node = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), NULL, "/", filetreeent_compare_func);
do
{
tpathnew = g_strconcat(tpath, pos, "/", NULL);
g_free(tpath);
tpath = tpathnew;
nextnode = gtk_ctree_find_by_row_data_custom(GTK_CTREE(tree), node, tpath, filetreeent_compare_func);
if (!nextnode)
break;
node = nextnode;
pos = strtok(NULL, "/");
gtk_ctree_get_node_info(GTK_CTREE(tree), node, NULL, NULL, NULL, NULL, NULL, NULL, &leaf, NULL);
if (!leaf && pos)
gtk_ctree_expand(GTK_CTREE(tree), node);
else
{
gtk_ctree_select(GTK_CTREE(tree), node);
break;
}
}
while (pos);
g_free(tpath);
g_free(currentdir);
}
else
gtk_ctree_select(GTK_CTREE(tree), root_node);
return window;
}
static Tcolsel *colsel_dialog(Tbfwin *bfwin,const gchar *setcolor, gint modal, gint startpos, gint endpos) {
Tcolsel *csd;
GtkWidget *vbox, *hbox, *but;
GdkColor gcolor;
const gchar *this_color=setcolor;
csd = g_new0(Tcolsel, 1);
/* warning: bfwin might be NULL if this dialog is started by return_color() */
csd->bfwin = bfwin;
csd->is_modal = modal;
csd->startpos = startpos;
csd->endpos = endpos;
csd->returnval = setcolor ? g_strdup(setcolor) : g_strdup("");
DEBUG_MSG("colsel_dialog, malloced at %p, setcolor=%s\n", csd, setcolor);
csd->win = window_full2(_("Bluefish: Select color"), GTK_WIN_POS_CENTER, 12, G_CALLBACK(colsel_destroy_lcb), csd, TRUE, bfwin?bfwin->main_window:NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(csd->win), vbox);
csd->csel = gtk_color_selection_new();
gtk_color_selection_set_has_opacity_control(GTK_COLOR_SELECTION(csd->csel), FALSE);
if (this_color) {
if (gdk_color_parse(this_color, &gcolor)) {
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(csd->csel), &gcolor);
} else {
this_color=NULL;
}
}
gtk_color_selection_set_has_palette(GTK_COLOR_SELECTION(csd->csel), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), csd->csel, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 12);
#if GTK_CHECK_VERSION(3,0,0)
hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
hbox = gtk_hbutton_box_new();
#endif
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 12);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
but = bf_stock_cancel_button(G_CALLBACK(colsel_cancel_clicked_lcb), csd);
gtk_box_pack_start(GTK_BOX(hbox), but, TRUE, TRUE, 0);
but = bf_stock_ok_button(G_CALLBACK(colsel_ok_clicked_lcb), csd);
gtk_window_set_default(GTK_WINDOW(csd->win), but);
gtk_box_pack_start(GTK_BOX(hbox), but, TRUE, TRUE, 0);
if (bfwin && bfwin->session->colorlist) {
GtkSettings* gtksettings;
/* Note that this function can only be called when the GtkWidget is attached to a toplevel, since the settings object is specific to a particular GdkScreen. */
gtksettings = gtk_widget_get_settings(GTK_WIDGET(csd->csel));
if (gtksettings) {
gchar *strings;
DEBUG_MSG("pallette list=%d\n",g_list_length(bfwin->session->colorlist));
bfwin->session->colorlist = limit_stringlist(bfwin->session->colorlist, 20, TRUE);
DEBUG_MSG("pallette list=%d\n",g_list_length(bfwin->session->colorlist));
strings = stringlist_to_string(bfwin->session->colorlist, ":");
strings[strlen(strings)-1] = '\0';
/* this property may contain max 20 colors, otherwise gtk will crash */
g_object_set(G_OBJECT(gtksettings), "gtk-color-palette", strings, NULL);
g_free(strings);
}
/* DEBUG_MSG("colsel_dialog, setting palette from %s\n", strings);
if (gtk_color_selection_palette_from_string(strings, &gcolorarr, &num)) {
DEBUG_MSG("num=%d, gcolorarr=%p\n",num,gcolorarr);
} else {
DEBUG_MSG("hmm, failed to parse our string :(\n");
} */
}
gtk_widget_show_all(csd->win);
DEBUG_MSG("colsel_dialog, finished\n");
return csd;
}
static void
gdict_applet_build_window (GdictApplet *applet)
{
GdictAppletPrivate *priv = applet->priv;
GtkWidget *window;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *bbox;
GtkWidget *button;
if (!priv->entry)
{
g_warning ("No entry widget defined");
return;
}
window = gdict_aligned_window_new (priv->toggle);
g_signal_connect (window, "key-press-event",
G_CALLBACK (window_key_press_event_cb),
applet);
g_signal_connect (window, "show",
G_CALLBACK (window_show_cb),
applet);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (window), frame);
gtk_widget_show (frame);
priv->frame = frame;
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
priv->defbox = gdict_defbox_new ();
if (priv->context)
gdict_defbox_set_context (GDICT_DEFBOX (priv->defbox), priv->context);
gtk_box_pack_start (GTK_BOX (vbox), priv->defbox, TRUE, TRUE, 0);
gtk_widget_show (priv->defbox);
gtk_widget_set_can_focus (priv->defbox, TRUE);
gtk_widget_set_can_default (priv->defbox, TRUE);
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (bbox), 6);
gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
gtk_widget_show (bbox);
button = gtk_button_new_from_stock (GTK_STOCK_CLEAR);
gtk_widget_set_tooltip_text (button, _("Clear the definitions found"));
set_atk_name_description (button,
_("Clear definition"),
_("Clear the text of the definition"));
g_signal_connect (button, "clicked", G_CALLBACK (clear_cb), applet);
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = gtk_button_new_from_stock (GTK_STOCK_PRINT);
gtk_widget_set_tooltip_text (button, _("Print the definitions found"));
set_atk_name_description (button,
_("Print definition"),
_("Print the text of the definition"));
g_signal_connect (button, "clicked", G_CALLBACK (print_cb), applet);
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
gtk_widget_set_tooltip_text (button, _("Save the definitions found"));
set_atk_name_description (button,
_("Save definition"),
_("Save the text of the definition to a file"));
g_signal_connect (button, "clicked", G_CALLBACK (save_cb), applet);
gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
gtk_window_set_default (GTK_WINDOW (window), priv->defbox);
priv->window = window;
priv->is_window_showing = FALSE;
}
void InternetGo (void)
{
if ((ifilestuff == 0) && (inet == 0))
{
shost = gtk_entry_get_text (GTK_ENTRY (connectentry1));
theaddress = atoaddr (shost);
iport = atoi (gtk_entry_get_text (GTK_ENTRY (connectentry2)));
gtk_widget_destroy (connectwindow);
iyesno = 0;
bzero ((char *) &host_addr, sizeof (host_addr));
host_addr.sin_family = AF_INET;
host_addr.sin_addr.s_addr = inet_addr (inet_ntoa (*theaddress));
host_addr.sin_port = htons (iport);
if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0)
{
Message ("Unable to open socket.", 3, 0);
}
itheerror = connect (sockfd, (struct sockaddr *) &host_addr, sizeof
(host_addr));
if (itheerror < 0)
{
sprintf (serrortemp, "Unable to connect to host (%s).", strerror
(errno));
Message (serrortemp, 3, 0);
}
else
{
fcntl (sockfd, F_SETFL, O_NONBLOCK);
biscomputer = 0;
sprintf (bplayername, "%s", "unknown");
wiscomputer = 0;
sprintf (wplayername, "%s", "unknown");
StatusBar ();
if (ichangestuff == 0)
{
Play ("open.mp3", 0);
}
internetwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (internetwindow), "Internet window");
gtk_signal_connect (GTK_OBJECT (internetwindow), "delete_event",
GTK_SIGNAL_FUNC (CloseSocket), NULL);
gtk_window_set_policy (GTK_WINDOW (internetwindow), 0, 0, 1);
gtk_container_border_width (GTK_CONTAINER (internetwindow), 0);
gtk_widget_realize (internetwindow);
internetbox1 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (internetbox1), 0);
gtk_container_add (GTK_CONTAINER (internetwindow), internetbox1);
gtk_widget_show (internetbox1);
internetbox2 = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (internetbox2), 0);
gtk_box_pack_start (GTK_BOX (internetbox1), internetbox2, TRUE, TRUE, 5);
gtk_widget_show (internetbox2);
internetbox3 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (internetbox3), 0);
gtk_box_pack_start (GTK_BOX (internetbox2), internetbox3, TRUE, TRUE, 0);
gtk_widget_show (internetbox3);
internettable1 = gtk_table_new (2, 1, FALSE);
gtk_widget_show (internettable1);
gtk_box_pack_start (GTK_BOX (internetbox3), internettable1, TRUE, TRUE,
0);
internettable2 = gtk_table_new (2, 3, FALSE);
gtk_widget_show (internettable2);
gtk_box_pack_start (GTK_BOX (internetbox3), internettable2, TRUE, TRUE,
0);
text = gtk_text_new (NULL, NULL);
gtk_widget_set_usize (text, 535, 266);
gtk_text_set_editable (GTK_TEXT (text), FALSE);
gtk_table_attach (GTK_TABLE (internettable1), text, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0);
gtk_widget_show (text);
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
adj = (GTK_TEXT (text))->vadj;
gtk_table_attach (GTK_TABLE (internettable1), vscrollbar, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0);
gtk_widget_show (vscrollbar);
cmap = gdk_colormap_get_system ();
color.red = 0xffff;
color.green = 0;
color.blue = 0;
if (!gdk_color_alloc (cmap, &color))
{
Message ("Could not allocate color.", 3, 0);
}
gtk_widget_realize (text);
wrapcheck = gtk_check_button_new_with_label ("wrap");
gtk_table_attach (GTK_TABLE (internettable2), wrapcheck, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 5, 10);
gtk_signal_connect (GTK_OBJECT (wrapcheck), "toggled",
GTK_SIGNAL_FUNC (ToggleWrap), text);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wrapcheck), FALSE);
gtk_widget_show (wrapcheck);
internetentry = gtk_entry_new_with_max_length (50);
gtk_signal_connect (GTK_OBJECT (internetentry), "activate",
GTK_SIGNAL_FUNC (SendData), NULL);
gtk_table_attach (GTK_TABLE (internettable2), internetentry, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 10);
gtk_widget_grab_focus (internetentry);
gtk_widget_show (internetentry);
inetsep = gtk_hseparator_new ();
gtk_table_attach (GTK_TABLE (internettable2), inetsep, 0, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (inetsep);
inetbutton = gtk_button_new_with_label ("Disconnect");
gtk_signal_connect (GTK_OBJECT (inetbutton), "clicked",
GTK_SIGNAL_FUNC (CloseSocket), NULL);
GTK_WIDGET_SET_FLAGS (inetbutton, GTK_CAN_DEFAULT);
gtk_window_set_default (GTK_WINDOW (internetwindow), inetbutton);
gtk_table_attach (GTK_TABLE (internettable2), inetbutton, 0, 2, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 2, 2);
gtk_widget_show (inetbutton);
gtk_widget_show (internetwindow);
inet = 1;
ReceiveData ();
}
}
}
extern void change_refresh_popup(GtkAction *action, gpointer user_data)
{
GtkWidget *table = gtk_table_new(1, 2, FALSE);
GtkWidget *label = NULL;
GtkObject *adjustment = gtk_adjustment_new(
working_sview_config.refresh_delay,
1, 10000,
5, 60,
0);
GtkWidget *spin_button =
gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
GtkWidget *popup = gtk_dialog_new_with_buttons(
"Refresh Interval",
GTK_WINDOW (user_data),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
GError *error = NULL;
int response = 0;
char *temp = NULL;
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
label = gtk_label_new("Interval in Seconds ");
gtk_container_set_border_width(GTK_CONTAINER(table), 10);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
table, FALSE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), spin_button, 1, 2, 0, 1);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
working_sview_config.refresh_delay =
gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(spin_button));
temp = g_strdup_printf("Refresh Interval set to %d seconds.",
working_sview_config.refresh_delay);
gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar),
STATUS_REFRESH);
response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar),
STATUS_REFRESH,
temp);
g_free(temp);
if (!g_thread_create(_refresh_thr, GINT_TO_POINTER(response),
FALSE, &error)) {
g_printerr ("Failed to create refresh thread: %s\n",
error->message);
}
}
gtk_widget_destroy(popup);
return;
}
extern void create_create_popup(GtkAction *action, gpointer user_data)
{
GtkWidget *popup = gtk_dialog_new_with_buttons(
"Create",
GTK_WINDOW(user_data),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
int i, response = 0;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkTreeModel *model = NULL;
GtkTreeIter iter;
const gchar *name = gtk_action_get_name(action);
sview_search_info_t sview_search_info;
job_desc_msg_t *job_msg = NULL;
submit_response_msg_t *slurm_alloc_msg = NULL;
update_part_msg_t *part_msg = NULL;
resv_desc_msg_t *resv_msg = NULL;
char *res_name, *temp;
sview_search_info.gchar_data = NULL;
sview_search_info.int_data = NO_VAL;
sview_search_info.int_data2 = NO_VAL;
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_window_set_default_size(GTK_WINDOW(popup), 400, 600);
if (!strcmp(name, "batch_job")) {
sview_search_info.search_type = CREATE_BATCH_JOB;
entry = create_entry();
label = gtk_label_new(
"Batch job submission specifications\n\n"
"Specify size (task and/or node count) plus the\n"
"script. All other fields are optional.\n\n"
"More fields will be made available later.");
job_msg = xmalloc(sizeof(job_desc_msg_t));
slurm_init_job_desc_msg(job_msg);
job_msg->group_id = getgid();
job_msg->user_id = getuid();
job_msg->work_dir = xmalloc(1024);
if (!getcwd(job_msg->work_dir, 1024))
goto end_it;
entry = create_job_entry(job_msg, model, &iter);
} else if (!strcmp(name, "partition")) {
sview_search_info.search_type = CREATE_PARTITION;
entry = create_entry();
label = gtk_label_new(
"Partition creation specifications\n\n"
"Specify Name. All other fields are optional.");
part_msg = xmalloc(sizeof(update_part_msg_t));
slurm_init_part_desc_msg(part_msg);
entry = create_part_entry(part_msg, model, &iter);
} else if (!strcmp(name, "reservation")) {
sview_search_info.search_type = CREATE_RESERVATION;
label = gtk_label_new(
"Reservation creation specifications\n\n"
"Specify Time_Start and either Duration or Time_End.\n"
#ifdef HAVE_BG
"Specify either Node_Count or Midplane_List.\n"
#else
"Specify either Node_Count or Node_List.\n"
#endif
"Specify either Accounts or Users.\n\n"
"Supported Flags include: Maintenance, Overlap,\n"
"Ignore_Jobs, Daily and Weekly, License_Only\n"
"and Static_Alloc.\n"
"All other fields are optional.");
resv_msg = xmalloc(sizeof(resv_desc_msg_t));
slurm_init_resv_desc_msg(resv_msg);
entry = create_resv_entry(resv_msg, model, &iter);
} else {
sview_search_info.search_type = 0;
goto end_it;
}
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
entry, TRUE, TRUE, 0);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
if (!sview_search_info.search_type)
goto end_it;
switch(sview_search_info.search_type) {
case CREATE_BATCH_JOB:
response = slurm_submit_batch_job(job_msg,
&slurm_alloc_msg);
if (response == SLURM_SUCCESS) {
temp = g_strdup_printf(
"Job %u submitted",
slurm_alloc_msg->job_id);
} else {
temp = g_strdup_printf(
"Problem submitting job: %s",
slurm_strerror(slurm_get_errno()));
}
display_edit_note(temp);
g_free(temp);
break;
case CREATE_PARTITION:
response = slurm_create_partition(part_msg);
if (response == SLURM_SUCCESS) {
temp = g_strdup_printf("Partition %s created",
part_msg->name);
} else {
temp = g_strdup_printf(
"Problem creating partition: %s",
slurm_strerror(slurm_get_errno()));
}
display_edit_note(temp);
g_free(temp);
break;
case CREATE_RESERVATION:
res_name = slurm_create_reservation(resv_msg);
if (res_name) {
temp = g_strdup_printf(
"Reservation %s created",
res_name);
free(res_name);
} else {
temp = g_strdup_printf(
"Problem creating reservation: %s",
slurm_strerror(slurm_get_errno()));
}
display_edit_note(temp);
g_free(temp);
break;
default:
break;
}
}
end_it:
gtk_widget_destroy(popup);
if (slurm_alloc_msg)
slurm_free_submit_response_response_msg(slurm_alloc_msg);
if (job_msg) {
for (i = 0; i < job_msg->argc; i++)
xfree(job_msg->argv[i]);
xfree(job_msg->argv);
xfree(job_msg->name);
xfree(job_msg->script);
xfree(job_msg->work_dir);
xfree(job_msg);
}
xfree(part_msg);
if (resv_msg)
slurm_free_resv_desc_msg(resv_msg);
return;
}
void Internet (void)
{
if ((ifilestuff == 0) && ((biscomputer == 0) || (wiscomputer == 0))
&& (iyesno == 0) && (inet == 0))
{
connectwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (connectwindow), "Internet play");
gtk_signal_connect (GTK_OBJECT (connectwindow), "delete_event",
GTK_SIGNAL_FUNC (DestroyConnect), NULL);
gtk_window_set_policy (GTK_WINDOW (connectwindow), 0, 0, 1);
gtk_container_border_width (GTK_CONTAINER (connectwindow), 0);
gtk_widget_realize (connectwindow);
connectbox1 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (connectbox1), 0);
gtk_container_add (GTK_CONTAINER (connectwindow), connectbox1);
gtk_widget_show (connectbox1);
connectbox2 = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (connectbox2), 0);
gtk_box_pack_start (GTK_BOX (connectbox1), connectbox2, FALSE, FALSE, 0);
gtk_widget_show (connectbox2);
connecttable1 = gtk_table_new (2, 4, FALSE);
gtk_box_pack_start (GTK_BOX (connectbox2), connecttable1, TRUE, TRUE, 0);
gtk_widget_show (connecttable1);
entrylabel1 = gtk_label_new ("host:");
gtk_label_set (GTK_LABEL (entrylabel1), "host:");
gtk_label_set_justify (GTK_LABEL (entrylabel1), GTK_JUSTIFY_CENTER);
gtk_table_attach (GTK_TABLE (connecttable1), entrylabel1, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 10, 10);
gtk_widget_show (entrylabel1);
connectentry1 = gtk_entry_new_with_max_length (50);
gtk_entry_set_text (GTK_ENTRY (connectentry1), "nngs.cosmic.org");
gtk_entry_select_region (GTK_ENTRY (connectentry1), 0,
GTK_ENTRY (connectentry1)->text_length);
gtk_table_attach (GTK_TABLE (connecttable1), connectentry1, 1, 2, 0, 1,
GTK_EXPAND, GTK_EXPAND, 0, 10);
gtk_widget_grab_focus (connectentry1);
gtk_widget_show (connectentry1);
entrylabel2 = gtk_label_new ("port:");
gtk_label_set (GTK_LABEL (entrylabel2), "port:");
gtk_label_set_justify (GTK_LABEL (entrylabel2), GTK_JUSTIFY_CENTER);
gtk_table_attach (GTK_TABLE (connecttable1), entrylabel2, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 10, 10);
gtk_widget_show (entrylabel2);
connectentry2 = gtk_entry_new_with_max_length (5);
gtk_entry_set_text (GTK_ENTRY (connectentry2), "9696");
gtk_table_attach (GTK_TABLE (connecttable1), connectentry2, 1, 2, 1, 2,
GTK_EXPAND, GTK_EXPAND, 0, 10);
gtk_widget_show (connectentry2);
connectsep = gtk_hseparator_new ();
gtk_table_attach (GTK_TABLE (connecttable1), connectsep, 0, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (connectsep);
connectbutton = gtk_button_new_with_label ("Connect");
gtk_signal_connect (GTK_OBJECT (connectbutton), "clicked",
GTK_SIGNAL_FUNC (InternetGo), NULL);
GTK_WIDGET_SET_FLAGS (connectbutton, GTK_CAN_DEFAULT);
gtk_window_set_default (GTK_WINDOW (connectwindow), connectbutton);
gtk_table_attach (GTK_TABLE (connecttable1), connectbutton, 0, 2, 3, 4,
GTK_FILL, GTK_FILL, 2, 2);
gtk_widget_show (connectbutton);
gtk_widget_show (connectwindow);
iyesno = 1;
}
}
/**
* dialog_init:
* @state:
*
* Create the dialog (guru).
*
**/
static gboolean
dialog_goto_init (GotoState *state)
{
GtkTable *table;
GtkWidget *scrolled;
GtkTreeViewColumn *column;
table = GTK_TABLE (go_gtk_builder_get_widget (state->gui, "names"));
state->goto_text = GTK_ENTRY (gtk_entry_new ());
gtk_table_attach (table, GTK_WIDGET (state->goto_text),
0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, 0,
0, 0);
g_signal_connect_after (G_OBJECT (state->goto_text),
"changed",
G_CALLBACK (cb_dialog_goto_update_sensitivity), state);
state->spin_rows = GTK_SPIN_BUTTON
(go_gtk_builder_get_widget (state->gui, "spin-rows"));
state->spin_cols = GTK_SPIN_BUTTON
(go_gtk_builder_get_widget (state->gui, "spin-columns"));
/* Set-up treeview */
scrolled = go_gtk_builder_get_widget (state->gui, "scrolled");
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_ETCHED_IN);
state->model = gtk_tree_store_new (NUM_COLMNS, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER,
G_TYPE_POINTER);
state->treeview = GTK_TREE_VIEW (
gtk_tree_view_new_with_model (GTK_TREE_MODEL (state->model)));
state->selection = gtk_tree_view_get_selection (state->treeview);
gtk_tree_selection_set_mode (state->selection, GTK_SELECTION_BROWSE);
g_signal_connect (state->selection,
"changed",
G_CALLBACK (cb_dialog_goto_selection_changed), state);
column = gtk_tree_view_column_new_with_attributes (_("Sheet"),
gtk_cell_renderer_text_new (),
"text", SHEET_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (column, SHEET_NAME);
gtk_tree_view_append_column (state->treeview, column);
column = gtk_tree_view_column_new_with_attributes (_("Cell"),
gtk_cell_renderer_text_new (),
"text", ITEM_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (column, ITEM_NAME);
gtk_tree_view_append_column (state->treeview, column);
gtk_tree_view_set_headers_visible (state->treeview, TRUE);
gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (state->treeview));
dialog_goto_load_names (state);
/* Finished set-up of treeview */
/* Listen for sheet changes */
state->sheet_order_changed_listener = g_signal_connect (G_OBJECT (state->wb),
"sheet_order_changed", G_CALLBACK (cb_sheet_order_changed),
state);
state->sheet_added_listener = g_signal_connect (G_OBJECT (state->wb),
"sheet_added", G_CALLBACK (cb_sheet_added),
state);
state->sheet_deleted_listener = g_signal_connect (G_OBJECT (state->wb),
"sheet_deleted", G_CALLBACK (cb_sheet_deleted),
state);
state->close_button = go_gtk_builder_get_widget (state->gui, "close_button");
g_signal_connect (G_OBJECT (state->close_button),
"clicked",
G_CALLBACK (cb_dialog_goto_close_clicked), state);
state->go_button = go_gtk_builder_get_widget (state->gui, "go_button");
g_signal_connect (G_OBJECT (state->go_button),
"clicked",
G_CALLBACK (cb_dialog_goto_go_clicked), state);
gtk_window_set_default (GTK_WINDOW (state->dialog), state->go_button);
gnumeric_init_help_button (
go_gtk_builder_get_widget (state->gui, "help_button"),
GNUMERIC_HELP_LINK_GOTO_CELL);
dialog_goto_load_selection (state);
wbc_gtk_attach_guru (state->wbcg, state->dialog);
g_object_set_data_full (G_OBJECT (state->dialog),
"state", state, (GDestroyNotify) cb_dialog_goto_free);
return FALSE;
}
extern void create_search_popup(GtkAction *action, gpointer user_data)
{
GtkWidget *popup = gtk_dialog_new_with_buttons(
"Search",
GTK_WINDOW(user_data),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
int response = 0;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkTreeModel *model = NULL;
GtkTreeIter iter;
const gchar *name = gtk_action_get_name(action);
sview_search_info_t sview_search_info;
sview_search_info.gchar_data = NULL;
sview_search_info.int_data = NO_VAL;
sview_search_info.int_data2 = NO_VAL;
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
if (!strcmp(name, "jobid")) {
sview_search_info.search_type = SEARCH_JOB_ID;
entry = create_entry();
label = gtk_label_new("Which job id?");
} else if (!strcmp(name, "user_jobs")) {
sview_search_info.search_type = SEARCH_JOB_USER;
entry = create_entry();
label = gtk_label_new("Which user?");
} else if (!strcmp(name, "state_jobs")) {
display_data_t pulldown_display_data[] = {
{G_TYPE_NONE, JOB_PENDING, "Pending", TRUE, -1},
{G_TYPE_NONE, JOB_CONFIGURING, "Configuring", TRUE, -1},
{G_TYPE_NONE, JOB_RUNNING, "Running", TRUE, -1},
{G_TYPE_NONE, JOB_SUSPENDED, "Suspended", TRUE, -1},
{G_TYPE_NONE, JOB_COMPLETE, "Complete", TRUE, -1},
{G_TYPE_NONE, JOB_CANCELLED, "Cancelled", TRUE, -1},
{G_TYPE_NONE, JOB_FAILED, "Failed", TRUE, -1},
{G_TYPE_NONE, JOB_TIMEOUT, "Timeout", TRUE, -1},
{G_TYPE_NONE, JOB_NODE_FAIL, "Node Failure", TRUE, -1},
{G_TYPE_NONE, JOB_PREEMPTED, "Preempted", TRUE, -1},
{G_TYPE_NONE, -1, NULL, FALSE, -1}
};
sview_search_info.search_type = SEARCH_JOB_STATE;
entry = create_pulldown_combo(pulldown_display_data, JOB_END);
label = gtk_label_new("Which state?");
} else if (!strcmp(name, "partition_name")) {
sview_search_info.search_type = SEARCH_PARTITION_NAME;
entry = create_entry();
label = gtk_label_new("Which partition");
} else if (!strcmp(name, "partition_state")) {
display_data_t pulldown_display_data[] = {
{G_TYPE_NONE, PARTITION_UP, "Up", TRUE, -1},
{G_TYPE_NONE, PARTITION_DOWN, "Down", TRUE, -1},
{G_TYPE_NONE, PARTITION_INACTIVE, "Inactive", TRUE, -1},
{G_TYPE_NONE, PARTITION_DRAIN, "Drain", TRUE, -1},
{G_TYPE_NONE, -1, NULL, FALSE, -1}
};
sview_search_info.search_type = SEARCH_PARTITION_STATE;
entry = create_pulldown_combo(pulldown_display_data, 5);
label = gtk_label_new("Which state?");
} else if (!strcmp(name, "node_name")) {
sview_search_info.search_type = SEARCH_NODE_NAME;
entry = create_entry();
if (cluster_flags & CLUSTER_FLAG_BG)
label = gtk_label_new("Which Midplane(s)?\n"
"(ranged or comma separated)");
else
label = gtk_label_new("Which node(s)?\n"
"(ranged or comma separated)");
} else if (!strcmp(name, "node_state")) {
display_data_t pulldown_display_data[] = {
{G_TYPE_NONE, NODE_STATE_DOWN, "Down", TRUE, -1},
{G_TYPE_NONE, NODE_STATE_ALLOCATED | NODE_STATE_DRAIN,
"Draining", TRUE, -1},
{G_TYPE_NONE, NODE_STATE_IDLE | NODE_STATE_DRAIN,
"Drained", TRUE, -1},
{G_TYPE_NONE, NODE_STATE_IDLE, "Idle", TRUE, -1},
{G_TYPE_NONE, NODE_STATE_ALLOCATED, "Allocated",
TRUE, -1},
{G_TYPE_NONE, NODE_STATE_ERROR, "Error", TRUE, -1},
{G_TYPE_NONE, NODE_STATE_MIXED, "Mixed", TRUE, -1},
{G_TYPE_NONE, NODE_STATE_COMPLETING, "Completing",
TRUE, -1},
{G_TYPE_NONE, NODE_STATE_UNKNOWN, "Unknown", TRUE, -1},
{G_TYPE_NONE, -1, NULL, FALSE, -1}
};
sview_search_info.search_type = SEARCH_NODE_STATE;
entry = create_pulldown_combo(pulldown_display_data, PAGE_CNT);
label = gtk_label_new("Which state?");
} else if ((cluster_flags & CLUSTER_FLAG_BG)
&& !strcmp(name, "bg_block_name")) {
sview_search_info.search_type = SEARCH_BLOCK_NAME;
entry = create_entry();
label = gtk_label_new("Which block?");
} else if ((cluster_flags & CLUSTER_FLAG_BG)
&& !strcmp(name, "bg_block_size")) {
sview_search_info.search_type = SEARCH_BLOCK_SIZE;
entry = create_entry();
label = gtk_label_new("Which block size?");
} else if (!strcmp(name, "bg_block_state")) {
display_data_t pulldown_display_data[] = {
{G_TYPE_NONE, BG_BLOCK_NAV, "Nav", TRUE, -1},
{G_TYPE_NONE, BG_BLOCK_FREE, "Free", TRUE, -1},
{G_TYPE_NONE, BG_BLOCK_BUSY, NULL, TRUE, -1},
{G_TYPE_NONE, BG_BLOCK_BOOTING, "Booting", TRUE, -1},
{G_TYPE_NONE, BG_BLOCK_REBOOTING, NULL, TRUE, -1},
{G_TYPE_NONE, BG_BLOCK_INITED, "Inited", TRUE, -1},
{G_TYPE_NONE, BG_BLOCK_ALLOCATED, NULL, TRUE, -1},
{G_TYPE_NONE, BG_BLOCK_TERM, "Terminating", TRUE, -1},
{G_TYPE_NONE, BG_BLOCK_ERROR_FLAG, "Error", TRUE, -1},
{G_TYPE_NONE, -1, NULL, FALSE, -1}
};
display_data_t *display_data = pulldown_display_data;
while (display_data++) {
if (display_data->id == -1)
break;
if (cluster_flags & CLUSTER_FLAG_BGL) {
switch(display_data->id) {
case BG_BLOCK_BUSY:
display_data->name = "Busy";
break;
}
} else if (cluster_flags & CLUSTER_FLAG_BGP){
switch(display_data->id) {
case BG_BLOCK_REBOOTING:
display_data->name = "Rebooting";
break;
}
} else {
switch(display_data->id) {
case BG_BLOCK_ALLOCATED:
display_data->name = "Allocated";
break;
}
}
}
sview_search_info.search_type = SEARCH_BLOCK_STATE;
entry = create_pulldown_combo(pulldown_display_data, PAGE_CNT);
label = gtk_label_new("Which state?");
} else if (!strcmp(name, "reservation_name")) {
sview_search_info.search_type = SEARCH_RESERVATION_NAME;
entry = create_entry();
label = gtk_label_new("Which reservation");
} else {
sview_search_info.search_type = 0;
goto end_it;
}
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
entry, FALSE, FALSE, 0);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
if (!sview_search_info.search_type)
goto end_it;
switch(sview_search_info.search_type) {
case SEARCH_BLOCK_STATE:
case SEARCH_JOB_STATE:
case SEARCH_NODE_STATE:
case SEARCH_PARTITION_STATE:
if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(entry),
&iter)) {
g_print("nothing selected\n");
return;
}
model = gtk_combo_box_get_model(GTK_COMBO_BOX(entry));
if (!model) {
g_print("nothing selected\n");
return;
}
gtk_tree_model_get(model, &iter, 0,
&sview_search_info.int_data, -1);
break;
case SEARCH_JOB_ID:
case SEARCH_JOB_USER:
case SEARCH_BLOCK_NAME:
case SEARCH_BLOCK_SIZE:
case SEARCH_PARTITION_NAME:
case SEARCH_NODE_NAME:
case SEARCH_RESERVATION_NAME:
sview_search_info.gchar_data =
g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
break;
default:
break;
}
_search_entry(&sview_search_info);
}
end_it:
gtk_widget_destroy(popup);
return;
}
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);
#ifdef POLYMER
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 0);
#else
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 7);
#endif
// 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);
}
#ifdef POLYMER
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
#else
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, (GtkAttachOptions)0, 4, 7);
#endif
// Fullscreen checkbox
stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0);
#ifdef POLYMER
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 0);
#else
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 7);
#endif
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, (GtkAttachOptions)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,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)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, (GtkAttachOptions)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,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)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, (GtkAttachOptions)0,
(GtkAttachOptions)(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, (GtkAttachOptions)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, (GtkAttachOptions)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;
}
extern void change_grid_popup(GtkAction *action, gpointer user_data)
{
GtkWidget *table = gtk_table_new(1, 2, FALSE);
GtkWidget *label;
GtkObject *adjustment;
GtkWidget *width_sb, *hori_sb, *vert_sb;
int width = working_sview_config.grid_x_width,
hori = working_sview_config.grid_hori,
vert = working_sview_config.grid_vert;
GtkWidget *popup = gtk_dialog_new_with_buttons(
"Grid Properties",
GTK_WINDOW (user_data),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
GError *error = NULL;
int response = 0;
char *temp = NULL;
label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
table, FALSE, FALSE, 0);
label = gtk_label_new("Nodes in row ");
adjustment = gtk_adjustment_new(working_sview_config.grid_x_width,
1, 1000, 1, 60, 0);
width_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
gtk_container_set_border_width(GTK_CONTAINER(table), 10);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), width_sb, 1, 2, 0, 1);
label = gtk_label_new("Nodes before horizontal break ");
adjustment = gtk_adjustment_new(working_sview_config.grid_hori,
1, 1000, 1, 60, 0);
hori_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
gtk_container_set_border_width(GTK_CONTAINER(table), 10);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(table), hori_sb, 1, 2, 1, 2);
label = gtk_label_new("Nodes before vertical break ");
adjustment = gtk_adjustment_new(working_sview_config.grid_vert,
1, 1000, 1, 60, 0);
vert_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
gtk_container_set_border_width(GTK_CONTAINER(table), 10);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(table), vert_sb, 1, 2, 2, 3);
/*TODO
* do we care about this?
label = gtk_label_new("Topology ordered ");
adjustment = gtk_adjustment_new(working_sview_config.grid_topological,
1, 1000, 1, 60, 0);
GtkWidget *gtbtton = gtk_check_button_new ();
gtk_container_set_border_width(GTK_CONTAINER(table), 10);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(table), gtbtton, 1, 2, 3, 4);
gtk_toggle_button_set_active (>btton,
working_sview_config.grid_topological);
*/
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
working_sview_config.grid_x_width =
gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(width_sb));
working_sview_config.grid_hori =
gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(hori_sb));
working_sview_config.grid_vert =
gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(vert_sb));
memcpy(&default_sview_config, &working_sview_config,
sizeof(sview_config_t));
if ((width == working_sview_config.grid_x_width)
&& (hori == working_sview_config.grid_hori)
&& (vert == working_sview_config.grid_vert)) {
temp = g_strdup_printf("Grid: Nothing changed.");
} else if (working_sview_config.grid_topological) {
temp = g_strdup_printf("Grid: Invalid mode .."
" switch to non-topology "
"order first.");
} else {
bool refresh = 0;
temp = g_strdup_printf(
"Grid set to %d nodes breaks "
"at %d H and %d V.",
working_sview_config.grid_x_width,
working_sview_config.grid_hori,
working_sview_config.grid_vert);
/* If the old width was wider than the
* current we need to remake the list so the
* table gets set up correctly, so destroy it
* here and it will be remade in get_system_stats(). */
if ((width > working_sview_config.grid_x_width)
&& grid_button_list) {
list_destroy(grid_button_list);
grid_button_list = NULL;
refresh = 1;
}
get_system_stats(main_grid_table);
if (refresh)
refresh_main(NULL, NULL);
}
gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar),
STATUS_REFRESH);
response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar),
STATUS_REFRESH,
temp);
g_free(temp);
if (!g_thread_create(_refresh_thr, GINT_TO_POINTER(response),
FALSE, &error)) {
g_printerr ("Failed to create refresh thread: %s\n",
error->message);
}
}
gtk_widget_destroy(popup);
return;
}
void
fallback_dialog_show (Defaults* d,
const gchar* sender,
const gchar* app_name,
int id,
const gchar* title_text,
const gchar* _body_message,
gchar** actions)
{
GtkWidget* dialog;
GtkWidget* hbox;
GtkWidget* vbox;
GtkWidget* title;
GtkWidget* body;
GtkWidget* image;
gchar* body_message = NULL;
gchar* new_body_message = NULL;
guint gap = EM2PIXELS (defaults_get_margin_size (d), d);
gboolean success = FALSE;
GError* error = NULL;
if (!IS_DEFAULTS (d) ||
!sender ||
!app_name ||
!title_text ||
!_body_message ||
!actions)
return;
DialogInfo* dialog_info = g_new0 (DialogInfo, 1);
if (!dialog_info)
return;
dialog_info->id = id;
dialog_info->sender = g_strdup(sender);
dialog = gtk_dialog_new ();
hbox = g_object_new (GTK_TYPE_HBOX,
"spacing", gap,
"border-width", 12,
NULL);
// We deliberately use the gtk-dialog-warning icon rather than
// the specified one to discourage people from trying to use
// the notification system as a way of showing custom alert
// dialogs.
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
vbox = g_object_new (GTK_TYPE_VBOX,
NULL);
title = gtk_label_new (NULL);
gtk_label_set_text (GTK_LABEL (title), title_text);
gtk_label_set_line_wrap (GTK_LABEL (title), TRUE);
body = gtk_label_new (NULL);
body_message = filter_text (_body_message);
if (body_message)
{
success = pango_parse_markup (body_message,
-1,
0,
NULL,
&new_body_message,
NULL,
&error);
if (error && !success)
{
g_warning ("fallback_dialog_show(): Got error \"%s\"\n",
error->message);
g_error_free (error);
error = NULL;
}
}
if (new_body_message)
{
gtk_label_set_text (GTK_LABEL (body), new_body_message);
g_free (new_body_message);
}
else
gtk_label_set_text (GTK_LABEL (body), body_message);
g_free (body_message);
gtk_label_set_line_wrap (GTK_LABEL (body), TRUE);
gtk_misc_set_alignment (GTK_MISC (title), 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), title, TRUE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (body), 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), body, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
gtk_container_add (GTK_CONTAINER (
gtk_dialog_get_content_area (
GTK_DIALOG (dialog))),
hbox);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 2);
gtk_window_set_position (GTK_WINDOW (dialog),
GTK_WIN_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (dialog),
EM2PIXELS (defaults_get_bubble_width (d) * 1.2f, d),
-1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (dialog), app_name);
gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE);
// is it a bad notification with actions?
if (actions[0] != NULL)
add_pathological_action_buttons (dialog, actions);
GtkButton *cancel = GTK_BUTTON (
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL));
g_signal_connect_swapped (G_OBJECT (cancel),
"button-release-event",
G_CALLBACK (handle_close),
dialog);
gtk_widget_set_can_default(GTK_WIDGET(cancel), FALSE);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (handle_close),
dialog);
GtkButton *ok = GTK_BUTTON (
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_OK,
GTK_RESPONSE_OK));
g_object_set_data_full (G_OBJECT (ok),
"_libnotify_action",
g_strdup ("default"),
g_free);
g_signal_connect (G_OBJECT (ok),
"button-release-event",
G_CALLBACK (handle_response),
dialog);
gtk_widget_set_can_default(GTK_WIDGET(ok), FALSE);
g_object_set_data (G_OBJECT (dialog),
"_dialog_info",
dialog_info);
g_signal_connect (G_OBJECT (dialog),
"button-release-event",
G_CALLBACK (handle_response),
dialog);
gtk_window_set_focus (GTK_WINDOW (dialog),
NULL);
gtk_window_set_default (GTK_WINDOW (dialog),
NULL);
gtk_widget_show_all (dialog);
}
