XeTeXDialog::XeTeXDialog(int dummy)
{
extern Settings *settings;
ProjectConfiguration *projectconfig = settings->projectconfig(settings->genconfig.project_get());
gtkbuilder = gtk_builder_new ();
gtk_builder_add_from_file (gtkbuilder, gw_build_filename (Directories->get_package_data(), "gtkbuilder.xetexdialog.xml").c_str(), NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "dialog"));
label_portion = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_portion"));
button_portion = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_portion"));
g_signal_connect((gpointer) button_portion, "clicked", G_CALLBACK(on_button_portion_clicked), gpointer(this));
expander = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "expander"));
gtk_expander_set_expanded(GTK_EXPANDER(expander), settings->session.print_dialog_options_expanded);
label_expander = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_expander"));
notebook = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "notebook"));
g_signal_connect_after((gpointer) notebook, "switch_page", G_CALLBACK(on_notebook_switch_page), gpointer(this));
label_tab_notes = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_tab_notes"));
checkbutton_full_references = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_full_references"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_full_references), settings->session.print_references_in_notes_in_full);
// Set widget insensitive since is has not yet been implemented.
gtk_widget_set_sensitive (checkbutton_full_references, false);
label_tab_page = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_tab_page"));
checkbutton_cropmarks = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_cropmarks"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_cropmarks), settings->session.print_crop_marks);
label_tab_mapping = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_tab_mapping"));
button_font_mapping_clear = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_font_mapping_clear"));
filechooserbutton_font_mapping_file = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "filechooserbutton_font_mapping_file"));
g_signal_connect((gpointer) button_font_mapping_clear, "clicked", G_CALLBACK(on_button_font_mapping_clear_clicked), gpointer(filechooserbutton_font_mapping_file));
if (!projectconfig->xetex_font_mapping_file_get().empty()) {
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filechooserbutton_font_mapping_file), projectconfig->xetex_font_mapping_file_get().c_str());
}
label_tab_engine = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_tab_engine"));
GSList *shaping_engine_group = NULL;
radiobutton_shaping_engine_generic = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_shaping_engine_generic"));
gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_shaping_engine_generic), shaping_engine_group);
shaping_engine_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_shaping_engine_generic));
radiobutton_shaping_engine_arab = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_shaping_engine_arab"));
gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_shaping_engine_arab), shaping_engine_group);
shaping_engine_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_shaping_engine_arab));
shaping_engine_set (projectconfig->xetex_shaping_engine_get());
InDialogHelp * indialoghelp = new InDialogHelp(dialog, gtkbuilder, NULL, "file/print/project");
cancelbutton = indialoghelp->cancelbutton;
okbutton = indialoghelp->okbutton;
gtk_widget_grab_focus(okbutton);
gtk_widget_grab_default(okbutton);
g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
set_gui();
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkRadioButton_gtk_1radio_1button_1set_1group
(
JNIEnv* env,
jclass cls,
jlong _self,
jlongArray _group
)
{
GtkRadioButton* self;
GSList* group;
// convert parameter self
self = (GtkRadioButton*) _self;
// convert parameter group
group = (GSList*) bindings_java_convert_jarray_to_gslist(env, _group);
if (group == NULL) {
return; // Java Exception already thrown
}
// call function
gtk_radio_button_set_group(self, group);
// cleanup parameter self
// cleanup parameter group
g_slist_free(group);
}
foreach(item, group, n) {
if(n == 0) continue;
GSList *currentGroup = gtk_radio_button_get_group(GTK_RADIO_BUTTON(group[0].p.gtkWidget));
if(currentGroup != gtk_radio_button_get_group(GTK_RADIO_BUTTON(gtkWidget))) {
gtk_radio_button_set_group(GTK_RADIO_BUTTON(gtkWidget), currentGroup);
}
}
/**
* gtk_radio_tool_button_set_group:
* @button: a #GtkRadioToolButton
* @group: (element-type GtkRadioButton) (allow-none): an existing radio button group, or %NULL
*
* Adds @button to @group, removing it from the group it belonged to before.
*
* Since: 2.4
**/
void
gtk_radio_tool_button_set_group (GtkRadioToolButton *button,
GSList *group)
{
g_return_if_fail (GTK_IS_RADIO_TOOL_BUTTON (button));
gtk_radio_button_set_group (get_radio_button (button), group);
}
void cgraphics_radiobutton_set_group( widget_t *rr )
{
radiobutton_widget_t *radio = (radiobutton_widget_t *)rr;
/* first, set the group to the list we have */
gtk_radio_button_set_group( radio->widget.native, radio->group->ndata );
/* then get it back so we have the new head pointer (incase it changed, like on first item) */
radio->group->ndata = gtk_radio_button_get_group( radio->widget.native );
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkCheckboxPeer_nativeSetCheckboxGroup
(JNIEnv *env, jobject obj, jobject group)
{
GtkRadioButton *button;
void *native_group, *ptr;
ptr = NSA_GET_PTR (env, obj);
gdk_threads_enter ();
/* FIXME: we can't yet switch between a checkbutton and a
radiobutton. However, AWT requires this. For now we just
crash. */
button = GTK_RADIO_BUTTON (ptr);
native_group = NSA_GET_PTR (env, group);
if (native_group == NULL)
gtk_radio_button_set_group (button, NULL);
else
gtk_radio_button_set_group (button,
gtk_radio_button_group
(GTK_RADIO_BUTTON (native_group)));
gdk_threads_leave ();
/* If the native group wasn't set on the new CheckboxGroup, then set
it now so that the right thing will happen with the next
radiobutton. The native state for a CheckboxGroup is a pointer
to one of the widgets in the group. We are careful to keep this
always pointing at a live widget; whenever a widget is destroyed
(or otherwise removed from the group), the CheckboxGroup peer is
notified. */
if (native_group == NULL)
NSA_SET_PTR (env, group, native_group);
}
void pRadioLabel::setGroup(const group<RadioLabel>& group) {
if(&parent() == this) return;
parent().locked = true;
gtk_radio_button_set_group(
GTK_RADIO_BUTTON(gtkWidget),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(parent().gtkWidget))
);
for(auto& item : radioLabel.state.group) {
if(item.state.checked) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(item.p.gtkWidget), true);
break;
}
}
parent().locked = false;
}
int
clip_GTK_RADIOBUTTONSETGROUP(ClipMachine * cm)
{
C_widget *cbtn = _fetch_cw_arg(cm);
C_widget *cgrp = _fetch_cwidget(cm,_clip_spar(cm,2));
GSList * group = NULL;
CHECKARG2(2,MAP_t,NUMERIC_t);
CHECKCWID(cbtn,GTK_IS_RADIO_BUTTON);
if (cgrp && cgrp->type != GTK_WIDGET_RADIO_GROUP) goto err;
if (cgrp && cgrp->data)
group = gtk_radio_button_get_group(
GTK_RADIO_BUTTON(((GSList*)(cgrp->data))->data));
gtk_radio_button_set_group(GTK_RADIO_BUTTON(cbtn->widget),group);
if (cgrp && cgrp->data)
cgrp->data = gtk_radio_button_get_group(GTK_RADIO_BUTTON(cbtn->widget));
return 0;
err:
return 1;
}
BackupAssistant::BackupAssistant(int dummy) :
AssistantBase(_("Backup"), _("backup"))
// Backup assistant.
{
gtk_assistant_set_forward_page_func (GTK_ASSISTANT (assistant), GtkAssistantPageFunc (assistant_forward_function), gpointer(this), NULL);
g_signal_connect (G_OBJECT (assistant), "apply", G_CALLBACK (on_assistant_apply_signal), gpointer(this));
g_signal_connect (G_OBJECT (assistant), "prepare", G_CALLBACK (on_assistant_prepare_signal), gpointer(this));
introduction (_("A backup helps keep your data safe"));
// Configuration and initialization.
extern Settings *settings;
ustring project = settings->genconfig.project_get();
// Build the GUI for the task selector.
vbox_select_type = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_select_type);
page_number_select_type = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_select_type);
gtk_container_set_border_width (GTK_CONTAINER (vbox_select_type), 10);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_select_type, _("What would you like to backup?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_select_type, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_select_type, true);
GSList *radiobutton_select_type_group = NULL;
radiobutton_select_type_bible = gtk_radio_button_new_with_mnemonic (NULL, _("Bible"));
gtk_widget_show (radiobutton_select_type_bible);
gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_bible, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_bible), radiobutton_select_type_group);
radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_bible));
radiobutton_select_type_notes = gtk_radio_button_new_with_mnemonic (NULL, _("Notes"));
gtk_widget_show (radiobutton_select_type_notes);
gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_notes, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_notes), radiobutton_select_type_group);
radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_notes));
radiobutton_select_type_resource = gtk_radio_button_new_with_mnemonic (NULL, _("Resource"));
gtk_widget_show (radiobutton_select_type_resource);
gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_resource, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_resource), radiobutton_select_type_group);
radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_resource));
radiobutton_select_type_everything = gtk_radio_button_new_with_mnemonic (NULL, _("Everything"));
gtk_widget_show (radiobutton_select_type_everything);
gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_everything, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_everything), radiobutton_select_type_group);
radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_everything));
Shortcuts shortcuts_select_type (0);
shortcuts_select_type.button (radiobutton_select_type_bible);
shortcuts_select_type.button (radiobutton_select_type_notes);
shortcuts_select_type.button (radiobutton_select_type_resource);
shortcuts_select_type.button (radiobutton_select_type_everything);
shortcuts_select_type.consider_assistant();
shortcuts_select_type.process();
// Confirm or change Bible.
vbox_bible_name = gtk_vbox_new (FALSE, 5);
gtk_widget_show (vbox_bible_name);
page_number_bible_name = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_bible_name);
gtk_container_set_border_width (GTK_CONTAINER (vbox_bible_name), 10);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_bible_name, _("Is this the right Bible?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_bible_name, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_bible_name, true);
label_bible_name = gtk_label_new (_("Bible name"));
gtk_widget_show (label_bible_name);
gtk_box_pack_start (GTK_BOX (vbox_bible_name), label_bible_name, FALSE, FALSE, 0);
button_bible_name = gtk_button_new ();
gtk_widget_show (button_bible_name);
gtk_box_pack_start (GTK_BOX (vbox_bible_name), button_bible_name, FALSE, FALSE, 0);
g_signal_connect ((gpointer) button_bible_name, "clicked", G_CALLBACK (on_button_bible_name_clicked), gpointer (this));
GtkWidget *alignment1;
GtkWidget *hbox1;
GtkWidget *image1;
GtkWidget *label1;
alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (button_bible_name), alignment1);
hbox1 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (alignment1), hbox1);
image1 = gtk_image_new_from_stock (_("gtk-open"), GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, FALSE, 0);
label1 = gtk_label_new_with_mnemonic (_("Choose another one"));
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0);
Shortcuts shortcuts_bible_name (0);
shortcuts_bible_name.label (label1);
shortcuts_bible_name.consider_assistant();
shortcuts_bible_name.process();
// Confirm or change Resource.
vbox_resource_name = gtk_vbox_new (FALSE, 5);
gtk_widget_show (vbox_resource_name);
page_number_resource_name = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_resource_name);
gtk_container_set_border_width (GTK_CONTAINER (vbox_resource_name), 10);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_resource_name, _("Is this the right Resource?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_resource_name, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_resource_name, true);
label_resource_name = gtk_label_new (_("Resource name"));
gtk_widget_show (label_resource_name);
gtk_box_pack_start (GTK_BOX (vbox_resource_name), label_resource_name, FALSE, FALSE, 0);
button_resource_name = gtk_button_new ();
gtk_widget_show (button_resource_name);
gtk_box_pack_start (GTK_BOX (vbox_resource_name), button_resource_name, FALSE, FALSE, 0);
g_signal_connect ((gpointer) button_resource_name, "clicked", G_CALLBACK (on_button_resource_name_clicked), gpointer (this));
alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (button_resource_name), alignment1);
hbox1 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (alignment1), hbox1);
image1 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, FALSE, 0);
label1 = gtk_label_new_with_mnemonic (_("Choose another one"));
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0);
Shortcuts shortcuts_resource_name (0);
shortcuts_resource_name.label (label1);
shortcuts_resource_name.consider_assistant();
shortcuts_resource_name.process();
// Select file where to save to.
vbox_file = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_file);
page_number_file = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_file);
gtk_container_set_border_width (GTK_CONTAINER (vbox_file), 10);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_file, _("Where would you like to save it?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_file, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_file, false);
button_file = gtk_button_new ();
gtk_widget_show (button_file);
gtk_box_pack_start (GTK_BOX (vbox_file), button_file, FALSE, FALSE, 0);
GtkWidget *alignment2;
GtkWidget *hbox2;
GtkWidget *image2;
alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (button_file), alignment2);
hbox2 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox2);
gtk_container_add (GTK_CONTAINER (alignment2), hbox2);
image2 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image2);
gtk_box_pack_start (GTK_BOX (hbox2), image2, FALSE, FALSE, 0);
label_file = gtk_label_new_with_mnemonic ("");
gtk_widget_show (label_file);
gtk_box_pack_start (GTK_BOX (hbox2), label_file, FALSE, FALSE, 0);
g_signal_connect ((gpointer) button_file, "clicked", G_CALLBACK (on_button_file_clicked), gpointer(this));
// Build the confirmation stuff.
label_confirm = gtk_label_new (_("Backup is about to be made"));
gtk_widget_show (label_confirm);
page_number_confirm = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_confirm);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_confirm, _("Backup is about to be made"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_confirm, GTK_ASSISTANT_PAGE_CONFIRM);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_confirm, true);
label_progress = gtk_label_new ("");
gtk_widget_show (label_progress);
gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_progress);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_progress, "");
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_progress, GTK_ASSISTANT_PAGE_PROGRESS);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_progress, true);
label_summary = gtk_label_new (_("Backup is done"));
gtk_widget_show (label_summary);
summary_page_number = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_summary);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_summary, _("The backup was completed successfully."));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_summary, GTK_ASSISTANT_PAGE_SUMMARY);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_summary, true);
// Finish building assistant.
gtk_widget_show_all (assistant);
gtk_assistant_set_current_page (GTK_ASSISTANT (assistant), 0);
}
void konepuremilitary_single_cpi_selector_set_group(KonepuremilitarySingleCpiSelector *selector, GSList *group) {
gtk_radio_button_set_group(selector->priv->radio, group);
}
GtkDialog* nsgtk_options_init(struct browser_window *bw, GtkWindow *parent)
{
GError* error = NULL;
gladeFile = gtk_builder_new();
if (!gtk_builder_add_from_file(gladeFile, glade_file_location->options, &error)) {
g_warning("Couldn't load builder file: %s", error->message);
g_error_free(error);
return NULL;
}
current_browser = bw;
wndPreferences = GTK_DIALOG(gtk_builder_get_object(gladeFile, "dlgPreferences"));
gtk_window_set_transient_for(GTK_WINDOW(wndPreferences), parent);
FIND_WIDGET(sourceButtonTab);
FIND_WIDGET(sourceButtonWindow);
GSList *group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(
sourceButtonWindow));
gtk_radio_button_set_group(GTK_RADIO_BUTTON(sourceButtonTab), group);
/* set the widgets to reflect the current options */
nsgtk_options_load();
/* Connect all widgets to their appropriate callbacks */
CONNECT(entryHomePageURL, "focus-out-event");
CONNECT(setCurrentPage, "clicked");
CONNECT(setDefaultPage, "clicked");
CONNECT(checkHideAdverts, "toggled");
CONNECT(checkDisablePopups, "toggled");
CONNECT(checkDisablePlugins, "toggled");
CONNECT(spinHistoryAge, "focus-out-event");
CONNECT(checkHoverURLs, "toggled");
CONNECT(comboLanguage, "changed");
CONNECT(checkDisplayRecentURLs, "toggled");
CONNECT(checkSendReferer, "toggled");
CONNECT(checkShowSingleTab, "toggled");
CONNECT(comboProxyType, "changed");
CONNECT(entryProxyHost, "focus-out-event");
CONNECT(entryProxyPort, "focus-out-event");
CONNECT(entryProxyUser, "focus-out-event");
CONNECT(entryProxyPassword, "focus-out-event");
CONNECT(spinMaxFetchers, "value-changed");
CONNECT(spinFetchesPerHost, "value-changed");
CONNECT(spinCachedConnections, "value-changed");
CONNECT(checkResampleImages, "toggled");
CONNECT(spinAnimationSpeed, "value-changed");
CONNECT(checkDisableAnimations, "toggled");
CONNECT(fontSansSerif, "font-set");
CONNECT(fontSerif, "font-set");
CONNECT(fontMonospace, "font-set");
CONNECT(fontCursive, "font-set");
CONNECT(fontFantasy, "font-set");
CONNECT(comboDefault, "changed");
CONNECT(spinDefaultSize, "value-changed");
CONNECT(spinMinimumSize, "value-changed");
CONNECT(fontPreview, "clicked");
CONNECT(comboButtonType, "changed");
CONNECT(comboTabPosition, "changed");
CONNECT(spinMemoryCacheSize, "value-changed");
CONNECT(spinDiscCacheAge, "value-changed");
CONNECT(checkClearDownloads, "toggled");
CONNECT(checkRequestOverwrite, "toggled");
CONNECT(fileChooserDownloads, "current-folder-changed");
CONNECT(checkFocusNew, "toggled");
CONNECT(checkNewBlank, "toggled");
CONNECT(checkUrlSearch, "toggled");
CONNECT(comboSearch, "changed");
CONNECT(combotheme, "changed");
CONNECT(buttonaddtheme, "clicked");
CONNECT(sourceButtonTab, "toggled");
CONNECT(spinMarginTop, "value-changed");
CONNECT(spinMarginBottom, "value-changed");
CONNECT(spinMarginLeft, "value-changed");
CONNECT(spinMarginRight, "value-changed");
CONNECT(spinExportScale, "value-changed");
CONNECT(checkSuppressImages, "toggled");
CONNECT(checkRemoveBackgrounds, "toggled");
CONNECT(checkFitPage, "toggled");
CONNECT(checkCompressPDF, "toggled");
CONNECT(checkPasswordPDF, "toggled");
CONNECT(setDefaultExportOptions, "clicked");
g_signal_connect(G_OBJECT(wndPreferences), "response",
G_CALLBACK (dialog_response_handler), NULL);
g_signal_connect(G_OBJECT(wndPreferences), "delete-event",
G_CALLBACK (on_dialog_close), (gpointer)TRUE);
g_signal_connect(G_OBJECT(wndPreferences), "destroy",
G_CALLBACK (on_dialog_close), (gpointer)FALSE);
gtk_widget_show(GTK_WIDGET(wndPreferences));
return wndPreferences;
}
void
create_main_window (ContactsData *data)
{
GtkWidget *main_window;
GtkWidget *vbox7;
GtkWidget *main_menubar;
GtkWidget *contacts_menu;
GtkWidget *contacts_menu_menu;
GtkWidget *new_menuitem;
GtkWidget *edit_menuitem;
GtkWidget *delete_menuitem;
GtkWidget *contacts_import;
GtkWidget *contacts_quit;
GtkWidget *contact_menu;
GtkWidget *contact_menu_menu;
GtkWidget *contact_delete;
GtkWidget *edit_groups;
GtkWidget *contact_export;
GtkWidget *contact_quit;
GtkWidget *edit_menu;
GtkWidget *menuitem5_menu;
GtkWidget *cut;
GtkWidget *copy;
GtkWidget *paste;
GtkWidget *help_menu;
GtkWidget *menuitem7_menu;
GtkWidget *about1;
GtkWidget *main_notebook;
GtkWidget *main_hpane;
GtkWidget *contacts_vbox;
GtkWidget *scrolledwindow2;
GtkWidget *contacts_treeview;
GtkWidget *search_hbox;
GtkWidget *search_entry_hbox;
GtkWidget *search_entry;
GtkWidget *search_tab_hbox;
GtkWidget *symbols_radiobutton;
GSList *symbols_radiobutton_group = NULL;
GtkWidget *atog_radiobutton;
GtkWidget *hton_radiobutton;
GtkWidget *otou_radiobutton;
GtkWidget *vtoz_radiobutton;
GtkWidget *vbox3;
GtkWidget *summary_vbox;
GtkWidget *preview_header_hbox;
GtkWidget *preview_namegroup_vbox;
GtkWidget *summary_name_label;
GtkWidget *summary_group_label;
GtkWidget *photo_image;
GtkWidget *scrolledwindow3;
GtkWidget *viewport1;
GtkWidget *summary_table;
GtkWidget *summary_hbuttonbox;
GtkWidget *new_button;
GtkWidget *edit_button;
GtkWidget *delete_button;
GtkWidget *vbox4;
GtkWidget *scrolledwindow4;
GtkWidget *viewport2;
GtkWidget *edit_table;
GtkWidget *hbuttonbox2;
GtkWidget *add_field_button;
GtkWidget *remove_field_button;
GtkWidget *edit_done_button;
GtkWidget *widget;
GtkAccelGroup *accel_group;
ContactsUI *ui = data->ui;
GtkSizeGroup *size_group;
#ifdef HAVE_GCONF
GConfClient *client;
gchar *search;
gint width, height;
#endif
accel_group = gtk_accel_group_new ();
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (main_window), _("Contacts"));
gtk_window_set_icon_name (GTK_WINDOW (main_window), "contacts");
gtk_window_set_default_size (GTK_WINDOW (main_window), 320, 240);
vbox7 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (main_window), vbox7);
main_menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox7), main_menubar, FALSE, FALSE, 0);
contacts_menu = gtk_menu_item_new_with_mnemonic (_("C_ontacts"));
gtk_container_add (GTK_CONTAINER (main_menubar), contacts_menu);
contacts_menu_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (contacts_menu), contacts_menu_menu);
new_menuitem = gtk_image_menu_item_new_from_stock ("gtk-new", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), new_menuitem);
edit_menuitem = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), edit_menuitem);
gtk_widget_set_sensitive (edit_menuitem, FALSE);
delete_menuitem = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), delete_menuitem);
gtk_widget_set_sensitive (delete_menuitem, FALSE);
contacts_import = gtk_menu_item_new_with_mnemonic (_("_Import..."));
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), contacts_import);
widget = gtk_separator_menu_item_new ();
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), widget);
gtk_widget_set_sensitive (widget, FALSE);
contacts_quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_container_add (GTK_CONTAINER (contacts_menu_menu), contacts_quit);
contact_menu = gtk_menu_item_new_with_mnemonic (_("C_ontact"));
gtk_container_add (GTK_CONTAINER (main_menubar), contact_menu);
g_object_set (G_OBJECT (contact_menu), "no-show-all", TRUE, NULL);
contact_menu_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (contact_menu), contact_menu_menu);
contact_delete = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group);
gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_delete);
edit_groups = gtk_menu_item_new_with_mnemonic (_("_Groups"));
gtk_container_add (GTK_CONTAINER (contact_menu_menu), edit_groups);
contact_export = gtk_menu_item_new_with_mnemonic (_("_Export"));
gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_export);
widget = gtk_separator_menu_item_new ();
gtk_container_add (GTK_CONTAINER (contact_menu_menu), widget);
gtk_widget_set_sensitive (widget, FALSE);
contact_quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_container_add (GTK_CONTAINER (contact_menu_menu), contact_quit);
edit_menu = gtk_menu_item_new_with_mnemonic (_("Ed_it"));
gtk_container_add (GTK_CONTAINER (main_menubar), edit_menu);
menuitem5_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (edit_menu), menuitem5_menu);
cut = gtk_image_menu_item_new_from_stock ("gtk-cut", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem5_menu), cut);
copy = gtk_image_menu_item_new_from_stock ("gtk-copy", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem5_menu), copy);
paste = gtk_image_menu_item_new_from_stock ("gtk-paste", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem5_menu), paste);
help_menu = gtk_menu_item_new_with_mnemonic (_("_Help"));
gtk_container_add (GTK_CONTAINER (main_menubar), help_menu);
menuitem7_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (help_menu), menuitem7_menu);
about1 = gtk_image_menu_item_new_from_stock ("gtk-about", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem7_menu), about1);
main_notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox7), main_notebook, TRUE, TRUE, 0);
GTK_WIDGET_UNSET_FLAGS (main_notebook, GTK_CAN_FOCUS);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (main_notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (main_notebook), FALSE);
main_hpane = gtk_hpaned_new ();
gtk_container_add (GTK_CONTAINER (main_notebook), main_hpane);
contacts_vbox = gtk_vbox_new (FALSE, 6);
gtk_paned_pack1 (GTK_PANED (main_hpane), contacts_vbox, FALSE, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (contacts_vbox), 6);
groups_combobox = gtk_combo_box_new ();
GtkListStore *ls = gtk_list_store_new (1, G_TYPE_STRING);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (groups_combobox),
groups_combo_seperator_func, NULL, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (groups_combobox), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (groups_combobox), renderer, "text", 0);
gtk_combo_box_set_model (GTK_COMBO_BOX (groups_combobox), GTK_TREE_MODEL(ls));
gtk_box_pack_start (GTK_BOX (contacts_vbox), groups_combobox, FALSE, TRUE, 0);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (groups_combobox), FALSE);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (contacts_vbox), scrolledwindow2, TRUE, TRUE, 0);
GTK_WIDGET_UNSET_FLAGS (scrolledwindow2, GTK_CAN_FOCUS);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN);
contacts_treeview = gtk_tree_view_new ();
gtk_container_add (GTK_CONTAINER (scrolledwindow2), contacts_treeview);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (contacts_treeview), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (contacts_treeview), FALSE);
search_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX (contacts_vbox), search_hbox, FALSE, TRUE, 0);
search_entry_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (search_hbox), search_entry_hbox, TRUE, TRUE, 0);
search_entry = gtk_entry_new ();
gtk_box_pack_end (GTK_BOX (search_entry_hbox), search_entry, TRUE, TRUE, 0);
gtk_entry_set_activates_default (GTK_ENTRY (search_entry), TRUE);
widget = gtk_label_new_with_mnemonic (_("_Search:"));
gtk_box_pack_start (GTK_BOX (search_entry_hbox), widget, FALSE, FALSE, 0);
gtk_misc_set_padding (GTK_MISC (widget), 6, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), search_entry);
search_tab_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (search_hbox), search_tab_hbox, TRUE, TRUE, 0);
g_object_set (G_OBJECT (search_tab_hbox), "no-show-all", TRUE, NULL);
symbols_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("0-9#"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), symbols_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (symbols_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (symbols_radiobutton));
atog_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("A-G"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), atog_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (atog_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (atog_radiobutton));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (atog_radiobutton), TRUE);
hton_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("H-N"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), hton_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (hton_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (hton_radiobutton));
otou_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("O-U"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), otou_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (otou_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (otou_radiobutton));
vtoz_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("V-Z"));
gtk_box_pack_start (GTK_BOX (search_tab_hbox), vtoz_radiobutton, TRUE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (vtoz_radiobutton), symbols_radiobutton_group);
symbols_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (vtoz_radiobutton));
vbox3 = gtk_vbox_new (FALSE, 6);
gtk_paned_pack2 (GTK_PANED (main_hpane), vbox3, TRUE, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (vbox3), 6);
summary_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox3), summary_vbox, TRUE, TRUE, 0);
preview_header_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (summary_vbox), preview_header_hbox, FALSE, TRUE, 0);
preview_namegroup_vbox = gtk_vbox_new (FALSE, 0);
summary_name_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (preview_namegroup_vbox), summary_name_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (summary_name_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (summary_name_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (summary_name_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (summary_name_label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (summary_name_label), 6, 0);
gtk_label_set_ellipsize (GTK_LABEL (summary_name_label), PANGO_ELLIPSIZE_END);
summary_group_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (preview_namegroup_vbox), summary_group_label, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (summary_group_label, GTK_CAN_FOCUS);
gtk_label_set_use_markup (GTK_LABEL (summary_group_label), TRUE);
gtk_label_set_selectable (GTK_LABEL (summary_group_label), TRUE);
gtk_misc_set_alignment (GTK_MISC (summary_group_label), 0, 0.5);
gtk_misc_set_padding (GTK_MISC (summary_group_label), 6, 0);
gtk_label_set_ellipsize (GTK_LABEL (summary_group_label), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (preview_header_hbox), preview_namegroup_vbox, TRUE, TRUE, 0);
/* load stock_person as the default icon so the image has the correct
* size before a contact is loaded */
photo_image = gtk_image_new_from_icon_name ("stock_person", GTK_ICON_SIZE_DIALOG);
gtk_box_pack_end (GTK_BOX (preview_header_hbox), photo_image, FALSE, TRUE, 6);
gtk_misc_set_padding (GTK_MISC (photo_image), 1, 0);
scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (summary_vbox), scrolledwindow3, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport1 = gtk_viewport_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolledwindow3), viewport1);
summary_table = gtk_table_new (1, 2, FALSE);
gtk_container_add (GTK_CONTAINER (viewport1), summary_table);
gtk_table_set_row_spacings (GTK_TABLE (summary_table), 6);
gtk_table_set_col_spacings (GTK_TABLE (summary_table), 6);
summary_hbuttonbox = gtk_hbutton_box_new ();
gtk_box_pack_end (GTK_BOX (vbox3), summary_hbuttonbox, FALSE, FALSE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (summary_hbuttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (summary_hbuttonbox), 6);
new_button = gtk_button_new_from_stock ("gtk-new");
gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), new_button);
GTK_WIDGET_SET_FLAGS (new_button, GTK_CAN_DEFAULT);
edit_button = gtk_button_new_from_stock ("gtk-edit");
gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), edit_button);
gtk_widget_set_sensitive (edit_button, FALSE);
GTK_WIDGET_SET_FLAGS (edit_button, GTK_CAN_DEFAULT);
delete_button = gtk_button_new_from_stock ("gtk-delete");
gtk_container_add (GTK_CONTAINER (summary_hbuttonbox), delete_button);
gtk_widget_set_sensitive (delete_button, FALSE);
GTK_WIDGET_SET_FLAGS (delete_button, GTK_CAN_DEFAULT);
gtk_button_set_focus_on_click (GTK_BUTTON (delete_button), FALSE);
vbox4 = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (main_notebook), vbox4);
gtk_container_set_border_width (GTK_CONTAINER (vbox4), 6);
scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox4), scrolledwindow4, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport2 = gtk_viewport_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolledwindow4), viewport2);
edit_table = gtk_table_new (1, 2, FALSE);
gtk_container_add (GTK_CONTAINER (viewport2), edit_table);
gtk_container_set_border_width (GTK_CONTAINER (edit_table), 6);
gtk_table_set_row_spacings (GTK_TABLE (edit_table), 6);
hbuttonbox2 = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (vbox4), hbuttonbox2, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox2), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox2), 6);
add_field_button = gtk_button_new_with_mnemonic (_("_Add Field"));
gtk_container_add (GTK_CONTAINER (hbuttonbox2), add_field_button);
GTK_WIDGET_SET_FLAGS (add_field_button, GTK_CAN_DEFAULT);
remove_field_button = gtk_button_new_with_mnemonic (_("_Remove Field"));
gtk_container_add (GTK_CONTAINER (hbuttonbox2), remove_field_button);
GTK_WIDGET_SET_FLAGS (remove_field_button, GTK_CAN_DEFAULT);
gtk_button_set_focus_on_click (GTK_BUTTON (remove_field_button), FALSE);
edit_done_button = gtk_button_new_from_stock ("gtk-close");
gtk_container_add (GTK_CONTAINER (hbuttonbox2), edit_done_button);
GTK_WIDGET_SET_FLAGS (edit_done_button, GTK_CAN_DEFAULT);
gtk_widget_grab_focus (contacts_treeview);
gtk_widget_grab_default (edit_button);
gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
/* Set up size group for bottom row of buttons and search */
size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
gtk_size_group_add_widget (size_group, search_hbox);
gtk_size_group_add_widget (size_group, summary_hbuttonbox);
g_object_unref (size_group);
/* connect signals */
g_signal_connect (G_OBJECT (main_window), "delete-event",
G_CALLBACK (contacts_main_window_delete_event_cb), data);
g_signal_connect ((gpointer) main_window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect_swapped ((gpointer) main_window, "set_focus",
G_CALLBACK (contacts_edit_set_focus_cb),
GTK_OBJECT (remove_field_button));
g_signal_connect ((gpointer) contacts_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect ((gpointer) contact_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect_swapped ((gpointer) cut, "activate",
G_CALLBACK (contacts_cut_cb),
GTK_OBJECT (main_window));
g_signal_connect_swapped ((gpointer) copy, "activate",
G_CALLBACK (contacts_copy_cb),
GTK_OBJECT (main_window));
g_signal_connect_swapped ((gpointer) paste, "activate",
G_CALLBACK (contacts_paste_cb),
GTK_OBJECT (main_window));
g_signal_connect_swapped ((gpointer) about1, "activate",
G_CALLBACK (contacts_about_cb),
main_window);
g_signal_connect_swapped ((gpointer) groups_combobox, "changed",
G_CALLBACK (contacts_update_treeview),
data);
g_signal_connect_data ((gpointer) contacts_treeview, "key_press_event",
G_CALLBACK (contacts_treeview_search_cb),
GTK_OBJECT (search_entry),
NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED);
g_signal_connect ((gpointer) search_entry, "changed",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) symbols_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) atog_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) hton_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) otou_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) vtoz_radiobutton, "clicked",
G_CALLBACK (contacts_search_changed_cb),
data);
g_signal_connect ((gpointer) remove_field_button, "clicked",
G_CALLBACK (contacts_remove_field_cb),
NULL);
g_signal_connect (G_OBJECT (new_button), "clicked",
G_CALLBACK (contacts_new_cb), data);
g_signal_connect (G_OBJECT (new_menuitem), "activate",
G_CALLBACK (contacts_new_cb), data);
g_signal_connect (G_OBJECT (edit_button), "clicked",
G_CALLBACK (contacts_edit_cb), data);
g_signal_connect (G_OBJECT (contacts_treeview), "row_activated",
G_CALLBACK (contacts_treeview_edit_cb), data);
g_signal_connect (G_OBJECT (edit_menuitem), "activate",
G_CALLBACK (contacts_edit_cb), data);
g_signal_connect (G_OBJECT (delete_button), "clicked",
G_CALLBACK (contacts_delete_cb), data);
g_signal_connect (G_OBJECT (delete_menuitem), "activate",
G_CALLBACK (contacts_delete_cb), data);
g_signal_connect (G_OBJECT (contacts_import), "activate",
G_CALLBACK (contacts_import_cb), data);
g_signal_connect (G_OBJECT (edit_menu), "activate",
G_CALLBACK (contacts_edit_menu_activate_cb), data);
g_signal_connect (G_OBJECT (groups_combobox), "changed",
G_CALLBACK (groups_combobox_changed_cb), data);
ui->contact_delete = contact_delete;
ui->contact_export = contact_export;
ui->contact_menu = contact_menu;
ui->contacts_import = contacts_import;
ui->contacts_menu = contacts_menu;
ui->contacts_treeview = contacts_treeview;
ui->new_menuitem = new_menuitem;
ui->copy_menuitem = copy;
ui->cut_menuitem = cut;
ui->delete_menuitem = delete_menuitem;
ui->delete_button = delete_button;
ui->edit_menuitem = edit_menuitem;
ui->edit_button = edit_button;
ui->edit_done_button = edit_done_button;
ui->edit_groups = edit_groups;
ui->edit_menu = edit_menu;
ui->edit_table = edit_table;
ui->main_menubar = main_menubar;
ui->main_notebook = main_notebook;
ui->main_window = main_window;
ui->new_button = new_button;
ui->paste_menuitem = paste;
ui->photo_image = photo_image;
ui->preview_header_hbox = preview_header_hbox;
ui->add_field_button = add_field_button;
ui->remove_field_button = remove_field_button;
ui->search_entry = search_entry;
ui->search_entry_hbox = search_entry_hbox;
ui->search_hbox = search_hbox;
ui->search_tab_hbox = search_tab_hbox;
//ui->groups_combobox = groups_combobox;
ui->summary_hbuttonbox = summary_hbuttonbox;
ui->summary_name_label = summary_name_label;
ui->summary_group_label = summary_group_label;
ui->summary_table = summary_table;
ui->summary_vbox = summary_vbox;
#ifdef HAVE_GCONF
client = gconf_client_get_default ();
search = gconf_client_get_string (client, GCONF_KEY_SEARCH, NULL);
if (!search) {
gconf_client_set_string (
client, GCONF_KEY_SEARCH, "entry", NULL);
} else {
if (strcmp (search, "alphatab") == 0) {
gtk_widget_hide (search_entry_hbox);
gtk_widget_show (search_tab_hbox);
}
g_free (search);
}
gconf_client_add_dir (client, GCONF_PATH, GCONF_CLIENT_PRELOAD_NONE,
NULL);
gconf_client_notify_add (client, GCONF_KEY_SEARCH,
contacts_gconf_search_cb, data, NULL, NULL);
width = gconf_client_get_int (client, GCONF_PATH "/width", NULL);
height = gconf_client_get_int (client, GCONF_PATH "/height", NULL);
gtk_window_set_default_size (GTK_WINDOW (main_window), width, height);
#endif
}
void
gui_create_about(GtkWidget *notebook) {
GtkWidget *vbox1;
GtkWidget *label;
GtkWidget *hseparator;
GtkWidget *logo_area;
GdkPixbuf *logo;
GtkWidget *viewport;
GtkWidget *hbuttonbox;
GSList *radiobutton_group = NULL;
label = gtk_label_new(NULL);
gtk_label_set_angle (GTK_LABEL(label), -90.0);
gtk_label_set_markup (GTK_LABEL (label), _("About"));
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox1, label);
logo_area = gtk_image_new();
logo = gdk_pixbuf_new_from_inline(-1, osmo_logo, FALSE, NULL);
gtk_widget_show(logo_area);
gtk_box_pack_start (GTK_BOX (vbox1), logo_area, FALSE, TRUE, 0);
#ifndef REV
sprintf(tmpbuf, "%s %s", _("version"), VERSION);
#else
sprintf(tmpbuf, "%s %d", _("SVN revision"), REV);
#endif
label = gtk_label_new(tmpbuf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox1), label, FALSE, TRUE, 4);
gtk_image_set_from_pixbuf (GTK_IMAGE (logo_area), logo);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
/*--------------------------------------------------------------------------*/
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
about_radiobutton = gui_image_label_radio_button(_("About"), osmo_stock_about);
gtk_widget_show (about_radiobutton);
gtk_button_set_relief (GTK_BUTTON (about_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS(about_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (about_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (about_radiobutton));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (about_radiobutton), TRUE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (about_radiobutton), FALSE);
gtk_container_add (GTK_CONTAINER (hbuttonbox), about_radiobutton);
g_signal_connect (G_OBJECT (about_radiobutton), "released",
G_CALLBACK(button_released_cb), NULL);
help_radiobutton = gui_image_label_radio_button(_("Key shortcuts"), osmo_stock_help);
gtk_widget_show (help_radiobutton);
gtk_button_set_relief (GTK_BUTTON (help_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS(help_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (help_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (help_radiobutton));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (help_radiobutton), FALSE);
gtk_container_add (GTK_CONTAINER (hbuttonbox), help_radiobutton);
g_signal_connect (G_OBJECT (help_radiobutton), "released",
G_CALLBACK(button_released_cb), NULL);
license_radiobutton = gui_image_label_radio_button(_("License"), osmo_stock_license);
gtk_widget_show (license_radiobutton);
gtk_button_set_relief (GTK_BUTTON (license_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS(license_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (license_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (license_radiobutton));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (license_radiobutton), FALSE);
gtk_container_add (GTK_CONTAINER (hbuttonbox), license_radiobutton);
g_signal_connect (G_OBJECT (license_radiobutton), "released",
G_CALLBACK(button_released_cb), NULL);
/*--------------------------------------------------------------------------*/
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox1), scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolled_window);
viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport);
gtk_container_set_border_width (GTK_CONTAINER (viewport), 0);
gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
entry_buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_get_iter_at_offset (entry_buffer, &entry_iter, 0);
gtk_text_buffer_create_tag (entry_buffer, "bold", "weight", PANGO_WEIGHT_ULTRABOLD, NULL);
gtk_text_buffer_create_tag (entry_buffer, "big", "size", 16 * PANGO_SCALE, NULL);
gtk_text_buffer_create_tag (entry_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL);
gtk_text_buffer_create_tag (entry_buffer, "center", "justification", GTK_JUSTIFY_CENTER, NULL);
gtk_text_buffer_get_iter_at_offset (entry_buffer, &entry_iter, 0);
about_textview = gtk_text_view_new_with_buffer (entry_buffer);
gtk_container_set_border_width (GTK_CONTAINER (about_textview), 1);
gtk_text_view_set_editable(GTK_TEXT_VIEW (about_textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (about_textview), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (about_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(about_textview), 2);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(about_textview), 6);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(about_textview), 6);
gtk_widget_show (about_textview);
gtk_container_add (GTK_CONTAINER (viewport), about_textview);
gui_url_setup(&about_links_list, &about_link_index, about_textview);
display_about();
}
/*
* 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)));
}
}
}
}
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;
}
static GtkWidget *
create_extra_widget (DialogData *data)
{
GtkWidget *vbox1;
GtkWidget *hbox28;
GtkWidget *vbox19;
GtkWidget *e_files_label;
GtkWidget *hbox29;
GtkWidget *label47;
GtkWidget *table1;
GSList *e_files_radiobutton_group = NULL;
GtkWidget *vbox20;
GtkWidget *e_actions_label;
GtkWidget *hbox30;
GtkWidget *label48;
GtkWidget *vbox15;
vbox1 = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 0);
hbox28 = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox1), hbox28, TRUE, TRUE, 0);
vbox19 = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox28), vbox19, TRUE, TRUE, 0);
e_files_label = gtk_label_new ("");
set_bold_label (e_files_label, _("Extract"));
gtk_box_pack_start (GTK_BOX (vbox19), e_files_label, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (e_files_label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (e_files_label), 0, 0.5);
hbox29 = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox19), hbox29, TRUE, TRUE, 0);
label47 = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox29), label47, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label47), GTK_JUSTIFY_LEFT);
table1 = gtk_table_new (3, 2, FALSE);
gtk_box_pack_start (GTK_BOX (hbox29), table1, TRUE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table1), 6);
gtk_table_set_col_spacings (GTK_TABLE (table1), 6);
data->e_files_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("_Files:"));
gtk_table_attach (GTK_TABLE (table1), data->e_files_radiobutton, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (data->e_files_radiobutton), e_files_radiobutton_group);
e_files_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (data->e_files_radiobutton));
data->e_files_entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table1), data->e_files_entry, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_widget_set_tooltip_text (data->e_files_entry, _("example: *.txt; *.doc"));
gtk_entry_set_activates_default (GTK_ENTRY (data->e_files_entry), TRUE);
data->e_all_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("_All files"));
gtk_table_attach (GTK_TABLE (table1), data->e_all_radiobutton, 0, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (data->e_all_radiobutton), e_files_radiobutton_group);
e_files_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (data->e_all_radiobutton));
data->e_selected_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, _("_Selected files"));
gtk_table_attach (GTK_TABLE (table1), data->e_selected_radiobutton, 0, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (data->e_selected_radiobutton), e_files_radiobutton_group);
e_files_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (data->e_selected_radiobutton));
vbox20 = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox28), vbox20, TRUE, TRUE, 0);
e_actions_label = gtk_label_new ("");
set_bold_label (e_actions_label, _("Actions"));
gtk_box_pack_start (GTK_BOX (vbox20), e_actions_label, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (e_actions_label), TRUE);
gtk_label_set_justify (GTK_LABEL (e_actions_label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (e_actions_label), 0, 0.5);
hbox30 = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox20), hbox30, TRUE, TRUE, 0);
label48 = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox30), label48, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label48), GTK_JUSTIFY_LEFT);
vbox15 = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox30), vbox15, TRUE, TRUE, 0);
data->e_recreate_dir_checkbutton = gtk_check_button_new_with_mnemonic (_("Re-crea_te folders"));
gtk_box_pack_start (GTK_BOX (vbox15), data->e_recreate_dir_checkbutton, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_recreate_dir_checkbutton), TRUE);
data->e_overwrite_checkbutton = gtk_check_button_new_with_mnemonic (_("Over_write existing files"));
gtk_box_pack_start (GTK_BOX (vbox15), data->e_overwrite_checkbutton, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton), TRUE);
data->e_not_newer_checkbutton = gtk_check_button_new_with_mnemonic (_("Do not e_xtract older files"));
gtk_box_pack_start (GTK_BOX (vbox15), data->e_not_newer_checkbutton, FALSE, FALSE, 0);
gtk_widget_show_all (vbox1);
return vbox1;
}
ImportAssistant::ImportAssistant(WindowReferences * references_window, WindowStyles * styles_window, WindowCheckKeyterms * check_keyterms_window, WindowsOutpost * windows_outpost) :
AssistantBase(_("Import"), _("import"))
// Import assistant.
{
gtk_assistant_set_forward_page_func (GTK_ASSISTANT (assistant), GtkAssistantPageFunc (assistant_forward_function), gpointer(this), NULL);
g_signal_connect (G_OBJECT (assistant), "apply", G_CALLBACK (on_assistant_apply_signal), gpointer(this));
g_signal_connect (G_OBJECT (assistant), "prepare", G_CALLBACK (on_assistant_prepare_signal), gpointer(this));
introduction (_("This helps you importing data"));
// Configuration and initialization.
extern Settings *settings;
ustring project = settings->genconfig.project_get();
my_references_window = references_window;
my_styles_window = styles_window;
my_check_keyterms_window = check_keyterms_window;
my_windows_outpost = windows_outpost;
import_notes = false;
import_keyterms = false;
// Build the GUI for the task selector.
vbox_select_type = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_select_type);
page_number_select_type = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_select_type);
gtk_container_set_border_width (GTK_CONTAINER (vbox_select_type), 10);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_select_type, _("What would you like to import?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_select_type, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_select_type, true);
GSList *radiobutton_select_type_group = NULL;
radiobutton_select_type_bible = gtk_radio_button_new_with_mnemonic (NULL, _("Bible"));
gtk_widget_show (radiobutton_select_type_bible);
gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_bible, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_bible), radiobutton_select_type_group);
radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_bible));
radiobutton_select_type_references = gtk_radio_button_new_with_mnemonic (NULL, _("References"));
gtk_widget_show (radiobutton_select_type_references);
gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_references, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_references), radiobutton_select_type_group);
radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_references));
// Importing references only works when the references window shows.
gtk_widget_set_sensitive (radiobutton_select_type_references, references_window != NULL);
radiobutton_select_type_stylesheet = gtk_radio_button_new_with_mnemonic (NULL, _("Stylesheet"));
gtk_widget_show (radiobutton_select_type_stylesheet);
gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_stylesheet, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_stylesheet), radiobutton_select_type_group);
radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_stylesheet));
// Importing styles only works when the styles window shows.
gtk_widget_set_sensitive (radiobutton_select_type_stylesheet, my_styles_window != NULL);
radiobutton_select_type_notes = gtk_radio_button_new_with_mnemonic (NULL, _("Notes"));
gtk_widget_show (radiobutton_select_type_notes);
gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_notes, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_notes), radiobutton_select_type_group);
radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_notes));
radiobutton_select_type_keyterms = gtk_radio_button_new_with_mnemonic (NULL, _("Keyterms"));
gtk_widget_show (radiobutton_select_type_keyterms);
gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_keyterms, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_keyterms), radiobutton_select_type_group);
radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_keyterms));
// Importing keyterms only works when the check keyterms window shows.
gtk_widget_set_sensitive (radiobutton_select_type_keyterms, my_check_keyterms_window != NULL);
Shortcuts shortcuts_select_type (0);
shortcuts_select_type.button (radiobutton_select_type_bible);
shortcuts_select_type.button (radiobutton_select_type_references);
shortcuts_select_type.button (radiobutton_select_type_stylesheet);
shortcuts_select_type.button (radiobutton_select_type_notes);
shortcuts_select_type.button (radiobutton_select_type_keyterms);
shortcuts_select_type.consider_assistant();
shortcuts_select_type.process();
// Confirm or change Bible to import into.
vbox_bible_name = gtk_vbox_new (FALSE, 5);
gtk_widget_show (vbox_bible_name);
page_number_bible_name = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_bible_name);
gtk_container_set_border_width (GTK_CONTAINER (vbox_bible_name), 10);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_bible_name, _("Is this the right Bible to import into?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_bible_name, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_bible_name, true);
label_project_name = gtk_label_new (_("Bible name"));
gtk_widget_show (label_project_name);
gtk_box_pack_start (GTK_BOX (vbox_bible_name), label_project_name, FALSE, FALSE, 0);
button_bible_name = gtk_button_new ();
gtk_widget_show (button_bible_name);
gtk_box_pack_start (GTK_BOX (vbox_bible_name), button_bible_name, FALSE, FALSE, 0);
g_signal_connect ((gpointer) button_bible_name, "clicked", G_CALLBACK (on_button_bible_name_clicked), gpointer (this));
GtkWidget *alignment1;
GtkWidget *hbox1;
GtkWidget *image1;
GtkWidget *label12;
alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (button_bible_name), alignment1);
hbox1 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (alignment1), hbox1);
image1 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, FALSE, 0);
label12 = gtk_label_new_with_mnemonic (_("Choose another one"));
gtk_widget_show (label12);
gtk_box_pack_start (GTK_BOX (hbox1), label12, FALSE, FALSE, 0);
Shortcuts shortcuts_bible_name (0);
shortcuts_bible_name.label (label12);
shortcuts_bible_name.consider_assistant();
shortcuts_bible_name.process();
// Select what type of Bible data to import.
vbox_bible_type = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_bible_type);
page_number_bible_type = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_bible_type);
gtk_container_set_border_width (GTK_CONTAINER (vbox_bible_type), 10);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_bible_type, _("What type of data would you like to import?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_bible_type, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_bible_type, true);
GSList *radiobutton_bible_type_group = NULL;
radiobutton_bible_usfm = gtk_radio_button_new_with_mnemonic (NULL, _("Unified Standard Format Markers (USFM)"));
gtk_widget_show (radiobutton_bible_usfm);
gtk_box_pack_start (GTK_BOX (vbox_bible_type), radiobutton_bible_usfm, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_bible_usfm), radiobutton_bible_type_group);
radiobutton_bible_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_bible_usfm));
radiobutton_bible_bibleworks = gtk_radio_button_new_with_mnemonic (NULL, _("BibleWorks Exported Database"));
gtk_widget_show (radiobutton_bible_bibleworks);
gtk_box_pack_start (GTK_BOX (vbox_bible_type), radiobutton_bible_bibleworks, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_bible_bibleworks), radiobutton_bible_type_group);
radiobutton_bible_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_bible_bibleworks));
radiobutton_bible_online_bible = gtk_radio_button_new_with_mnemonic (NULL, _("Online Bible Text"));
gtk_widget_show (radiobutton_bible_online_bible);
gtk_box_pack_start (GTK_BOX (vbox_bible_type), radiobutton_bible_online_bible, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_bible_online_bible), radiobutton_bible_type_group);
radiobutton_bible_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_bible_online_bible));
radiobutton_bible_raw_text = gtk_radio_button_new_with_mnemonic (NULL, _("Raw Text"));
gtk_widget_show (radiobutton_bible_raw_text);
gtk_box_pack_start (GTK_BOX (vbox_bible_type), radiobutton_bible_raw_text, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_bible_raw_text), radiobutton_bible_type_group);
radiobutton_bible_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_bible_raw_text));
Shortcuts shortcuts_select_bible_type (0);
shortcuts_select_bible_type.button (radiobutton_bible_usfm);
shortcuts_select_bible_type.button (radiobutton_bible_bibleworks);
shortcuts_select_bible_type.button (radiobutton_bible_online_bible);
shortcuts_select_bible_type.button (radiobutton_bible_raw_text);
shortcuts_select_bible_type.consider_assistant();
shortcuts_select_bible_type.process();
// Online Bible connection?
label_online_bible_running = gtk_label_new ("");
gtk_widget_show (label_online_bible_running);
page_number_online_bible_running = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_online_bible_running);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_online_bible_running, _("Connected to the Online Bible?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_online_bible_running, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_online_bible_running, false);
// In case there's no data in the project, the Online Bible won't get connected.
// Therefore connect manually.
if (online_bible_is_running ()) {
my_windows_outpost->OnlineBibleReferenceGet ();
}
// Online Bible to import.
vbox_online_bible_bible = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_online_bible_bible);
page_number_online_bible_bible = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_online_bible_bible);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_online_bible_bible, _("Which Bible would you like to import?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_online_bible_bible, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_online_bible_bible, false);
combobox_online_bible_bible = gtk_combo_box_new_text ();
gtk_widget_show (combobox_online_bible_bible);
gtk_box_pack_start (GTK_BOX (vbox_online_bible_bible), combobox_online_bible_bible, false, false, 0);
g_signal_connect ((gpointer) combobox_online_bible_bible, "changed", G_CALLBACK (on_combobox_online_bible_bible_changed), gpointer (this));
// Select files to import from.
vbox_files = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_files);
page_number_files = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_files);
gtk_container_set_border_width (GTK_CONTAINER (vbox_files), 10);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_files, _("Which file or files would you like to import?"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_files, GTK_ASSISTANT_PAGE_CONTENT);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_files, false);
button_files = gtk_button_new ();
gtk_widget_show (button_files);
gtk_box_pack_start (GTK_BOX (vbox_files), button_files, FALSE, FALSE, 0);
GtkWidget * alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (button_files), alignment2);
GtkWidget * hbox2 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox2);
gtk_container_add (GTK_CONTAINER (alignment2), hbox2);
GtkWidget * image2 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image2);
gtk_box_pack_start (GTK_BOX (hbox2), image2, FALSE, FALSE, 0);
GtkWidget * label = gtk_label_new_with_mnemonic (_("Select files"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
g_signal_connect ((gpointer) button_files, "clicked", G_CALLBACK (on_button_files_clicked), gpointer(this));
label_files = gtk_label_new ("");
gtk_widget_show (label_files);
gtk_box_pack_start (GTK_BOX (vbox_files), label_files, FALSE, FALSE, 0);
// Build the confirmation stuff.
label_confirm = gtk_label_new (_("Import about to be done"));
gtk_widget_show (label_confirm);
page_number_confirm = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_confirm);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_confirm, _("The import is about to be done"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_confirm, GTK_ASSISTANT_PAGE_CONFIRM);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_confirm, true);
label_progress = gtk_label_new ("");
gtk_widget_show (label_progress);
gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_progress);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_progress, "");
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_progress, GTK_ASSISTANT_PAGE_PROGRESS);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_progress, true);
label_summary = gtk_label_new (_("Import done"));
gtk_widget_show (label_summary);
summary_page_number = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_summary);
gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_summary, _("Ready"));
gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_summary, GTK_ASSISTANT_PAGE_SUMMARY);
gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_summary, true);
// Finish building assistant.
gtk_widget_show_all (assistant);
gtk_assistant_set_current_page (GTK_ASSISTANT (assistant), 0);
}
void
gui_create_about (GtkWidget *vbox_top, GUI *appGUI)
{
GtkWidget *hbox = NULL, *vbox = NULL;
GtkWidget *label;
GtkWidget *hseparator;
GtkWidget *logo_area;
GdkPixbuf *logo, *logo_scaled = NULL;
GtkWidget *viewport;
GtkWidget *hbuttonbox = NULL;
GSList *radiobutton_group = NULL;
char *str;
appGUI->about_counter = 0;
appGUI->about_vbox = GTK_BOX (vbox_top);
logo_area = gtk_image_new ();
logo = gdk_pixbuf_new_from_inline (-1, osmo_logo, FALSE, NULL);
gtk_widget_show (logo_area);
gtk_box_pack_start (GTK_BOX (vbox_top), logo_area, FALSE, TRUE, 0);
if (appGUI->tiny_gui == TRUE) {
logo_scaled = gdk_pixbuf_scale_simple (logo,
gdk_pixbuf_get_width (logo) / 2,
gdk_pixbuf_get_height (logo) / 2,
GDK_INTERP_HYPER);
}
#ifndef REV
str = g_strdup_printf ("%s %s", _("version"), VERSION);
#else
str = g_strdup_printf ("%s %d", _("SVN revision"), REV);
#endif
label = gtk_label_new (str);
g_free (str);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox_top), label, FALSE, TRUE, 4);
if (logo_scaled != NULL) {
gtk_image_set_from_pixbuf (GTK_IMAGE (logo_area), logo_scaled);
g_object_unref (logo_scaled);
} else {
gtk_image_set_from_pixbuf (GTK_IMAGE (logo_area), logo);
g_object_unref (logo);
}
/*--------------------------------------------------------------------------*/
vbox = gtk_vbox_new (FALSE, 4);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (vbox_top), vbox, FALSE, TRUE, 0);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 0);
if (appGUI->tiny_gui == TRUE) {
hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
} else {
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox), hbuttonbox, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
}
if (appGUI->tiny_gui == TRUE) {
appGUI->about_radiobutton = utl_gui_stock_label_radio_button (NULL, OSMO_STOCK_ABOUT, GTK_ICON_SIZE_LARGE_TOOLBAR);
} else {
appGUI->about_radiobutton = utl_gui_stock_label_radio_button (_("About"), OSMO_STOCK_ABOUT, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->about_radiobutton);
}
gtk_widget_show (appGUI->about_radiobutton);
gtk_button_set_relief (GTK_BUTTON (appGUI->about_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS (appGUI->about_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (appGUI->about_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (appGUI->about_radiobutton));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (appGUI->about_radiobutton), TRUE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (appGUI->about_radiobutton), FALSE);
g_signal_connect (G_OBJECT (appGUI->about_radiobutton), "released",
G_CALLBACK (button_released_cb), appGUI);
if (appGUI->tiny_gui == TRUE) {
appGUI->help_radiobutton = utl_gui_stock_label_radio_button (NULL, OSMO_STOCK_HELP, GTK_ICON_SIZE_LARGE_TOOLBAR);
} else {
appGUI->help_radiobutton = utl_gui_stock_label_radio_button (_("Key shortcuts"), OSMO_STOCK_HELP, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->help_radiobutton);
}
gtk_widget_show (appGUI->help_radiobutton);
gtk_button_set_relief (GTK_BUTTON (appGUI->help_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS (appGUI->help_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (appGUI->help_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (appGUI->help_radiobutton));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (appGUI->help_radiobutton), FALSE);
g_signal_connect (G_OBJECT (appGUI->help_radiobutton), "released",
G_CALLBACK (button_released_cb), appGUI);
if (appGUI->tiny_gui == TRUE) {
appGUI->license_radiobutton = utl_gui_stock_label_radio_button (NULL, OSMO_STOCK_LICENSE, GTK_ICON_SIZE_LARGE_TOOLBAR);
} else {
appGUI->license_radiobutton = utl_gui_stock_label_radio_button (_("License"), OSMO_STOCK_LICENSE, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->license_radiobutton);
}
gtk_widget_show (appGUI->license_radiobutton);
gtk_button_set_relief (GTK_BUTTON (appGUI->license_radiobutton), GTK_RELIEF_NONE);
GTK_WIDGET_UNSET_FLAGS (appGUI->license_radiobutton, GTK_CAN_FOCUS);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (appGUI->license_radiobutton), radiobutton_group);
radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (appGUI->license_radiobutton));
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (appGUI->license_radiobutton), FALSE);
g_signal_connect (G_OBJECT (appGUI->license_radiobutton), "released",
G_CALLBACK (button_released_cb), appGUI);
if (appGUI->tiny_gui == TRUE) {
gtk_box_pack_end (GTK_BOX (hbox), appGUI->license_radiobutton, FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (hbox), appGUI->help_radiobutton, FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (hbox), appGUI->about_radiobutton, FALSE, TRUE, 0);
}
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 0);
/*--------------------------------------------------------------------------*/
appGUI->scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox_top), appGUI->scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (appGUI->scrolled_window);
viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport);
gtk_container_set_border_width (GTK_CONTAINER (viewport), 0);
gtk_container_add (GTK_CONTAINER (appGUI->scrolled_window), viewport);
appGUI->about_entry_buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_get_iter_at_offset (appGUI->about_entry_buffer, &appGUI->about_entry_iter, 0);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "fixed", "family", "monospace", NULL);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "bold", "weight", PANGO_WEIGHT_ULTRABOLD, NULL);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "big", "size", 16 * PANGO_SCALE, NULL);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL);
gtk_text_buffer_create_tag (appGUI->about_entry_buffer, "center", "justification", GTK_JUSTIFY_CENTER, NULL);
gtk_text_buffer_get_iter_at_offset (appGUI->about_entry_buffer, &appGUI->about_entry_iter, 0);
appGUI->about_textview = gtk_text_view_new_with_buffer (appGUI->about_entry_buffer);
gtk_container_set_border_width (GTK_CONTAINER (appGUI->about_textview), 1);
gtk_text_view_set_editable (GTK_TEXT_VIEW (appGUI->about_textview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (appGUI->about_textview), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->about_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (appGUI->about_textview), 2);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (appGUI->about_textview), 6);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (appGUI->about_textview), 6);
gtk_widget_show (appGUI->about_textview);
gtk_container_add (GTK_CONTAINER (viewport), appGUI->about_textview);
utl_gui_url_setup (&appGUI->about_links_list, &appGUI->about_link_index, appGUI->about_textview, appGUI);
display_about (appGUI);
}
void
contacts_create_export_window(GUI *appGUI) {
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *vbox2;
GtkWidget *hbox2;
GtkWidget *vbox3;
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *vbox4;
GtkWidget *vbox5;
GtkWidget *format_xhtml_radiobutton;
GSList *format_radiobutton_group = NULL;
GtkWidget *label;
GtkWidget *vseparator;
GtkWidget *scrolledwindow;
GtkWidget *viewport;
GtkWidget *fields_table;
GtkWidget *hbox3;
GtkWidget *browse_dir_button;
GtkWidget *hseparator;
GtkWidget *hbuttonbox;
GtkWidget *hbuttonbox_s;
GtkWidget *cancel_button;
GtkWidget *select_all_button;
GtkWidget *select_none_button;
GtkWidget *invert_selection_button;
gint i;
gchar tmpbuf[BUFFER_SIZE];
static MESSAGE msg_export_field[CONTACTS_NUM_COLUMNS];
static MESSAGE msg_select[3]; /* select all, select none, select invert */
appGUI->cnt->export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (appGUI->cnt->export_window), _("Export contacts"));
gtk_container_set_border_width (GTK_CONTAINER (appGUI->cnt->export_window), 6);
gtk_window_move (GTK_WINDOW (appGUI->cnt->export_window),
config.contacts_export_win_x, config.contacts_export_win_y);
gtk_window_set_default_size (GTK_WINDOW(appGUI->cnt->export_window),
config.contacts_export_win_w, config.contacts_export_win_h);
gtk_window_set_transient_for(GTK_WINDOW(appGUI->cnt->export_window), GTK_WINDOW(appGUI->main_window));
gtk_window_set_modal(GTK_WINDOW(appGUI->cnt->export_window), TRUE);
g_signal_connect (G_OBJECT (appGUI->cnt->export_window), "key_press_event",
G_CALLBACK (export_key_press_cb), appGUI);
g_signal_connect (G_OBJECT (appGUI->cnt->export_window), "delete_event",
G_CALLBACK(export_window_close_cb), appGUI);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (appGUI->cnt->export_window), vbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (hbox2), vbox3, FALSE, TRUE, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (vbox3), frame, FALSE, FALSE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
vbox4 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox4);
gtk_container_add (GTK_CONTAINER (alignment), vbox4);
gtk_container_set_border_width (GTK_CONTAINER (vbox4), 8);
appGUI->cnt->format_csv_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "CSV");
gtk_widget_show (appGUI->cnt->format_csv_radiobutton);
g_signal_connect (G_OBJECT (appGUI->cnt->format_csv_radiobutton), "clicked",
G_CALLBACK(format_changed_cb), appGUI);
GTK_WIDGET_UNSET_FLAGS(appGUI->cnt->format_csv_radiobutton, GTK_CAN_FOCUS);
gtk_box_pack_start (GTK_BOX (vbox4), appGUI->cnt->format_csv_radiobutton, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (appGUI->cnt->format_csv_radiobutton), format_radiobutton_group);
format_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (appGUI->cnt->format_csv_radiobutton));
format_xhtml_radiobutton = gtk_radio_button_new_with_mnemonic (NULL, "XHTML");
gtk_widget_show (format_xhtml_radiobutton);
g_signal_connect (G_OBJECT (format_xhtml_radiobutton), "clicked",
G_CALLBACK(format_changed_cb), appGUI);
GTK_WIDGET_UNSET_FLAGS(format_xhtml_radiobutton, GTK_CAN_FOCUS);
gtk_box_pack_start (GTK_BOX (vbox4), format_xhtml_radiobutton, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (format_xhtml_radiobutton), format_radiobutton_group);
format_radiobutton_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (format_xhtml_radiobutton));
if (config.export_format) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(format_xhtml_radiobutton), TRUE);
}
sprintf(tmpbuf, "<b>%s:</b>", _("Output format"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (vbox3), frame, FALSE, FALSE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
vbox4 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox4);
gtk_container_add (GTK_CONTAINER (alignment), vbox4);
gtk_container_set_border_width (GTK_CONTAINER (vbox4), 8);
sprintf(tmpbuf, "<b>%s:</b>", _("Options"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
sprintf(tmpbuf, "%s", _("Add header"));
appGUI->cnt->first_row_header_check_button = gtk_check_button_new_with_mnemonic (tmpbuf);
gtk_widget_show (appGUI->cnt->first_row_header_check_button);
gtk_box_pack_start (GTK_BOX (vbox4), appGUI->cnt->first_row_header_check_button, TRUE, TRUE, 0);
GTK_WIDGET_UNSET_FLAGS(appGUI->cnt->first_row_header_check_button, GTK_CAN_FOCUS);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(appGUI->cnt->first_row_header_check_button), TRUE);
vseparator = gtk_vseparator_new ();
gtk_widget_show (vseparator);
gtk_box_pack_start (GTK_BOX (hbox2), vseparator, FALSE, TRUE, 4);
vbox5 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox5);
gtk_box_pack_start (GTK_BOX (hbox2), vbox5, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox4), 8);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (vbox5), frame, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_container_add (GTK_CONTAINER (alignment), scrolledwindow);
gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow), 8);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport);
gtk_container_add (GTK_CONTAINER (scrolledwindow), viewport);
fields_table = gtk_table_new (CONTACTS_NUM_COLUMNS, 1, FALSE);
gtk_widget_show (fields_table);
gtk_container_add (GTK_CONTAINER (viewport), fields_table);
sprintf(tmpbuf, "<b>%s:</b>", _("Fields to export"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (vbox5), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
hbuttonbox_s = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox_s);
gtk_box_pack_start (GTK_BOX (vbox5), hbuttonbox_s, FALSE, TRUE, 0);
gtk_box_set_spacing (GTK_BOX (hbuttonbox_s), 4);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox_s), GTK_BUTTONBOX_END);
select_all_button = gtk_button_new_with_label (_("All"));
GTK_WIDGET_UNSET_FLAGS(select_all_button, GTK_CAN_FOCUS);
gtk_widget_show (select_all_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox_s), select_all_button);
msg_select[0].appGUI = appGUI;
msg_select[0].data = (gpointer) SELECT_ALL;
g_signal_connect (G_OBJECT (select_all_button), "clicked",
G_CALLBACK (select_action_cb), &msg_select[0]);
select_none_button = gtk_button_new_with_label (_("None"));
GTK_WIDGET_UNSET_FLAGS(select_none_button, GTK_CAN_FOCUS);
gtk_widget_show (select_none_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox_s), select_none_button);
msg_select[1].appGUI = appGUI;
msg_select[1].data = (gpointer) SELECT_NONE;
g_signal_connect (G_OBJECT (select_none_button), "clicked",
G_CALLBACK (select_action_cb), &msg_select[1]);
invert_selection_button = gtk_button_new_with_label (_("Invert"));
GTK_WIDGET_UNSET_FLAGS(invert_selection_button, GTK_CAN_FOCUS);
gtk_widget_show (select_none_button);
gtk_widget_show (invert_selection_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox_s), invert_selection_button);
msg_select[2].appGUI = appGUI;
msg_select[2].data = (gpointer) SELECT_INVERT;
g_signal_connect (G_OBJECT (invert_selection_button), "clicked",
G_CALLBACK (select_action_cb), &msg_select[2]);
sprintf(tmpbuf, "<b>%s:</b>", _("Select fields"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (vbox1), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);
hbox3 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox3);
gtk_container_add (GTK_CONTAINER (alignment), hbox3);
appGUI->cnt->output_file_entry = gtk_entry_new ();
gtk_widget_show (appGUI->cnt->output_file_entry);
gtk_box_pack_start (GTK_BOX (hbox3), appGUI->cnt->output_file_entry, TRUE, TRUE, 0);
GTK_WIDGET_UNSET_FLAGS(appGUI->cnt->output_file_entry, GTK_CAN_FOCUS);
gtk_editable_set_editable (GTK_EDITABLE(appGUI->cnt->output_file_entry), FALSE);
for(i=0; i < CONTACTS_NUM_COLUMNS; i++) {
if (i != COLUMN_PHOTO && i != COLUMN_ID) {
appGUI->cnt->check_buttons[i] = gtk_check_button_new_with_mnemonic (appGUI->cnt->contact_fields_tags_name[i*2]);
gtk_widget_show (appGUI->cnt->check_buttons[i]);
msg_export_field[i].appGUI = appGUI;
msg_export_field[i].data = (gpointer) i;
g_signal_connect (G_OBJECT (appGUI->cnt->check_buttons[i]), "toggled",
G_CALLBACK (export_field_selected_cb), &msg_export_field[i]);
GTK_WIDGET_UNSET_FLAGS(appGUI->cnt->check_buttons[i], GTK_CAN_FOCUS);
gtk_table_attach (GTK_TABLE (fields_table), appGUI->cnt->check_buttons[i], 0, 1, i, i+1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
if(config.export_fields[i] == '+') {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(appGUI->cnt->check_buttons[i]), TRUE);
}
}
}
if (config.default_stock_icons) {
browse_dir_button = utl_gui_stock_button (GTK_STOCK_DIRECTORY, FALSE);
} else {
browse_dir_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_OPEN);
}
gtk_widget_show (browse_dir_button);
GTK_WIDGET_UNSET_FLAGS(browse_dir_button, GTK_CAN_FOCUS);
g_signal_connect(browse_dir_button, "clicked", G_CALLBACK(browse_dir_cb), appGUI);
gtk_box_pack_start (GTK_BOX (hbox3), browse_dir_button, FALSE, FALSE, 0);
sprintf(tmpbuf, "<b>%s:</b>", _("Output filename"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox), 8);
if (config.default_stock_icons) {
cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
} else {
cancel_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CANCEL);
}
gtk_widget_show (cancel_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox), cancel_button);
GTK_WIDGET_SET_FLAGS (cancel_button, GTK_CAN_DEFAULT);
g_signal_connect(cancel_button, "clicked", G_CALLBACK(button_export_window_close_cb), appGUI);
appGUI->cnt->export_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CONTACTS_EXPORT);
gtk_widget_show (appGUI->cnt->export_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->cnt->export_button);
GTK_WIDGET_SET_FLAGS (appGUI->cnt->export_button, GTK_CAN_DEFAULT);
g_signal_connect(appGUI->cnt->export_button, "clicked", G_CALLBACK(export_cb), appGUI);
gtk_widget_set_sensitive(appGUI->cnt->export_button, FALSE);
gtk_widget_show(appGUI->cnt->export_window);
}
GtkWidget*
create_connection_setup (void)
{
GtkWidget *connection_setup;
GtkWidget *dialog_vbox1;
GtkWidget *fixed1;
GtkWidget *nom_joueur_entry;
GtkWidget *server_hbox;
GtkWidget *port_server_label;
GtkWidget *port_server_entry;
GtkWidget *nom_joueur_label;
GtkWidget *client_vbox;
GtkWidget *client_hbox1;
GtkWidget *ip_client_label;
GtkWidget *client_ip_entry;
GtkWidget *client_hbox2;
GtkWidget *port_client_label;
GtkWidget *port_client_entry;
GtkWidget *radio_im_server;
GSList *radio_im_server_group = NULL;
GtkWidget *radio_im_not_server;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *alignment2;
GtkWidget *hbox2;
GtkWidget *image56;
GtkWidget *label5;
GtkWidget *okbutton1;
GtkWidget *alignment1;
GtkWidget *hbox1;
GtkWidget *image55;
GtkWidget *label4;
connection_setup = gtk_dialog_new ();
gtk_widget_set_size_request (connection_setup, 276, 301);
gtk_window_set_title (GTK_WINDOW (connection_setup), "Partie R\303\251seau");
gtk_window_set_resizable (GTK_WINDOW (connection_setup), FALSE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (connection_setup), TRUE);
//gtk_window_set_icon_name (GTK_WINDOW (connection_setup), "gtk-dialog-info");
gtk_window_set_type_hint (GTK_WINDOW (connection_setup), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (connection_setup)->vbox;
gtk_widget_show (dialog_vbox1);
fixed1 = gtk_fixed_new ();
gtk_widget_show (fixed1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), fixed1, TRUE, TRUE, 0);
nom_joueur_entry = gtk_entry_new ();
gtk_widget_show (nom_joueur_entry);
gtk_fixed_put (GTK_FIXED (fixed1), nom_joueur_entry, 72, 49);
gtk_widget_set_size_request (nom_joueur_entry, 158, 26);
gtk_entry_set_text (GTK_ENTRY (nom_joueur_entry), "Bob");
server_hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (server_hbox);
gtk_fixed_put (GTK_FIXED (fixed1), server_hbox, 37, 122);
gtk_widget_set_size_request (server_hbox, 32, 16);
port_server_label = gtk_label_new ("Port");
gtk_widget_show (port_server_label);
gtk_box_pack_start (GTK_BOX (server_hbox), port_server_label, FALSE, FALSE, 0);
gtk_widget_set_size_request (port_server_label, 36, 18);
port_server_entry = gtk_entry_new ();
gtk_widget_show (port_server_entry);
gtk_box_pack_start (GTK_BOX (server_hbox), port_server_entry, FALSE, FALSE, 0);
gtk_widget_set_size_request (port_server_entry, 158, 26);
gtk_entry_set_text (GTK_ENTRY (port_server_entry), "5010");
nom_joueur_label = gtk_label_new ("<b>Mon nom de joueur :</b>");
gtk_widget_show (nom_joueur_label);
gtk_fixed_put (GTK_FIXED (fixed1), nom_joueur_label, 16, 16);
gtk_widget_set_size_request (nom_joueur_label, 152, 26);
gtk_label_set_use_markup (GTK_LABEL (nom_joueur_label), TRUE);
client_vbox = gtk_vbox_new (FALSE, 29);
gtk_widget_show (client_vbox);
gtk_fixed_put (GTK_FIXED (fixed1), client_vbox, 36, 197);
gtk_widget_set_size_request (client_vbox, 16, 32);
gtk_widget_set_sensitive (client_vbox, FALSE);
client_hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (client_hbox1);
gtk_box_pack_start (GTK_BOX (client_vbox), client_hbox1, TRUE, FALSE, 0);
gtk_widget_set_size_request (client_hbox1, 32, 16);
ip_client_label = gtk_label_new ("IP");
gtk_widget_show (ip_client_label);
gtk_box_pack_start (GTK_BOX (client_hbox1), ip_client_label, FALSE, FALSE, 0);
gtk_widget_set_size_request (ip_client_label, 36, 18);
client_ip_entry = gtk_entry_new ();
gtk_widget_show (client_ip_entry);
gtk_box_pack_start (GTK_BOX (client_hbox1), client_ip_entry, FALSE, FALSE, 0);
gtk_widget_set_size_request (client_ip_entry, 158, 26);
client_hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (client_hbox2);
gtk_box_pack_start (GTK_BOX (client_vbox), client_hbox2, TRUE, FALSE, 0);
gtk_widget_set_size_request (client_hbox2, 32, 16);
port_client_label = gtk_label_new ("Port");
gtk_widget_show (port_client_label);
gtk_box_pack_start (GTK_BOX (client_hbox2), port_client_label, FALSE, FALSE, 0);
gtk_widget_set_size_request (port_client_label, 36, 18);
port_client_entry = gtk_entry_new ();
gtk_widget_show (port_client_entry);
gtk_box_pack_start (GTK_BOX (client_hbox2), port_client_entry, FALSE, FALSE, 0);
gtk_widget_set_size_request (port_client_entry, 158, 26);
gtk_entry_set_text (GTK_ENTRY (port_client_entry), "5010");
radio_im_server = gtk_radio_button_new_with_mnemonic (NULL, "J'h\303\251berge la partie");
gtk_widget_show (radio_im_server);
gtk_fixed_put (GTK_FIXED (fixed1), radio_im_server, 32, 89);
gtk_widget_set_size_request (radio_im_server, 152, 22);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio_im_server), radio_im_server_group);
radio_im_server_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_im_server));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_im_server), TRUE);
radio_im_not_server = gtk_radio_button_new_with_mnemonic (NULL, "Je me connecte chez quelqu'un");
gtk_widget_show (radio_im_not_server);
gtk_fixed_put (GTK_FIXED (fixed1), radio_im_not_server, 32, 160);
gtk_widget_set_size_request (radio_im_not_server, 240, 22);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio_im_not_server), radio_im_server_group);
radio_im_server_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_im_not_server));
dialog_action_area1 = GTK_DIALOG (connection_setup)->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 ();
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (connection_setup), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (cancelbutton1), alignment2);
hbox2 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox2);
gtk_container_add (GTK_CONTAINER (alignment2), hbox2);
image56 = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image56);
gtk_box_pack_start (GTK_BOX (hbox2), image56, FALSE, FALSE, 0);
label5 = gtk_label_new_with_mnemonic ("Annuler");
gtk_widget_show (label5);
gtk_box_pack_start (GTK_BOX (hbox2), label5, FALSE, FALSE, 0);
okbutton1 = gtk_button_new ();
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (connection_setup), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (okbutton1), alignment1);
hbox1 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (alignment1), hbox1);
image55 = gtk_image_new_from_stock ("gtk-goto-last", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image55);
gtk_box_pack_start (GTK_BOX (hbox1), image55, FALSE, FALSE, 0);
label4 = gtk_label_new_with_mnemonic ("C'est parti !");
gtk_widget_show (label4);
gtk_box_pack_start (GTK_BOX (hbox1), label4, FALSE, FALSE, 0);
g_signal_connect_swapped ((gpointer) radio_im_server, "toggled",
G_CALLBACK (on_radio_im_server_toggled),
GTK_OBJECT (client_vbox));
g_signal_connect_swapped ((gpointer) radio_im_not_server, "toggled",
G_CALLBACK (on_radio_im_not_server_toggled),
GTK_OBJECT (server_hbox));
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (connection_setup, connection_setup, "connection_setup");
GLADE_HOOKUP_OBJECT_NO_REF (connection_setup, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (connection_setup, fixed1, "fixed1");
GLADE_HOOKUP_OBJECT (connection_setup, nom_joueur_entry, "nom_joueur_entry");
GLADE_HOOKUP_OBJECT (connection_setup, server_hbox, "server_hbox");
GLADE_HOOKUP_OBJECT (connection_setup, port_server_label, "port_server_label");
GLADE_HOOKUP_OBJECT (connection_setup, port_server_entry, "port_server_entry");
GLADE_HOOKUP_OBJECT (connection_setup, nom_joueur_label, "nom_joueur_label");
GLADE_HOOKUP_OBJECT (connection_setup, client_vbox, "client_vbox");
GLADE_HOOKUP_OBJECT (connection_setup, client_hbox1, "client_hbox1");
GLADE_HOOKUP_OBJECT (connection_setup, ip_client_label, "ip_client_label");
GLADE_HOOKUP_OBJECT (connection_setup, client_ip_entry, "client_ip_entry");
GLADE_HOOKUP_OBJECT (connection_setup, client_hbox2, "client_hbox2");
GLADE_HOOKUP_OBJECT (connection_setup, port_client_label, "port_client_label");
GLADE_HOOKUP_OBJECT (connection_setup, port_client_entry, "port_client_entry");
GLADE_HOOKUP_OBJECT (connection_setup, radio_im_server, "radio_im_server");
GLADE_HOOKUP_OBJECT (connection_setup, radio_im_not_server, "radio_im_not_server");
GLADE_HOOKUP_OBJECT_NO_REF (connection_setup, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (connection_setup, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (connection_setup, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT (connection_setup, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (connection_setup, image56, "image56");
GLADE_HOOKUP_OBJECT (connection_setup, label5, "label5");
GLADE_HOOKUP_OBJECT (connection_setup, okbutton1, "okbutton1");
GLADE_HOOKUP_OBJECT (connection_setup, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (connection_setup, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (connection_setup, image55, "image55");
GLADE_HOOKUP_OBJECT (connection_setup, label4, "label4");
gtk_widget_grab_focus (okbutton1);
gtk_widget_grab_default (okbutton1);
return connection_setup;
}
static void
run_add_edit_dialog (LogviewFilterManager *manager, LogviewFilter *filter)
{
GError *error;
gchar *name, *regex;
const gchar *title;
GtkWidget *dialog, *entry_name, *entry_regex, *radio_color;
GtkWidget *radio_visible, *check_foreground, *check_background;
GtkWidget *color_foreground, *color_background, *vbox_color;
gboolean foreground_set, background_set, invisible;
GtkTextTag *tag;
GtkBuilder* builder;
builder = manager->priv->builder;
error = NULL;
name = NULL;
gtk_builder_add_from_file (builder, UI_FILE, &error);
if (error) {
g_warning ("Could not load filter ui: %s", error->message);
g_error_free (error);
return;
}
title = (filter != NULL ? _("Edit filter") : _("Add new filter"));
dialog = GTK_WIDGET (gtk_builder_get_object (builder,
"dialog_filter"));
entry_name = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_name"));
entry_regex = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_regex"));
radio_color = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_color"));
radio_visible = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_visible"));
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio_color),
gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_visible)));
check_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"check_foreground"));
check_background = GTK_WIDGET (gtk_builder_get_object (builder,
"check_background"));
color_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"color_foreground"));
color_background = GTK_WIDGET (gtk_builder_get_object (builder,
"color_background"));
g_signal_connect (check_foreground, "toggled", G_CALLBACK (on_check_toggled),
color_foreground);
g_signal_connect (check_background, "toggled", G_CALLBACK (on_check_toggled),
color_background);
on_check_toggled (GTK_TOGGLE_BUTTON (check_foreground),
color_foreground);
on_check_toggled (GTK_TOGGLE_BUTTON (check_background),
color_background);
vbox_color = GTK_WIDGET (gtk_builder_get_object (builder, "vbox_color"));
g_signal_connect (radio_color, "toggled", G_CALLBACK (on_check_toggled),
vbox_color);
on_check_toggled (GTK_TOGGLE_BUTTON (radio_color),
vbox_color);
if (filter) {
g_object_get (filter,
"name", &name,
"regex", ®ex,
"texttag", &tag,
NULL);
g_object_get (tag,
"foreground-set", &foreground_set,
"paragraph-background-set", &background_set,
"invisible", &invisible, NULL);
gtk_entry_set_text (GTK_ENTRY(entry_name), name);
gtk_entry_set_text (GTK_ENTRY(entry_regex), regex);
if (foreground_set) {
GdkColor *foreground;
g_object_get (tag, "foreground-gdk", &foreground, NULL);
gtk_color_button_set_color (GTK_COLOR_BUTTON (color_foreground),
foreground);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_foreground),
TRUE);
gdk_color_free (foreground);
}
if (background_set) {
GdkColor *background;
g_object_get (tag, "paragraph-background-gdk", &background, NULL);
gtk_color_button_set_color (GTK_COLOR_BUTTON (color_background),
background);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_background),
TRUE);
gdk_color_free (background);
}
if (background_set || foreground_set) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_color), TRUE);
} else if (invisible) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_visible), TRUE);
}
g_free (regex);
g_object_unref (tag);
}
g_object_set_data_full (G_OBJECT (manager), "old_name", name, g_free);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (on_dialog_add_edit_reponse), manager);
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (manager));
gtk_window_set_modal (GTK_WINDOW (dialog),
TRUE);
gtk_widget_show (GTK_WIDGET (dialog));
}
GotoReferenceDialog::GotoReferenceDialog(unsigned int currentbook, unsigned int currentchapter, const ustring & currentverse)
{
// Init variables
extern Settings *settings;
ProjectConfiguration *projectconfig = settings->projectconfig(settings->genconfig.project_get());
language = projectconfig->language_get();
newreference = false;
oldbook = currentbook;
oldchapter = currentchapter;
oldverse = currentverse;
go_back = false;
go_forward = false;
Shortcuts shortcuts(0);
gtkbuilder = gtk_builder_new ();
gtk_builder_add_from_file (gtkbuilder, gw_build_filename (Directories->get_package_data(), "gtkbuilder.gotoreferencedialog.xml").c_str(), NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "dialog"));
g_signal_connect((gpointer) dialog, "key_press_event", G_CALLBACK(on_key_press_event), gpointer(this));
notebook = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "notebook"));
// Enter current reference into the free entry, and select it, so user can use that.
entry_free = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_free"));
gtk_widget_grab_focus(entry_free);
ustring ref = books_id_to_name(language, currentbook) + " " + convert_to_string(currentchapter) + ":" + currentverse;
gtk_entry_set_text(GTK_ENTRY(entry_free), ref.c_str());
gtk_editable_select_region(GTK_EDITABLE(entry_free), 0, -1);
// Completion for the reference entry.
completion_setup(entry_free, cpGoto);
// Signals entry.
g_signal_connect((gpointer) entry_free, "activate", G_CALLBACK(on_entry_free_activate), gpointer(this));
// Aided entry widgets.
treeview_book = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_book"));
treeview_chapter = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_chapter"));
treeview_verse = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_verse"));
// Connect to the signals of the treeviews.
g_signal_connect_after((gpointer) treeview_book, "move_cursor", G_CALLBACK(on_treeview_book_move_cursor), gpointer(this));
g_signal_connect_after((gpointer) treeview_book, "row_activated", G_CALLBACK(on_treeview_book_row_activated), gpointer(this));
g_signal_connect_after((gpointer) treeview_chapter, "move_cursor", G_CALLBACK(on_treeview_chapter_move_cursor), gpointer(this));
g_signal_connect_after((gpointer) treeview_chapter, "row_activated", G_CALLBACK(on_treeview_chapter_row_activated), gpointer(this));
g_signal_connect_after((gpointer) treeview_verse, "move_cursor", G_CALLBACK(on_treeview_verse_move_cursor), gpointer(this));
g_signal_connect_after((gpointer) treeview_verse, "row_activated", G_CALLBACK(on_treeview_verse_row_activated), gpointer(this));
// Create stores and fill the book store.
store_book = gtk_list_store_new(1, G_TYPE_STRING);
store_chapter = gtk_list_store_new(1, G_TYPE_STRING);
store_verse = gtk_list_store_new(1, G_TYPE_STRING);
vector < unsigned int >ibooks = project_get_books(settings->genconfig.project_get());
vector < ustring > ubooks;
for (unsigned int i = 0; i < ibooks.size(); i++)
ubooks.push_back(books_id_to_name(language, ibooks[i]));
listview_set_strings(treeview_book, store_book, ubooks);
// Set the stores as models for the treeviews.
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_book), GTK_TREE_MODEL(store_book));
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_chapter), GTK_TREE_MODEL(store_chapter));
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_verse), GTK_TREE_MODEL(store_verse));
// Unreference the stores once, so they get destroyed with the treeview.
g_object_unref(store_book);
g_object_unref(store_chapter);
g_object_unref(store_verse);
// Text cell renderer.
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new();
// Columns.
GtkTreeViewColumn *column_book;
column_book = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_book), column_book);
GtkTreeViewColumn *column_chapter;
column_chapter = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_chapter), column_chapter);
GtkTreeViewColumn *column_verse;
column_verse = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_verse), column_verse);
// Set up the selection for each of the tree views.
GtkTreeSelection *select_book;
select_book = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_book));
gtk_tree_selection_set_mode(select_book, GTK_SELECTION_SINGLE);
GtkTreeSelection *select_chapter;
select_chapter = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_chapter));
gtk_tree_selection_set_mode(select_chapter, GTK_SELECTION_SINGLE);
GtkTreeSelection *select_verse;
select_verse = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_verse));
gtk_tree_selection_set_mode(select_verse, GTK_SELECTION_SINGLE);
// History back.
radiobutton_back = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_back"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton_back), true);
// History forward.
radiobutton_forward = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_forward"));
// Link history button.
GSList *history_button_group = NULL;
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_back), history_button_group);
history_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_back));
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_forward), history_button_group);
history_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_forward));
// Dialog action area.
InDialogHelp * indialoghelp = new InDialogHelp(dialog, gtkbuilder, &shortcuts, NULL);
cancelbutton = indialoghelp->cancelbutton;
okbutton = indialoghelp->okbutton;
gtk_widget_grab_default(okbutton);
g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
}
RevertDialog::RevertDialog(Reference * reference)
{
// Save variables.
extern Settings *settings;
project = settings->genconfig.project_get();
ProjectConfiguration *projectconfig = settings->projectconfig(project);
language = projectconfig->language_get();
reference_chapter = reference->chapter_get();
revisionloaded = false;
branch = 0;
// Build dialog.
Shortcuts shortcuts(0);
revertdialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(revertdialog), _("Revert"));
gtk_window_set_position(GTK_WINDOW(revertdialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_type_hint(GTK_WINDOW(revertdialog), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (revertdialog));
gtk_widget_show(dialog_vbox1);
hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), hbox1, TRUE, TRUE, 0);
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(hbox1), vbox1, TRUE, TRUE, 0);
table1 = gtk_table_new(2, 2, FALSE);
gtk_widget_show(table1);
gtk_box_pack_start(GTK_BOX(vbox1), table1, FALSE, TRUE, 0);
comboboxbook = gtk_combo_box_new_text();
gtk_widget_show(comboboxbook);
gtk_table_attach(GTK_TABLE(table1), comboboxbook, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
comboboxchapter = gtk_combo_box_new_text();
gtk_widget_show(comboboxchapter);
gtk_table_attach(GTK_TABLE(table1), comboboxchapter, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0);
labelbook = gtk_label_new(_("Book"));
gtk_widget_show(labelbook);
gtk_table_attach(GTK_TABLE(table1), labelbook, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(labelbook), 0, 0.5);
shortcuts.label(labelbook);
gtk_label_set_mnemonic_widget(GTK_LABEL(labelbook), comboboxbook);
labelchapter = gtk_label_new(_("Chapter"));
gtk_widget_show(labelchapter);
gtk_table_attach(GTK_TABLE(table1), labelchapter, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(labelchapter), 0, 0.5);
shortcuts.label(labelchapter);
gtk_label_set_mnemonic_widget(GTK_LABEL(labelchapter), comboboxchapter);
hseparator1 = gtk_hseparator_new();
gtk_widget_show(hseparator1);
gtk_box_pack_start(GTK_BOX(vbox1), hseparator1, FALSE, TRUE, 0);
labelrevisions = gtk_label_new(_("Revisions"));
gtk_widget_show(labelrevisions);
gtk_box_pack_start(GTK_BOX(vbox1), labelrevisions, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(labelrevisions), 0, 0.5);
shortcuts.label(labelrevisions);
scrolledwindowrevisions = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindowrevisions);
gtk_box_pack_start(GTK_BOX(vbox1), scrolledwindowrevisions, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindowrevisions), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindowrevisions), GTK_SHADOW_IN);
treeviewrevisions = gtk_tree_view_new();
gtk_widget_show(treeviewrevisions);
gtk_container_add(GTK_CONTAINER(scrolledwindowrevisions), treeviewrevisions);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeviewrevisions), FALSE);
gtk_label_set_mnemonic_widget(GTK_LABEL(labelrevisions), treeviewrevisions);
// Create treeview related stuff.
store = gtk_list_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeviewrevisions), GTK_TREE_MODEL(store));
g_object_unref(store);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeviewrevisions), column);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviewrevisions));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
vseparator1 = gtk_vseparator_new();
gtk_widget_show(vseparator1);
gtk_box_pack_start(GTK_BOX(hbox1), vseparator1, FALSE, TRUE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox2);
gtk_box_pack_start(GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0);
GSList *radiobutton_current_group = NULL;
radiobutton_current = gtk_radio_button_new_with_mnemonic (NULL, _("View current version"));
gtk_widget_show (radiobutton_current);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton_current, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_current), radiobutton_current_group);
radiobutton_current_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_current));
shortcuts.button(radiobutton_current);
radiobutton_previous = gtk_radio_button_new_with_mnemonic (NULL, _("View previous revision"));
gtk_widget_show (radiobutton_previous);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton_previous, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_previous), radiobutton_current_group);
radiobutton_current_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_previous));
shortcuts.button(radiobutton_previous);
radiobutton_changes = gtk_radio_button_new_with_mnemonic (NULL, _("View changes if reverting to previous revision"));
gtk_widget_show (radiobutton_changes);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton_changes, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_changes), radiobutton_current_group);
radiobutton_current_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_changes));
shortcuts.button(radiobutton_changes);
changes_gui = new DisplayChangesGui (vbox2);
gtk_widget_set_size_request(changes_gui->textview, 450, 500);
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(revertdialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(revertdialog, NULL, &shortcuts, "edit/revert");
cancelbutton1 = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(revertdialog), cancelbutton1, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true);
okbutton1 = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(revertdialog), okbutton1, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton1), true);
shortcuts.stockbutton(cancelbutton1);
shortcuts.stockbutton(okbutton1);
shortcuts.process();
g_signal_connect((gpointer) comboboxbook, "changed", G_CALLBACK(on_comboboxbook_changed), gpointer(this));
g_signal_connect((gpointer) comboboxchapter, "changed", G_CALLBACK(on_comboboxchapter_changed), gpointer(this));
g_signal_connect((gpointer) treeviewrevisions, "row_activated", G_CALLBACK(on_treeviewrevisions_row_activated), gpointer(this));
g_signal_connect((gpointer) okbutton1, "clicked", G_CALLBACK(on_okbutton1_clicked), gpointer(this));
g_signal_connect ((gpointer) radiobutton_current, "toggled", G_CALLBACK (on_radiobutton_toggled), gpointer(this));
g_signal_connect ((gpointer) radiobutton_previous, "toggled", G_CALLBACK (on_radiobutton_toggled), gpointer(this));
g_signal_connect ((gpointer) radiobutton_changes, "toggled", G_CALLBACK (on_radiobutton_toggled), gpointer(this));
gtk_widget_grab_focus(okbutton1);
gtk_widget_grab_default(okbutton1);
// Load books. This also loads the chapters through the callback.
vector < unsigned int >books = project_get_books(project);
vector < ustring > localbooks;
for (unsigned int i = 0; i < books.size(); i++) {
localbooks.push_back(books_id_to_name(language, books[i]));
}
combobox_set_strings(comboboxbook, localbooks);
combobox_set_string(comboboxbook, books_id_to_name(language, reference->book_get()));
// By default view changes.
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton_changes), true);
}
GtkWidget*
create_dialogAudio (void)
{
GtkWidget *dialogAudio;
GtkWidget *dialog_vbox1;
GtkWidget *vbox3;
GtkWidget *frame3;
GtkWidget *vbox6;
GtkWidget *checkbuttonNormalize;
GtkWidget *checkbuttonDRC;
GtkWidget *hbox3;
GtkWidget *checkbuttonTimeShift;
GtkWidget *entryTimeshift;
GtkWidget *label5;
GtkWidget *frame1;
GtkWidget *vbox4;
GtkWidget *radiobuttonNone;
GSList *radiobuttonNone_group = NULL;
GtkWidget *radiobutton2;
GtkWidget *hbox2;
GtkWidget *radiobuttonSox;
GtkWidget *entryFrequency;
GtkWidget *label3;
GtkWidget *frame2;
GtkWidget *vbox5;
GtkWidget *radiobutton_fpsnone;
GSList *radiobutton_fpsnone_group = NULL;
GtkWidget *radiobutton_fpsfilm;
GtkWidget *radiobutton_fpsPAL;
GtkWidget *label4;
GtkWidget *frame4;
GtkWidget *vbox7;
GtkWidget *radiobutton_2to2;
GSList *radiobutton_2to2_group = NULL;
GtkWidget *radiobutton2to1;
GtkWidget *radiobutton1to2;
GtkWidget *label6;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialogAudio = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialogAudio), _("Audio Processing"));
dialog_vbox1 = GTK_DIALOG (dialogAudio)->vbox;
gtk_widget_show (dialog_vbox1);
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox3, TRUE, TRUE, 0);
frame3 = gtk_frame_new (NULL);
gtk_widget_show (frame3);
gtk_box_pack_start (GTK_BOX (vbox3), frame3, FALSE, FALSE, 0);
vbox6 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox6);
gtk_container_add (GTK_CONTAINER (frame3), vbox6);
checkbuttonNormalize = gtk_check_button_new_with_mnemonic (_("Normalize"));
gtk_widget_show (checkbuttonNormalize);
gtk_box_pack_start (GTK_BOX (vbox6), checkbuttonNormalize, FALSE, FALSE, 0);
checkbuttonDRC = gtk_check_button_new_with_mnemonic (_("DRC"));
gtk_widget_show (checkbuttonDRC);
gtk_box_pack_start (GTK_BOX (vbox6), checkbuttonDRC, FALSE, FALSE, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (vbox6), hbox3, TRUE, TRUE, 0);
checkbuttonTimeShift = gtk_check_button_new_with_mnemonic (_("Timeshift"));
gtk_widget_show (checkbuttonTimeShift);
gtk_box_pack_start (GTK_BOX (hbox3), checkbuttonTimeShift, FALSE, FALSE, 0);
entryTimeshift = gtk_entry_new ();
gtk_widget_show (entryTimeshift);
gtk_box_pack_start (GTK_BOX (hbox3), entryTimeshift, TRUE, TRUE, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryTimeshift), 5);
label5 = gtk_label_new (_("<b>Misc</b>"));
gtk_widget_show (label5);
gtk_frame_set_label_widget (GTK_FRAME (frame3), label5);
gtk_label_set_use_markup (GTK_LABEL (label5), TRUE);
gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox3), frame1, FALSE, FALSE, 0);
vbox4 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox4);
gtk_container_add (GTK_CONTAINER (frame1), vbox4);
radiobuttonNone = gtk_radio_button_new_with_mnemonic (NULL, _("None"));
gtk_widget_show (radiobuttonNone);
gtk_box_pack_start (GTK_BOX (vbox4), radiobuttonNone, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobuttonNone), radiobuttonNone_group);
radiobuttonNone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobuttonNone));
radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, _("48 to 44.1 khz"));
gtk_widget_show (radiobutton2);
gtk_box_pack_start (GTK_BOX (vbox4), radiobutton2, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobuttonNone_group);
radiobuttonNone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2));
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox4), hbox2, TRUE, TRUE, 0);
radiobuttonSox = gtk_radio_button_new_with_mnemonic (NULL, _("Resample to hz"));
gtk_widget_show (radiobuttonSox);
gtk_box_pack_start (GTK_BOX (hbox2), radiobuttonSox, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobuttonSox), radiobuttonNone_group);
radiobuttonNone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobuttonSox));
entryFrequency = gtk_entry_new ();
gtk_widget_show (entryFrequency);
gtk_box_pack_start (GTK_BOX (hbox2), entryFrequency, TRUE, TRUE, 0);
label3 = gtk_label_new (_("<b>Resampling</b>"));
gtk_widget_show (label3);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label3);
gtk_label_set_use_markup (GTK_LABEL (label3), TRUE);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (vbox3), frame2, TRUE, TRUE, 0);
vbox5 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox5);
gtk_container_add (GTK_CONTAINER (frame2), vbox5);
radiobutton_fpsnone = gtk_radio_button_new_with_mnemonic (NULL, _("None"));
gtk_widget_show (radiobutton_fpsnone);
gtk_box_pack_start (GTK_BOX (vbox5), radiobutton_fpsnone, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_fpsnone), radiobutton_fpsnone_group);
radiobutton_fpsnone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_fpsnone));
radiobutton_fpsfilm = gtk_radio_button_new_with_mnemonic (NULL, _("Film -> PAL"));
gtk_widget_show (radiobutton_fpsfilm);
gtk_box_pack_start (GTK_BOX (vbox5), radiobutton_fpsfilm, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_fpsfilm), radiobutton_fpsnone_group);
radiobutton_fpsnone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_fpsfilm));
radiobutton_fpsPAL = gtk_radio_button_new_with_mnemonic (NULL, _("PAL->Film"));
gtk_widget_show (radiobutton_fpsPAL);
gtk_box_pack_start (GTK_BOX (vbox5), radiobutton_fpsPAL, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_fpsPAL), radiobutton_fpsnone_group);
radiobutton_fpsnone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_fpsPAL));
label4 = gtk_label_new (_("<b>Fps convert</b>"));
gtk_widget_show (label4);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label4);
gtk_label_set_use_markup (GTK_LABEL (label4), TRUE);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);
frame4 = gtk_frame_new (NULL);
gtk_widget_show (frame4);
gtk_box_pack_start (GTK_BOX (vbox3), frame4, TRUE, TRUE, 0);
vbox7 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox7);
gtk_container_add (GTK_CONTAINER (frame4), vbox7);
radiobutton_2to2 = gtk_radio_button_new_with_mnemonic (NULL, _("None"));
gtk_widget_show (radiobutton_2to2);
gtk_box_pack_start (GTK_BOX (vbox7), radiobutton_2to2, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_2to2), radiobutton_2to2_group);
radiobutton_2to2_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_2to2));
radiobutton2to1 = gtk_radio_button_new_with_mnemonic (NULL, _("Stereo to Mono"));
gtk_widget_show (radiobutton2to1);
gtk_box_pack_start (GTK_BOX (vbox7), radiobutton2to1, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2to1), radiobutton_2to2_group);
radiobutton_2to2_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2to1));
radiobutton1to2 = gtk_radio_button_new_with_mnemonic (NULL, _("Mono to Stereo"));
gtk_widget_show (radiobutton1to2);
gtk_box_pack_start (GTK_BOX (vbox7), radiobutton1to2, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton1to2), radiobutton_2to2_group);
radiobutton_2to2_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1to2));
label6 = gtk_label_new (_("<b>Channels</b>"));
gtk_widget_show (label6);
gtk_frame_set_label_widget (GTK_FRAME (frame4), label6);
gtk_label_set_use_markup (GTK_LABEL (label6), TRUE);
gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT);
dialog_action_area1 = GTK_DIALOG (dialogAudio)->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 (dialogAudio), 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 (dialogAudio), 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 (dialogAudio, dialogAudio, "dialogAudio");
GLADE_HOOKUP_OBJECT_NO_REF (dialogAudio, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialogAudio, vbox3, "vbox3");
GLADE_HOOKUP_OBJECT (dialogAudio, frame3, "frame3");
GLADE_HOOKUP_OBJECT (dialogAudio, vbox6, "vbox6");
GLADE_HOOKUP_OBJECT (dialogAudio, checkbuttonNormalize, "checkbuttonNormalize");
GLADE_HOOKUP_OBJECT (dialogAudio, checkbuttonDRC, "checkbuttonDRC");
GLADE_HOOKUP_OBJECT (dialogAudio, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT (dialogAudio, checkbuttonTimeShift, "checkbuttonTimeShift");
GLADE_HOOKUP_OBJECT (dialogAudio, entryTimeshift, "entryTimeshift");
GLADE_HOOKUP_OBJECT (dialogAudio, label5, "label5");
GLADE_HOOKUP_OBJECT (dialogAudio, frame1, "frame1");
GLADE_HOOKUP_OBJECT (dialogAudio, vbox4, "vbox4");
GLADE_HOOKUP_OBJECT (dialogAudio, radiobuttonNone, "radiobuttonNone");
GLADE_HOOKUP_OBJECT (dialogAudio, radiobutton2, "radiobutton2");
GLADE_HOOKUP_OBJECT (dialogAudio, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (dialogAudio, radiobuttonSox, "radiobuttonSox");
GLADE_HOOKUP_OBJECT (dialogAudio, entryFrequency, "entryFrequency");
GLADE_HOOKUP_OBJECT (dialogAudio, label3, "label3");
GLADE_HOOKUP_OBJECT (dialogAudio, frame2, "frame2");
GLADE_HOOKUP_OBJECT (dialogAudio, vbox5, "vbox5");
GLADE_HOOKUP_OBJECT (dialogAudio, radiobutton_fpsnone, "radiobutton_fpsnone");
GLADE_HOOKUP_OBJECT (dialogAudio, radiobutton_fpsfilm, "radiobutton_fpsfilm");
GLADE_HOOKUP_OBJECT (dialogAudio, radiobutton_fpsPAL, "radiobutton_fpsPAL");
GLADE_HOOKUP_OBJECT (dialogAudio, label4, "label4");
GLADE_HOOKUP_OBJECT (dialogAudio, frame4, "frame4");
GLADE_HOOKUP_OBJECT (dialogAudio, vbox7, "vbox7");
GLADE_HOOKUP_OBJECT (dialogAudio, radiobutton_2to2, "radiobutton_2to2");
GLADE_HOOKUP_OBJECT (dialogAudio, radiobutton2to1, "radiobutton2to1");
GLADE_HOOKUP_OBJECT (dialogAudio, radiobutton1to2, "radiobutton1to2");
GLADE_HOOKUP_OBJECT (dialogAudio, label6, "label6");
GLADE_HOOKUP_OBJECT_NO_REF (dialogAudio, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialogAudio, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialogAudio, okbutton1, "okbutton1");
return dialogAudio;
}
GtkWidget* build_gui ( void ) {
GtkWidget *window1;
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *label4;
GtkWidget *radiobutton1;
GSList *radiobutton1_group = NULL;
GtkWidget *radiobutton2;
GtkWidget *entry1;
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window1), "tracking antenna");
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (window1), vbox1);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
table1 = gtk_table_new (4, 3, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox2), table1, TRUE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table1), 5);
label1 = gtk_label_new ("Azimuth");
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label2 = gtk_label_new ("Elevation");
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
label3 = gtk_label_new ("Id");
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label4 = gtk_label_new ("mode");
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, "manual");
gtk_widget_show (radiobutton1);
gtk_table_attach (GTK_TABLE (table1), radiobutton1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton1), radiobutton1_group);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1));
radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, "tracking");
gtk_widget_show (radiobutton2);
gtk_table_attach (GTK_TABLE (table1), radiobutton2, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobutton1_group);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2));
azim_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (144.7, 0, 360, 1, 1, 1)));
gtk_widget_show (azim_scale);
gtk_table_attach (GTK_TABLE (table1), azim_scale, 1, 3, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_range_set_update_policy (GTK_RANGE (azim_scale), GTK_UPDATE_DELAYED);
elev_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (32.3, 0, 90, 1, 1, 1)));
gtk_widget_show (elev_scale);
gtk_table_attach (GTK_TABLE (table1), elev_scale, 1, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
entry1 = gtk_entry_new ();
gtk_widget_show (entry1);
gtk_table_attach (GTK_TABLE (table1), entry1, 1, 3, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect ((gpointer) radiobutton1, "toggled",
G_CALLBACK (on_mode_changed),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (window1, window1, "window1");
GLADE_HOOKUP_OBJECT (window1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (window1, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (window1, table1, "table1");
GLADE_HOOKUP_OBJECT (window1, label1, "label1");
GLADE_HOOKUP_OBJECT (window1, label2, "label2");
GLADE_HOOKUP_OBJECT (window1, label3, "label3");
GLADE_HOOKUP_OBJECT (window1, label4, "label4");
GLADE_HOOKUP_OBJECT (window1, radiobutton1, "radiobutton1");
GLADE_HOOKUP_OBJECT (window1, radiobutton2, "radiobutton2");
GLADE_HOOKUP_OBJECT (window1, entry1, "entry1");
return window1;
}
static void
joind_show_dialog (server *serv)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *image1;
GtkWidget *vbox2;
GtkWidget *label;
GtkWidget *radiobutton1;
GtkWidget *radiobutton2;
GtkWidget *radiobutton3;
GSList *radiobutton1_group;
GtkWidget *hbox2;
GtkWidget *entry1;
GtkWidget *checkbutton1;
GtkWidget *dialog_action_area1;
GtkWidget *okbutton1;
char buf[256];
char buf2[256];
serv->gui->joind_win = dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("XChat: Connection Complete"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_position (GTK_WINDOW (dialog1), GTK_WIN_POS_MOUSE);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
image1 = gtk_image_new_from_stock ("gtk-yes", GTK_ICON_SIZE_DIALOG);
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, TRUE, 24);
gtk_misc_set_alignment (GTK_MISC (image1), 0.5, 0.06);
vbox2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 6);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0);
snprintf (buf2, sizeof (buf2), _("Connection to %s complete."),
server_get_network (serv, TRUE));
snprintf (buf, sizeof (buf), "\n<b>%s</b>", buf2);
label = gtk_label_new (buf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
label = gtk_label_new (_("In the Server-List window, no channel (chat room) has been entered to be automatically joined for this network."));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
GTK_LABEL (label)->wrap = TRUE;
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
label = gtk_label_new (_("What would you like to do next?"));
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
serv->gui->joind_radio1 = radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, _("_Nothing, I'll join a channel later."));
gtk_widget_show (radiobutton1);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton1, FALSE, FALSE, 0);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1));
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
serv->gui->joind_radio2 = radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, _("_Join this channel:"));
gtk_widget_show (radiobutton2);
gtk_box_pack_start (GTK_BOX (hbox2), radiobutton2, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobutton1_group);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2));
serv->gui->joind_entry = entry1 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry1), "#");
gtk_widget_show (entry1);
gtk_box_pack_start (GTK_BOX (hbox2), entry1, TRUE, TRUE, 8);
snprintf (buf, sizeof (buf), "<small> %s</small>",
_("If you know the name of the channel you want to join, enter it here."));
label = gtk_label_new (buf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
radiobutton3 = gtk_radio_button_new_with_mnemonic (NULL, _("O_pen the Channel-List window."));
gtk_widget_show (radiobutton3);
gtk_box_pack_start (GTK_BOX (vbox2), radiobutton3, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton3), radiobutton1_group);
radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton3));
snprintf (buf, sizeof (buf), "<small> %s</small>",
_("Retrieving the Channel-List may take a minute or two."));
label = gtk_label_new (buf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
serv->gui->joind_check = checkbutton1 = gtk_check_button_new_with_mnemonic (_("_Always show this dialog after connecting."));
if (prefs.gui_join_dialog)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton1), TRUE);
gtk_widget_show (checkbutton1);
gtk_box_pack_start (GTK_BOX (vbox1), checkbutton1, FALSE, FALSE, 0);
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);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog1)->action_area), okbutton1, FALSE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
g_signal_connect (G_OBJECT (dialog1), "destroy",
G_CALLBACK (joind_destroy_cb), serv);
g_signal_connect (G_OBJECT (entry1), "focus_in_event",
G_CALLBACK (joind_entryfocus_cb), serv);
g_signal_connect (G_OBJECT (entry1), "activate",
G_CALLBACK (joind_entryenter_cb), okbutton1);
g_signal_connect (G_OBJECT (radiobutton2), "toggled",
G_CALLBACK (joind_radio2_cb), serv);
g_signal_connect (G_OBJECT (okbutton1), "clicked",
G_CALLBACK (joind_ok_cb), serv);
gtk_widget_grab_focus (okbutton1);
gtk_widget_show_all (dialog1);
}
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;
}
orcaData orcaGtk::ex_set_attr(orcaVM* vm, int n)/*{{{*/
{
if (n < 2) vm->need_param();
orcaData key = vm->get_param(0);
orcaData val = vm->get_param(1);
attr[key] = val;
if ((type == GUI_LIST || type == GUI_TREE) && is<TYPE_STR>(key)) {
if (key.s() == "column") {
orcaList* lp = castobj<orcaList>(val);
if (lp == NULL) {
throw orcaException(vm, "orca.type", "list type is required");
}
int width = lp->size();
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
vector<pair<GtkCellRenderer*, orcaObject*> > signals;
GType* types = new GType[width];
for (int i=0; i<width; i++) {
orcaTuple* tp = NULL;
if (is<TYPE_STR>(lp->at(i))) {
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(lp->at(i).String().c_str(), renderer, "text", i, NULL);
types[i] = G_TYPE_STRING;
}
else if (tp = castobj<orcaTuple>(lp->at(i))) {
string type = tp->at(1).String();
if (type == "string") {
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(tp->at(0).String().c_str(), renderer, "text", i, NULL);
types[i] = G_TYPE_STRING;
}
else if (type == "toggle") {
renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes(tp->at(0).String().c_str(), renderer, "active", i, NULL);
if (tp->size() >= 3) {
pair<GtkCellRenderer*, orcaObject*> p;
p.first = renderer;
p.second = tp->at(2).Object();
signals.push_back(p);
}
types[i] = G_TYPE_BOOLEAN;
}
}
gtk_tree_view_append_column(GTK_TREE_VIEW(handle), column);
}
if (type == GUI_LIST)
store = GTK_TREE_MODEL(gtk_list_store_newv(width, types));
else
store = GTK_TREE_MODEL(gtk_tree_store_newv(width, types));
delete types;
gtk_tree_view_set_model(GTK_TREE_VIEW(handle), store);
// register toggle signal
if (!signals.empty()) {
GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW(handle));
for (int i=0; i<signals.size(); i++) {
signal_t* p = new signal_t;
p->fun = signals[i].second;
p->tree = model;
p->owner = this;
m_signals.push_back(p);
if (type == GUI_LIST) {
g_signal_connect(signals[i].first, "toggled",
G_CALLBACK(gui_list_toggled_callback), (gpointer)p);
}
else {
g_signal_connect(signals[i].first, "toggled",
G_CALLBACK(gui_tree_toggled_callback), (gpointer)p);
}
}
}
}
}
else if (type == GUI_WINDOW && is<TYPE_STR>(key)) {
if (key.s() == "wh") {
if (isobj<orcaTuple>(val)) {
orcaTuple* tp = castobj<orcaTuple>(val);
int w = tp->at(0).Integer();
int h = tp->at(1).Integer();
gtk_window_set_default_size(GTK_WINDOW(handle), w, h);
gtk_window_resize(GTK_WINDOW(handle), w, h);
}
}
else if (key.s() == "xy") {
if (isobj<orcaTuple>(val)) {
orcaTuple* tp = castobj<orcaTuple>(val);
int x = tp->at(0).Integer();
int y = tp->at(1).Integer();
gtk_window_move(GTK_WINDOW(handle), x, y);
}
}
else if (key.s() == "resizable") {
bool flag = val.Boolean();
gtk_window_set_resizable(GTK_WINDOW(handle), flag);
}
}
else if (type == GUI_RADIO && is<TYPE_STR>(key)) {
if (key.s() == "group") {
orcaObject* op = attr["group"].Object();
orcaGtk* gp = castobj<orcaGtk>(op->get_member("handle"));
if (gp == NULL) {
throw orcaException(vm, "orca.param", "invalid radio");
}
GSList* group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(gp->handle));
gtk_radio_button_set_group(GTK_RADIO_BUTTON(handle), group);
}
}
else if (type == GUI_TABLE && is<TYPE_STR>(key)) {
if (key.s() == "wh") {
orcaData d = attr["wh"];
if (isobj<orcaTuple>(d)) {
orcaTuple* tp = castobj<orcaTuple>(d);
int w = tp->at(0).Integer();
int h = tp->at(1).Integer();
handle = gtk_table_new(w, h, TRUE);
}
}
}
else if (type == GUI_BUTTON && is<TYPE_STR>(key)) {
if (key.s() == "wh") {
orcaData d = attr["wh"];
if (isobj<orcaTuple>(d)) {
orcaTuple* tp = castobj<orcaTuple>(val);
int w = tp->at(0).Integer();
int h = tp->at(1).Integer();
gtk_widget_set_size_request(handle, w, h);
}
}
}
else if (type == GUI_IMAGE && is<TYPE_STR>(key)) {
if (key.s() == "file") {
gtk_image_set_from_file(GTK_IMAGE(handle), val.String().c_str());
}
if (key.s() == "file" || key.s() == "wh") {
orcaData d = attr["wh"];
if (isobj<orcaTuple>(d)) {
orcaTuple* tp = castobj<orcaTuple>(d);
int w = tp->at(0).Integer();
int h = tp->at(1).Integer();
GdkPixbuf *pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(handle));
if (pixbuf == NULL) {
return NIL;
}
pixbuf = gdk_pixbuf_scale_simple(pixbuf, w, h, GDK_INTERP_BILINEAR);
gtk_image_set_from_pixbuf(GTK_IMAGE(handle), pixbuf);
}
}
}
return NIL;
}
void ui_common_study_preferences_widgets(GtkWidget * packing_table,
gint table_row,
GtkWidget ** proi_width_spin,
GnomeCanvasItem ** proi_item,
#ifdef AMIDE_LIBGNOMECANVAS_AA
GtkWidget ** proi_transparency_spin,
#else
GtkWidget ** pline_style_menu,
GtkWidget ** pfill_roi_button,
#endif
GtkWidget ** playout_button1,
GtkWidget ** playout_button2,
GtkWidget ** ppanel_layout_button1,
GtkWidget ** ppanel_layout_button2,
GtkWidget ** ppanel_layout_button3,
GtkWidget ** pmaintain_size_button,
GtkWidget ** ptarget_size_spin) {
GtkWidget * label;
GtkObject * adjustment;
GtkWidget * roi_canvas;
GnomeCanvasPoints * roi_line_points;
GtkWidget * image;
GtkWidget * hseparator;
#ifndef AMIDE_LIBGNOMECANVAS_AA
GdkLineStyle i_line_style;
#endif
/* widgets to change the roi's size */
label = gtk_label_new(_("ROI Width (pixels)"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_ROI_WIDTH,
AMITK_PREFERENCES_MIN_ROI_WIDTH,
AMITK_PREFERENCES_MAX_ROI_WIDTH,1.0, 1.0, 0.0);
*proi_width_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*proi_width_spin),FALSE);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*proi_width_spin), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_width_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*proi_width_spin), GTK_UPDATE_ALWAYS);
gtk_table_attach(GTK_TABLE(packing_table), *proi_width_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*proi_width_spin);
/* a little canvas indicator thingie to show the user who the new preferences will look */
#ifdef AMIDE_LIBGNOMECANVAS_AA
roi_canvas = gnome_canvas_new_aa();
#else
roi_canvas = gnome_canvas_new();
#endif
gtk_widget_set_size_request(roi_canvas, 100, 100);
gnome_canvas_set_scroll_region(GNOME_CANVAS(roi_canvas), 0.0, 0.0, 100.0, 100.0);
gtk_table_attach(GTK_TABLE(packing_table), roi_canvas, 2,3,table_row,table_row+2,
GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(roi_canvas);
/* the box */
roi_line_points = gnome_canvas_points_new(5);
roi_line_points->coords[0] = 25.0; /* x1 */
roi_line_points->coords[1] = 25.0; /* y1 */
roi_line_points->coords[2] = 75.0; /* x2 */
roi_line_points->coords[3] = 25.0; /* y2 */
roi_line_points->coords[4] = 75.0; /* x3 */
roi_line_points->coords[5] = 75.0; /* y3 */
roi_line_points->coords[6] = 25.0; /* x4 */
roi_line_points->coords[7] = 75.0; /* y4 */
roi_line_points->coords[8] = 25.0; /* x4 */
roi_line_points->coords[9] = 25.0; /* y4 */
*proi_item = gnome_canvas_item_new(gnome_canvas_root(GNOME_CANVAS(roi_canvas)),
#ifdef AMIDE_LIBGNOMECANVAS_AA
gnome_canvas_polygon_get_type(),
#else
gnome_canvas_line_get_type(),
#endif
"points", roi_line_points,
NULL);
gnome_canvas_points_unref(roi_line_points);
table_row++;
#ifdef AMIDE_LIBGNOMECANVAS_AA
/* widget to change the transparency level */
/* only works for anti-aliased canvases */
/* widgets to change the roi's size */
label = gtk_label_new(_("ROI Transparency"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0, 1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*proi_transparency_spin = gtk_spin_button_new_with_range(0.0,1.0,AMITK_PREFERENCES_DEFAULT_CANVAS_ROI_TRANSPARENCY);
gtk_spin_button_set_increments(GTK_SPIN_BUTTON(*proi_transparency_spin),0.1,0.1);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*proi_transparency_spin),FALSE);
gtk_table_attach(GTK_TABLE(packing_table), *proi_transparency_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*proi_transparency_spin);
table_row++;
#else
/* widgets to change the roi's line style */
/* Anti-aliased canvas doesn't yet support this */
/* also need to remove #ifndef for relevant lines in amitk_canvas_object.c and other locations */
label = gtk_label_new(_("ROI Line Style:"));
gtk_table_attach(GTK_TABLE(packing_table), label, 0,1,
table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pline_style_menu = gtk_combo_box_new_text();
for (i_line_style=0; i_line_style<=GDK_LINE_DOUBLE_DASH; i_line_style++)
gtk_combo_box_append_text(GTK_COMBO_BOX(*pline_style_menu),
line_style_names[i_line_style]);
gtk_widget_set_size_request (*pline_style_menu, 125, -1);
gtk_table_attach(GTK_TABLE(packing_table), *pline_style_menu, 1,2,
table_row,table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pline_style_menu);
table_row++;
/* do we want to fill in isocontour roi's */
label = gtk_label_new(_("Draw Isocontours/Freehands Filled:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pfill_roi_button = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(packing_table), *pfill_roi_button,
1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pfill_roi_button);
table_row++;
#endif
hseparator = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(packing_table), hseparator,
0, 3, table_row, table_row+1,
GTK_FILL, 0, X_PADDING, Y_PADDING);
table_row++;
gtk_widget_show(hseparator);
label = gtk_label_new(_("Canvas Layout:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
/* the radio buttons */
*playout_button1 = gtk_radio_button_new(NULL);
image = gtk_image_new_from_stock("amide_icon_layout_linear",GTK_ICON_SIZE_DIALOG);
gtk_button_set_image(GTK_BUTTON(*playout_button1), image);
gtk_table_attach(GTK_TABLE(packing_table), *playout_button1,
1,2, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*playout_button1), "layout", GINT_TO_POINTER(AMITK_LAYOUT_LINEAR));
gtk_widget_show(*playout_button1);
*playout_button2 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*playout_button2),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*playout_button1)));
image = gtk_image_new_from_stock("amide_icon_layout_orthogonal",GTK_ICON_SIZE_DIALOG);
gtk_button_set_image(GTK_BUTTON(*playout_button2), image);
gtk_table_attach(GTK_TABLE(packing_table), *playout_button2, 2,3, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*playout_button2), "layout", GINT_TO_POINTER(AMITK_LAYOUT_ORTHOGONAL));
gtk_widget_show(*playout_button2);
table_row++;
label = gtk_label_new(_("Multiple Canvases Layout:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
/* the radio buttons */
*ppanel_layout_button1 = gtk_radio_button_new(NULL);
image = gtk_image_new_from_stock("amide_icon_panels_mixed", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button1), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button1,
1,2, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button1), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_MIXED));
gtk_widget_show(*ppanel_layout_button1);
*ppanel_layout_button2 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button2),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1)));
image = gtk_image_new_from_stock("amide_icon_panels_linear_x", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button2), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button2,
2,3, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button2), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_X));
gtk_widget_show(*ppanel_layout_button2);
*ppanel_layout_button3 = gtk_radio_button_new(NULL);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(*ppanel_layout_button3),
gtk_radio_button_get_group(GTK_RADIO_BUTTON(*ppanel_layout_button1)));
image = gtk_image_new_from_stock("amide_icon_panels_linear_y", GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_button_set_image(GTK_BUTTON(*ppanel_layout_button3), image);
gtk_table_attach(GTK_TABLE(packing_table), *ppanel_layout_button3,
3,4, table_row, table_row+1,
0, 0, X_PADDING, Y_PADDING);
g_object_set_data(G_OBJECT(*ppanel_layout_button3), "panel_layout", GINT_TO_POINTER(AMITK_PANEL_LAYOUT_LINEAR_Y));
gtk_widget_show(*ppanel_layout_button3);
table_row++;
/* do we want the size of the canvas to not resize */
label = gtk_label_new(_("Maintain view size constant:"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
*pmaintain_size_button = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(packing_table), *pmaintain_size_button,
1,2, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*pmaintain_size_button);
table_row++;
/* widgets to change the amount of empty space in the center of the target */
label = gtk_label_new(_("Target Empty Area (pixels)"));
gtk_table_attach(GTK_TABLE(packing_table), label,
0,1, table_row, table_row+1, 0, 0, X_PADDING, Y_PADDING);
gtk_widget_show(label);
adjustment = gtk_adjustment_new(AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA,
AMITK_PREFERENCES_MIN_TARGET_EMPTY_AREA,
AMITK_PREFERENCES_MAX_TARGET_EMPTY_AREA, 1.0, 1.0, 0.0);
*ptarget_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1.0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(*ptarget_size_spin),FALSE);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(*ptarget_size_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(*ptarget_size_spin), GTK_UPDATE_ALWAYS);
gtk_table_attach(GTK_TABLE(packing_table), *ptarget_size_spin, 1,2,
table_row, table_row+1, GTK_FILL, 0, X_PADDING, Y_PADDING);
gtk_widget_show(*ptarget_size_spin);
return;
}
GtkWidget *create_dialog1 (uint8_t prefilled)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *hbox2;
GtkWidget *labelmpeg;
GtkWidget *button_mpeg;
GtkWidget *hbox3;
GtkWidget *label_index;
GtkWidget *button_index;
GtkWidget *hbox1;
GtkWidget *table1;
GtkWidget *radiobutton_ac3;
GSList *radiobutton_ac3_group = NULL;
GtkWidget *radiobutton_mpeg;
GtkWidget *radiobutton1;
GtkWidget *button_scan;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), _("Mpeg Indexer"));
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, TRUE, TRUE, 0);
labelmpeg = gtk_label_new ("");
gtk_widget_show (labelmpeg);
gtk_box_pack_start (GTK_BOX (hbox2), labelmpeg, TRUE, FALSE, 0);
button_mpeg = gtk_button_new_with_mnemonic (_("Select Mpeg"));
gtk_widget_show (button_mpeg);
gtk_box_pack_start (GTK_BOX (hbox2), button_mpeg, FALSE, FALSE, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (vbox1), hbox3, TRUE, TRUE, 0);
label_index = gtk_label_new ("");
gtk_widget_show (label_index);
gtk_box_pack_start (GTK_BOX (hbox3), label_index, TRUE, FALSE, 0);
button_index = gtk_button_new_with_mnemonic (_("Select Index"));
gtk_widget_show (button_index);
gtk_box_pack_start (GTK_BOX (hbox3), button_index, FALSE, FALSE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (hbox1), table1, TRUE, TRUE, 0);
radiobutton_ac3 = gtk_radio_button_new_with_mnemonic (NULL, _("AC3 audio"));
gtk_widget_show (radiobutton_ac3);
gtk_table_attach (GTK_TABLE (table1), radiobutton_ac3, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_ac3), radiobutton_ac3_group);
radiobutton_ac3_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_ac3));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton_ac3), TRUE);
radiobutton_mpeg = gtk_radio_button_new_with_mnemonic (NULL, _("Mpeg audio"));
gtk_widget_show (radiobutton_mpeg);
gtk_table_attach (GTK_TABLE (table1), radiobutton_mpeg, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_mpeg), radiobutton_ac3_group);
radiobutton_ac3_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_mpeg));
/*------------------*/
menuBuild(table1,NULL);
//--------------------------------------------------
/*---------------*/
radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, _("LPCM"));
gtk_widget_show (radiobutton1);
gtk_table_attach (GTK_TABLE (table1), radiobutton1, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton1), radiobutton_ac3_group);
radiobutton_ac3_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1));
button_scan = gtk_button_new_with_mnemonic (_("Scan file for audio stream"));
gtk_widget_show (button_scan);
gtk_box_pack_start (GTK_BOX (vbox1), button_scan, FALSE, FALSE, 0);
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, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (dialog1, labelmpeg, "labelmpeg");
GLADE_HOOKUP_OBJECT (dialog1, button_mpeg, "button_mpeg");
GLADE_HOOKUP_OBJECT (dialog1, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT (dialog1, label_index, "label_index");
GLADE_HOOKUP_OBJECT (dialog1, button_index, "button_index");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
GLADE_HOOKUP_OBJECT (dialog1, radiobutton_ac3, "radiobutton_ac3");
GLADE_HOOKUP_OBJECT (dialog1, optionmenuL, "optionmenuL");
// GLADE_HOOKUP_OBJECT (dialog1, menu3, "menu3");
GLADE_HOOKUP_OBJECT (dialog1, radiobutton_mpeg, "radiobutton_mpeg");
GLADE_HOOKUP_OBJECT (dialog1, optionmenuM, "optionmenuM");
// GLADE_HOOKUP_OBJECT (dialog1, menu1, "menu1");
GLADE_HOOKUP_OBJECT (dialog1, optionmenuA, "optionmenuA");
// GLADE_HOOKUP_OBJECT (dialog1, menu2, "menu2");
GLADE_HOOKUP_OBJECT (dialog1, radiobutton1, "radiobutton1");
GLADE_HOOKUP_OBJECT (dialog1, button_scan, "button_scan");
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;
}