bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[], int majorDim,
long style, const wxValidator& validator,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxRadioBox creation failed") );
return false;
}
m_widget = gtk_frame_new( wxGTK_CONV( title ) );
// majorDim may be 0 if all trailing parameters were omitted, so don't
// assert here but just use the correct value for it
m_majorDim = majorDim == 0 ? n : majorDim;
int num_per_major = (n - 1) / m_majorDim +1;
int num_of_cols = 0;
int num_of_rows = 0;
if (HasFlag(wxRA_SPECIFY_COLS))
{
num_of_cols = m_majorDim;
num_of_rows = num_per_major;
}
else
{
num_of_cols = num_per_major;
num_of_rows = m_majorDim;
}
GtkRadioButton *m_radio = (GtkRadioButton*) NULL;
GtkWidget *table = gtk_table_new( num_of_rows, num_of_cols, FALSE );
gtk_table_set_col_spacings( GTK_TABLE(table), 1 );
gtk_table_set_row_spacings( GTK_TABLE(table), 1 );
gtk_widget_show( table );
gtk_container_add( GTK_CONTAINER(m_widget), table );
wxString label;
GSList *radio_button_group = (GSList *) NULL;
for (int i = 0; i < n; i++)
{
if ( i != 0 )
radio_button_group = gtk_radio_button_group( GTK_RADIO_BUTTON(m_radio) );
label.Empty();
for ( const wxChar *pc = choices[i]; *pc; pc++ )
{
if ( *pc != wxT('&') )
label += *pc;
}
m_radio = GTK_RADIO_BUTTON( gtk_radio_button_new_with_label( radio_button_group, wxGTK_CONV( label ) ) );
gtk_widget_show( GTK_WIDGET(m_radio) );
gtk_signal_connect( GTK_OBJECT(m_radio), "key_press_event",
GTK_SIGNAL_FUNC(gtk_radiobox_keypress_callback), (gpointer)this );
m_boxes.Append( (wxObject*) m_radio );
if (HasFlag(wxRA_SPECIFY_COLS))
{
int left = i%num_of_cols;
int right = (i%num_of_cols) + 1;
int top = i/num_of_cols;
int bottom = (i/num_of_cols)+1;
gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(m_radio), left, right, top, bottom,
GTK_FILL, GTK_FILL, 1, 1 );
}
else
{
int left = i/num_of_rows;
int right = (i/num_of_rows) + 1;
int top = i%num_of_rows;
int bottom = (i%num_of_rows)+1;
gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(m_radio), left, right, top, bottom,
GTK_FILL, GTK_FILL, 1, 1 );
}
ConnectWidget( GTK_WIDGET(m_radio) );
if (!i) gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(m_radio), TRUE );
gtk_signal_connect( GTK_OBJECT(m_radio), "clicked",
GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this );
gtk_signal_connect( GTK_OBJECT(m_radio), "focus_in_event",
GTK_SIGNAL_FUNC(gtk_radiobutton_focus_in), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(m_radio), "focus_out_event",
GTK_SIGNAL_FUNC(gtk_radiobutton_focus_out), (gpointer)this );
}
m_parent->DoAddChild( this );
SetLabel( title );
PostCreation(size);
return true;
}
//This function returns a table containing the elements of the page arranged
GtkWidget * setPageLayout(GtkWidget* window, GtkWidget* browserForm){
GtkWidget * tableInitialing;
GtkWidget *image;
GtkWidget * mainSearchBox, *miniSearchBox, *centerSearchBox;
GtkWidget *searchMainBut, *searchMiniBut, *searchCenterBut, *exitButton , *goBackBut, *stopBut, *frontBut;
GtkWidget *scrolledWindow;
GtkWidget *webView;
GtkWidget *pageLayoutExpander;
webView = webkit_web_view_new();
pageLayoutExpander = gtk_expander_new_with_mnemonic("V_iew page");
//creates a table with 20 rows and 17 columns
tableInitialing = gtk_table_new( 30, 17, TRUE);
exitButton = gtk_button_new_with_mnemonic("E_xit One click browser");
g_signal_connect_swapped( G_OBJECT(exitButton), "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer) window);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), exitButton, 0, 17, 29,30);
//Start of expander setting
//declaration of variables involved in setting position of tabs
GtkWidget *settingExpander, *expanderVBox;
GtkWidget *setTapUpRadio, *setTapDownRadio, *clearHistoryBut, *viewHistoryBut;
GtkWidget *facebookLogo, *twitterLogo, *gmailLogo, *skypeLogo, *googleLogo;
GtkWidget *facebookEventBox, *twitterEventBox, *gmailEventBox, *skypeEventBox, *googleEventBox;
//Initialising variables
setTapUpRadio = gtk_radio_button_new_with_label(NULL,"Set tab position up");
setTapDownRadio = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(setTapUpRadio), "Set tab position down");
//Initialises the clearHistoryBut and associate a callback to it
clearHistoryBut = gtk_button_new_with_mnemonic("_Clear history");
g_signal_connect(G_OBJECT(clearHistoryBut), "clicked", G_CALLBACK(clearHistory), NULL);
viewHistoryBut = gtk_button_new_with_mnemonic("_View history");
g_signal_connect_swapped(G_OBJECT(viewHistoryBut),"clicked", G_CALLBACK(viewHistory), NULL);
//Initialises the expander and the vbox
settingExpander = gtk_expander_new_with_mnemonic("_Settings");
expanderVBox = gtk_vbox_new(TRUE, 0);
//Adds radio buttons to the vbox
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapUpRadio);
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapDownRadio);
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), clearHistoryBut);
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), viewHistoryBut);
//Linking signals of radio buttons to the respective callbacks
g_signal_connect_swapped( G_OBJECT(setTapUpRadio), "toggled", G_CALLBACK(setTapUp), browserForm);
g_signal_connect_swapped( G_OBJECT(setTapDownRadio), "toggled", G_CALLBACK(setTapDown), browserForm);
gtk_container_add( GTK_CONTAINER(settingExpander), expanderVBox);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing),settingExpander, 0,3,20,24);
//End of expander setting
goBackBut = gtk_button_new_with_label(" <-- ");
gtk_widget_set_size_request(goBackBut, 10, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), goBackBut, 1, 2, 1, 2);
g_signal_connect_swapped(goBackBut, "clicked", G_CALLBACK(back), webView);
stopBut = gtk_button_new_with_label(" X ");
gtk_widget_set_size_request(stopBut, 10, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), stopBut, 2, 3, 1, 2);
g_signal_connect_swapped(stopBut, "clicked", G_CALLBACK(stop), webView);
frontBut = gtk_button_new_with_label(" --> ");
gtk_widget_set_size_request(frontBut, 10, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), frontBut, 16, 17, 1, 2);
g_signal_connect_swapped(frontBut, "clicked", G_CALLBACK(forward), webView);
//This patch of code initiates autocompletion of the search box
GtkEntryCompletion *completion;
GtkTreeIter *iter;
GtkListStore *store_list;
FILE * historyPtr;
store_list = gtk_list_store_new(1,G_TYPE_STRING);
completion = gtk_entry_completion_new();
if( (historyPtr = fopen("History/History.htm","r+")) == NULL)
g_print("Error");
gchar historyString[100];
while( !feof(historyPtr)){
fscanf(historyPtr,"%s",historyString);
gtk_list_store_append(store_list, iter);
gtk_list_store_set(store_list, iter, 0, historyString, -1);
}
fclose(historyPtr);
gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(store_list));
gtk_entry_completion_set_text_column(completion, 0);
mainSearchBox = gtk_entry_new();
gtk_entry_set_completion(GTK_ENTRY(mainSearchBox), completion);
gtk_widget_set_size_request(mainSearchBox, 500, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), mainSearchBox, 3, 15, 1, 2 );
g_signal_connect_swapped(mainSearchBox, "activate", G_CALLBACK(activate), webView);
searchMainBut = gtk_button_new_with_mnemonic("Sear_ch");
gtk_widget_set_size_request(searchMainBut, 10,15);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), searchMainBut, 15, 16, 1, 2 );
g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(setUri), mainSearchBox);
g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(go), webView);
//g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(initialiseEntryCompletion), completion);
//Linking callbacks to signals emitted by webview widget
g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-progress-changed",G_CALLBACK(progress),mainSearchBox);
g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(finished),mainSearchBox);
scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(scrolledWindow), webView);
gtk_widget_show_all(scrolledWindow);
//PageLayout expander
//gtk_widget_set_sensitive(pageLayoutExpander, FALSE);
gtk_container_add( GTK_CONTAINER(pageLayoutExpander), scrolledWindow);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), pageLayoutExpander, 0, 17, 2, 29);
g_signal_connect_swapped(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(viewSearchedPage),pageLayoutExpander);
image = gtk_image_new_from_file("images/OneClickLogo.png");
GtkWidget* imageEventBox = initialiseEventBox(image);
g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(searchOneClick), webView);
g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(logoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), imageEventBox, 3, 14, 14, 24);
//Adding pictures of some social media to the browser's home page
facebookLogo = gtk_image_new_from_file("images/facebook.jpg");
skypeLogo = gtk_image_new_from_file("images/skype.jpg");
twitterLogo = gtk_image_new_from_file("images/twitter.jpg");
gmailLogo = gtk_image_new_from_file("images/gmail.jpg");
googleLogo = gtk_image_new_from_file("images/google.jpg");
//Adding event handlers to images
facebookEventBox = initialiseEventBox(facebookLogo);
g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(searchFacebook), webView);
g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(facebookLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), facebookEventBox, 4, 6, 24, 28 );
gmailEventBox = initialiseEventBox(gmailLogo);
g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(searchGmail), webView);
g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(gmailLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), gmailEventBox, 6, 8, 24, 28 );
twitterEventBox = initialiseEventBox(twitterLogo);
g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(searchTwitter), webView);
g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(twitterLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), twitterEventBox, 8, 10, 24, 28 );
skypeEventBox = initialiseEventBox(skypeLogo);
g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(searchSKype), webView);
g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(skypeLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), skypeEventBox, 10, 12, 24, 28 );
googleEventBox = initialiseEventBox(googleLogo);
g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(searchGoogle), webView);
g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(googleLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), googleEventBox, 12, 14, 24, 28 );
//This patch of code implements the file chooser button that opens files on the user's computer
GtkWidget *openFileChooser;
openFileChooser = gtk_file_chooser_button_new("Select an html document to open",GTK_FILE_CHOOSER_ACTION_OPEN);
g_signal_connect_swapped(G_OBJECT(openFileChooser), "selection_changed", G_CALLBACK(openFile), webView);
//gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(openFileChooser), g_get_home_dir());
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), openFileChooser, 4, 12, 0, 1 );
GtkFileFilter *filter;
filter = gtk_file_filter_new();
gtk_file_filter_set_name (filter, "HTML Files");
gtk_file_filter_add_pattern (filter, "*.html");
gtk_file_filter_add_pattern (filter, "*.htm");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (openFileChooser), filter);
return tableInitialing;
}
static GtkWidget * build_properties_area(WBPlugin *wb, const gchar *buffer, gsize length) {
GError *error = NULL;
GObject *area = NULL;
GtkRadioButton *only_maximized, *active_window;
GtkToggleButton *show_on_desktop, *sync_wm_theme;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkListStore *list_store;
GtkWidget *view, *theme_name_treeview;
GtkEntry *button_layout;
wb->prefs->builder = gtk_builder_new();
if (gtk_builder_add_from_string(wb->prefs->builder, buffer, length, &error)) {
area = gtk_builder_get_object(wb->prefs->builder, "alignment0");
if (G_LIKELY (area != NULL))
{
only_maximized = GTK_RADIO_BUTTON(gtk_builder_get_object(wb->prefs->builder, "only_maximized"));
active_window = GTK_RADIO_BUTTON(gtk_builder_get_object(wb->prefs->builder, "active_window"));
if (G_LIKELY (only_maximized != NULL))
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(only_maximized), wb->prefs->only_maximized);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(active_window), !wb->prefs->only_maximized);
g_signal_connect(only_maximized, "toggled", G_CALLBACK(on_only_maximized_toggled), wb);
}
else {
DBG("No widget with the name \"only_maximized\" found");
}
show_on_desktop = GTK_TOGGLE_BUTTON(gtk_builder_get_object(wb->prefs->builder, "show_on_desktop"));
if (G_LIKELY (show_on_desktop != NULL)) {
gtk_toggle_button_set_active(show_on_desktop, wb->prefs->show_on_desktop);
g_signal_connect(show_on_desktop, "toggled", G_CALLBACK(on_show_on_desktop_toggled), wb);
}
else {
DBG("No widget with the name \"show_on_desktop\" found");
}
/* Style widgets */
theme_name_treeview = GTK_WIDGET (gtk_builder_get_object (wb->prefs->builder, "theme_name_treeview"));
/* theme name */
{
list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (list_store), COL_THEME_NAME,
(GtkTreeIterCompareFunc) wckbuttons_theme_sort_func,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store), COL_THEME_NAME, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (theme_name_treeview), GTK_TREE_MODEL (list_store));
g_object_unref (G_OBJECT (list_store));
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (theme_name_treeview),
0, _("Directory"), renderer, "text", 1, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (theme_name_treeview),
0, _("Themes usable"), renderer, "text", 0, NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (theme_name_treeview));
g_signal_connect (selection, "changed", G_CALLBACK (wckbuttons_theme_selection_changed),
wb);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
view = GTK_WIDGET (gtk_builder_get_object (wb->prefs->builder, "theme_name_treeview"));
wckbuttons_load_themes (view, wb);
}
sync_wm_theme = GTK_TOGGLE_BUTTON(gtk_builder_get_object(wb->prefs->builder, "sync_wm_theme"));
if (G_LIKELY (sync_wm_theme != NULL))
{
if (wb->wm_channel)
{
gtk_toggle_button_set_active(sync_wm_theme, wb->prefs->sync_wm_theme);
g_signal_connect(sync_wm_theme, "toggled", G_CALLBACK(on_sync_theme_with_wm_toggled), wb);
}
else {
gtk_widget_set_sensitive (GTK_WIDGET(sync_wm_theme), FALSE);
}
}
else {
DBG("No widget with the name \"sync_wm_theme\" found");
}
button_layout = GTK_ENTRY(gtk_builder_get_object(wb->prefs->builder, "button_layout"));
if (G_LIKELY (button_layout != NULL))
{
gtk_entry_set_text(button_layout, wb->prefs->button_layout);
g_signal_connect(GTK_EDITABLE(button_layout), "changed", G_CALLBACK(on_button_layout_changed), wb);
}
else {
DBG("No widget with the name \"button_layout\" found");
}
return GTK_WIDGET(area) ;
}
else {
g_set_error_literal(&error, 0, 0, "No widget with the name \"contentarea\" found");
}
}
g_critical("Faild to construct the builder for plugin %s-%d: %s.", xfce_panel_plugin_get_name (wb->plugin), xfce_panel_plugin_get_unique_id (wb->plugin), error->message);
g_error_free(error);
g_object_unref(G_OBJECT (wb->prefs->builder) );
return NULL ;
}
static GtkWidget *
account_assistant_build_enter_or_create_page (EmpathyAccountAssistant *self)
{
EmpathyAccountAssistantPriv *priv = GET_PRIV (self);
GtkWidget *main_vbox, *w, *chooser, *vbox, *hbox, *radio;
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_widget_show (main_vbox);
w = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (w), 0, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
priv->first_label = w;
w = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
chooser = empathy_protocol_chooser_new ();
gtk_container_add (GTK_CONTAINER (w), chooser);
gtk_widget_show (chooser);
priv->chooser = chooser;
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_end (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
w = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_widget_show (w);
priv->second_label = w;
w = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0);
gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (w), hbox);
gtk_widget_show (hbox);
radio = gtk_radio_button_new_with_label (NULL, _("Yes"));
gtk_box_pack_start (GTK_BOX (hbox), radio, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (radio), "response",
GINT_TO_POINTER (RESPONSE_CREATE_AGAIN));
gtk_widget_show (radio);
w = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio),
_("No, that's all for now"));
gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (w), "response",
GINT_TO_POINTER (RESPONSE_CREATE_STOP));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), TRUE);
priv->create_enter_resp = RESPONSE_CREATE_STOP;
priv->create_again_radio = w;
gtk_widget_show (w);
g_signal_connect (w, "clicked",
G_CALLBACK (account_assistant_radio_create_again_clicked_cb), self);
g_signal_connect (radio, "clicked",
G_CALLBACK (account_assistant_radio_create_again_clicked_cb), self);
return main_vbox;
}
void
grg_pref_dialog (GtkWidget * parent)
{
GtkWidget *prefs, *notebook, *tab1, *tab2, *tab3;
GtkWidget *frame1, *frame2, *frame3;
GtkWidget *crypt_box, *hash_box, *comp_box;
GtkWidget *frame_font;
GtkWidget *frame_file, *but_file, *box_file, *but_file_clear;
GtkWidget *frame_save, *box_save;
GtkWidget *frame_misc, *box_misc;
GtkWidget *frame_xpire, *box_xpire, *xpire_lbl;
GtkWidget *frame_passes, *box_passes, *lbl_passes;
GtkWidget *frame_clip, *box_clip;
gint response;
PangoFontDescription *fdesc;
if (active_flag)
return;
prefs = gtk_dialog_new_with_buttons (_("Preferences"),
GTK_WINDOW (parent),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_APPLY,
GTK_RESPONSE_APPLY,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, NULL);
//first page: algorithms
tab1 = gtk_table_new (3, 2, FALSE);
frame1 = gtk_frame_new (_("Encryption"));
gtk_table_attach_defaults (GTK_TABLE (tab1), frame1, 0, 1, 0, 3);
crypt_box = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame1), crypt_box);
NEW_RADIO_BUTTON (rij1_but, NULL, modify_crypto, GRG_AES,
"AES (Rijndael 128)", crypt_box);
NEW_RADIO_BUTTON (ser_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_SERPENT, "Serpent", crypt_box);
NEW_RADIO_BUTTON (twof_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_TWOFISH, "Twofish", crypt_box);
NEW_RADIO_BUTTON (cast_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_CAST_256, "Cast 256", crypt_box);
NEW_RADIO_BUTTON (safer_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_SAFERPLUS, "Safer+", crypt_box);
NEW_RADIO_BUTTON (loki_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_LOKI97, "Loki97", crypt_box);
NEW_RADIO_BUTTON (tdes_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_3DES, "3-DES", crypt_box);
NEW_RADIO_BUTTON (rij2_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(rij1_but)),
modify_crypto, GRG_RIJNDAEL_256, "Rijndael 256",
crypt_box);
NEW_ROW_SEPARATOR (crypt_box);
NEW_LABEL (crypto_block_lbl, crypt_box, "");
NEW_LABEL (crypto_key_lbl, crypt_box, "");
update_crypto_label ();
frame2 = gtk_frame_new (_("Hashing"));
gtk_table_attach_defaults (GTK_TABLE (tab1), frame2, 1, 2, 0, 1);
hash_box = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame2), hash_box);
NEW_RADIO_BUTTON (sha_but, NULL, modify_hash, GRG_SHA1, "SHA1",
hash_box);
NEW_RADIO_BUTTON (ripe_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(sha_but)), modify_hash,
GRG_RIPEMD_160, "RIPEMD 160", hash_box);
frame3 = gtk_frame_new (_("Compression"));
gtk_table_attach_defaults (GTK_TABLE (tab1), frame3, 1, 2, 1, 2);
comp_box = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame3), comp_box);
NEW_RADIO_BUTTON (zlib_but, NULL, modify_comp, GRG_ZLIB, "ZLib",
comp_box);
NEW_RADIO_BUTTON (bz_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(zlib_but)),
modify_comp, GRG_BZIP, "BZip2", comp_box);
NEW_ROW_SEPARATOR (comp_box);
NEW_RADIO_BUTTON (r0_but, NULL, modify_ratio, GRG_LVL_NONE, _("None"),
comp_box);
NEW_RADIO_BUTTON (r3_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(r0_but)), modify_ratio,
GRG_LVL_FAST, _("Fast"), comp_box);
NEW_RADIO_BUTTON (r6_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(r0_but)), modify_ratio,
GRG_LVL_GOOD, _("Good"), comp_box);
NEW_RADIO_BUTTON (r9_but,
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(r0_but)), modify_ratio,
GRG_LVL_BEST, _("Best"), comp_box);
notebook = gtk_notebook_new ();
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab1,
gtk_label_new (_("Algorithms")));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (prefs)->vbox), notebook,
TRUE, TRUE, GRG_PAD);
//second page: General options
tab2 = gtk_vbox_new (FALSE, GRG_PAD);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab2,
gtk_label_new (_("General options")));
frame_font = gtk_frame_new (_("Editor font"));
gtk_box_pack_start (GTK_BOX (tab2), frame_font, FALSE, TRUE, 1);
but_font =
gtk_button_new_with_label (_
("Click to change the editor font"));
gtk_container_add (GTK_CONTAINER (frame_font), but_font);
fdesc = pango_font_description_from_string (grg_prefs_editor_font);
gtk_widget_modify_font (but_font, fdesc);
g_free (fdesc);
g_signal_connect (G_OBJECT (but_font), "clicked",
G_CALLBACK (modify_font), prefs);
frame_misc = gtk_frame_new (_("Decorations"));
gtk_box_pack_start (GTK_BOX (tab2), frame_misc, FALSE, TRUE, 1);
box_misc = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_misc), box_misc);
NEW_ROW_SEPARATOR (tab2);
splash_check = gtk_check_button_new_with_label (_("Splash screen"));
g_signal_connect (G_OBJECT (splash_check), "toggled",
G_CALLBACK (modify_splash), NULL);
gtk_box_pack_start (GTK_BOX (box_misc), splash_check, FALSE, TRUE, 1);
frame_file = gtk_frame_new (_("File to open at startup"));
gtk_box_pack_start (GTK_BOX (tab2), frame_file, FALSE, TRUE, 1);
box_file = gtk_hbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_file), box_file);
file_entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (box_file), file_entry, FALSE, TRUE, 1);
but_file = gtk_button_new_from_stock (GTK_STOCK_OPEN);
gtk_box_pack_start (GTK_BOX (box_file), but_file, FALSE, TRUE, 1);
g_signal_connect (G_OBJECT (but_file), "clicked",
G_CALLBACK (meta_open_startup_file),
(gpointer) prefs);
but_file_clear = gtk_button_new_from_stock (GTK_STOCK_CLEAR);
gtk_box_pack_start (GTK_BOX (box_file), but_file_clear, FALSE, TRUE,
1);
g_signal_connect (G_OBJECT (but_file_clear), "clicked",
G_CALLBACK (clear_file), NULL);
frame_save = gtk_frame_new (_("File saving"));
gtk_box_pack_start (GTK_BOX (tab2), frame_save, FALSE, TRUE, 1);
box_save = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_save), box_save);
bak_check =
gtk_check_button_new_with_label (_("Make backups of files"));
g_signal_connect (G_OBJECT (bak_check), "toggled",
G_CALLBACK (modify_bak), NULL);
gtk_box_pack_start (GTK_BOX (box_save), bak_check, FALSE, TRUE, 1);
over_check =
gtk_check_button_new_with_label (_
("Ask when overwriting files"));
g_signal_connect (G_OBJECT (over_check), "toggled",
G_CALLBACK (modify_over), NULL);
gtk_box_pack_start (GTK_BOX (box_save), over_check, FALSE, TRUE, 1);
//third page: Security
tab3 = gtk_vbox_new (FALSE, GRG_PAD);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab3,
gtk_label_new (_("Security")));
frame_xpire = gtk_frame_new (_("Password expiration"));
gtk_box_pack_start (GTK_BOX (tab3), frame_xpire, FALSE, TRUE, 1);
box_xpire = gtk_hbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_xpire), box_xpire);
xpire_check =
gtk_check_button_new_with_label (_("Password expires in"));
xpire_spin =
gtk_spin_button_new_with_range (EXP_TIME_MIN, EXP_TIME_MAX,
1);
xpire_lbl = gtk_label_new (_("days"));
g_signal_connect (G_OBJECT (xpire_check), "toggled",
G_CALLBACK (modify_xpire), xpire_spin);
g_signal_connect (G_OBJECT (xpire_spin), "value-changed",
G_CALLBACK (modify_xpin), xpire_check);
gtk_box_pack_start (GTK_BOX (box_xpire), xpire_check, FALSE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_xpire), xpire_spin, FALSE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (box_xpire), xpire_lbl, FALSE, TRUE, 1);
//this means "passes in wiping a file", not "wipe the passes" :)
frame_passes = gtk_frame_new (_("Wipe passes"));
gtk_box_pack_start (GTK_BOX (tab3), frame_passes, FALSE, TRUE, 1);
box_passes = gtk_hbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_passes), box_passes);
lbl_passes = gtk_label_new (_("Number of overwritings with random\n"
"data, when wiping a file:"));
gtk_box_pack_start (GTK_BOX (box_passes), lbl_passes, FALSE, TRUE, 1);
passes_spin =
gtk_spin_button_new_with_range (WIPE_PASSES_MIN,
WIPE_PASSES_MAX, 1);
gtk_box_pack_start (GTK_BOX (box_passes), passes_spin, FALSE, TRUE,
1);
g_signal_connect (G_OBJECT (passes_spin), "value-changed",
G_CALLBACK (modify_passes), NULL);
frame_clip = gtk_frame_new (_("Clipboard"));
gtk_box_pack_start (GTK_BOX (tab3), frame_clip, FALSE, TRUE, 1);
box_clip = gtk_vbox_new (FALSE, GRG_PAD);
gtk_container_add (GTK_CONTAINER (frame_clip), box_clip);
cclip_check =
gtk_check_button_new_with_label (_
("Clear clipboard on closing file"));
g_signal_connect (G_OBJECT (cclip_check), "toggled",
G_CALLBACK (modify_cclip), NULL);
gtk_box_pack_start (GTK_BOX (box_clip), cclip_check, FALSE, TRUE, 1);
qclip_check =
gtk_check_button_new_with_label (_
("Clear clipboard on exit"));
g_signal_connect (G_OBJECT (qclip_check), "toggled",
G_CALLBACK (modify_qclip), NULL);
gtk_box_pack_start (GTK_BOX (box_clip), qclip_check, FALSE, TRUE, 1);
//end of last tab
active_flag = TRUE;
reset_values (prefs);
update_buttons ();
gtk_widget_show_all (prefs);
while (TRUE)
{
gboolean exit = TRUE;
response = gtk_dialog_run (GTK_DIALOG (prefs));
switch (response)
{
case GTK_RESPONSE_OK:
apply_values ();
break;
case GTK_RESPONSE_APPLY:
apply_values ();
exit = FALSE;
break;
case GTK_RESPONSE_CANCEL:
default:
break;
}
if (exit)
{
gtk_widget_destroy (prefs);
active_flag = FALSE;
break;
}
}
}
static void
xpad_preferences_init (XpadPreferences *pref)
{
GtkWidget *hbox, *font_hbox, *vbox;
const GdkColor *color;
const gchar *fontname;
GtkStyle *style;
GtkWidget *label, *appearance_frame, *alignment, *appearance_vbox;
GtkWidget *options_frame, *options_vbox, *global_vbox;
gchar *text;
GtkSizeGroup *size_group_labels = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
GtkRequisition req;
pref->priv = XPAD_PREFERENCES_GET_PRIVATE (pref);
text = g_strconcat ("<b>", _("Appearance"), "</b>", NULL);
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
"label", text,
"use-markup", TRUE,
"xalign", 0.0,
NULL));
g_free (text);
appearance_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
"homogeneous", FALSE,
"spacing", 18,
NULL));
alignment = gtk_alignment_new (1, 1, 1, 1);
g_object_set (G_OBJECT (alignment),
"left-padding", 12,
"top-padding", 12,
"child", appearance_vbox,
NULL);
appearance_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME,
"label-widget", label,
"shadow-type", GTK_SHADOW_NONE,
"child", alignment,
NULL));
pref->priv->textbutton = gtk_color_button_new ();
pref->priv->backbutton = gtk_color_button_new ();
pref->priv->fontbutton = gtk_font_button_new ();
pref->priv->antifontcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use font from theme"));
pref->priv->fontcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->antifontcheck), _("Use this font:"));
pref->priv->anticolorcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use colors from theme"));
pref->priv->colorcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->anticolorcheck), _("Use these colors:"));
font_hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontbutton, TRUE, TRUE, 0);
pref->priv->colorbox = gtk_vbox_new (FALSE, 6);
hbox = gtk_hbox_new (FALSE, 12);
label = gtk_label_new_with_mnemonic (_("Background:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_size_group_add_widget (size_group_labels, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), pref->priv->backbutton, TRUE, TRUE, 0);
g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL);
hbox = gtk_hbox_new (FALSE, 12);
label = gtk_label_new_with_mnemonic (_("Foreground:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_size_group_add_widget (size_group_labels, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), pref->priv->textbutton, TRUE, TRUE, 0);
g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL);
alignment = gtk_alignment_new (1, 1, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
gtk_container_add (GTK_CONTAINER (alignment), pref->priv->colorbox);
pref->priv->editcheck = gtk_check_button_new_with_mnemonic (_("_Edit lock"));
pref->priv->stickycheck = gtk_check_button_new_with_mnemonic (_("_Pads start on all workspaces"));
pref->priv->confirmcheck = gtk_check_button_new_with_mnemonic (_("_Confirm pad deletion"));
gtk_dialog_add_button (GTK_DIALOG (pref), "gtk-close", GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator (GTK_DIALOG (pref), FALSE);
g_signal_connect (pref, "response", G_CALLBACK (xpad_preferences_response), NULL);
gtk_window_set_title (GTK_WINDOW (pref), _("Xpad Preferences"));
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->textbutton), FALSE);
gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->backbutton), xpad_app_get_translucent ());
gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->textbutton), _("Set Foreground Color"));
gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->backbutton), _("Set Background Color"));
gtk_font_button_set_title (GTK_FONT_BUTTON (pref->priv->fontbutton), _("Set Font"));
/* Set current state */
style = gtk_widget_get_default_style ();
color = xpad_settings_get_back_color (xpad_settings ());
if (color)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->colorcheck), TRUE);
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), color);
}
else
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->anticolorcheck), TRUE);
gtk_widget_set_sensitive (pref->priv->colorbox, FALSE);
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), &style->base[GTK_STATE_NORMAL]);
}
color = xpad_settings_get_text_color (xpad_settings ());
if (color)
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), color);
else
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), &style->text[GTK_STATE_NORMAL]);
fontname = xpad_settings_get_fontname (xpad_settings ());
if (fontname)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->fontcheck), TRUE);
gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), fontname);
}
else
{
gchar *str;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->antifontcheck), TRUE);
gtk_widget_set_sensitive (pref->priv->fontbutton, FALSE);
str = pango_font_description_to_string (style->font_desc);
gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), str);
g_free (str);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->editcheck), xpad_settings_get_edit_lock (xpad_settings ()));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->stickycheck), xpad_settings_get_sticky (xpad_settings ()));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->confirmcheck), xpad_settings_get_confirm_destroy (xpad_settings ()));
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->antifontcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), font_hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->anticolorcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), pref->priv->colorcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0);
text = g_strconcat ("<b>", _("Options"), "</b>", NULL);
label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
"label", text,
"use-markup", TRUE,
"xalign", 0.0,
NULL));
g_free (text);
options_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
"homogeneous", FALSE,
"spacing", 6,
NULL));
alignment = gtk_alignment_new (1, 1, 1, 1);
g_object_set (G_OBJECT (alignment),
"left-padding", 12,
"top-padding", 12,
"child", options_vbox,
NULL);
options_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME,
"label-widget", label,
"shadow-type", GTK_SHADOW_NONE,
"child", alignment,
NULL));
gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->editcheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->stickycheck, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->confirmcheck, FALSE, FALSE, 0);
global_vbox = g_object_new (GTK_TYPE_VBOX,
"border-width", 6,
"homogeneous", FALSE,
"spacing", 18,
"child", appearance_frame,
"child", options_frame,
NULL);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pref)->vbox), global_vbox, FALSE, FALSE, 0);
pref->priv->editcheck_handler = g_signal_connect (pref->priv->editcheck, "toggled", G_CALLBACK (change_edit_check), pref);
pref->priv->stickycheck_handler = g_signal_connect (pref->priv->stickycheck, "toggled", G_CALLBACK (change_sticky_check), pref);
pref->priv->confirmcheck_handler = g_signal_connect (pref->priv->confirmcheck, "toggled", G_CALLBACK (change_confirm_check), pref);
pref->priv->colorcheck_handler = g_signal_connect (pref->priv->colorcheck, "toggled", G_CALLBACK (change_color_check), pref);
pref->priv->fontcheck_handler = g_signal_connect (pref->priv->fontcheck, "toggled", G_CALLBACK (change_font_check), pref);
pref->priv->text_handler = g_signal_connect (pref->priv->textbutton, "color-set", G_CALLBACK (change_text_color), pref);
pref->priv->back_handler = g_signal_connect (pref->priv->backbutton, "color-set", G_CALLBACK (change_back_color), pref);
pref->priv->font_handler = g_signal_connect (pref->priv->fontbutton, "font-set", G_CALLBACK (change_font_face), pref);
pref->priv->notify_font_handler = g_signal_connect_swapped (xpad_settings (), "notify::fontname", G_CALLBACK (notify_fontname), pref);
pref->priv->notify_text_handler = g_signal_connect_swapped (xpad_settings (), "notify::text-color", G_CALLBACK (notify_text_color), pref);
pref->priv->notify_back_handler = g_signal_connect_swapped (xpad_settings (), "notify::back-color", G_CALLBACK (notify_back_color), pref);
pref->priv->notify_sticky_handler = g_signal_connect_swapped (xpad_settings (), "notify::sticky", G_CALLBACK (notify_sticky), pref);
pref->priv->notify_edit_handler = g_signal_connect_swapped (xpad_settings (), "notify::edit-lock", G_CALLBACK (notify_edit), pref);
pref->priv->notify_confirm_handler = g_signal_connect_swapped (xpad_settings (), "notify::confirm-destroy", G_CALLBACK (notify_confirm), pref);
g_object_unref (size_group_labels);
gtk_widget_show_all (GTK_DIALOG (pref)->vbox);
/* Make window not so squished */
gtk_widget_size_request (GTK_WIDGET (pref), &req);
g_object_set (G_OBJECT (pref), "default-width", (gint) (req.height * 0.8), NULL);
}
void
create_configure_dialog(void)
{
GtkWidget *config_dialog;
GtkWidget *main_widget;
GtkWidget *cpu_hbox;
GtkWidget *cpu_frame;
GtkWidget *cpuframe_vbox;
GtkWidget *cpuclock_hbox;
GtkWidget *baseclock_combo;
GtkWidget *rate_combo;
GtkWidget *times_label;
GtkWidget *realclock_label;
GtkWidget *confirm_widget;
GtkWidget *ok_button;
GtkWidget *cancel_button;
GtkWidget *arch_frame;
GtkWidget *arch_hbox;
GtkWidget *arch_radiobutton[NELEMENTS(architecture)];
GtkWidget *sound_frame;
GtkWidget *soundframe_vbox;
GtkWidget *soundrate_hbox;
GtkWidget *rate_label;
GtkWidget *rate_radiobutton[NELEMENTS(samplingrate)];
GtkWidget *soundbuffer_hbox;
GtkWidget *buffer_label;
GtkWidget *ms_label;
gchar buf[8];
int i;
uninstall_idle_process();
config_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(config_dialog), "Configure");
gtk_window_set_position(GTK_WINDOW(config_dialog), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(config_dialog), TRUE);
gtk_window_set_resizable(GTK_WINDOW(config_dialog), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(config_dialog), 5);
g_signal_connect(GTK_OBJECT(config_dialog), "destroy",
G_CALLBACK(dialog_destroy), NULL);
main_widget = gtk_vbox_new(FALSE, 0);
gtk_widget_show(main_widget);
gtk_container_add(GTK_CONTAINER(config_dialog), main_widget);
/* CPU column */
cpu_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(cpu_hbox);
gtk_box_pack_start(GTK_BOX(main_widget), cpu_hbox, TRUE, TRUE, 0);
/*
* CPU frame
*/
cpu_frame = gtk_frame_new("CPU");
gtk_widget_show(cpu_frame);
gtk_box_pack_start(GTK_BOX(cpu_hbox), cpu_frame, TRUE, TRUE, 0);
cpuframe_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(cpuframe_vbox), 5);
gtk_widget_show(cpuframe_vbox);
gtk_container_add(GTK_CONTAINER(cpu_frame), cpuframe_vbox);
/* cpu clock */
cpuclock_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(cpuclock_hbox);
gtk_box_pack_start(GTK_BOX(cpuframe_vbox),cpuclock_hbox, TRUE, TRUE, 2);
baseclock_combo = gtk_combo_box_entry_new_text();
gtk_widget_show(baseclock_combo);
gtk_box_pack_start(GTK_BOX(cpuclock_hbox), baseclock_combo, TRUE, FALSE, 0);
gtk_widget_set_size_request(baseclock_combo, 96, -1);
for (i = 0; i < NELEMENTS(baseclock_str); i++) {
gtk_combo_box_append_text(GTK_COMBO_BOX(baseclock_combo), baseclock_str[i]);
}
baseclock_entry = GTK_BIN(baseclock_combo)->child;
gtk_widget_show(baseclock_entry);
gtk_editable_set_editable(GTK_EDITABLE(baseclock_entry), FALSE);
switch (np2cfg.baseclock) {
default:
np2cfg.baseclock = PCBASECLOCK25;
sysmng_update(SYS_UPDATECFG|SYS_UPDATECLOCK);
/*FALLTHROUGH*/
case PCBASECLOCK25:
gtk_entry_set_text(GTK_ENTRY(baseclock_entry),baseclock_str[1]);
break;
case PCBASECLOCK20:
gtk_entry_set_text(GTK_ENTRY(baseclock_entry),baseclock_str[0]);
break;
}
times_label = gtk_label_new("x");
gtk_widget_show(times_label);
gtk_box_pack_start(GTK_BOX(cpuclock_hbox), times_label, TRUE, FALSE, 0);
gtk_misc_set_padding(GTK_MISC(times_label), 5, 0);
rate_combo = gtk_combo_box_entry_new_text();
gtk_widget_show(rate_combo);
gtk_box_pack_start(GTK_BOX(cpuclock_hbox), rate_combo, TRUE, FALSE, 0);
gtk_widget_set_size_request(rate_combo, 48, -1);
for (i = 0; i < NELEMENTS(clockmult_str); i++) {
gtk_combo_box_append_text(GTK_COMBO_BOX(rate_combo), clockmult_str[i]);
}
clockmult_entry = GTK_BIN(rate_combo)->child;
gtk_widget_show(clockmult_entry);
gtk_editable_set_editable(GTK_EDITABLE(clockmult_entry), FALSE);
switch (np2cfg.multiple) {
case 1: case 2: case 4: case 5: case 6: case 8: case 10: case 12:
case 16: case 20:
g_snprintf(buf, sizeof(buf), "%d", np2cfg.multiple);
gtk_entry_set_text(GTK_ENTRY(clockmult_entry), buf);
break;
default:
gtk_entry_set_text(GTK_ENTRY(clockmult_entry), "4");
break;
}
/* calculated cpu clock */
realclock_label = gtk_label_new("MHz");
gtk_widget_show(realclock_label);
gtk_box_pack_start(GTK_BOX(cpuframe_vbox), realclock_label, FALSE, FALSE, 2);
gtk_misc_set_alignment(GTK_MISC(realclock_label), 1.0, 0.5);
g_signal_connect(GTK_OBJECT(baseclock_entry), "changed",
G_CALLBACK(clock_changed), (gpointer)realclock_label);
g_signal_connect(GTK_OBJECT(clockmult_entry), "changed",
G_CALLBACK(clock_changed), (gpointer)realclock_label);
clock_changed(NULL, realclock_label);
/* OK, Cancel button base widget */
confirm_widget = gtk_vbutton_box_new();
gtk_widget_show(confirm_widget);
gtk_box_pack_start(GTK_BOX(cpu_hbox), confirm_widget, TRUE, TRUE, 0);
gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_widget), GTK_BUTTONBOX_END);
//gtk_button_box_set_spacing(GTK_BUTTON_BOX(confirm_widget), 0);
/*
* Architecture frame
*/
arch_frame = gtk_frame_new("Architecture");
gtk_widget_show(arch_frame);
gtk_box_pack_start(GTK_BOX(main_widget), arch_frame, TRUE, TRUE, 0);
/* architecture */
arch_hbox = gtk_hbox_new(TRUE, 0);
gtk_widget_show(arch_hbox);
gtk_container_add(GTK_CONTAINER(arch_frame), arch_hbox);
for (i = 0; i < NELEMENTS(architecture); i++) {
arch_radiobutton[i] = gtk_radio_button_new_with_label_from_widget(i > 0 ? GTK_RADIO_BUTTON(arch_radiobutton[i-1]) : NULL, architecture[i].label);
gtk_widget_show(arch_radiobutton[i]);
gtk_box_pack_start(GTK_BOX(arch_hbox), arch_radiobutton[i], FALSE, FALSE, 0);
#if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18)
gtk_widget_set_can_focus(arch_radiobutton[i], FALSE);
#else
GTK_WIDGET_UNSET_FLAGS(rate_radiobutton[i], GTK_CAN_FOCUS);
#endif
g_signal_connect(GTK_OBJECT(arch_radiobutton[i]), "clicked",
G_CALLBACK(arch_radiobutton_clicked), (gpointer)architecture[i].arch);
}
for (i = 0; i < NELEMENTS(architecture); i++) {
if (strcmp(np2cfg.model, architecture[i].arch) == 0) {
break;
}
}
if (i == NELEMENTS(architecture)) {
i = 1;
milstr_ncpy(np2cfg.model, "VX", sizeof(np2cfg.model));
sysmng_update(SYS_UPDATECFG);
}
g_signal_emit_by_name(GTK_OBJECT(arch_radiobutton[i]), "clicked");
/*
* Sound frame
*/
sound_frame = gtk_frame_new("Sound");
gtk_widget_show(sound_frame);
gtk_box_pack_start(GTK_BOX(main_widget), sound_frame, TRUE, TRUE, 0);
soundframe_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(soundframe_vbox), 5);
gtk_widget_show(soundframe_vbox);
gtk_container_add(GTK_CONTAINER(sound_frame), soundframe_vbox);
/* sampling rate */
soundrate_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(soundrate_hbox);
gtk_box_pack_start(GTK_BOX(soundframe_vbox), soundrate_hbox, TRUE, TRUE, 2);
rate_label = gtk_label_new("Sampling Rate");
gtk_widget_show(rate_label);
gtk_box_pack_start(GTK_BOX(soundrate_hbox), rate_label, FALSE, TRUE, 3);
gtk_widget_set_size_request(rate_label, 96, -1);
for (i = 0; i < NELEMENTS(samplingrate); i++) {
rate_radiobutton[i] = gtk_radio_button_new_with_label_from_widget((i > 0) ? GTK_RADIO_BUTTON(rate_radiobutton[i-1]) : NULL, samplingrate[i].label);
gtk_widget_show(rate_radiobutton[i]);
gtk_box_pack_start(GTK_BOX(soundrate_hbox), rate_radiobutton[i], FALSE, FALSE, 0);
#if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18)
gtk_widget_set_can_focus(rate_radiobutton[i], FALSE);
#else
GTK_WIDGET_UNSET_FLAGS(rate_radiobutton[i], GTK_CAN_FOCUS);
#endif
g_signal_connect(GTK_OBJECT(rate_radiobutton[i]), "clicked",
G_CALLBACK(rate_radiobutton_clicked), GINT_TO_POINTER(samplingrate[i].rate));
}
if (np2cfg.samplingrate == 11025) {
i = 0;
} else if (np2cfg.samplingrate == 22050) {
i = 1;
} else if (np2cfg.samplingrate == 44100) {
i = 2;
} else {
i = 1;
np2cfg.samplingrate = 22050;
sysmng_update(SYS_UPDATECFG|SYS_UPDATERATE);
}
g_signal_emit_by_name(GTK_OBJECT(rate_radiobutton[i]), "clicked");
soundbuffer_hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(soundbuffer_hbox);
gtk_box_pack_start(GTK_BOX(soundframe_vbox), soundbuffer_hbox, TRUE, TRUE, 2);
/* buffer size */
buffer_label = gtk_label_new("Buffer");
gtk_widget_show(buffer_label);
gtk_box_pack_start(GTK_BOX(soundbuffer_hbox), buffer_label, FALSE, FALSE, 0);
gtk_widget_set_size_request(buffer_label, 96, -1);
buffer_entry = gtk_entry_new();
gtk_widget_show(buffer_entry);
gtk_box_pack_start(GTK_BOX(soundbuffer_hbox), buffer_entry, FALSE, FALSE, 0);
gtk_widget_set_size_request(buffer_entry, 48, -1);
if (np2cfg.delayms >= 20 && np2cfg.delayms <= 1000) {
g_snprintf(buf, sizeof(buf), "%d", np2cfg.delayms);
gtk_entry_set_text(GTK_ENTRY(buffer_entry), buf);
} else {
gtk_entry_set_text(GTK_ENTRY(buffer_entry), "500");
np2cfg.delayms = 500;
sysmng_update(SYS_UPDATECFG|SYS_UPDATESBUF);
soundrenewal = 1;
}
ms_label = gtk_label_new(" ms");
gtk_widget_show(ms_label);
gtk_box_pack_start(GTK_BOX(soundbuffer_hbox),ms_label, FALSE, FALSE, 0);
#if defined(SUPPORT_RESUME)
/* resume */
resume_checkbutton = gtk_check_button_new_with_label("Resume");
gtk_widget_show(resume_checkbutton);
gtk_box_pack_start(GTK_BOX(main_widget), resume_checkbutton, FALSE, FALSE, 1);
if (np2oscfg.resume) {
g_signal_emit_by_name(GTK_OBJECT(resume_checkbutton), "clicked");
}
#endif
#if defined(GCC_CPU_ARCH_IA32)
/* Disable MMX */
disablemmx_checkbutton = gtk_check_button_new_with_label("Disable MMX");
gtk_widget_show(disablemmx_checkbutton);
gtk_box_pack_start(GTK_BOX(main_widget), disablemmx_checkbutton, FALSE, FALSE, 1);
if (mmxflag & MMXFLAG_NOTSUPPORT) {
gtk_widget_set_sensitive(disablemmx_checkbutton, FALSE);
} else if (mmxflag & MMXFLAG_DISABLE) {
g_signal_emit_by_name(GTK_OBJECT(disablemmx_checkbutton), "clicked");
}
#endif
/*
* OK, Cancel button
*/
ok_button = gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_widget_show(ok_button);
gtk_container_add(GTK_CONTAINER(confirm_widget), ok_button);
#if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18)
gtk_widget_set_can_default(ok_button, TRUE);
gtk_widget_has_default(ok_button);
#else
GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(ok_button, GTK_HAS_DEFAULT);
#endif
g_signal_connect(GTK_OBJECT(ok_button), "clicked",
G_CALLBACK(ok_button_clicked), (gpointer)config_dialog);
gtk_widget_grab_default(ok_button);
cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_widget_show(cancel_button);
gtk_container_add(GTK_CONTAINER(confirm_widget), cancel_button);
#if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18)
gtk_widget_set_can_default(cancel_button, TRUE);
#else
GTK_WIDGET_SET_FLAGS(cancel_button, GTK_CAN_DEFAULT);
#endif
g_signal_connect_swapped(GTK_OBJECT(cancel_button), "clicked",
G_CALLBACK(gtk_widget_destroy), GTK_OBJECT(config_dialog));
gtk_widget_show_all(config_dialog);
}
GtkWidget *
do_form_model_change (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *models [3];
window = gtk_dialog_new_with_buttons ("Changing data in a GdauiForm",
GTK_WINDOW (do_widget),
0,
"Close", GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The data in the same GdauiForm widget can be change don the fly.");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* creating data models */
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products ORDER BY ref, category LIMIT 15", NULL, NULL);
models[0] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[0]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products WHERE price > 20.2 ORDER BY ref, category LIMIT 10", NULL, NULL);
models[1] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[1]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT name, price, ref, category FROM products WHERE price > 20.2 ORDER BY name LIMIT 30", NULL, NULL);
models[2] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[2]), NULL);
g_object_unref (stmt);
/* allow choosing which data model to display */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>Choose which data model to display:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
GtkWidget *layout, *rb;
GSList *group = NULL;
gint i;
layout = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (vbox), layout, FALSE, FALSE, 0);
for (i = 0; i < 3; i++) {
gchar *str;
str = g_strdup_printf ("%d columns x %d rows", gda_data_model_get_n_columns (models[i]),
gda_data_model_get_n_rows (models[i]));
rb = gtk_radio_button_new_with_label (group, str);
g_free (str);
gtk_grid_attach (GTK_GRID (layout), rb, i, 0, 1, 1);
g_signal_connect (rb, "toggled", G_CALLBACK (model_toggled_cb), models[i]);
g_object_set_data_full (G_OBJECT (rb), "model", models[i], g_object_unref);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb));
}
/* Create the form widget */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>GdauiForm:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
form = gdaui_form_new (models[0]);
g_object_set (G_OBJECT (form), "info-flags",
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_ROW_MOVE_BUTTONS |
GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS, NULL);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
GdaDataProxy *proxy;
proxy = gdaui_data_proxy_get_proxy (GDAUI_DATA_PROXY (form));
g_object_set (proxy, "cache-changes", TRUE, NULL);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
void
settings_show (GtkWidget *widget, SchematicView *sv)
{
gint i;
GtkWidget *engine_group = NULL;
GtkWidget *w, *pbox, *toplevel;
GtkBuilder *gui;
GError *perror = NULL;
gchar *msg;
Settings *s;
Schematic *sm;
g_return_if_fail (sv != NULL);
// If no engine available, stop oregano
if ((g_find_program_in_path (engine[0]) == NULL) &&
(g_find_program_in_path (engine[1]) == NULL)) {
gchar *msg;
msg = g_strdup_printf (
_("No engine allowing analysis is available.\n"
"You might install one, at least! \n"
"Either ngspice or gnucap."));
oregano_error_with_title (_("Could not create settings dialog"), msg);
g_free (msg);
return;
}
g_return_if_fail (sv != NULL);
if ((gui = gtk_builder_new ()) == NULL) {
oregano_error (_("Could not create settings dialog"));
return;
}
gtk_builder_set_translation_domain (gui, NULL);
sm = schematic_view_get_schematic (sv);
s = schematic_get_settings (sm);
// Only allow one instance of the property box per schematic.
if (GTK_WIDGET (SETTINGS (s)->pbox)) {
gdk_window_raise (gtk_widget_get_window (
GTK_WIDGET (SETTINGS (s)->pbox)));
return;
}
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/settings.ui", &perror) <= 0) {
msg = perror->message;
oregano_error_with_title (_("Could not create settings dialog"), msg);
g_error_free (perror);
return;
}
w = toplevel = GTK_WIDGET (gtk_builder_get_object (gui, "toplevel"));
if (!w) {
oregano_error (_("Could not create settings dialog"));
return;
}
g_signal_connect (G_OBJECT (w), "delete_event",
G_CALLBACK (delete_event_callback), s);
pbox = toplevel;
s->pbox = GTK_WIDGET (pbox);
w = GTK_WIDGET (gtk_builder_get_object (gui, "close_bt"));
g_signal_connect (G_OBJECT (w), "clicked",
G_CALLBACK (apply_callback), s);
w = GTK_WIDGET (gtk_builder_get_object (gui, "splash-enable"));
s->w_show_splash = w;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), oregano.show_splash);
w = GTK_WIDGET (gtk_builder_get_object (gui, "compress-enable"));
s->w_compress_files = w;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
oregano.compress_files);
w = GTK_WIDGET (gtk_builder_get_object (gui, "log-enable"));
s->w_show_log = w;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), oregano.show_log);
w = GTK_WIDGET (gtk_builder_get_object (gui, "grid-size"));
gtk_widget_set_sensitive (w, FALSE);
w = GTK_WIDGET (gtk_builder_get_object (gui, "realtime-enable"));
gtk_widget_set_sensitive (w, FALSE);
w = GTK_WIDGET (gtk_builder_get_object (gui, "engine_table"));
for (i = 0; i < OREGANO_ENGINE_COUNT; i++) {
if (engine_group)
button[i] = gtk_radio_button_new_with_label_from_widget (
GTK_RADIO_BUTTON (engine_group), engine[i]);
else
button[i] = engine_group =
gtk_radio_button_new_with_label_from_widget (NULL, engine[i]);
g_object_set_data (G_OBJECT (button[i]), "id", GUINT_TO_POINTER (i));
gtk_grid_attach (GTK_GRID (w), button[i], 0, i, 1, 1);
g_signal_connect (G_OBJECT (button[i]), "clicked",
G_CALLBACK (set_engine_name), s);
}
// Is the engine available?
// In that case the button is active
if (g_find_program_in_path (engine[oregano.engine]) != NULL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button[oregano.engine]),
TRUE);
// Otherwise the button is inactive
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button[oregano.engine]),
FALSE);
// If no engine available, stop oregano
if ((g_find_program_in_path (engine[0]) == NULL) &&
(g_find_program_in_path (engine[1]) == NULL)) {
gchar *msg;
msg = g_strdup_printf (
_("No engine allowing analysis is available.\n"
"You might install one, at least! \n"
"Either ngspice or gnucap."));
oregano_error_with_title (_("Could not create settings dialog"), msg);
g_free (msg);
}
gtk_widget_show_all (toplevel);
}
//*********************************************************************************
void guiControl::guiControl(void *button, void* data)
{
if (pos_winPid != NULL)
{
gtk_window_set_keep_above (GTK_WINDOW(pos_winPid),true);
return;
}
gtkClassData* currentClassData = (gtkClassData*) data;
partMover *currentPart = currentClassData->partPointer;
joint = currentClassData->indexPointer;
icntrl2 = currentPart->get_IControlMode2();
iinteract = currentPart->get_IInteractionMode();
ipid = currentPart->get_IPidControl();
iamp = currentPart->get_IAmplifierControl();
bool ret = true;
int control_mode=VOCAB_CM_UNKNOWN;
yarp::dev::InteractionModeEnum interaction_mode=VOCAB_IM_UNKNOWN;
ret &= icntrl2->getControlMode(*joint, &control_mode);
ret &= iinteract->getInteractionMode(*joint, &interaction_mode);
if (control_mode==VOCAB_CM_HW_FAULT)
{
printf("WARNING: you cannot change control mode of a joint in HARDWARE FAULT\n");
return;
}
//GtkWidget *winPid = NULL;
GtkWidget *inv = NULL;
//adding a popup window
pos_winPid = gtk_window_new (GTK_WINDOW_TOPLEVEL);
char title[255];
sprintf(title,"Control mode JNT:%d",*joint);
gtk_window_set_title (GTK_WINDOW (pos_winPid), title);
//adding a set of display
inv = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (pos_winPid), inv);
label_title = gtk_label_new (title);
sprintf(title,"Interaction mode JNT:%d",*joint);
label_title2 = gtk_label_new (title);
radiobutton_mode_idl = gtk_radio_button_new_with_label (NULL, "idle");
radiobutton_mode_pos = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "position");
radiobutton_mode_vel = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "velocity");
radiobutton_mode_trq = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "torque");
radiobutton_mode_imp_pos = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "impedance position");
radiobutton_mode_imp_vel = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "impedance velocity");
radiobutton_mode_open = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "openloop");
radiobutton_mode_pos_direct = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "position direct");
radiobutton_mode_mixed = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "mixed");
radiobutton_interaction_stiff = gtk_radio_button_new_with_label (NULL, "stiff mode");
radiobutton_interaction_compl = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_interaction_stiff), "compliant mode");
gtk_fixed_put (GTK_FIXED(inv), label_title, 10, 10 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_idl, 10, 30 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_pos, 10, 50 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_pos_direct, 10, 70 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_mixed, 10, 90 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_vel, 10, 110 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_trq, 10, 130 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_imp_pos, 10, 150 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_imp_vel, 10, 170 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_open, 10, 190 );
gtk_fixed_put (GTK_FIXED(inv), label_title2, 10, 210 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_interaction_stiff,10, 230 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_interaction_compl,10, 250 );
update_menu(control_mode, interaction_mode);
gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_pos_direct), position_direct_enabled);
gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_open), openloop_enabled);
gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_imp_pos), old_impedance_enabled);
gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_imp_vel), old_impedance_enabled);
//Rememeber: these signal_connect MUST be placed after the update_menu!
g_signal_connect (radiobutton_mode_idl, "clicked",G_CALLBACK (radio_click_idl), &radiobutton_mode_idl);
g_signal_connect (radiobutton_mode_pos, "clicked",G_CALLBACK (radio_click_pos), &radiobutton_mode_pos);
g_signal_connect (radiobutton_mode_pos_direct, "clicked",G_CALLBACK (radio_click_pos_direct), &radiobutton_mode_pos_direct);
g_signal_connect (radiobutton_mode_mixed, "clicked",G_CALLBACK (radio_click_mode_mixed), &radiobutton_mode_mixed);
g_signal_connect (radiobutton_mode_vel, "clicked",G_CALLBACK (radio_click_vel), &radiobutton_mode_vel);
g_signal_connect (radiobutton_mode_trq, "clicked",G_CALLBACK (radio_click_trq), &radiobutton_mode_trq);
g_signal_connect (radiobutton_mode_imp_pos, "clicked",G_CALLBACK (radio_click_imp_pos), &radiobutton_mode_imp_pos);
g_signal_connect (radiobutton_mode_imp_vel, "clicked",G_CALLBACK (radio_click_imp_vel), &radiobutton_mode_imp_vel);
g_signal_connect (radiobutton_mode_open, "clicked",G_CALLBACK (radio_click_open), &radiobutton_mode_open);
g_signal_connect (radiobutton_interaction_stiff, "clicked",G_CALLBACK (radio_click_stiff), &radiobutton_interaction_stiff);
g_signal_connect (radiobutton_interaction_compl, "clicked",G_CALLBACK (radio_click_compl), &radiobutton_interaction_compl);
g_signal_connect (radiobutton_mode_idl, "key_press_event", G_CALLBACK (on_key_press), &radiobutton_mode_idl);
g_signal_connect (radiobutton_mode_pos, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_pos);
g_signal_connect (radiobutton_mode_pos_direct, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_pos_direct);
g_signal_connect (radiobutton_mode_mixed, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_mixed);
g_signal_connect (radiobutton_mode_vel, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_vel);
g_signal_connect (radiobutton_mode_trq, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_trq);
g_signal_connect (radiobutton_mode_imp_pos, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_imp_pos);
g_signal_connect (radiobutton_mode_imp_vel, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_imp_vel);
g_signal_connect (radiobutton_mode_open, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_open);
g_signal_connect (radiobutton_interaction_stiff, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_interaction_stiff);
g_signal_connect (radiobutton_interaction_compl, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_interaction_compl);
//connection to the destroyer
g_signal_connect (pos_winPid, "destroy",G_CALLBACK (destroy_main), &pos_winPid);
//make it visible
if (!GTK_WIDGET_VISIBLE (pos_winPid))
gtk_widget_show_all (pos_winPid);
else
{
gtk_widget_destroy (pos_winPid);
pos_winPid = NULL;
}
gtk_window_set_keep_above (GTK_WINDOW(pos_winPid),true);
gtk_main ();
return;
}
int iceb_l_sklad_v(class iceb_u_str *sklad_k,GtkWidget *wpredok)
{
char strsql[512];
iceb_u_str kikz;
class iceb_l_sklad_v data;
data.sklad_i.new_plus(sklad_k->ravno());
data.rk.clear_zero();
if(data.sklad_i.getdlinna() > 1)
{
data.rk.kod.new_plus(data.sklad_i.ravno());
sprintf(strsql,"select * from Sklad where kod=%s",data.sklad_i.ravno());
SQL_str row;
SQLCURSOR cur;
if(sql_readkey(&bd,strsql,&row,&cur) < 1)
{
iceb_menu_soob(gettext("Не найдена запись для корректировки !"),wpredok);
return(1);
}
data.rk.fmol.new_plus(row[2]);
data.rk.dolg.new_plus(row[3]);
data.rk.naim.new_plus(row[1]);
kikz.plus(iceb_kikz(row[4],row[5],wpredok));
data.rk.metka_isp_skl=atoi(row[6]);
}
else
{
sprintf(strsql,"%d",iceb_get_new_kod("Sklad",0,wpredok));
// printf("%s\n",strsql);
data.rk.kod.new_plus(strsql);
}
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
GtkWidget *label=NULL;
if(data.sklad_i.getdlinna() <= 1)
{
sprintf(strsql,"%s %s",name_system,gettext("Ввод новой записи"));
label=gtk_label_new(gettext("Ввод новой записи"));
}
else
{
sprintf(strsql,"%s %s",name_system,gettext("Корректировка записи"));
iceb_u_str repl;
repl.plus(gettext("Корректировка записи"));
repl.ps_plus(kikz.ravno());
label=gtk_label_new(repl.ravno_toutf());
}
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),&data.window);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(sklad_v_key_press),&data);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
GtkWidget *hbox[KOLENTER];
for(int i=0; i < KOLENTER; i++)
hbox[i] = gtk_hbox_new (FALSE, 0);
GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (data.window), vbox);
gtk_container_add (GTK_CONTAINER (vbox), label);
for(int i=0; i < KOLENTER; i++)
gtk_box_pack_start (GTK_BOX (vbox),hbox[i], TRUE, TRUE, 2);
// gtk_container_add (GTK_CONTAINER (vbox), hbox[i]);
GtkWidget *separator1=gtk_hseparator_new();
GtkWidget *separator3=gtk_hseparator_new();
gtk_box_pack_start (GTK_BOX (vbox),separator1, TRUE, TRUE, 2);
//Вставляем радиокнопки
data.radiobutton2[0]=gtk_radio_button_new_with_label_from_widget(NULL,gettext("Используется"));
data.radiobutton2[1]=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(data.radiobutton2[0]),gettext("Неиспользуется"));
gtk_box_pack_start (GTK_BOX (vbox), data.radiobutton2[0], TRUE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (vbox), data.radiobutton2[1], TRUE, TRUE, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton2[data.rk.metka_isp_skl]),TRUE); //Устанавливем активной кнопку
gtk_box_pack_start (GTK_BOX (vbox),separator3, TRUE, TRUE, 2);
gtk_box_pack_start (GTK_BOX (vbox),hboxknop, TRUE, TRUE, 2);
//gtk_container_add (GTK_CONTAINER (vbox), hboxknop);
label=gtk_label_new(gettext("Код"));
data.entry[E_KOD] = gtk_entry_new_with_max_length (4);
gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(sklad_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk.kod.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD);
label=gtk_label_new(gettext("Наименование"));
data.entry[E_NAIM] = gtk_entry_new_with_max_length (80);
gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(sklad_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk.naim.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM);
label=gtk_label_new(gettext("Фамилия материально-ответственного"));
data.entry[E_FIO] = gtk_entry_new_with_max_length (29);
gtk_box_pack_start (GTK_BOX (hbox[E_FIO]), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox[E_FIO]), data.entry[E_FIO], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_FIO]), "activate",GTK_SIGNAL_FUNC(sklad_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_FIO]),data.rk.fmol.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_FIO]),(gpointer)E_FIO);
label=gtk_label_new(gettext("Должность материально-ответственного"));
data.entry[E_DOLG] = gtk_entry_new_with_max_length (29);
gtk_box_pack_start (GTK_BOX (hbox[E_DOLG]), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox[E_DOLG]), data.entry[E_DOLG], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_DOLG]), "activate",GTK_SIGNAL_FUNC(sklad_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_DOLG]),data.rk.dolg.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DOLG]),(gpointer)E_DOLG);
GtkTooltips *tooltips[KOL_PFK];
sprintf(strsql,"F2 %s",gettext("Запись"));
data.knopka[PFK2]=gtk_button_new_with_label(strsql);
tooltips[PFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[PFK2],data.knopka[PFK2],gettext("Запись введеной в меню информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[PFK2]),"clicked",GTK_SIGNAL_FUNC(sklad_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK2]),(gpointer)PFK2);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[PFK10]=gtk_button_new_with_label(strsql);
tooltips[PFK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[PFK10],data.knopka[PFK10],gettext("Завершение работы с меню без записи введенной информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[PFK10]),"clicked",GTK_SIGNAL_FUNC(sklad_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK10]),(gpointer)PFK10);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK2], TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK10], TRUE, TRUE, 0);
gtk_widget_grab_focus(data.entry[1]);
gtk_widget_show_all (data.window);
gtk_main();
if(data.voz == 0)
sklad_k->new_plus(data.rk.kod.ravno());
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.voz);
}
GtkWidget *create_kbm_widget()
{
if (kbm_widget != NULL)
fprintf(stderr, "create_kbm_widget: kbm_widget was not NULL!\n");
load_settings();
GtkWidget *vbox_top = gtk_vbox_new (FALSE, 3);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL);
kbm_widget = vbox_top;
GtkWidget *hbox_lr = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_top), hbox_lr, FALSE, FALSE, 0);
GtkWidget *vbox_l = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_l), GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER (vbox_l), 10);
gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_l, TRUE, TRUE, 10);
GtkWidget *vbox_r = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_r), GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER (vbox_r), 10);
gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_r, TRUE, TRUE, 10);
GtkWidget *frame_kbm = gtk_frame_new(_("鍵盤排列方式/選擇鍵/選單每列字數"));
gtk_box_pack_start (GTK_BOX (vbox_l), frame_kbm, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_kbm), 1);
gtk_container_add (GTK_CONTAINER (frame_kbm), create_kbm_opts());
gtk_box_pack_start (GTK_BOX (vbox_l), create_en_pho_key_sel(_("(詞音) 切換[中/英]輸入"), 0), FALSE, FALSE, 0);
GtkWidget *frame_tsin_space_opt = gtk_frame_new(_("(詞音) 鍵入空白鍵"));
gtk_box_pack_start (GTK_BOX (vbox_l), frame_tsin_space_opt, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_space_opt), 1);
GtkWidget *box_tsin_space_opt = gtk_vbox_new (FALSE, 0);
gtk_orientable_set_orientation(GTK_ORIENTABLE(box_tsin_space_opt), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (frame_tsin_space_opt), box_tsin_space_opt);
gtk_container_set_border_width (GTK_CONTAINER (box_tsin_space_opt), 1);
GSList *group_tsin_space_opt = NULL;
int current_idx = get_currnet_tsin_space_option_idx();
new_select_idx_tsin_space_opt = current_idx;
gsize i;
for(i=0; i< tsin_space_optionsN; i++) {
GtkWidget *button = gtk_radio_button_new_with_label (group_tsin_space_opt, _(tsin_space_options[i].name));
gtk_box_pack_start (GTK_BOX (box_tsin_space_opt), button, FALSE, FALSE, 0);
group_tsin_space_opt = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (callback_button_clicked_tsin_space_opt), (gpointer) i);
if (i==current_idx)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
}
GtkWidget *hbox_tsin_phrase_pre_select = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_tsin_phrase_pre_select , FALSE, FALSE, 1);
check_button_tsin_phrase_pre_select = gtk_check_button_new_with_label(_("詞音輸入預選詞視窗"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_phrase_pre_select), check_button_tsin_phrase_pre_select, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_phrase_pre_select), tsin_phrase_pre_select);
GtkWidget *hbox_phonetic_char_dynamic_sequence = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_l), hbox_phonetic_char_dynamic_sequence , FALSE, FALSE, 1);
check_button_phonetic_char_dynamic_sequence = gtk_check_button_new_with_label(_("依使用頻率調整字的順序"));
gtk_box_pack_start (GTK_BOX (hbox_phonetic_char_dynamic_sequence), check_button_phonetic_char_dynamic_sequence, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_phonetic_char_dynamic_sequence), phonetic_char_dynamic_sequence);
GtkWidget *hbox_pho_hide_row2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_pho_hide_row2 , FALSE, FALSE, 1);
check_button_pho_hide_row2 = gtk_check_button_new_with_label(_("注音隱藏第二列 (注音符號)"));
gtk_box_pack_start (GTK_BOX (hbox_pho_hide_row2), check_button_pho_hide_row2, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_pho_hide_row2), pho_hide_row2);
GtkWidget *hbox_pho_in_row1 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_pho_in_row1 , FALSE, FALSE, 1);
check_button_pho_in_row1 = gtk_check_button_new_with_label(_("注音符號移至第一列"));
gtk_box_pack_start (GTK_BOX (hbox_pho_in_row1), check_button_pho_in_row1, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_pho_in_row1), pho_in_row1);
GtkWidget *hbox_phonetic_huge_tab = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_phonetic_huge_tab , FALSE, FALSE, 1);
check_button_phonetic_huge_tab = gtk_check_button_new_with_label(_("使用巨大 UTF-8 字集"));
gtk_box_pack_start (GTK_BOX (hbox_phonetic_huge_tab), check_button_phonetic_huge_tab, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_phonetic_huge_tab), phonetic_huge_tab);
GtkWidget *hbox_tsin_tone_char_input = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tone_char_input , FALSE, FALSE, 1);
check_button_tsin_tone_char_input = gtk_check_button_new_with_label(_("(詞音) 輸入注音聲調符號"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tone_char_input), check_button_tsin_tone_char_input, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tone_char_input), tsin_tone_char_input);
GtkWidget *hbox_tsin_tab_phrase_end = gtk_hbox_new(FALSE, 1);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tab_phrase_end , FALSE, FALSE, 1);
check_button_tsin_tab_phrase_end = gtk_check_button_new_with_label(_("(詞音) 使用 Escape/Tab 斷詞"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tab_phrase_end), check_button_tsin_tab_phrase_end, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tab_phrase_end), tsin_tab_phrase_end);
GtkWidget *hbox_tsin_tail_select_key = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tail_select_key , FALSE, FALSE, 1);
check_button_tsin_tail_select_key = gtk_check_button_new_with_label(_("選擇鍵顯示於候選字(詞)後方"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_tail_select_key), check_button_tsin_tail_select_key, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_tail_select_key), tsin_tail_select_key);
GtkWidget *hbox_tsin_buffer_editing_mode = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_buffer_editing_mode , FALSE, FALSE, 1);
check_button_tsin_buffer_editing_mode = gtk_check_button_new_with_label(_("\\ 鍵可切換 jkx 鍵編輯模式"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_buffer_editing_mode), check_button_tsin_buffer_editing_mode, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_buffer_editing_mode), tsin_buffer_editing_mode);
GtkWidget *hbox_tsin_use_pho_near = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_use_pho_near , FALSE, FALSE, 1);
check_button_tsin_use_pho_near = gtk_check_button_new_with_label(_("按下 ↑ 鍵查詢近似音"));
gtk_box_pack_start (GTK_BOX (hbox_tsin_use_pho_near), check_button_tsin_use_pho_near, FALSE, FALSE, 0);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(check_button_tsin_use_pho_near), tsin_use_pho_near);
GtkWidget *frame_tsin_buffer_size = gtk_frame_new(_("(詞音) 的編輯緩衝區大小"));
gtk_box_pack_start (GTK_BOX (vbox_r), frame_tsin_buffer_size, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_buffer_size), 1);
GtkAdjustment *adj_gtab_in =
(GtkAdjustment *) gtk_adjustment_new (tsin_buffer_size, 10.0, MAX_PH_BF, 1.0, 1.0, 0.0);
spinner_tsin_buffer_size = gtk_spin_button_new (adj_gtab_in, 0, 0);
gtk_container_add (GTK_CONTAINER (frame_tsin_buffer_size), spinner_tsin_buffer_size);
return kbm_widget;
}
static gboolean
shoot_dialog (GdkScreen **screen)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *notebook;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *toggle;
GtkWidget *spinner;
GdkPixbuf *pixbuf;
GSList *radio_group = NULL;
GtkObject *adj;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Screenshot"), PLUG_IN_BINARY,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
button = gtk_dialog_add_button (GTK_DIALOG (dialog),
_("S_nap"), GTK_RESPONSE_OK);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
pixbuf = gdk_pixbuf_new_from_inline (-1, screenshot_icon, FALSE, NULL);
if (pixbuf)
{
gtk_button_set_image (GTK_BUTTON (button),
gtk_image_new_from_pixbuf (pixbuf));
g_object_unref (pixbuf);
}
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox,
FALSE, FALSE, 0);
gtk_widget_show (main_vbox);
/* Hints */
notebook = g_object_new (GTK_TYPE_NOTEBOOK,
"show-border", FALSE,
"show-tabs", FALSE,
NULL);
gtk_box_pack_end (GTK_BOX (main_vbox), notebook, FALSE, FALSE, 0);
gtk_widget_show (notebook);
shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_ROOT,
_("After the delay, the screenshot is taken."));
shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_REGION,
_("After the delay, drag your mouse to select "
"the region for the screenshot."));
shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_WINDOW,
_("At the end of the delay, click in a window "
"to snap it."));
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), shootvals.shoot_type);
/* Area */
frame = gimp_frame_new (_("Area"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
/* single window */
button = gtk_radio_button_new_with_mnemonic (radio_group,
_("Take a screenshot of "
"a single _window"));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
shootvals.shoot_type == SHOOT_WINDOW);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (SHOOT_WINDOW));
g_signal_connect (button, "toggled",
G_CALLBACK (shoot_radio_button_toggled),
notebook);
#ifdef HAVE_X11_XMU_WINUTIL_H
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
toggle = gtk_check_button_new_with_mnemonic (_("Include window _decoration"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), shootvals.decorate);
gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 24);
gtk_widget_show (toggle);
g_object_set_data (G_OBJECT (button), "set_sensitive", toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&shootvals.decorate);
#endif /* HAVE_X11_XMU_WINUTIL_H */
/* whole screen */
button = gtk_radio_button_new_with_mnemonic (radio_group,
_("Take a screenshot of "
"the entire _screen"));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
shootvals.shoot_type == SHOOT_ROOT);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (SHOOT_ROOT));
g_signal_connect (button, "toggled",
G_CALLBACK (shoot_radio_button_toggled),
notebook);
/* dragged region */
button = gtk_radio_button_new_with_mnemonic (radio_group,
_("Select a _region to grab"));
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
shootvals.shoot_type == SHOOT_REGION);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (SHOOT_REGION));
g_signal_connect (button, "toggled",
G_CALLBACK (shoot_radio_button_toggled),
notebook);
/* Delay */
frame = gimp_frame_new (_("Delay"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
spinner = gimp_spin_button_new (&adj, shootvals.select_delay,
0.0, 100.0, 1.0, 5.0, 0.0, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);
gtk_widget_show (spinner);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
&shootvals.select_delay);
/* this is the unit label of a spinbutton */
label = gtk_label_new (_("seconds"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
/* get the screen on which we are running */
*screen = gtk_widget_get_screen (dialog);
}
gtk_widget_destroy (dialog);
if (run)
{
/* A short timeout to give the server a chance to
* redraw the area that was obscured by our dialog.
*/
g_timeout_add (100, shoot_quit_timeout, NULL);
gtk_main ();
}
return run;
}
dialogo_propiedades_red_t * dialogo_propiedades_red_crear() {
dialogo_propiedades_red_t * dialogo_propiedades_red =
(dialogo_propiedades_red_t*)malloc(sizeof(dialogo_propiedades_red_t));
dialogo_propiedades_red->rbt_ordenes_group = NULL;
dialogo_propiedades_red->dlg_propiedades_red = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialogo_propiedades_red->dlg_propiedades_red), "Propiedades de la red");
dialogo_propiedades_red->dialog_vbox1 = GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red)->vbox;
gtk_widget_show (dialogo_propiedades_red->dialog_vbox1);
dialogo_propiedades_red->vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (dialogo_propiedades_red->vbox1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->dialog_vbox1), dialogo_propiedades_red->vbox1, TRUE, TRUE, 0);
dialogo_propiedades_red->label1 = gtk_label_new_with_mnemonic ("_Ruta del archivo:");
gtk_widget_show (dialogo_propiedades_red->label1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->label1, FALSE, FALSE, 0);
dialogo_propiedades_red->hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (dialogo_propiedades_red->hbox1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->hbox1, TRUE, TRUE, 0);
dialogo_propiedades_red->entry_ruta = gtk_entry_new ();
gtk_widget_show (dialogo_propiedades_red->entry_ruta);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox1), dialogo_propiedades_red->entry_ruta, TRUE, TRUE, 0);
dialogo_propiedades_red->button1 = gtk_button_new ();
gtk_widget_show (dialogo_propiedades_red->button1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox1), dialogo_propiedades_red->button1, FALSE, FALSE, 0);
dialogo_propiedades_red->alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (dialogo_propiedades_red->alignment1);
gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->button1), dialogo_propiedades_red->alignment1);
dialogo_propiedades_red->hbox2 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (dialogo_propiedades_red->hbox2);
gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->alignment1), dialogo_propiedades_red->hbox2);
dialogo_propiedades_red->image1 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (dialogo_propiedades_red->image1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox2), dialogo_propiedades_red->image1, FALSE, FALSE, 0);
dialogo_propiedades_red->label4 = gtk_label_new_with_mnemonic ("_...");
gtk_widget_show (dialogo_propiedades_red->label4);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox2), dialogo_propiedades_red->label4, FALSE, FALSE, 0);
dialogo_propiedades_red->hseparator1 = gtk_hseparator_new ();
gtk_widget_show (dialogo_propiedades_red->hseparator1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->hseparator1, TRUE, TRUE, 0);
dialogo_propiedades_red->frame1 = gtk_frame_new (NULL);
gtk_widget_show (dialogo_propiedades_red->frame1);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->frame1, TRUE, TRUE, 0);
dialogo_propiedades_red->vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (dialogo_propiedades_red->vbox2);
gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->frame1), dialogo_propiedades_red->vbox2);
dialogo_propiedades_red->rbt_ordenes = gtk_radio_button_new_with_mnemonic (NULL, "\303\223_rdenes");
gtk_widget_show (dialogo_propiedades_red->rbt_ordenes);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox2), dialogo_propiedades_red->rbt_ordenes, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_ordenes), dialogo_propiedades_red->rbt_ordenes_group);
dialogo_propiedades_red->rbt_ordenes_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_ordenes));
dialogo_propiedades_red->rbt_parametros = gtk_radio_button_new_with_mnemonic (NULL, "P_ar\303\241metros");
gtk_widget_show (dialogo_propiedades_red->rbt_parametros);
gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox2), dialogo_propiedades_red->rbt_parametros, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_parametros), dialogo_propiedades_red->rbt_ordenes_group);
dialogo_propiedades_red->rbt_ordenes_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_parametros));
dialogo_propiedades_red->label3 = gtk_label_new ("M\303\263dulo");
gtk_widget_show (dialogo_propiedades_red->label3);
gtk_frame_set_label_widget (GTK_FRAME (dialogo_propiedades_red->frame1), dialogo_propiedades_red->label3);
dialogo_propiedades_red->dialog_action_area1 = GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red)->action_area;
gtk_widget_show (dialogo_propiedades_red->dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogo_propiedades_red->dialog_action_area1), GTK_BUTTONBOX_END);
dialogo_propiedades_red->cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (dialogo_propiedades_red->cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red), dialogo_propiedades_red->cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (dialogo_propiedades_red->cancelbutton1, GTK_CAN_DEFAULT);
dialogo_propiedades_red->okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (dialogo_propiedades_red->okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red), dialogo_propiedades_red->okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (dialogo_propiedades_red->okbutton1, GTK_CAN_DEFAULT);
g_signal_connect((gpointer) dialogo_propiedades_red->button1, "clicked",
G_CALLBACK(boton_abrir), dialogo_propiedades_red);
return dialogo_propiedades_red;
}
GtkWidget *create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *notebook1;
GtkWidget *table1;
GtkWidget *radioCQ;
GSList *radioCQ_group = NULL;
GtkWidget *radioCBR;
GtkWidget *radio2Pass;
GtkWidget *entryCQ;
GtkWidget *entryCBR;
GtkWidget *entry2Pass;
GtkWidget *label1;
GtkWidget *table2;
GtkWidget *label5;
GtkWidget *label6;
GtkWidget *label7;
GtkObject *spinbuttonMaxIFrame_adj;
GtkWidget *spinbuttonMaxIFrame;
GtkWidget *label8;
GtkObject *spinbuttonMinIFrame_adj;
GtkWidget *spinbuttonMinIFrame;
GtkWidget *optionME;
GtkWidget *menu4;
GtkWidget *_0___none1;
GtkWidget *_1__very_low1;
GtkWidget *_2__low1;
GtkWidget *_3__medium1;
GtkWidget *_4__high1;
GtkWidget *_5__very_high1;
GtkWidget *_6__ultra_high1;
GtkWidget *optionQzer;
GtkWidget *menu5;
GtkWidget *h263_quantizer1;
GtkWidget *mpeg_quantizer1;
GtkWidget *label2;
GtkWidget *table3;
GtkWidget *label9;
GtkWidget *label10;
GtkWidget *label11;
GtkWidget *label12;
GtkObject *spinImin_adj;
GtkWidget *spinImin;
GtkObject *spinImax_adj;
GtkWidget *spinImax;
GtkObject *spinPmin_adj;
GtkWidget *spinPmin;
GtkObject *spinPmax_adj;
GtkWidget *spinPmax;
GtkWidget *label3;
GtkWidget *label13;
GtkWidget *label4;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("Xvid Encoder"));
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
notebook1 = gtk_notebook_new ();
gtk_widget_show (notebook1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), notebook1, TRUE, TRUE, 0);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_container_add (GTK_CONTAINER (notebook1), table1);
radioCQ = gtk_radio_button_new_with_mnemonic (NULL, _("Constant Quantizer"));
gtk_widget_show (radioCQ);
gtk_table_attach (GTK_TABLE (table1), radioCQ, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioCQ), radioCQ_group);
radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioCQ));
radioCBR = gtk_radio_button_new_with_mnemonic (NULL, _("Constant Bitrate (kbps)"));
gtk_widget_show (radioCBR);
gtk_table_attach (GTK_TABLE (table1), radioCBR, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioCBR), radioCQ_group);
radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioCBR));
radio2Pass = gtk_radio_button_new_with_mnemonic (NULL, _("Dual pass (MBytes)"));
gtk_widget_show (radio2Pass);
gtk_table_attach (GTK_TABLE (table1), radio2Pass, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio2Pass), radioCQ_group);
radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio2Pass));
entryCQ = gtk_entry_new ();
gtk_widget_show (entryCQ);
gtk_table_attach (GTK_TABLE (table1), entryCQ, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entryCBR = gtk_entry_new ();
gtk_widget_show (entryCBR);
gtk_table_attach (GTK_TABLE (table1), entryCBR, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry2Pass = gtk_entry_new ();
gtk_widget_show (entry2Pass);
gtk_table_attach (GTK_TABLE (table1), entry2Pass, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label1 = gtk_label_new (_("Basic"));
gtk_widget_show (label1);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), label1);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
table2 = gtk_table_new (4, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (notebook1), table2);
label5 = gtk_label_new (_("Motion Search"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
label6 = gtk_label_new (_("Quantization"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table2), label6, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
label7 = gtk_label_new (_("Max I frame interval "));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
spinbuttonMaxIFrame_adj = gtk_adjustment_new (300, 0, 600, 1, 10, 10);
spinbuttonMaxIFrame = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonMaxIFrame_adj), 1, 0);
gtk_widget_show (spinbuttonMaxIFrame);
gtk_table_attach (GTK_TABLE (table2), spinbuttonMaxIFrame, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonMaxIFrame), TRUE);
label8 = gtk_label_new (_("Min I frame interval"));
gtk_widget_show (label8);
gtk_table_attach (GTK_TABLE (table2), label8, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5);
spinbuttonMinIFrame_adj = gtk_adjustment_new (1, 0, 600, 1, 10, 10);
spinbuttonMinIFrame = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonMinIFrame_adj), 1, 0);
gtk_widget_show (spinbuttonMinIFrame);
gtk_table_attach (GTK_TABLE (table2), spinbuttonMinIFrame, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonMinIFrame), TRUE);
optionME = gtk_option_menu_new ();
gtk_widget_show (optionME);
gtk_table_attach (GTK_TABLE (table2), optionME, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu4 = gtk_menu_new ();
_0___none1 = gtk_menu_item_new_with_mnemonic (_("0 - None"));
gtk_widget_show (_0___none1);
gtk_container_add (GTK_CONTAINER (menu4), _0___none1);
_1__very_low1 = gtk_menu_item_new_with_mnemonic (_("1- Very low"));
gtk_widget_show (_1__very_low1);
gtk_container_add (GTK_CONTAINER (menu4), _1__very_low1);
_2__low1 = gtk_menu_item_new_with_mnemonic (_("2- Low"));
gtk_widget_show (_2__low1);
gtk_container_add (GTK_CONTAINER (menu4), _2__low1);
_3__medium1 = gtk_menu_item_new_with_mnemonic (_("3- Medium"));
gtk_widget_show (_3__medium1);
gtk_container_add (GTK_CONTAINER (menu4), _3__medium1);
_4__high1 = gtk_menu_item_new_with_mnemonic (_("4- High"));
gtk_widget_show (_4__high1);
gtk_container_add (GTK_CONTAINER (menu4), _4__high1);
_5__very_high1 = gtk_menu_item_new_with_mnemonic (_("5- Very High"));
gtk_widget_show (_5__very_high1);
gtk_container_add (GTK_CONTAINER (menu4), _5__very_high1);
_6__ultra_high1 = gtk_menu_item_new_with_mnemonic (_("6- Ultra High"));
gtk_widget_show (_6__ultra_high1);
gtk_container_add (GTK_CONTAINER (menu4), _6__ultra_high1);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionME), menu4);
optionQzer = gtk_option_menu_new ();
gtk_widget_show (optionQzer);
gtk_table_attach (GTK_TABLE (table2), optionQzer, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu5 = gtk_menu_new ();
h263_quantizer1 = gtk_menu_item_new_with_mnemonic (_("H263 Quantizer"));
gtk_widget_show (h263_quantizer1);
gtk_container_add (GTK_CONTAINER (menu5), h263_quantizer1);
mpeg_quantizer1 = gtk_menu_item_new_with_mnemonic (_("MPEG Quantizer"));
gtk_widget_show (mpeg_quantizer1);
gtk_container_add (GTK_CONTAINER (menu5), mpeg_quantizer1);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionQzer), menu5);
label2 = gtk_label_new (_("Advanced"));
gtk_widget_show (label2);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), label2);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
table3 = gtk_table_new (4, 2, FALSE);
gtk_widget_show (table3);
gtk_container_add (GTK_CONTAINER (notebook1), table3);
label9 = gtk_label_new (_("Min I Frame Qzer"));
gtk_widget_show (label9);
gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5);
label10 = gtk_label_new (_("Max I Frame Qzer"));
gtk_widget_show (label10);
gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5);
label11 = gtk_label_new (_("Min P Frame Qzer"));
gtk_widget_show (label11);
gtk_table_attach (GTK_TABLE (table3), label11, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5);
label12 = gtk_label_new (_("Max P Frame Qzer"));
gtk_widget_show (label12);
gtk_table_attach (GTK_TABLE (table3), label12, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5);
spinImin_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10);
spinImin = gtk_spin_button_new (GTK_ADJUSTMENT (spinImin_adj), 1, 0);
gtk_widget_show (spinImin);
gtk_table_attach (GTK_TABLE (table3), spinImin, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinImin), TRUE);
spinImax_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10);
spinImax = gtk_spin_button_new (GTK_ADJUSTMENT (spinImax_adj), 1, 0);
gtk_widget_show (spinImax);
gtk_table_attach (GTK_TABLE (table3), spinImax, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinImax), TRUE);
spinPmin_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10);
spinPmin = gtk_spin_button_new (GTK_ADJUSTMENT (spinPmin_adj), 1, 0);
gtk_widget_show (spinPmin);
gtk_table_attach (GTK_TABLE (table3), spinPmin, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinPmin), TRUE);
spinPmax_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10);
spinPmax = gtk_spin_button_new (GTK_ADJUSTMENT (spinPmax_adj), 1, 0);
gtk_widget_show (spinPmax);
gtk_table_attach (GTK_TABLE (table3), spinPmax, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinPmax), TRUE);
label3 = gtk_label_new (_("Quantizer"));
gtk_widget_show (label3);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 2), label3);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT);
label13 = gtk_label_new (_("Not Yet!"));
gtk_widget_show (label13);
gtk_container_add (GTK_CONTAINER (notebook1), label13);
gtk_label_set_justify (GTK_LABEL (label13), GTK_JUSTIFY_LEFT);
label4 = gtk_label_new (_("B Frames"));
gtk_widget_show (label4);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 3), label4);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, notebook1, "notebook1");
GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
GLADE_HOOKUP_OBJECT (dialog1, radioCQ, "radioCQ");
GLADE_HOOKUP_OBJECT (dialog1, radioCBR, "radioCBR");
GLADE_HOOKUP_OBJECT (dialog1, radio2Pass, "radio2Pass");
GLADE_HOOKUP_OBJECT (dialog1, entryCQ, "entryCQ");
GLADE_HOOKUP_OBJECT (dialog1, entryCBR, "entryCBR");
GLADE_HOOKUP_OBJECT (dialog1, entry2Pass, "entry2Pass");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, table2, "table2");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
GLADE_HOOKUP_OBJECT (dialog1, spinbuttonMaxIFrame, "spinbuttonMaxIFrame");
GLADE_HOOKUP_OBJECT (dialog1, label8, "label8");
GLADE_HOOKUP_OBJECT (dialog1, spinbuttonMinIFrame, "spinbuttonMinIFrame");
GLADE_HOOKUP_OBJECT (dialog1, optionME, "optionME");
GLADE_HOOKUP_OBJECT (dialog1, menu4, "menu4");
GLADE_HOOKUP_OBJECT (dialog1, _0___none1, "_0___none1");
GLADE_HOOKUP_OBJECT (dialog1, _1__very_low1, "_1__very_low1");
GLADE_HOOKUP_OBJECT (dialog1, _2__low1, "_2__low1");
GLADE_HOOKUP_OBJECT (dialog1, _3__medium1, "_3__medium1");
GLADE_HOOKUP_OBJECT (dialog1, _4__high1, "_4__high1");
GLADE_HOOKUP_OBJECT (dialog1, _5__very_high1, "_5__very_high1");
GLADE_HOOKUP_OBJECT (dialog1, _6__ultra_high1, "_6__ultra_high1");
GLADE_HOOKUP_OBJECT (dialog1, optionQzer, "optionQzer");
GLADE_HOOKUP_OBJECT (dialog1, menu5, "menu5");
GLADE_HOOKUP_OBJECT (dialog1, h263_quantizer1, "h263_quantizer1");
GLADE_HOOKUP_OBJECT (dialog1, mpeg_quantizer1, "mpeg_quantizer1");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, table3, "table3");
GLADE_HOOKUP_OBJECT (dialog1, label9, "label9");
GLADE_HOOKUP_OBJECT (dialog1, label10, "label10");
GLADE_HOOKUP_OBJECT (dialog1, label11, "label11");
GLADE_HOOKUP_OBJECT (dialog1, label12, "label12");
GLADE_HOOKUP_OBJECT (dialog1, spinImin, "spinImin");
GLADE_HOOKUP_OBJECT (dialog1, spinImax, "spinImax");
GLADE_HOOKUP_OBJECT (dialog1, spinPmin, "spinPmin");
GLADE_HOOKUP_OBJECT (dialog1, spinPmax, "spinPmax");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label13, "label13");
GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
gint* mooLevelSettings(GtkMenuItem *menuitem, gint* LEVEL)
{
GtkWidget *mooPreferences;
GtkWidget *vBox;
GtkWidget *vBoxRadio;
GtkWidget *button;
GtkWidget *l1, *l2, *l3;
menu = menuitem;
*LEVEL = 4;
DIG_SELECTED = LEVEL;
mooPreferences = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (mooPreferences, 200, 190);
gtk_window_set_title (GTK_WINDOW (mooPreferences), "Select Game Level");
gtk_container_set_border_width (GTK_CONTAINER (mooPreferences), 10);
gtk_window_set_position (GTK_WINDOW (mooPreferences), GTK_WIN_POS_CENTER);
gtk_window_set_resizable (GTK_WINDOW (mooPreferences), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (mooPreferences), GTK_STOCK_PREFERENCES);
g_signal_connect (G_OBJECT (mooPreferences), "delete_event",
G_CALLBACK (close_settings), NULL);
vBox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (mooPreferences), vBox);
gtk_widget_show (vBox);
vBoxRadio = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vBoxRadio), 10);
gtk_box_pack_start (GTK_BOX (vBox), vBoxRadio, TRUE, TRUE, 0);
gtk_widget_show (vBoxRadio);
/*Level 1*/
l1 = gtk_radio_button_new_with_label ( NULL, "Easy: 3 Digits" );
/*Level 2*/
l2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (l1), "Medium: 4 Digits");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l2), TRUE);
/*Level 3*/
l3 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (l1), "Hard: 5 Digits");
gtk_box_pack_start (GTK_BOX (vBoxRadio), l1, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vBoxRadio), l2, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vBoxRadio), l3, TRUE, TRUE, 0);
gtk_widget_show (l1);
gtk_widget_show (l2);
gtk_widget_show (l3);
g_signal_connect (G_OBJECT (l1), "toggled",
G_CALLBACK (radio1Clicked), NULL);
g_signal_connect (G_OBJECT (l2), "toggled",
G_CALLBACK (radio2Clicked), NULL);
g_signal_connect (G_OBJECT (l3), "toggled",
G_CALLBACK (radio3Clicked), NULL);
vBoxRadio = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vBoxRadio), 10);
gtk_box_pack_start (GTK_BOX (vBox), vBoxRadio, FALSE, TRUE, 0);
gtk_widget_show (vBoxRadio);
button = gtk_button_new_with_label ("Moo");
gtk_box_pack_start (GTK_BOX (vBoxRadio), button, TRUE, TRUE, 0);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_HALF);
gtk_widget_show (button);
g_signal_connect_swapped (G_OBJECT (button), "clicked",
G_CALLBACK (close_settings), (gpointer)mooPreferences);
gtk_widget_show (mooPreferences);
return DIG_SELECTED;
}
GtkWidget *AP_UnixDialog_Lists::_constructWindowContents (void)
{
GtkWidget *vbox2;
GtkWidget *hbox2;
GtkWidget *vbox4;
GtkWidget *table1;
GtkWidget *style_om;
GtkWidget *type_om;
GtkWidget *type_lb;
GtkWidget *style_lb;
GtkWidget *customized_cb;
GtkWidget *frame1;
GtkWidget *table2;
GtkComboBox *font_om;
GtkListStore *font_om_menu;
GtkWidget *format_en;
GtkWidget *decimal_en;
GtkAdjustment *start_sb_adj;
GtkWidget *start_sb;
GtkAdjustment *text_align_sb_adj;
GtkWidget *text_align_sb;
GtkAdjustment *label_align_sb_adj;
GtkWidget *label_align_sb;
GtkWidget *format_lb;
GtkWidget *font_lb;
GtkWidget *delimiter_lb;
GtkWidget *start_at_lb;
GtkWidget *text_align_lb;
GtkWidget *label_align_lb;
GtkWidget *vbox3;
GtkWidget *preview_lb;
GtkWidget *hbox1;
GSList *action_group = NULL;
GtkWidget *start_list_rb;
GtkWidget *apply_list_rb;
GtkWidget *resume_list_rb;
GtkWidget *preview_area;
GtkWidget *preview_frame;
const XAP_StringSet * pSS = m_pApp->getStringSet();
UT_UTF8String s;
GtkWidget * wNoteBook = NULL;
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox2);
if(!isModal())
{
// Note Book creation
wNoteBook = gtk_notebook_new ();
gtk_widget_show(wNoteBook);
// Container for the lists
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageProperties,s);
GtkWidget * lbPageLists = gtk_label_new(s.utf8_str());
gtk_widget_show(lbPageLists);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),vbox2,lbPageLists);
m_iPageLists = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),vbox2);
// Container for Text Folding
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageFolding,s);
GtkWidget * lbPageFolding = gtk_label_new(s.utf8_str());
GtkWidget * wFoldingTable = gtk_table_new(6,3,FALSE);
gtk_widget_show(lbPageFolding);
gtk_widget_show(wFoldingTable);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),wFoldingTable,lbPageFolding);
m_iPageFold = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),wFoldingTable);
// Left Spacing Here
GtkWidget * lbLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbLeftSpacer,0,1,0,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbLeftSpacer);
// Bold markup
GtkWidget * lbFoldHeading = gtk_label_new("<b>%s</b>");
gtk_label_set_use_markup(GTK_LABEL(lbFoldHeading),TRUE);
localizeLabelMarkup(lbFoldHeading,pSS,AP_STRING_ID_DLG_Lists_FoldingLevelexp);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbFoldHeading,1,3,0,1,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(lbFoldHeading);
// Mid Left Spacing Here
GtkWidget * lbMidLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbMidLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbMidLeftSpacer,1,2,1,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbMidLeftSpacer);
m_vecFoldCheck.clear();
m_vecFoldID.clear();
UT_uint32 ID =0;
// RadioButtons
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel0,s);
GtkWidget * wF = gtk_radio_button_new_with_label(NULL, s.utf8_str());
GSList *wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"0");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,1,2,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel1,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"1");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,2,3,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel2,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"2");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,3,4,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel3,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"3");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,4,5,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel4,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"4");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,5,6,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
gtk_widget_show(wFoldingTable);
gtk_notebook_set_current_page(GTK_NOTEBOOK(wNoteBook),m_iPageLists);
}
// List Page
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
vbox4 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_widget_show (vbox4);
gtk_box_pack_start (GTK_BOX (hbox2), vbox4, FALSE, TRUE, 0);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox4), table1, FALSE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table1), 4);
style_om = gtk_combo_box_text_new();
gtk_widget_show (style_om);
gtk_table_attach (GTK_TABLE (table1), style_om, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
m_wListStyleNone_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillNoneStyleMenu(m_wListStyleNone_menu.obj());
m_wListStyleNumbered_menu = gtk_list_store_new (2, G_TYPE_STRING,
G_TYPE_INT);
_fillNumberedStyleMenu(m_wListStyleNumbered_menu.obj());
m_wListStyleBulleted_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillBulletedStyleMenu(m_wListStyleBulleted_menu.obj());
// This is the default list. Change if the list style changes
//
m_wListStyle_menu = m_wListStyleNumbered_menu;
gtk_combo_box_set_model(GTK_COMBO_BOX (style_om),
GTK_TREE_MODEL(m_wListStyleNumbered_menu.obj()));
type_om = gtk_combo_box_text_new();
gtk_widget_show (type_om);
gtk_table_attach (GTK_TABLE (table1), type_om, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_none,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_bullet,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_numbered,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
gtk_combo_box_set_active(GTK_COMBO_BOX(type_om), 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type,s);
type_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (type_lb);
gtk_table_attach (GTK_TABLE (table1), type_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (type_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Style,s);
style_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (style_lb);
gtk_table_attach (GTK_TABLE (table1), style_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (style_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_SetDefault,s);
customized_cb = gtk_dialog_add_button (GTK_DIALOG(m_wMainWindow), s.utf8_str(), BUTTON_RESET);
gtk_widget_show (customized_cb);
/* todo
gtk_table_attach (GTK_TABLE (table1), customized_cb, 0, 2, 2, 3,
(GtkAttachOptions) (GTK_SHRINK),
(GtkAttachOptions) (0), 0, 0);
*/
frame1 = gtk_frame_new (NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame1), GTK_SHADOW_NONE);
//gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox4), frame1, TRUE, TRUE, 0);
table2 = gtk_table_new (6, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame1), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 4);
gtk_widget_set_sensitive (table2, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table2), 4);
gtk_table_set_col_spacings (GTK_TABLE (table2), 4);
font_om_menu = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
_fillFontMenu(font_om_menu);
font_om = GTK_COMBO_BOX(gtk_combo_box_new());
gtk_combo_box_set_model(font_om, GTK_TREE_MODEL(font_om_menu));
gtk_widget_show (GTK_WIDGET(font_om));
gtk_table_attach (GTK_TABLE (table2), GTK_WIDGET(font_om), 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
format_en = gtk_entry_new ();
gtk_entry_set_max_length(GTK_ENTRY(format_en), 20);
gtk_widget_show (format_en);
gtk_table_attach (GTK_TABLE (table2), format_en, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "%L");
decimal_en = gtk_entry_new ();
gtk_widget_show (decimal_en);
gtk_table_attach (GTK_TABLE (table2), decimal_en, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "");
start_sb_adj = (GtkAdjustment*)gtk_adjustment_new (1, 0, G_MAXINT32, 1, 10, 10);
start_sb = gtk_spin_button_new (GTK_ADJUSTMENT (start_sb_adj), 1, 0);
gtk_widget_show (start_sb);
gtk_table_attach (GTK_TABLE (table2), start_sb, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
text_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0.25, 0, 10, 0.01, 0.2, 1);
text_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (text_align_sb_adj), 0.05, 2);
gtk_widget_show (text_align_sb);
gtk_table_attach (GTK_TABLE (table2), text_align_sb, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (text_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (text_align_sb), TRUE);
label_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0, 0, 10, 0.01, 0.2, 1);
label_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (label_align_sb_adj), 0.05, 2);
gtk_widget_show (label_align_sb);
gtk_table_attach (GTK_TABLE (table2), label_align_sb, 1, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (label_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (label_align_sb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Format,s);
format_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (format_lb);
gtk_table_attach (GTK_TABLE (table2), format_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (format_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Font,s);
font_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (font_lb);
gtk_table_attach (GTK_TABLE (table2), font_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (font_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_DelimiterString,s);
delimiter_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (delimiter_lb);
gtk_table_attach (GTK_TABLE (table2), delimiter_lb, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (delimiter_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start,s);
start_at_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (start_at_lb);
gtk_table_attach (GTK_TABLE (table2), start_at_lb, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (start_at_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Align,s);
text_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (text_align_lb);
gtk_table_attach (GTK_TABLE (table2), text_align_lb, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (text_align_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Indent,s);
label_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (label_align_lb);
gtk_table_attach (GTK_TABLE (table2), label_align_lb, 0, 1, 5, 6,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_align_lb), 0.0, 0.5);
vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (hbox2), vbox3, TRUE, TRUE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Preview,s);
preview_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (preview_lb);
gtk_box_pack_start (GTK_BOX (vbox3), preview_lb, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (preview_lb), 0.0, 0.5);
preview_frame = gtk_frame_new (NULL);
gtk_widget_show (preview_frame);
gtk_box_pack_start (GTK_BOX (vbox3), preview_frame, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (preview_frame), 3);
gtk_frame_set_shadow_type (GTK_FRAME (preview_frame), GTK_SHADOW_NONE);
preview_area = createDrawingArea ();
gtk_widget_set_size_request (preview_area,180,225);
gtk_widget_show (preview_area);
gtk_container_add (GTK_CONTAINER (preview_frame), preview_area);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
if(!isModal())
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start_New,s);
start_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (start_list_rb));
if(!isModal())
gtk_widget_show (start_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), start_list_rb, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (start_list_rb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Apply_Current,s);
apply_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (apply_list_rb));
if(!isModal())
gtk_widget_show (apply_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), apply_list_rb, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Resume,s);
resume_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (resume_list_rb));
if(!isModal())
gtk_widget_show (resume_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), resume_list_rb, FALSE, FALSE, 0);
// Save useful widgets in member variables
if(isModal())
{
m_wContents = vbox2;
}
else
{
m_wContents = wNoteBook;
}
m_wStartNewList = start_list_rb;
m_wStartNew_label = gtk_bin_get_child(GTK_BIN(start_list_rb));
m_wApplyCurrent = apply_list_rb;
m_wStartSubList = resume_list_rb;
m_wStartSub_label = gtk_bin_get_child(GTK_BIN(resume_list_rb));
m_wRadioGroup = action_group;
m_wPreviewArea = preview_area;
m_wDelimEntry = format_en;
m_oAlignList_adj = text_align_sb_adj;
m_wAlignListSpin = text_align_sb;
m_oIndentAlign_adj = label_align_sb_adj;
m_wIndentAlignSpin = label_align_sb;
m_wDecimalEntry = decimal_en;
m_oStartSpin_adj = start_sb_adj;
m_wStartSpin = start_sb;
m_wFontOptions = font_om;
m_wFontOptions_menu = font_om_menu;
m_wCustomFrame = frame1;
m_wCustomLabel = customized_cb;
m_wCustomTable = table2;
m_wListStyleBox = GTK_COMBO_BOX(style_om);
m_wListTypeBox = GTK_COMBO_BOX(type_om);
m_wListType_menu = m_wListStyleNumbered_menu;
// Start by hiding the Custom frame
//
// gtk_widget_hide(m_wCustomFrame);
gtk_widget_show(m_wCustomFrame);
setbisCustomized(false);
return m_wContents;
}
static void
create_screenshot_frame (GtkWidget *outer_vbox,
const gchar *frame_title)
{
GtkWidget *main_vbox, *vbox, *hbox;
GtkWidget *align;
GtkWidget *radio;
GtkWidget *image;
GtkWidget *spin;
GtkWidget *label;
GtkAdjustment *adjust;
GSList *group;
gchar *title;
#if GTK_CHECK_VERSION (3, 0, 0)
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
main_vbox = gtk_vbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (outer_vbox), main_vbox, FALSE, FALSE, 0);
gtk_widget_show (main_vbox);
title = g_strconcat ("<b>", frame_title, "</b>", NULL);
label = gtk_label_new (title);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (title);
#if GTK_CHECK_VERSION (3, 0, 0)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
#else
hbox = gtk_hbox_new (FALSE, 12);
#endif
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
align = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
gtk_widget_set_size_request (align, 48, -1);
gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, FALSE, 0);
gtk_widget_show (align);
image = gtk_image_new_from_stock (SCREENSHOOTER_ICON,
GTK_ICON_SIZE_DIALOG);
gtk_container_add (GTK_CONTAINER (align), image);
gtk_widget_show (image);
#if GTK_CHECK_VERSION (3, 0, 0)
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
#else
vbox = gtk_vbox_new (FALSE, 6);
#endif
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
/** Grab whole desktop **/
group = NULL;
radio = gtk_radio_button_new_with_mnemonic (group,
_("Grab the whole _desktop"));
if (take_window_shot || take_area_shot)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), FALSE);
g_signal_connect (radio, "toggled",
G_CALLBACK (target_toggled_cb),
GINT_TO_POINTER (TARGET_TOGGLE_DESKTOP));
gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
gtk_widget_show (radio);
/** Grab current window **/
radio = gtk_radio_button_new_with_mnemonic (group,
_("Grab the current _window"));
if (take_window_shot)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE);
g_signal_connect (radio, "toggled",
G_CALLBACK (target_toggled_cb),
GINT_TO_POINTER (TARGET_TOGGLE_WINDOW));
gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio));
gtk_widget_show (radio);
/** Grab area of the desktop **/
radio = gtk_radio_button_new_with_mnemonic (group,
_("Select _area to grab"));
if (take_area_shot)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE);
g_signal_connect (radio, "toggled",
G_CALLBACK (target_toggled_cb),
GINT_TO_POINTER (TARGET_TOGGLE_AREA));
gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0);
gtk_widget_show (radio);
/** Grab after delay **/
#if GTK_CHECK_VERSION (3, 0, 0)
delay_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
#else
delay_hbox = gtk_hbox_new (FALSE, 6);
#endif
gtk_widget_set_sensitive (delay_hbox, !take_area_shot);
gtk_box_pack_start (GTK_BOX (vbox), delay_hbox, FALSE, FALSE, 0);
gtk_widget_show (delay_hbox);
/* translators: this is the first part of the "grab after a
* delay of <spin button> seconds".
*/
label = gtk_label_new_with_mnemonic (_("Grab _after a delay of"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_box_pack_start (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adjust = GTK_ADJUSTMENT (gtk_adjustment_new ((gdouble) delay,
0.0, 99.0,
1.0, 1.0,
0.0));
spin = gtk_spin_button_new (adjust, 1.0, 0);
g_signal_connect (spin, "value-changed",
G_CALLBACK (delay_spin_value_changed_cb),
NULL);
gtk_box_pack_start (GTK_BOX (delay_hbox), spin, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin);
gtk_widget_show (spin);
/* translators: this is the last part of the "grab after a
* delay of <spin button> seconds".
*/
label = gtk_label_new (_("seconds"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_box_pack_end (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
}
/*
* snap_dialog
*
* Bring up the GTK dialog for setting snapshot
* parameters.
*/
static gboolean
snap_dialog (void)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkObject *adj;
GSList *radio_group = NULL;
gint radio_pressed[2];
gint decorations;
gboolean run;
/* Set defaults */
radio_pressed[0] = (winsnapvals.root == FALSE);
radio_pressed[1] = (winsnapvals.root == TRUE);
decorations = winsnapvals.decor;
/* Init GTK */
gimp_ui_init (PLUG_IN_BINARY, FALSE);
/* Main Dialog */
dialog = gimp_dialog_new (PLUG_IN_PRINT_NAME, PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Grab"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
winsnapintf.single_button =
gtk_radio_button_new_with_label (radio_group,
_("Grab a single window"));
gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.single_button, FALSE, FALSE, 0);
g_signal_connect (winsnapintf.single_button, "toggled",
G_CALLBACK (snap_toggle_update),
&radio_pressed[0]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.single_button),
radio_pressed[0]);
gtk_widget_show (winsnapintf.single_button);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.single_button));
winsnapintf.root_button =
gtk_radio_button_new_with_label (radio_group,
_("Grab the whole screen"));
gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.root_button, FALSE, FALSE, 0);
g_signal_connect (winsnapintf.root_button, "toggled",
G_CALLBACK (snap_toggle_update),
&radio_pressed[1]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.root_button),
radio_pressed[1]);
gtk_widget_show (winsnapintf.root_button);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.root_button));
/* with delay */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("after"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
winsnapintf.delay_spinner = gimp_spin_button_new (&adj,
winsnapvals.delay,
0.0, 100.0,
1.0, 5.0, 0.0, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox),
winsnapintf.delay_spinner, FALSE, FALSE, 0);
gtk_widget_show (winsnapintf.delay_spinner);
label = gtk_label_new (_("Seconds delay"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
#ifdef CAN_SET_DECOR
/* With decorations */
winsnapintf.decor_button =
gtk_check_button_new_with_label (_("Include decorations"));
g_signal_connect (winsnapintf.decor_button, "toggled",
G_CALLBACK (snap_toggle_update),
&decorations);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.decor_button),
decorations);
gtk_box_pack_end (GTK_BOX (vbox), winsnapintf.decor_button, FALSE, FALSE, 0);
gtk_widget_set_sensitive (winsnapintf.decor_button, radio_pressed[0]);
gtk_widget_show (winsnapintf.decor_button);
#endif /* CAN_SET_DECOR */
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
winsnapvals.root = radio_pressed[1];
winsnapvals.decor = decorations;
winsnapvals.delay =
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (winsnapintf.delay_spinner));
}
gtk_widget_destroy (dialog);
return run;
}
static GtkWidget *
message_get_properties(Message *message)
{
MessageDialog *prop_dialog;
GtkWidget *dialog;
GtkWidget *entry;
GtkWidget *hbox;
GtkWidget *label;
GSList *group;
if (properties_dialog == NULL) {
prop_dialog = g_new(MessageDialog, 1);
properties_dialog = prop_dialog;
dialog = gtk_vbox_new(FALSE, 0);
prop_dialog->dialog = dialog;
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Message:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
entry = gtk_entry_new();
prop_dialog->text = GTK_ENTRY(entry);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_widget_show (label);
gtk_widget_show (entry);
gtk_box_pack_start (GTK_BOX (dialog), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
label = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (dialog), label, FALSE, TRUE, 0);
gtk_widget_show (label);
label = gtk_label_new(_("Message type:"));
gtk_box_pack_start (GTK_BOX (dialog), label, FALSE, TRUE, 0);
gtk_widget_show (label);
/* */
prop_dialog->m_call = gtk_radio_button_new_with_label (NULL, _("Call"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_call, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_call);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prop_dialog->m_call), TRUE);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_call));
prop_dialog->m_return = gtk_radio_button_new_with_label(group, _("Return"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_return, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_return);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_return));
prop_dialog->m_send = gtk_radio_button_new_with_label(group, _("Asynchronous"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_send, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_send);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_send));
prop_dialog->m_create = gtk_radio_button_new_with_label(group, _("Create"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_create, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_create);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_create));
prop_dialog->m_destroy = gtk_radio_button_new_with_label(group, _("Destroy"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_destroy, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_destroy);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_destroy));
prop_dialog->m_simple = gtk_radio_button_new_with_label(group, _("Simple"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_simple, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_simple);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_simple));
prop_dialog->m_recursive = gtk_radio_button_new_with_label(group, _("Recursive"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_recursive, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_recursive);
}
fill_in_dialog(message);
gtk_widget_show (properties_dialog->dialog);
return properties_dialog->dialog;
}
static GtkWidget *
account_assistant_build_introduction_page (EmpathyAccountAssistant *self)
{
EmpathyAccountAssistantPriv *priv = GET_PRIV (self);
GtkWidget *main_vbox, *hbox_1, *w, *vbox_1;
GtkWidget *radio = NULL;
GdkPixbuf *pix;
const gchar *str;
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (main_vbox);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
hbox_1 = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox_1, TRUE, TRUE, 0);
gtk_widget_show (hbox_1);
w = gtk_label_new (
_("With Empathy you can chat with people "
"online nearby and with friends and colleagues "
"who use Google Talk, AIM, Windows Live "
"and many other chat programs. With a microphone "
"or a webcam you can also have audio or video calls."));
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_box_pack_start (GTK_BOX (hbox_1), w, FALSE, FALSE, 0);
gtk_widget_show (w);
pix = empathy_pixbuf_from_icon_name_sized ("empathy", 80);
w = gtk_image_new_from_pixbuf (pix);
gtk_box_pack_start (GTK_BOX (hbox_1), w, FALSE, FALSE, 6);
gtk_widget_show (w);
g_object_unref (pix);
w = gtk_label_new (_("Do you have an account you've been using "
"with another chat program?"));
gtk_misc_set_alignment (GTK_MISC (w), 0, 0);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
w = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), w, TRUE, TRUE, 0);
gtk_widget_show (w);
vbox_1 = gtk_vbox_new (TRUE, 0);
gtk_container_add (GTK_CONTAINER (w), vbox_1);
gtk_widget_show (vbox_1);
if (empathy_import_accounts_to_import ())
{
hbox_1 = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_1), hbox_1, TRUE, TRUE, 0);
gtk_widget_show (hbox_1);
radio = gtk_radio_button_new_with_label (NULL,
_("Yes, import my account details from "));
gtk_box_pack_start (GTK_BOX (hbox_1), radio, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (radio), "response",
GINT_TO_POINTER (RESPONSE_IMPORT));
gtk_widget_show (radio);
w = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (w), "Pidgin");
gtk_box_pack_start (GTK_BOX (hbox_1), w, TRUE, TRUE, 0);
gtk_combo_box_set_active (GTK_COMBO_BOX (w), 0);
gtk_widget_show (w);
g_signal_connect (radio, "clicked",
G_CALLBACK (account_assistant_radio_choice_toggled_cb), self);
priv->first_resp = RESPONSE_IMPORT;
}
else
{
priv->first_resp = RESPONSE_ENTER_ACCOUNT;
}
str = _("Yes, I'll enter my account details now");
if (radio == NULL)
{
radio = gtk_radio_button_new_with_label (NULL, str);
w = radio;
}
else
{
w = gtk_radio_button_new_with_label_from_widget (
GTK_RADIO_BUTTON (radio), str);
}
gtk_box_pack_start (GTK_BOX (vbox_1), w, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (w), "response",
GINT_TO_POINTER (RESPONSE_ENTER_ACCOUNT));
gtk_widget_show (w);
g_signal_connect (w, "clicked",
G_CALLBACK (account_assistant_radio_choice_toggled_cb), self);
w = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio),
_("No, I want a new account"));
gtk_box_pack_start (GTK_BOX (vbox_1), w, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (w), "response",
GINT_TO_POINTER (RESPONSE_CREATE_ACCOUNT));
gtk_widget_show (w);
g_signal_connect (w, "clicked",
G_CALLBACK (account_assistant_radio_choice_toggled_cb), self);
w = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio),
_("No, I just want to see people online nearby for now"));
gtk_box_pack_start (GTK_BOX (vbox_1), w, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (w), "response",
GINT_TO_POINTER (RESPONSE_SALUT_ONLY));
gtk_widget_show (w);
g_signal_connect (w, "clicked",
G_CALLBACK (account_assistant_radio_choice_toggled_cb), self);
return main_vbox;
}
static void
target_version_box_fill (GladeProjectProperties *properties)
{
GladeProjectPropertiesPrivate *priv = properties->priv;
GladeProject *project = priv->project;
GtkWidget *vbox = priv->toolkit_box;
GtkWidget *label, *active_radio, *target_radio, *hbox;
GList *list, *targets;
/* Add stuff to vbox */
for (list = glade_app_get_catalogs (); list; list = g_list_next (list))
{
GladeCatalog *catalog = list->data;
gint minor, major;
/* Skip if theres only one option */
if (g_list_length (glade_catalog_get_targets (catalog)) <= 1)
continue;
glade_project_get_target_version (project,
glade_catalog_get_name (catalog),
&major, &minor);
/* Special case to mark GTK+ in upper case */
if (strcmp (glade_catalog_get_name (catalog), "gtk+") == 0)
label = gtk_label_new ("GTK+");
else
label = gtk_label_new (glade_catalog_get_name (catalog));
gtk_misc_set_alignment (GTK_MISC (label), 0.0F, 0.5F);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
active_radio = target_radio = NULL;
for (targets = glade_catalog_get_targets (catalog);
targets; targets = targets->next)
{
GladeTargetableVersion *version = targets->data;
gchar *name = g_strdup_printf ("%d.%d",
version->major,
version->minor);
if (!target_radio)
target_radio = gtk_radio_button_new_with_label (NULL, name);
else
target_radio =
gtk_radio_button_new_with_label_from_widget
(GTK_RADIO_BUTTON (target_radio), name);
g_free (name);
g_signal_connect (G_OBJECT (target_radio), "clicked",
G_CALLBACK (target_button_clicked), properties);
g_object_set_data (G_OBJECT (target_radio), "version", version);
g_object_set_data (G_OBJECT (target_radio), "catalog",
(gchar *) glade_catalog_get_name (catalog));
gtk_widget_show (target_radio);
gtk_box_pack_end (GTK_BOX (hbox), target_radio, TRUE, TRUE, 2);
if (major == version->major && minor == version->minor)
active_radio = target_radio;
}
if (active_radio)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (active_radio), TRUE);
g_hash_table_insert (priv->target_radios,
g_strdup (glade_catalog_get_name (catalog)),
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(active_radio)));
}
else
g_warning ("Corrupt catalog versions");
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2);
}
}
static void
greeter_system_handler (GreeterItemInfo *info,
gpointer user_data)
{
GtkWidget *w = NULL;
GtkWidget *hbox = NULL;
GtkWidget *main_vbox = NULL;
GtkWidget *vbox = NULL;
GtkWidget *cat_vbox = NULL;
GtkWidget *group_radio = NULL;
GtkWidget *halt_radio = NULL;
GtkWidget *suspend_radio = NULL;
GtkWidget *restart_radio = NULL;
GtkWidget *config_radio = NULL;
gchar *s;
int ret;
gint i;
GSList *radio_group = NULL;
static GtkTooltips *tooltips = NULL;
/* should never be allowed by the UI */
if ( ! mdm_config_get_bool (MDM_KEY_SYSTEM_MENU) ||
ve_string_empty (g_getenv ("MDM_IS_LOCAL")))
return;
dialog = gtk_dialog_new ();
if (tooltips == NULL)
tooltips = gtk_tooltips_new ();
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
main_vbox = gtk_vbox_new (FALSE, 18);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
main_vbox,
FALSE, FALSE, 0);
cat_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (main_vbox),
cat_vbox,
FALSE, FALSE, 0);
s = g_strdup_printf ("<b>%s</b>",
_("Choose an Action"));
w = gtk_label_new (s);
gtk_label_set_use_markup (GTK_LABEL (w), TRUE);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (cat_vbox), w, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (cat_vbox),
hbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox),
gtk_label_new (" "),
FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox),
vbox,
TRUE, TRUE, 0);
if (MdmHaltFound) {
if (group_radio != NULL)
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio));
halt_radio = gtk_radio_button_new_with_mnemonic (radio_group,
_("Shut _down the computer"));
group_radio = halt_radio;
gtk_tooltips_set_tip (tooltips, GTK_WIDGET (halt_radio),
_("Shut Down your computer so that "
"you may turn it off."),
NULL);
g_signal_connect (G_OBJECT(halt_radio), "button_press_event",
G_CALLBACK(radio_button_press_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox),
halt_radio,
FALSE, FALSE, 4);
gtk_widget_show (halt_radio);
}
if (MdmRebootFound) {
if (group_radio != NULL)
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio));
restart_radio = gtk_radio_button_new_with_mnemonic (radio_group,
_("_Restart the computer"));
group_radio = restart_radio;
gtk_tooltips_set_tip (tooltips, GTK_WIDGET (restart_radio),
_("Restart your computer"),
NULL);
g_signal_connect (G_OBJECT(restart_radio), "button_press_event",
G_CALLBACK(radio_button_press_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox),
restart_radio,
FALSE, FALSE, 4);
gtk_widget_show (restart_radio);
}
if (MdmSuspendFound) {
if (group_radio != NULL)
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio));
suspend_radio = gtk_radio_button_new_with_mnemonic (radio_group,
_("Sus_pend the computer"));
group_radio = suspend_radio;
gtk_tooltips_set_tip (tooltips, GTK_WIDGET (suspend_radio),
_("Suspend your computer"),
NULL);
g_signal_connect (G_OBJECT(suspend_radio), "button_press_event",
G_CALLBACK(radio_button_press_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox),
suspend_radio,
FALSE, FALSE, 4);
gtk_widget_show (suspend_radio);
}
/*
* Disable Configuration if using accessibility (AddGtkModules) since
* using it with accessibility causes a hang.
*/
if (mdm_config_get_bool (MDM_KEY_CONFIG_AVAILABLE) &&
!mdm_config_get_bool (MDM_KEY_ADD_GTK_MODULES) &&
bin_exists (mdm_config_get_string (MDM_KEY_CONFIGURATOR))) {
if (group_radio != NULL)
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio));
config_radio = gtk_radio_button_new_with_mnemonic (radio_group,
_("Confi_gure the login manager"));
group_radio = config_radio;
gtk_tooltips_set_tip (tooltips, GTK_WIDGET (config_radio),
_("Configure MDM (this login manager). "
"This will require the root password."),
NULL);
g_signal_connect (G_OBJECT(config_radio), "button_press_event",
G_CALLBACK(radio_button_press_event), NULL);
gtk_box_pack_start (GTK_BOX (vbox),
config_radio,
FALSE, FALSE, 4);
gtk_widget_show (config_radio);
}
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_OK,
GTK_RESPONSE_OK);
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
gtk_widget_show_all (dialog);
mdm_wm_center_window (GTK_WINDOW (dialog));
mdm_wm_no_login_focus_push ();
ret = gtk_dialog_run (GTK_DIALOG (dialog));
mdm_wm_no_login_focus_pop ();
if (ret != GTK_RESPONSE_OK)
{
gtk_widget_destroy (dialog);
return;
}
if (halt_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (halt_radio)))
greeter_halt_handler ();
else if (restart_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (restart_radio)))
greeter_restart_handler ();
else if (suspend_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (suspend_radio)))
greeter_suspend_handler ();
else if (config_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (config_radio)))
greeter_config_handler ();
gtk_widget_destroy (dialog);
}
void CUIHandler::ShowSettingsDlg(void)
{
GtkWidget* settingsDlg;
GtkWidget* dialog_vbox1;
GtkWidget* frame4;
GtkWidget* alignment4;
GtkWidget* vbox2;
GtkWidget* radiobuttonBt;
GtkWidget* hbox2;
GtkWidget* radiobuttonInet;
GtkWidget* label5;
GtkWidget* inetPort;
GtkWidget* label4;
GtkWidget* dialog_action_area1;
CUserSettings crtSettings = pSmartEngine->GetSettings();
settingsDlg = gtk_dialog_new_with_buttons("SmartCam Preferences",
GTK_WINDOW(pSmartEngine->GetMainWindow()),
GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_window_set_type_hint(GTK_WINDOW (settingsDlg), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (settingsDlg)->vbox;
gtk_widget_show (dialog_vbox1);
frame4 = gtk_frame_new (NULL);
gtk_widget_show (frame4);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), frame4, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame4), GTK_SHADOW_IN);
alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment4);
gtk_container_add (GTK_CONTAINER (frame4), alignment4);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 10, 10, 12, 12);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_add (GTK_CONTAINER (alignment4), vbox2);
radiobuttonBt = gtk_radio_button_new_with_mnemonic(NULL, "Bluetooth");
gtk_box_pack_start(GTK_BOX (vbox2), radiobuttonBt, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox2);
gtk_box_pack_start(GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
radiobuttonInet = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(radiobuttonBt), "TCP/IP (WiFi)");
gtk_box_pack_start(GTK_BOX (hbox2), radiobuttonInet, FALSE, FALSE, 0);
label5 = gtk_label_new(" Port: ");
gtk_box_pack_start(GTK_BOX(hbox2), label5, FALSE, FALSE, 0);
inetPort = gtk_spin_button_new_with_range(1025, 65536, 1);
gtk_box_pack_start(GTK_BOX(hbox2), inetPort, TRUE, TRUE, 0);
label4 = gtk_label_new("Connection");
gtk_frame_set_label_widget(GTK_FRAME(frame4), label4);
gtk_label_set_use_markup(GTK_LABEL(label4), TRUE);
dialog_action_area1 = GTK_DIALOG(settingsDlg)->action_area;
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
g_signal_connect(G_OBJECT(radiobuttonBt), "toggled", G_CALLBACK(OnRadiobuttonBluetooth), inetPort);
if(crtSettings.connectionType == CONN_BLUETOOTH)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), FALSE);
g_object_set(G_OBJECT(inetPort), "sensitive", FALSE, NULL);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), FALSE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), TRUE);
g_object_set(G_OBJECT(inetPort), "sensitive", TRUE, NULL);
}
gtk_spin_button_set_value(GTK_SPIN_BUTTON(inetPort), crtSettings.inetPort);
gtk_widget_show_all(settingsDlg);
if(gtk_dialog_run(GTK_DIALOG(settingsDlg)) == GTK_RESPONSE_OK)
{
CUserSettings newSettings = crtSettings;
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobuttonBt)))
{
newSettings.connectionType = CONN_BLUETOOTH;
}
else
{
newSettings.connectionType = CONN_INET;
newSettings.inetPort = gtk_spin_button_get_value(GTK_SPIN_BUTTON(inetPort));
}
pSmartEngine->SaveSettings(newSettings);
}
gtk_widget_destroy(settingsDlg);
}
int l_kasopp_v(iceb_u_str *kodzap, //Код записи для корректировки ; возвращается код только что введённой записи
GtkWidget *wpredok)
{
l_kasopp_v_data data;
data.kodk.new_plus(kodzap->ravno());
iceb_u_str naim_shet("");
iceb_u_str naim_shetk("");
class iceb_u_str naim_kodcn("");
char strsql[512];
class iceb_u_str kikz;
if(kodzap->getdlinna() > 1)
{
//читаем корректируемую запись
SQL_str row;
SQLCURSOR cur;
sprintf(strsql,"select * from Kasop1 where kod='%s'",kodzap->ravno());
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) != 1)
{
iceb_menu_soob(gettext("Не найдена запись для корректировки !"),wpredok);
return(1);
}
data.rk.kod.new_plus(row[0]);
data.rk.naim.new_plus(row[1]);
data.rk.shet.new_plus(row[2]);
data.rk.shetk.new_plus(row[3]);
data.rk.prov=atoi(row[4]);
kikz.plus(iceb_kikz(row[5],row[6],wpredok));
if(atoi(row[7]) != 0)
data.rk.kod_cn.new_plus(row[7]);
if(data.rk.shet.getdlinna() > 1)
{
//Узнаём наименование счёта
sprintf(strsql,"select nais from Plansh where ns='%s'",data.rk.shet.ravno());
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1)
naim_shet.new_plus(row[0]);
}
if(data.rk.shetk.getdlinna() > 1)
{
//Узнаём наименование счёта корреспондента
sprintf(strsql,"select nais from Plansh where ns='%s'",data.rk.shetk .ravno());
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1)
naim_shetk.new_plus(row[0]);
}
if(data.rk.kod_cn.getdlinna() > 1)
{
//Узнаём наименование счёта корреспондента
sprintf(strsql,"select naik from Kascn where kod=%d",data.rk.kod_cn.ravno_atoi());
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1)
naim_kodcn.new_plus(row[0]);
}
}
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
if(kodzap->getdlinna() > 1)
sprintf(strsql,"%s %s",name_system,gettext("Корректировка записи"));
else
sprintf(strsql,"%s %s",name_system,gettext("Ввод новой записи"));
gtk_window_set_title (GTK_WINDOW (data.window),strsql);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_kasopp_v_v_key_press),&data);
iceb_u_str zagolov;
if(kodzap->getdlinna() <= 1)
zagolov.new_plus(gettext("Ввод новой записи"));
else
{
zagolov.new_plus(gettext("Корректировка записи"));
zagolov.ps_plus(kikz.ravno());
}
GtkWidget *label=gtk_label_new(zagolov.ravno_toutf());
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
GtkWidget *hbox[KOLENTER];
for(int i=0; i < KOLENTER; i++)
hbox[i] = gtk_hbox_new (FALSE, 0);
GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (data.window), vbox);
gtk_box_pack_start (GTK_BOX (vbox),label, TRUE, TRUE, 1);
for(int i=0; i < KOLENTER; i++)
gtk_box_pack_start (GTK_BOX (vbox),hbox[i], TRUE, TRUE, 1);
GtkWidget *separator1=gtk_hseparator_new();
GtkWidget *separator3=gtk_hseparator_new();
gtk_box_pack_start (GTK_BOX (vbox),separator1, TRUE, TRUE, 2);
//Вставляем радиокнопки
data.radiobutton2[0]=gtk_radio_button_new_with_label_from_widget(NULL,gettext("Проводки не нужно делать"));
data.radiobutton2[1]=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(data.radiobutton2[0]),gettext("Проводки нужно делать"));
gtk_box_pack_start (GTK_BOX (vbox), data.radiobutton2[0], TRUE, TRUE, 1);
gtk_box_pack_start (GTK_BOX (vbox), data.radiobutton2[1], TRUE, TRUE, 1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton2[data.rk.prov]),TRUE); //Устанавливем активной кнопку
gtk_box_pack_start (GTK_BOX (vbox),separator3, TRUE, TRUE, 2);
gtk_box_pack_start (GTK_BOX (vbox),hboxknop, TRUE, TRUE, 1);
GtkTooltips *tooltips_enter[KOLENTER];
sprintf(strsql,"%s",gettext("Код операции"));
label=gtk_label_new(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE, 0);
data.entry[E_KOD] = gtk_entry_new_with_max_length (20);
gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD],TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk.kod.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD);
sprintf(strsql,"%s",gettext("Наименование операции"));
label=gtk_label_new(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label,FALSE, FALSE, 0);
data.entry[E_NAIM] = gtk_entry_new_with_max_length (249);
gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM],TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk.naim.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM);
sprintf(strsql,"%s",gettext("Счёт"));
data.knopka_enter[E_SHET]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.knopka_enter[E_SHET], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_SHET]),"clicked",GTK_SIGNAL_FUNC(kasopp_v_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_SHET]),(gpointer)E_SHET);
tooltips_enter[E_SHET]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips_enter[E_SHET],data.knopka_enter[E_SHET],gettext("Выбор счёта в плане счетов"),NULL);
data.entry[E_SHET] = gtk_entry_new_with_max_length (19);
gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.entry[E_SHET],TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_SHET]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_SHET]),data.rk.shet.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SHET]),(gpointer)E_SHET);
data.label_naishet=gtk_label_new(naim_shet.ravno_toutf(20));
gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.label_naishet,TRUE, TRUE, 0);
sprintf(strsql,"%s",gettext("Счёт корреспондент"));
data.knopka_enter[E_SHETK]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_SHETK]), data.knopka_enter[E_SHETK], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_SHETK]),"clicked",GTK_SIGNAL_FUNC(kasopp_v_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_SHETK]),(gpointer)E_SHETK);
tooltips_enter[E_SHETK]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips_enter[E_SHETK],data.knopka_enter[E_SHETK],gettext("Выбор счёта в плане счетов"),NULL);
data.entry[E_SHETK] = gtk_entry_new_with_max_length (19);
gtk_box_pack_start (GTK_BOX (hbox[E_SHETK]), data.entry[E_SHETK],TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_SHETK]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_SHETK]),data.rk.shetk.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SHETK]),(gpointer)E_SHETK);
data.label_naishetk=gtk_label_new(naim_shetk.ravno_toutf(20));
gtk_box_pack_start (GTK_BOX (hbox[E_SHETK]), data.label_naishetk,TRUE, TRUE, 0);
sprintf(strsql,"%s",gettext("Код целевого назначения"));
data.knopka_enter[E_KOD_CN]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_KOD_CN]), data.knopka_enter[E_KOD_CN], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KOD_CN]),"clicked",GTK_SIGNAL_FUNC(kasopp_v_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KOD_CN]),(gpointer)E_KOD_CN);
tooltips_enter[E_KOD_CN]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips_enter[E_KOD_CN],data.knopka_enter[E_KOD_CN],gettext("Выбор кода целевого назначения"),NULL);
data.entry[E_KOD_CN] = gtk_entry_new_with_max_length (19);
gtk_box_pack_start (GTK_BOX (hbox[E_KOD_CN]), data.entry[E_KOD_CN],TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_CN]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_CN]),data.rk.kod_cn.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_CN]),(gpointer)E_KOD_CN);
data.label_naikodcn=gtk_label_new(naim_kodcn.ravno_toutf(20));
gtk_box_pack_start (GTK_BOX (hbox[E_KOD_CN]), data.label_naikodcn,TRUE, TRUE, 0);
GtkTooltips *tooltips[KOL_F_KL];
sprintf(strsql,"F2 %s",gettext("Запись"));
data.knopka[FK2]=gtk_button_new_with_label(strsql);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Запись введённой в меню информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(l_kasopp_v_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(strsql);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(l_kasopp_v_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0);
gtk_widget_grab_focus(data.entry[0]);
gtk_widget_show_all (data.window);
gtk_main();
if(data.voz == 0)
kodzap->new_plus(data.rk.kod.ravno());
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.voz);
}
static void
setup_dialog (GtkBuilder *builder)
{
GSList *mode_group;
GtkListStore *store;
g_signal_connect (proxy_settings, "changed::" IGNORE_HOSTS_KEY,
G_CALLBACK (cb_ignore_hosts_gsettings_changed), NULL);
/* Mode */
proxy_mode_gsettings_changed (proxy_settings, PROXY_MODE_KEY, builder);
mode_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (gtk_builder_get_object (builder, "none_radiobutton")));
connect_sensitivity_signals (builder, mode_group);
g_signal_connect (proxy_settings, "changed::" PROXY_MODE_KEY,
G_CALLBACK (proxy_mode_gsettings_changed), builder);
/* Http */
g_settings_bind (http_proxy_settings, HTTP_PROXY_PORT_KEY,
gtk_builder_get_object (builder, "http_port_spinbutton"), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (http_proxy_settings, HTTP_PROXY_HOST_KEY,
gtk_builder_get_object (builder, "http_host_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
g_signal_connect (gtk_builder_get_object (builder, "details_button"),
"clicked",
G_CALLBACK (cb_http_details_button_clicked),
_gtk_builder_get_widget (builder, "network_dialog"));
/* Secure */
g_settings_bind (https_proxy_settings, SECURE_PROXY_PORT_KEY,
gtk_builder_get_object (builder, "secure_port_spinbutton"), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (https_proxy_settings, SECURE_PROXY_HOST_KEY,
gtk_builder_get_object (builder, "secure_host_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
/* Ftp */
g_settings_bind (ftp_proxy_settings, FTP_PROXY_PORT_KEY,
gtk_builder_get_object (builder, "ftp_port_spinbutton"), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (ftp_proxy_settings, FTP_PROXY_HOST_KEY,
gtk_builder_get_object (builder, "ftp_host_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
/* Socks */
g_settings_bind (socks_proxy_settings, SOCKS_PROXY_PORT_KEY,
gtk_builder_get_object (builder, "socks_port_spinbutton"), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (socks_proxy_settings, SOCKS_PROXY_HOST_KEY,
gtk_builder_get_object (builder, "socks_host_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
/* Autoconfiguration */
g_settings_bind (proxy_settings, PROXY_AUTOCONFIG_URL_KEY,
gtk_builder_get_object (builder, "autoconfig_entry"), "text",
G_SETTINGS_BIND_DEFAULT);
g_signal_connect (gtk_builder_get_object (builder, "network_dialog"),
"response", G_CALLBACK (cb_dialog_response), NULL);
read_ignore_hosts_from_gsettings ();
model = create_listmodel();
populate_listmodel(GTK_LIST_STORE(model), ignore_hosts);
config_treeview(GTK_TREE_VIEW(gtk_builder_get_object (builder, "treeview_ignore_host")), model);
g_signal_connect (gtk_builder_get_object (builder, "button_add_url"),
"clicked", G_CALLBACK (cb_add_url), builder);
g_signal_connect (gtk_builder_get_object (builder, "entry_url"),
"activate", G_CALLBACK (cb_add_url), builder);
g_signal_connect (gtk_builder_get_object (builder, "button_remove_url"),
"clicked", G_CALLBACK (cb_remove_url), builder);
}
/* Set up the property editors in the dialog. */
static void
setup_dialog (CcMousePropertiesPrivate *d)
{
GtkRadioButton *radio;
/* Orientation radio buttons */
radio = GTK_RADIO_BUTTON (WID ("left_handed_radio"));
g_settings_bind (d->mouse_settings, "left-handed", radio, "active", G_SETTINGS_BIND_DEFAULT);
/* explicitly connect to button-release so that you can change orientation with either button */
g_signal_connect (WID ("right_handed_radio"), "button_release_event",
G_CALLBACK (orientation_radio_button_release_event), NULL);
g_signal_connect (WID ("left_handed_radio"), "button_release_event",
G_CALLBACK (orientation_radio_button_release_event), NULL);
/* Double-click time */
g_settings_bind (d->gsd_mouse_settings, "double-click",
gtk_range_get_adjustment (GTK_RANGE (WID ("double_click_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
/* Mouse section */
gtk_widget_set_visible (WID ("mouse_vbox"), d->have_mouse);
gtk_scale_add_mark (GTK_SCALE (WID ("pointer_speed_scale")), 0,
GTK_POS_TOP, NULL);
g_settings_bind (d->mouse_settings, "speed",
gtk_range_get_adjustment (GTK_RANGE (WID ("pointer_speed_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
/* Trackpad page */
gtk_widget_set_visible (WID ("touchpad_vbox"), d->have_touchpad);
gtk_widget_set_visible (WID ("touchpad_enabled_switch"),
show_touchpad_enabling_switch (d));
g_settings_bind_with_mapping (d->touchpad_settings, "send-events",
WID ("touchpad_enabled_switch"), "active",
G_SETTINGS_BIND_DEFAULT,
touchpad_enabled_get_mapping,
touchpad_enabled_set_mapping,
NULL, NULL);
g_settings_bind_with_mapping (d->touchpad_settings, "send-events",
WID ("touchpad_options_box"), "sensitive",
G_SETTINGS_BIND_GET,
touchpad_enabled_get_mapping,
touchpad_enabled_set_mapping,
NULL, NULL);
g_settings_bind (d->touchpad_settings, "tap-to-click",
WID ("tap_to_click_toggle"), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (d->touchpad_settings, "natural-scroll",
WID ("natural_scroll_toggle"), "active",
G_SETTINGS_BIND_DEFAULT);
gtk_scale_add_mark (GTK_SCALE (WID ("touchpad_pointer_speed_scale")), 0,
GTK_POS_TOP, NULL);
g_settings_bind (d->touchpad_settings, "speed",
gtk_range_get_adjustment (GTK_RANGE (WID ("touchpad_pointer_speed_scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
if (d->have_touchpad) {
synaptics_check_capabilities (d);
setup_scrollmethod_radios (d);
}
g_signal_connect (WID ("two_finger_scroll_toggle"), "toggled",
G_CALLBACK (scrollmethod_changed_event), d);
}
gboolean
on_key_treeview_selection ( GtkTreeSelection *selection,
GtkTreeModel *model,
GtkTreePath *path,
gboolean path_currently_selected,
gpointer userdata )
/*
Global input:
key_list - The list containing the settings for every key
Global output:
selected_key - Will point to the KTKeySettings in 'key_list' that
corresponds to the selected key (if a key is selected)
Description:
This function sets all the settings of the selected key (if one selected) to
the GUI and sets 'selected_key' to the address of the selected key settings.
The key settings will be found in 'key_list'.
*/
{
GtkEntry *program_entry = NULL,
*default_entry,
*plugin_combo_entry,
*plugin_function_combo_entry;
GtkRadioButton *radiobutton,
*default_radiobutton,
*program_radiobutton,
*special_action_radiobutton;
GtkList *plugin_combo_list,
*plugin_function_combo_list;
GtkTreeView *key_treeview;
GtkTreeIter iter;
char *key_name,
*program_user = "",
*default_action;
KTPluginInfoEntry *plugin;
/* If a row was selected instead of deselected */
if (gtk_tree_model_get_iter(model, &iter, path))
{
/* Get the name of the selected key */
gtk_tree_model_get (model, &iter, FIRST_COLUMN, &key_name, -1);
if (key_name != NULL) /* If a listitem was selected instead of deselected */
{
key_treeview = gtk_tree_selection_get_tree_view(selection);
program_entry = KTGUI_program_entry();
default_entry = KTGUI_default_entry();
plugin_combo_entry = KTGUI_plugin_combo_entry();
plugin_function_combo_entry = KTGUI_plugin_function_combo_entry();
default_radiobutton = KTGUI_default_radiobutton();
program_radiobutton = KTGUI_program_radiobutton();
special_action_radiobutton = KTGUI_special_action_radiobutton();
plugin_combo_list = KTGUI_plugin_combo_list();
plugin_function_combo_list = KTGUI_plugin_function_combo_list();
/* Block the signal handlers of the entries and the radiobuttons */
g_signal_handlers_block_by_func (GTK_OBJECT(program_entry),
(void *)on_program_entry_changed, NULL);
g_signal_handlers_block_by_func (GTK_OBJECT(default_radiobutton),
(void *)on_default_radiobutton_toggled, NULL);
g_signal_handlers_block_by_func (GTK_OBJECT(program_radiobutton),
(void *)on_program_radiobutton_toggled, NULL);
g_signal_handlers_block_by_func (GTK_OBJECT(special_action_radiobutton),
(void *)on_special_action_radiobutton_toggled, NULL);
g_signal_handlers_block_by_func (GTK_OBJECT(plugin_combo_entry),
(void *)on_plugin_combo_entry_changed, NULL);
g_signal_handlers_block_by_func (GTK_OBJECT(plugin_function_combo_entry),
(void *)on_plugin_function_combo_entry_changed, NULL);
gtk_entry_set_text (plugin_combo_entry, "");
gtk_entry_set_text (plugin_function_combo_entry, "");
/* Clear the plugin function list */
gtk_list_clear_items (plugin_function_combo_list, 0, -1); /* Clear the whole list */
/* Select the key in the linked list */
selected_key = find_key_settings(key_name, &key_list);
/* Read the settings of the key */
if (!memcmp(&selected_key->action, &selected_key->default_action, sizeof(KTAction)))
{
radiobutton = default_radiobutton;
}
else if (selected_key->action.type == KTActionTypeProgram)
{
program_user = selected_key->action.program.command;
radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "program_radiobutton") );
}
else if (selected_key->action.type == KTActionTypePlugin)
{
plugin = find_plugin (selected_key->action.plugin.plugin_name, &plugin_list);
if (plugin_function_exists (selected_key->action.plugin.plugin_name,
selected_key->action.plugin.function_name,
&plugin_list))
{
reload_plugin_function_list (KTGUI_plugin_function_combo_list(),
GTK_OBJECT( KTGUI_plugin_function_combo_entry() ),
on_plugin_function_combo_entry_changed,
plugin);
gtk_entry_set_text (plugin_combo_entry,
selected_key->action.plugin.plugin_name);
gtk_entry_set_text (plugin_function_combo_entry,
selected_key->action.plugin.function_name);
radiobutton = special_action_radiobutton;
}
else
{
radiobutton = default_radiobutton;
}
}
/* Show the settings of the key */
gtk_label_set_text (KTGUI_key_name_label(), key_name);
gtk_entry_set_text (GTK_ENTRY(program_entry), program_user);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radiobutton), TRUE);
if (selected_key->default_action.type == KTActionTypePlugin)
{
/* If the plugin is not available on this system */
if (selected_key->default_action.plugin.plugin_name == NULL)
{
default_action = "";
}
else
{
default_action = (char *)g_strdup_printf ("%s - %s",
selected_key->default_action.plugin.plugin_name,
selected_key->default_action.plugin.function_name);
}
}
else if (selected_key->default_action.type == KTActionTypeProgram)
{
default_action = (char *)g_strdup_printf(
selected_key->default_action.program.command);
}
/* Show the default action */
gtk_entry_set_text (GTK_ENTRY(default_entry), default_action);
if (default_action[0] != '\0')
{
g_free (default_action);
}
/* Unblock the signal handlers of the entries and the radiobuttons */
g_signal_handlers_unblock_by_func (GTK_OBJECT(program_entry),
(void *)on_program_entry_changed, NULL);
g_signal_handlers_unblock_by_func (GTK_OBJECT(default_radiobutton),
(void *)on_default_radiobutton_toggled, NULL);
g_signal_handlers_unblock_by_func (GTK_OBJECT(program_radiobutton),
(void *)on_program_radiobutton_toggled, NULL);
g_signal_handlers_unblock_by_func (GTK_OBJECT(special_action_radiobutton),
(void *)on_special_action_radiobutton_toggled, NULL);
g_signal_handlers_unblock_by_func (GTK_OBJECT(plugin_combo_entry),
(void *)on_plugin_combo_entry_changed, NULL);
g_signal_handlers_unblock_by_func (GTK_OBJECT(plugin_function_combo_entry),
(void *)on_plugin_function_combo_entry_changed, NULL);
g_free (key_name);
}
}
return (TRUE);
}
static void on_insert_numbers_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED
gpointer gdata)
{
InsertNumbersDialog d;
GtkWidget *vbox, *label, *upper, *space, *button;
GtkGrid *grid;
GtkComboBoxText *combo;
const char *case_tip = _("For base 11 and above");
gchar *base_text;
gint result;
d.dialog = gtk_dialog_new_with_buttons(_("Insert Numbers"),
GTK_WINDOW(geany->main_widgets->window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
vbox = ui_dialog_vbox_new(GTK_DIALOG(d.dialog));
gtk_box_set_spacing(GTK_BOX(vbox), 9);
#if GTK_CHECK_VERSION(3, 0, 0)
grid = GTK_GRID(gtk_grid_new());
#else
grid = GTK_TABLE(gtk_table_new(3, 6, FALSE));
#endif
gtk_grid_set_row_spacing(grid, 6);
gtk_grid_set_column_spacing(grid, 6);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(grid), TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic(_("_Start:"));
gtk_grid_attach(grid, label, 0, 0, 1, 1);
d.start = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.start, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.start, 1, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("S_tep:"));
gtk_grid_attach(grid, label, 3, 0, 1, 1);
d.step = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1);
set_entry(d.step, RANGE_LEN, label, RANGE_TOOLTIP);
gtk_grid_attach(grid, d.step, 4, 0, 2, 1);
label = gtk_label_new_with_mnemonic(_("_Base:"));
gtk_grid_attach(grid, label, 0, 1, 1, 1),
combo = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new_with_entry());
d.base = gtk_bin_get_child(GTK_BIN(combo));
set_entry(d.base, 2, label, "2..36");
g_signal_connect(d.base, "insert-text", G_CALLBACK(on_base_insert_text), NULL);
gtk_combo_box_text_append_text(combo, "2");
gtk_combo_box_text_append_text(combo, "8");
gtk_combo_box_text_append_text(combo, "10");
gtk_combo_box_text_append_text(combo, "16");
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_grid_attach(grid, GTK_WIDGET(combo), 1, 1, 2, 1);
gtk_widget_set_hexpand(GTK_WIDGET(combo), TRUE);
#else
gtk_table_attach(grid, GTK_WIDGET(combo), 1, 3, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0);
#endif
label = gtk_label_new(_("Letters:"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_grid_attach(grid, label, 3, 1, 1, 1);
upper = gtk_radio_button_new_with_mnemonic(NULL, _("_Upper"));
gtk_widget_set_tooltip_text(upper, case_tip);
gtk_grid_attach(grid, upper, 4, 1, 1, 1);
d.lower = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(upper));
gtk_widget_set_tooltip_text(label, case_tip);
label = gtk_label_new_with_mnemonic(_("_Lower"));
gtk_widget_set_tooltip_text(label, case_tip);
gtk_container_add(GTK_CONTAINER(d.lower), label);
gtk_grid_attach(grid, d.lower, 5, 1, 1, 1);
d.prefix = gtk_check_button_new_with_mnemonic(_("Base _prefix"));
gtk_widget_set_tooltip_text(d.prefix,
_("0 for octal, 0x for hex, + for positive decimal"));
gtk_grid_attach(grid, d.prefix, 1, 2, 2, 1);
label = gtk_label_new(_("Padding:"));
gtk_grid_attach(grid, label, 3, 2, 1, 1);
space = gtk_radio_button_new_with_mnemonic(NULL, _("Sp_ace"));
gtk_grid_attach(grid, space, 4, 2, 1, 1);
d.zero = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(space));
label = gtk_label_new_with_mnemonic(_("_Zero"));
gtk_container_add(GTK_CONTAINER(d.zero), label);
gtk_grid_attach(grid, d.zero, 5, 2, 1, 1);
button = gtk_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect(button, "clicked", G_CALLBACK(on_insert_numbers_ok_clicked), &d);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(d.dialog))), button,
TRUE, TRUE, 0);
#if GTK_CHECK_VERSION(2, 18, 0)
gtk_widget_set_can_default(button, TRUE);
#else
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
#endif
gtk_widget_grab_default(button);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.start), start_value);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.step), step_value);
base_text = g_strdup_printf("%d", base_value);
gtk_entry_set_text(GTK_ENTRY(d.base), base_text);
g_free(base_text);
gtk_button_clicked(GTK_BUTTON(lower_case ? d.lower : upper));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d.prefix), base_prefix);
gtk_button_clicked(GTK_BUTTON(pad_zeros ? d.zero : space));
gtk_widget_show_all(d.dialog);
result = gtk_dialog_run(GTK_DIALOG(d.dialog));
if (result == GTK_RESPONSE_ACCEPT)
{
if (can_insert_numbers())
{
if (end_line - start_line < 1000)
{
/* quick version */
gtk_widget_hide(d.dialog);
insert_numbers(NULL);
}
else
{
gboolean cancel = FALSE;
gtk_widget_set_sensitive(GTK_WIDGET(grid), FALSE);
gtk_widget_set_sensitive(button, FALSE);
update_display();
g_signal_connect(d.dialog, "response",
G_CALLBACK(on_insert_numbers_response), &cancel);
insert_numbers(&cancel);
}
}
else
plugin_beep(); /* reloaded or something */
}
gtk_widget_destroy(d.dialog);
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_radio_button_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gboolean state, indicator;
gchar *group_name;
GSList *group = NULL, *current_group;
GbFindGroupData find_group_data;
if (gb_toolbar_is_toolbar_button (widget))
{
gb_toolbar_input_child_label (widget, data, Label);
gb_toolbar_input_child_icon (widget, data, Icon);
}
else
{
gb_widget_input_child_label (widget, data, Label);
}
state = gb_widget_input_bool (data, State);
if (data->apply)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), state);
if (state)
data->widget_data->flags |= GLADE_ACTIVE;
else
data->widget_data->flags &= ~GLADE_ACTIVE;
}
indicator = gb_widget_input_bool (data, Indicator);
if (data->apply)
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (widget), indicator);
/* Find any widgets in given group and set this widgets group.
If group is NULL try to find radiobuttons with same parent and use
their group. If these don't succeed, set group to NULL. */
group_name = gb_widget_input_combo (data, Group);
if (data->apply)
{
if (group_name && group_name[0] == '\0')
group_name = NULL;
current_group = gtk_radio_button_group (GTK_RADIO_BUTTON (widget));
if (group_name == NULL)
gtk_container_foreach (GTK_CONTAINER (widget->parent),
(GtkCallback) find_parents_group, &group);
else
{
find_group_data.group_name = group_name;
find_group_data.group = NULL;
find_group (gtk_widget_get_toplevel (widget), &find_group_data);
group = find_group_data.group;
}
g_free (gtk_object_get_data (GTK_OBJECT (widget), Group));
gtk_object_set_data (GTK_OBJECT (widget), Group, g_strdup (group_name));
/* This crashes if we set the group to NULL, so we have to reset the
group ourself. We only set the group if it has changed. */
if (group)
{
if (group != current_group)
{
if (current_group->data == widget)
current_group = current_group->next;
gtk_radio_button_set_group (GTK_RADIO_BUTTON (widget), group);
gb_radio_button_update_radio_group (current_group);
gb_radio_button_update_radio_group (gtk_radio_button_group (GTK_RADIO_BUTTON (widget)));
}
}
else
{
if (g_slist_length (current_group) != 1)
{
current_group = gb_radio_button_reset_radio_group (widget);
gb_radio_button_update_radio_group (current_group);
gb_radio_button_update_radio_group (gtk_radio_button_group (GTK_RADIO_BUTTON (widget)));
}
}
}
}
