void
eel_gtk_message_dialog_set_details_label (GtkMessageDialog *dialog,
const gchar *details_text)
{
GtkWidget *content_area, *expander, *label;
content_area = gtk_message_dialog_get_message_area (dialog);
expander = gtk_expander_new_with_mnemonic (_("Show more _details"));
gtk_expander_set_spacing (GTK_EXPANDER (expander), 6);
label = gtk_label_new (details_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_container_add (GTK_CONTAINER (expander), label);
gtk_box_pack_start (GTK_BOX (content_area), expander, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_widget_show (expander);
}
static void
gimp_file_dialog_add_proc_selection (GimpFileDialog *dialog,
Gimp *gimp,
GSList *file_procs,
const gchar *automatic,
const gchar *automatic_help_id)
{
GtkWidget *scrolled_window;
dialog->proc_expander = gtk_expander_new_with_mnemonic (NULL);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog),
dialog->proc_expander);
gtk_widget_show (dialog->proc_expander);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (dialog->proc_expander), scrolled_window);
gtk_widget_show (scrolled_window);
gtk_widget_set_size_request (scrolled_window, -1, 200);
dialog->proc_view = gimp_file_proc_view_new (gimp, file_procs, automatic,
automatic_help_id);
gtk_container_add (GTK_CONTAINER (scrolled_window), dialog->proc_view);
gtk_widget_show (dialog->proc_view);
g_signal_connect (dialog->proc_view, "changed",
G_CALLBACK (gimp_file_dialog_proc_changed),
dialog);
gimp_file_proc_view_set_proc (GIMP_FILE_PROC_VIEW (dialog->proc_view), NULL);
}
GtkWidget *simulate_window_create ()
{
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *sep;
GtkWidget *expander;
GtkWidget *file_chooser;
GtkWidget *hbox, *entry_run, *label;
vbox = gtk_vbox_new (FALSE, 0);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
led1 = gtk_matrix_led_new (16, 16, 0);
gtk_box_pack_start (GTK_BOX (hbox), led1, TRUE, TRUE, 5);
led2 = gtk_matrix_led_new (16, 16, 1);
gtk_box_pack_start (GTK_BOX (hbox), led2, TRUE, TRUE, 5);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, TRUE, TRUE, 5);
expander = gtk_expander_new_with_mnemonic ("(_Display)显示点阵数据");
GtkWidget *tree = create_list ();
gtk_container_add (GTK_CONTAINER (expander), tree);
gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 5);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
label = gtk_label_new ("数据文件:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 5);
file_chooser = gtk_file_chooser_button_new ("选择点阵数据文件",
GTK_FILE_CHOOSER_ACTION_OPEN);
g_signal_connect (G_OBJECT (file_chooser), "file-set",
G_CALLBACK (load_file), NULL);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_chooser), "./");
gtk_box_pack_start (GTK_BOX (hbox), file_chooser, FALSE, TRUE, 5);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 5);
button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (matrix_play), file_chooser);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5);
button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PAUSE);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (matrix_pause), file_chooser);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5);
button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_STOP);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (matrix_stop), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 5);
return vbox;
}
int main (int argc,
char *argv[])
{
GtkWidget *window, *expander, *label;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Expander");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_size_request (window, 200, 100);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
expander = gtk_expander_new_with_mnemonic ("Click _Me For More!");
label = gtk_label_new ("Hide me or show me,\nthat is your choice.");
gtk_container_add (GTK_CONTAINER (expander), label);
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
gtk_container_add (GTK_CONTAINER (window), expander);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
bool wxCollapsiblePane::Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& val,
const wxString& name)
{
if (gtk_check_version(2,4,0))
return wxGenericCollapsiblePane::Create(parent, id, label,
pos, size, style, val, name);
m_needParent = true;
m_acceptsFocus = true;
m_bIgnoreNextChange = false;
if ( !PreCreation( parent, pos, size ) ||
!wxControl::CreateBase(parent, id, pos, size, style, val, name) )
{
wxFAIL_MSG( wxT("wxCollapsiblePane creation failed") );
return false;
}
m_widget =
gtk_expander_new_with_mnemonic(wxGTK_CONV(GTKConvertMnemonics(label)));
// see the gtk_collapsiblepane_expanded_callback comments to understand why
// we connect to the "notify::expanded" signal instead of the more common
// "activate" one
g_signal_connect(m_widget, "notify::expanded",
G_CALLBACK(gtk_collapsiblepane_expanded_callback), this);
// before creating m_pPane, we need to makesure our own insert callback
// will be used
m_insertCallback = gtk_collapsiblepane_insert_callback;
// this the real "pane"
m_pPane = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize,
wxTAB_TRAVERSAL|wxNO_BORDER);
gtk_widget_show( GTK_WIDGET(m_widget) );
m_parent->DoAddChild( this );
PostCreation(size);
// remember the size of this control when it's collapsed
m_szCollapsed = GetBestSize();
return true;
}
bool wxCollapsiblePane::Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& val,
const wxString& name)
{
m_bIgnoreNextChange = false;
if ( !PreCreation( parent, pos, size ) ||
!wxControl::CreateBase(parent, id, pos, size, style, val, name) )
{
wxFAIL_MSG( wxT("wxCollapsiblePane creation failed") );
return false;
}
m_widget =
gtk_expander_new_with_mnemonic(wxGTK_CONV(GTKConvertMnemonics(label)));
g_object_ref(m_widget);
g_signal_connect_after(m_widget, "notify::expanded",
G_CALLBACK(gtk_collapsiblepane_expanded_callback), this);
// this the real "pane"
m_pPane = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize,
wxTAB_TRAVERSAL|wxNO_BORDER, wxT("wxCollapsiblePanePane") );
gtk_widget_show(m_widget);
m_parent->DoAddChild( this );
PostCreation(size);
// remember the size of this control when it's collapsed
GtkRequisition req;
req.width = 2;
req.height = 2;
(* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(m_widget) )->size_request )
(m_widget, &req );
m_szCollapsed = wxSize( req.width, req.height );
g_signal_connect (m_pPane->m_widget, "map_event",
G_CALLBACK (gtk_collpane_map_unmap_callback), this);
g_signal_connect (m_pPane->m_widget, "unmap_event",
G_CALLBACK (gtk_collpane_map_unmap_callback), this);
return true;
}
static gboolean sslcertwindow_ask_expired_cert(SSLCertificate *cert)
{
gchar *buf, *sig_status;
AlertValue val;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *cert_widget;
gchar *invalid_str = sslcertwindow_get_invalid_str(cert);
const gchar *title;
vbox = gtk_vbox_new(FALSE, 5);
buf = g_strdup_printf(_("Certificate for %s is expired.\n%sDo you want to continue?"), cert->host, invalid_str);
g_free(invalid_str);
label = gtk_label_new(buf);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
g_free(buf);
sig_status = ssl_certificate_check_signer(cert->x509_cert, cert->status);
if (sig_status==NULL)
sig_status = g_strdup(_("Correct"));
buf = g_strdup_printf(_("Signature status: %s"), sig_status);
label = gtk_label_new(buf);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
g_free(buf);
g_free(sig_status);
button = gtk_expander_new_with_mnemonic(_("_View certificate"));
gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
cert_widget = cert_presenter(cert);
gtk_container_add(GTK_CONTAINER(button), cert_widget);
if (!ssl_certificate_check_subject_cn(cert))
title = _("SSL certificate is invalid and expired");
else
title = _("SSL certificate is expired");
val = alertpanel_full(title, NULL,
_("_Cancel connection"), _("_Accept"), NULL,
FALSE, vbox, ALERT_QUESTION, G_ALERTDEFAULT);
return (val == G_ALERTALTERNATE);
}
bool wxCollapsiblePane::Create(wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& val,
const wxString& name)
{
m_bIgnoreNextChange = false;
if ( !PreCreation( parent, pos, size ) ||
!wxControl::CreateBase(parent, id, pos, size, style, val, name) )
{
wxFAIL_MSG( wxT("wxCollapsiblePane creation failed") );
return false;
}
m_widget =
gtk_expander_new_with_mnemonic(wxGTK_CONV(GTKConvertMnemonics(label)));
g_object_ref(m_widget);
// see the gtk_collapsiblepane_expanded_callback comments to understand why
// we connect to the "notify::expanded" signal instead of the more common
// "activate" one
g_signal_connect(m_widget, "notify::expanded",
G_CALLBACK(gtk_collapsiblepane_expanded_callback), this);
// this the real "pane"
m_pPane = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize,
wxTAB_TRAVERSAL|wxNO_BORDER, wxS("wxCollapsiblePanePane"));
gtk_widget_show(m_widget);
m_parent->DoAddChild( this );
PostCreation(size);
// we should blend into our parent background
const wxColour bg = parent->GetBackgroundColour();
SetBackgroundColour(bg);
m_pPane->SetBackgroundColour(bg);
// remember the size of this control when it's collapsed
m_szCollapsed = GetBestSize();
return true;
}
int main(int argc, char *argv[])
{
GtkWidget *window,*expander,*label;
gtk_init(&argc,&argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"DEmo");
gtk_container_set_border_width(GTK_CONTAINER(window),10);
gtk_widget_set_size_request(window,200,100);
expander = gtk_expander_new_with_mnemonic("click here");
label = gtk_label_new("Sudip is a gtk Developer.");
gtk_container_add(GTK_CONTAINER(expander),label);
gtk_expander_set_expanded(GTK_EXPANDER(expander),FALSE);
gtk_container_add(GTK_CONTAINER(window),expander);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
GtkWidget *
color_profile_dialog_new (ColorProfileDialogType dialog_type,
GimpImage *image,
GimpContext *context,
GtkWidget *parent,
GimpProgress *progress)
{
ProfileDialog *dialog;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *expander;
GtkWidget *label;
GimpColorProfile *src_profile;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
dialog = g_slice_new0 (ProfileDialog);
dialog->dialog_type = dialog_type;
dialog->image = image;
dialog->progress = progress;
dialog->config = image->gimp->config->color_management;
if (saved_intent == -1)
{
dialog->intent = GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC;
dialog->bpc = TRUE;
}
else
{
dialog->intent = saved_intent;
dialog->bpc = saved_bpc;
}
switch (dialog_type)
{
const Babl *format;
case COLOR_PROFILE_DIALOG_ASSIGN_PROFILE:
dialog->dialog =
gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context,
_("Assign ICC Color Profile"),
"gimp-image-color-profile-assign",
NULL,
_("Assign a color profile to the image"),
parent,
gimp_standard_help_func,
GIMP_HELP_IMAGE_COLOR_PROFILE_ASSIGN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("_Assign"), GTK_RESPONSE_OK,
NULL);
dialog->builtin_profile =
gimp_image_get_builtin_color_profile (dialog->image);
break;
case COLOR_PROFILE_DIALOG_CONVERT_TO_PROFILE:
dialog->dialog =
gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context,
_("Convert to ICC Color Profile"),
"gimp-image-color-profile-convert",
NULL,
_("Convert the image to a color profile"),
parent,
gimp_standard_help_func,
GIMP_HELP_IMAGE_COLOR_PROFILE_CONVERT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_CONVERT, GTK_RESPONSE_OK,
NULL);
dialog->builtin_profile =
gimp_image_get_builtin_color_profile (dialog->image);
break;
case COLOR_PROFILE_DIALOG_CONVERT_TO_RGB:
dialog->dialog =
gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context,
_("RGB Conversion"),
"gimp-image-convert-rgb",
GIMP_STOCK_CONVERT_RGB,
_("Convert Image to RGB"),
parent,
gimp_standard_help_func,
GIMP_HELP_IMAGE_CONVERT_RGB,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_CONVERT, GTK_RESPONSE_OK,
NULL);
format = gimp_babl_format (GIMP_RGB,
gimp_image_get_precision (dialog->image),
TRUE);
dialog->builtin_profile = gimp_babl_format_get_color_profile (format);
break;
case COLOR_PROFILE_DIALOG_CONVERT_TO_GRAY:
dialog->dialog =
gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context,
_("Grayscale Conversion"),
"gimp-image-convert-gray",
GIMP_STOCK_CONVERT_GRAYSCALE,
_("Convert Image to Grayscale"),
parent,
gimp_standard_help_func,
GIMP_HELP_IMAGE_CONVERT_GRAYSCALE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_CONVERT, GTK_RESPONSE_OK,
NULL);
format = gimp_babl_format (GIMP_GRAY,
gimp_image_get_precision (dialog->image),
TRUE);
dialog->builtin_profile = gimp_babl_format_get_color_profile (format);
break;
}
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), FALSE);
g_object_weak_ref (G_OBJECT (dialog->dialog),
(GWeakNotify) color_profile_dialog_free, dialog);
g_signal_connect (dialog->dialog, "response",
G_CALLBACK (color_profile_dialog_response),
dialog);
dialog->main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (dialog->main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))),
dialog->main_vbox, TRUE, TRUE, 0);
gtk_widget_show (dialog->main_vbox);
frame = gimp_frame_new (_("Current Color Profile"));
gtk_box_pack_start (GTK_BOX (dialog->main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
src_profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (image));
label = gimp_color_profile_label_new (src_profile);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_widget_show (label);
frame = gimp_frame_new (dialog_type == COLOR_PROFILE_DIALOG_ASSIGN_PROFILE ?
_("Assign") : _("Convert to"));
gtk_box_pack_start (GTK_BOX (dialog->main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
dialog->combo = color_profile_combo_box_new (dialog);
gtk_box_pack_start (GTK_BOX (vbox), dialog->combo, FALSE, FALSE, 0);
gtk_widget_show (dialog->combo);
expander = gtk_expander_new_with_mnemonic (_("Profile _details"));
gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
gtk_widget_show (expander);
dialog->dest_view = gimp_color_profile_view_new ();
gtk_container_add (GTK_CONTAINER (expander), dialog->dest_view);
gtk_widget_show (dialog->dest_view);
g_signal_connect (dialog->combo, "changed",
G_CALLBACK (color_profile_dest_changed),
dialog);
color_profile_dest_changed (dialog->combo, dialog);
if (dialog_type == COLOR_PROFILE_DIALOG_CONVERT_TO_PROFILE)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *combo;
GtkWidget *toggle;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (dialog->main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("_Rendering Intent:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gimp_enum_combo_box_new (GIMP_TYPE_COLOR_RENDERING_INTENT);
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
gtk_widget_show (combo);
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
dialog->intent,
G_CALLBACK (gimp_int_combo_box_get_active),
&dialog->intent);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
toggle =
gtk_check_button_new_with_mnemonic (_("_Black Point Compensation"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dialog->bpc);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&dialog->bpc);
}
return dialog->dialog;
}
static GtkWidget *create_field_selection_box(struct field_views *fields_vws, GtkWidget *window)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *label;
GtkWidget *scrolled_window;
GtkWidget *combobox_field;
GtkWidget *combobox_comp;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeModel *child_model;
gulong changed_handler_id;
GList *list;
GtkWidget *expander;
GtkWidget *hbox_1, *vbox_1, *Frame_1;
GtkWidget *label_1;
GtkWidget *scrolled_window_1;
GtkWidget *hbox_11;
GtkTreeSelection *selection_1;
GtkTreeModel *model_1;
GtkTreeModel *child_model_1;
gulong changed_handler_id_1;
GList *list_1;
GtkCellRenderer *column;
char *c_label;
c_label = (char *)calloc(KCHARA_C, sizeof(char));
vbox = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* Delete data bottun */
button = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(remove_field_to_use), fields_vws);
/* Close window bottun */
button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(cb_close_window), window);
/* ラベル */
label = gtk_label_new("");
gtk_box_pack_end(GTK_BOX(hbox), label, TRUE, TRUE, 0);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(scrolled_window, 400, 300);
gtk_container_add(GTK_CONTAINER(scrolled_window), fields_vws->used_tree_view);
gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
/*
* selectionにchangedシグナルハンドラを登録する。
* 後で同じchild_modelを使用しているselectionのchangedシグナルをブロック出来るように
* child_modelにselectionのリストを、selectionにシグナルハンドラIDを登録する。
* changedハンドラ内で使用するlabelも同様に登録しておく。
*/
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(fields_vws->used_tree_view));
changed_handler_id = g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(sum_selected_rows), NULL);
g_object_set_data(G_OBJECT(selection), "changed_handler_id", GUINT_TO_POINTER(changed_handler_id));
g_object_set_data(G_OBJECT(selection), "label", label);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(fields_vws->used_tree_view));
child_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
list = g_object_get_data(G_OBJECT(child_model), "selection_list");
list = g_list_append(list, selection);
g_object_set_data(G_OBJECT(child_model), "selection_list", list);
get_label_MHD_control_head(c_label);
expander = gtk_expander_new_with_mnemonic("Field to add");
vbox_1 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
Frame_1 = gtk_frame_new("");
gtk_frame_set_shadow_type(GTK_FRAME(Frame_1), GTK_SHADOW_IN);
scrolled_window_1 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window_1),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
// gtk_widget_set_size_request(scrolled_window_1, 400, 300);
gtk_container_add(GTK_CONTAINER(scrolled_window_1), fields_vws->unused_field_tree_view);
gtk_box_pack_start(GTK_BOX(vbox_1), scrolled_window_1, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(Frame_1), vbox_1);
/* Add data bottun */
hbox_1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
button = gtk_button_new_from_stock(GTK_STOCK_ADD);
gtk_box_pack_start(GTK_BOX(hbox_1), button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(add_field_to_use), fields_vws);
label_1 = gtk_label_new("");
gtk_box_pack_end(GTK_BOX(hbox_1), label_1, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox_1), gtk_label_new(" "), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_1), Frame_1, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(expander), hbox_1);
gtk_box_pack_start(GTK_BOX(vbox), expander, TRUE, TRUE, 0);
selection_1 = gtk_tree_view_get_selection(GTK_TREE_VIEW(fields_vws->unused_field_tree_view));
changed_handler_id_1 = g_signal_connect(G_OBJECT(selection_1), "changed",
G_CALLBACK(sum_selected_rows), NULL);
g_object_set_data(G_OBJECT(selection_1), "changed_handler_id", GUINT_TO_POINTER(changed_handler_id_1));
g_object_set_data(G_OBJECT(selection_1), "label", label_1);
model_1 = gtk_tree_view_get_model(GTK_TREE_VIEW(fields_vws->unused_field_tree_view));
child_model_1 = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model_1));
list_1 = g_object_get_data(G_OBJECT(child_model_1), "selection_list");
list_1 = g_list_append(list_1, selection_1);
g_object_set_data(G_OBJECT(child_model_1), "selection_list", list_1);
hbox_11 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
combobox_field = gtk_combo_box_new_with_model(model);
g_signal_connect(G_OBJECT(combobox_field), "changed",
G_CALLBACK(format_entry_text_callback), fields_vws->used_tree_view);
column = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_field), column, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_field), column,
"text", COLUMN_FIELD_NAME, NULL);
gtk_box_pack_start(GTK_BOX(hbox_11), combobox_field, FALSE, FALSE, 0);
combobox_comp = gtk_combo_box_new();
g_signal_connect(G_OBJECT(combobox_comp), "changed",
G_CALLBACK(format_entry_text_callback), fields_vws->used_tree_view);
column = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_comp), column, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_comp), column,
"text", COLUMN_FIELD_NAME, NULL);
gtk_box_pack_start(GTK_BOX(hbox_11), combobox_comp, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox_11, FALSE, FALSE, 0);
return vbox;
}
GtkWidget *gui_build_dialog_gtk_table(GSList * list, gint cols, gboolean use_progress)
{
GSList *listtmp = list;
GtkWidget *adv_vbox = NULL;
GtkWidget *adv_expander = NULL;
gint ielements = g_slist_position(list, g_slist_last(list));
gint rows = ((ielements + 1) / cols) + use_progress;
GtkWidget *tab = gtk_table_new(rows, cols, FALSE);
gint actC = 0, actR = 0;
GtkWidget *to_grab_focus = NULL;
gboolean need_advanced = FALSE;
gtk_container_set_border_width(GTK_CONTAINER(tab), 15);
/* remember to free adv_expander */
adv_vbox = gtk_vbox_new(FALSE, 5);
while (listtmp)
{
GGaduKeyValue *kv = (GGaduKeyValue *) listtmp->data;
GtkWidget *entry = NULL;
gboolean need_label = TRUE;
gboolean is_advanced = FALSE;
switch (kv->type)
{
case VAR_STR:
entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(entry), g_strdup(kv->value));
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
break;
case VAR_INT:
{
entry = gtk_spin_button_new_with_range(0, 999999999, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry), (gint) kv->value);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
}
break;
case VAR_INT_WITH_NEGATIVE:
{
entry = gtk_spin_button_new_with_range(-999999999, 999999999, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(entry), (gint) kv->value);
gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
}
break;
case VAR_BOOL:
need_label = FALSE;
entry = gtk_check_button_new_with_mnemonic(kv->description);
if (kv->value)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(entry), TRUE);
break;
case VAR_FILE_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_button_new_from_stock("gtk-open");
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect_swapped(button_entry, "clicked", G_CALLBACK(gui_dialog_show_filename), txt_entry);
}
break;
case VAR_FONT_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_button_new_from_stock("gtk-select-font");
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect_swapped(button_entry, "clicked", G_CALLBACK(gui_dialog_show_fontchooser), txt_entry);
}
break;
case VAR_COLOUR_CHOOSER:
{
GtkWidget *txt_entry = NULL;
GtkWidget *button_entry = NULL;
GdkColor color;
entry = gtk_hbox_new(FALSE, 2);
txt_entry = gtk_entry_new();
if (kv->value)
gtk_entry_set_text(GTK_ENTRY(txt_entry), g_strdup(kv->value));
gdk_color_parse(gtk_entry_get_text(GTK_ENTRY(txt_entry)), &color);
g_object_set_data(G_OBJECT(txt_entry), "kv", kv);
g_object_set_data(G_OBJECT(entry), "txt_entry", txt_entry);
button_entry = gtk_color_button_new_with_color(&color);
gtk_box_pack_start_defaults(GTK_BOX(entry), txt_entry);
gtk_box_pack_start_defaults(GTK_BOX(entry), button_entry);
g_signal_connect(G_OBJECT(button_entry), "color-set", G_CALLBACK(gui_dialog_show_colorchooser), txt_entry);
}
break;
case VAR_IMG:
need_label = FALSE;
entry = gtk_image_new_from_file(kv->value);
gtk_table_set_homogeneous(GTK_TABLE(tab), FALSE);
break;
case VAR_LIST:
{
GSList *selected = g_slist_nth((GSList *) kv->value, 0);
GSList *restlist = g_slist_nth((GSList *) kv->value, 1);
gint selected_index = 0;
gint i = -1;
entry = gtk_combo_box_new_text();
g_object_set_data(G_OBJECT(entry), "options-list", restlist);
while (restlist)
{
i++;
if (!g_strcasecmp(selected->data, restlist->data))
{
selected_index = i;
print_debug("############# %d %s", selected_index, selected->data);
}
gtk_combo_box_append_text(GTK_COMBO_BOX(entry), g_strdup(restlist->data));
restlist = restlist->next;
}
gtk_combo_box_set_active(GTK_COMBO_BOX(entry), selected_index);
}
break;
default:
break;
}
if ((kv->flag & VAR_FLAG_SENSITIVE) != 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(entry), TRUE);
gtk_editable_set_editable(GTK_EDITABLE(entry), TRUE);
}
if ((kv->flag & VAR_FLAG_INSENSITIVE) != 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(entry), FALSE);
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
}
if ((kv->flag & VAR_FLAG_PASSWORD) != 0)
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
if ((kv->flag & VAR_FLAG_FOCUS) != 0)
to_grab_focus = entry;
kv->user_data = (gpointer) entry;
if ((kv->flag & VAR_FLAG_ADVANCED) != 0)
{
GtkWidget *hbox = gtk_hbox_new(FALSE, 5);
GtkWidget *align;
GtkWidget *label;
need_advanced = TRUE;
is_advanced = TRUE;
gtk_box_pack_end_defaults(GTK_BOX(hbox), entry);
if (need_label)
{
align = gtk_alignment_new(0, 0.5, 0, 0);
label = gtk_label_new_with_mnemonic(kv->description);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_box_pack_end_defaults(GTK_BOX(hbox), align);
}
gtk_box_pack_start_defaults(GTK_BOX(adv_vbox), hbox);
}
if (need_label && !is_advanced)
{
GtkWidget *align = gtk_alignment_new(0, 0.5, 0, 0);
GtkWidget *label = gtk_label_new_with_mnemonic(kv->description);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_table_attach_defaults(GTK_TABLE(tab), align, 0, 1, actR, actR + 1);
if (entry)
gtk_table_attach_defaults(GTK_TABLE(tab), entry, 1, 2, actR, actR + 1);
}
else if (!is_advanced)
{
gtk_table_attach(GTK_TABLE(tab), entry, actC, actC + 2, actR, actR + 1, GTK_FILL, GTK_SHRINK, 0, 0);
}
if (!is_advanced)
{
if ((actC + 1) < cols)
actC++;
else
{
actC = 0;
actR++;
}
}
listtmp = listtmp->next;
}
if (need_advanced)
{
adv_expander = gtk_expander_new_with_mnemonic(_("_More options"));
gtk_container_add(GTK_CONTAINER(adv_expander), adv_vbox);
gtk_table_attach_defaults(GTK_TABLE(tab), adv_expander, 0, rows, actR, actR + 1);
}
else
{
gtk_widget_destroy(adv_vbox);
}
/* progress stuff */
if (use_progress)
{
GtkWidget *progress = gtk_progress_bar_new();
gtk_table_attach_defaults(GTK_TABLE(tab), progress, 0, rows, actR, actR + 1);
}
if (to_grab_focus)
gtk_widget_grab_focus(GTK_WIDGET(to_grab_focus));
return tab;
}
int main (int argc, char *argv[])
{
/* GUI widgets */
GtkWidget *window;
GtkWidget *align;
GtkWidget *expander;
GtkWidget *label;
GtkWidget *radio1, *radio2;
GtkWidget *check;
GtkWidget *button;
GtkWidget *entry;
GtkTooltips *tooltip;
/* Packing boxes */
GtkWidget *vbMain; /* main vertical box */
GtkWidget *hbox1, *vbox1, *vbox2; /* username/password */
GtkWidget *hbox2, *vbox3, *hbMac; /* login options */
GtkWidget *hbox3; /* cancel/login buttons */
GtkWidget *hbox9; /* show pwd & gtl */
/* Initialize multihreading and gtk functions */
g_thread_init (NULL);
gdk_threads_init ();
gdk_threads_enter ();
gtk_init (&argc, &argv);
/* Create main window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window), "Glawn");
gtk_window_set_resizable (GTK_WINDOW(window), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
g_signal_connect (window, "destroy", G_CALLBACK(quit_glawn), NULL);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file ("./icons/glawn-icon.png", NULL);
gtk_window_set_icon (GTK_WINDOW(window), pixbuf);
/* Create pack boxes */
vbMain= gtk_vbox_new (FALSE, 3);
vbox1 = gtk_vbox_new (FALSE, 0);
vbox2 = gtk_vbox_new (FALSE, 3);
vbox3 = gtk_vbox_new (FALSE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
hbox2 = gtk_hbox_new (FALSE, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
hbMac = gtk_hbox_new (FALSE, 0);
hbox9 = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbMain);
/* Username entry label */
label = gtk_label_new ("GT Account : ");
gtk_misc_set_alignment ((GtkMisc *)label, 0, 0);
gtk_box_pack_start (GTK_BOX(vbox1), label, TRUE, FALSE, 0);
/* Password entry label */
label = gtk_label_new ("Password : "******"");
gtk_box_pack_start (GTK_BOX(vbox1),label,FALSE, FALSE, 2);
/* Username entry field */
data.nameEntry = entry = gtk_entry_new_with_max_length (50);
gtk_entry_set_width_chars (GTK_ENTRY(entry), 25);
g_signal_connect (entry, "activate", G_CALLBACK(login), NULL);
gtk_box_pack_start (GTK_BOX(vbox2), entry, FALSE, FALSE, 0);
/* Password entry field */
data.pwdEntry = entry = gtk_entry_new_with_max_length(50);
gtk_entry_set_visibility (GTK_ENTRY(entry), FALSE);
g_signal_connect (entry, "activate", G_CALLBACK(login), NULL);
gtk_box_pack_start (GTK_BOX(vbox2), entry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX(vbMain), hbox1, FALSE, FALSE, 0);
/* Show password checkbox */
data.pwdCBox = check = gtk_check_button_new_with_mnemonic ("_Show password");
g_signal_connect (check, "toggled", G_CALLBACK(show_pass), GTK_ENTRY(entry));
gtk_box_pack_start (GTK_BOX(hbox9), check, FALSE, FALSE, 0);
/* Location checkbox */
data.locCBox = check = gtk_check_button_new_with_mnemonic ("_GTL");
tooltip = gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltip, check, "Enable Georgia Tech-Lorraine support", NULL);
gtk_box_pack_start (GTK_BOX(hbox9), check, FALSE, FALSE, 9);
gtk_box_pack_start (GTK_BOX(vbox2), hbox9, FALSE, FALSE, 0);
/* Options expander */
expander = gtk_expander_new_with_mnemonic ("_Options");
gtk_box_pack_start (GTK_BOX(vbMain), expander, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER(expander), hbox2);
/* Left indent alignment for expander */
align = gtk_alignment_new (0, 0, 1 , 1);
gtk_widget_set_size_request (align, 17, 0);
gtk_box_pack_start (GTK_BOX(hbox2), align, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox2), vbox3, FALSE, FALSE, 0);
/* ISS checkbox */
data.issCBox = check = gtk_check_button_new_with_mnemonic
("_Enable Inbound Service Security");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check), TRUE);
gtk_box_pack_start (GTK_BOX(vbox3), check, FALSE, FALSE, 0);
tooltip = gtk_tooltips_new ();
gtk_tooltips_set_tip (tooltip, check, "When turned on,"
" devices outside of the LAWN network are blocked from "
"connecting to services running on your device.", NULL);
/* Login this device radio */
data.radio_this = radio1 = gtk_radio_button_new_with_mnemonic_from_widget
(NULL, "Lo_gin this device");
g_signal_connect (radio1, "toggled", G_CALLBACK(mac_switch), (gpointer) FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radio1), TRUE);
gtk_box_pack_start (GTK_BOX(vbox3), radio1, FALSE, FALSE, 0);
/* Login other device radio */
data.radio_other = radio2 = gtk_radio_button_new_with_mnemonic_from_widget
(GTK_RADIO_BUTTON(radio1), "Login a _different device");
g_signal_connect (radio2, "toggled", G_CALLBACK(mac_switch), (gpointer) TRUE);
gtk_box_pack_start (GTK_BOX(vbox3), radio2, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltip, radio2, "You can authenticate other"
" devices currently on LAWN. The login will last as long as the"
" device maintains a valid DHCP lease. You accept responsibility"
" for all usage associated with this device.", NULL);
/* MAC address label and entry */
label = gtk_label_new (" MAC Address : "); // more elegance
data.macEntry = entry = gtk_entry_new_with_max_length (12);
gtk_entry_set_width_chars (GTK_ENTRY(entry), 18);
gtk_widget_set_sensitive (entry, FALSE);
gtk_box_pack_start (GTK_BOX(hbMac), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbMac), entry, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(vbox3), hbMac, FALSE, FALSE, 0);
/* Login button */
data.login = button = gtk_button_new_with_mnemonic (" _Login ");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK(login), NULL);
gtk_box_pack_end (GTK_BOX(hbox3), button, FALSE, FALSE, 5);
/* Logout button */
data.logout = button = gtk_button_new_with_mnemonic ("Logou_t");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK(logout), NULL);
gtk_box_pack_end (GTK_BOX(hbox3), button, FALSE, FALSE, 0);
/* Spinner */
data.spinner = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX(hbox3), data.spinner, FALSE, FALSE, 2);
/* Statusbar */
data.status = label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX(hbox3), label, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX(vbMain), hbox3, FALSE, FALSE, 0);
/* Display window */
gtk_widget_show_all (window);
/* Ascii art */
g_printf ("\n===========================\n"
" Welcome to Glawn!\n"
"===========================\n\n");
/*Load_settings */
init_mutex();
load_settings();
update_gui (LOAD_INI_START);
// send curl request for status
update_gui (CHECK_STAT_START);
g_thread_create((GThreadFunc)check_status, NULL, FALSE, NULL);
g_timeout_add_seconds_full(G_PRIORITY_LOW, 1, init_check_status, NULL, NULL);
/* Start main loop */
gtk_main ();
gdk_threads_leave ();
return 0;
}
GtkWidget *
create_dialog (void)
{
GtkWidget *dlg;
GtkWidget *hbox, *vbox, *hbox2, *bbox;
GtkWidget *image;
GtkWidget *text;
GtkWidget *main_widget = NULL;
GtkWidget *topb = NULL;
/* create dialog window */
dlg = gtk_dialog_new ();
if (options.data.splash)
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
else
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_window_set_title (GTK_WINDOW (dlg), options.data.dialog_title);
gtk_widget_set_name (dlg, "yad-dialog-window");
#ifndef G_OS_WIN32
if (options.parent)
{
gdk_window_set_transient_for (gtk_widget_get_window (dlg),
gdk_x11_window_foreign_new_for_display (gdk_display_get_default (),
options.parent));
}
#endif
if (options.data.no_escape)
g_signal_connect (G_OBJECT (dlg), "close", G_CALLBACK (ignore_close_cb) , NULL);
/* get buttons container */
bbox = gtk_dialog_get_action_area (GTK_DIALOG (dlg));
/* set window icon */
if (options.data.window_icon)
{
if (g_file_test (options.data.window_icon, G_FILE_TEST_EXISTS))
gtk_window_set_icon_from_file (GTK_WINDOW (dlg), options.data.window_icon, NULL);
else
gtk_window_set_icon_name (GTK_WINDOW (dlg), options.data.window_icon);
}
/* set window borders */
if (options.data.borders == -1)
options.data.borders = (gint) gtk_container_get_border_width (GTK_CONTAINER (dlg));
gtk_container_set_border_width (GTK_CONTAINER (dlg), (guint) options.data.borders);
/* set window size and position */
if (!options.data.geometry && !options.data.maximized && !options.data.fullscreen)
{
gtk_window_set_default_size (GTK_WINDOW (dlg), options.data.width, options.data.height);
if (options.data.center)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER);
else if (options.data.mouse)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
}
/* set window behavior */
if (options.data.sticky)
gtk_window_stick (GTK_WINDOW (dlg));
gtk_window_set_keep_above (GTK_WINDOW (dlg), options.data.ontop);
gtk_window_set_decorated (GTK_WINDOW (dlg), !options.data.undecorated);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
gtk_window_set_skip_pager_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
/* create timeout indicator widget */
if (options.data.timeout)
{
if (G_LIKELY (options.data.to_indicator) && g_ascii_strcasecmp (options.data.to_indicator, "none"))
{
topb = gtk_progress_bar_new ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (topb), 1.0);
gtk_widget_set_name (topb, "yad-timeout-indicator");
}
}
/* add top label widgets */
#if !GTK_CHECK_VERSION(3,0,0)
hbox = hbox2 = gtk_hbox_new (FALSE, 0);
#else
hbox = hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), hbox, TRUE, TRUE, 5);
#if !GTK_CHECK_VERSION(3,0,0)
vbox = gtk_vbox_new (FALSE, 0);
#else
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#endif
/* add timeout indicator */
if (topb)
{
if (g_ascii_strcasecmp (options.data.to_indicator, "top") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT);
#endif
gtk_box_pack_start (GTK_BOX (vbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "bottom") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT);
#endif
gtk_box_pack_end (GTK_BOX (vbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "left") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP);
#endif
gtk_box_pack_start (GTK_BOX (hbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "right") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP);
#endif
gtk_box_pack_end (GTK_BOX (hbox), topb, FALSE, FALSE, 2);
}
if (settings.show_remain)
{
gchar *lbl = g_strdup_printf (_("%d sec"), options.data.timeout);
#if GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (topb), TRUE);
#endif
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (topb), lbl);
g_free (lbl);
}
}
/* must be after indicator! */
gtk_box_pack_end (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
if (options.data.image_on_top)
{
#if !GTK_CHECK_VERSION(3,0,0)
hbox2 = gtk_hbox_new (FALSE, 0);
#else
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0);
}
if (options.data.dialog_image)
{
GdkPixbuf *pb = NULL;
pb = get_pixbuf (options.data.dialog_image, YAD_BIG_ICON);
image = gtk_image_new_from_pixbuf (pb);
if (pb)
g_object_unref (pb);
gtk_widget_set_name (image, "yad-dialog-image");
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), image, FALSE, FALSE, 2);
}
if (options.data.dialog_text)
{
/* for dnd's tooltip we don't need text label */
if (options.mode != YAD_MODE_DND || !options.dnd_data.tooltip)
{
gchar *buf = g_strcompress (options.data.dialog_text);
text = gtk_label_new (NULL);
if (!options.data.no_markup)
gtk_label_set_markup (GTK_LABEL (text), buf);
else
gtk_label_set_text (GTK_LABEL (text), buf);
g_free (buf);
gtk_widget_set_name (text, "yad-dialog-label");
gtk_label_set_line_wrap (GTK_LABEL (text), TRUE);
gtk_label_set_selectable (GTK_LABEL (text), options.data.selectable_labels);
gtk_label_set_justify (GTK_LABEL (text), options.data.text_align);
switch (options.data.text_align)
{
case GTK_JUSTIFY_LEFT:
case GTK_JUSTIFY_FILL:
gtk_misc_set_alignment (GTK_MISC (text), 0.0, 0.5);
break;
case GTK_JUSTIFY_CENTER:
gtk_misc_set_alignment (GTK_MISC (text), 0.5, 0.5);
break;
case GTK_JUSTIFY_RIGHT:
gtk_misc_set_alignment (GTK_MISC (text), 1.0, 0.5);
break;
}
if (options.data.image_on_top)
gtk_box_pack_start (GTK_BOX (hbox2), text, TRUE, TRUE, 2);
else
gtk_box_pack_start (GTK_BOX (vbox), text, FALSE, FALSE, 2);
#if !GTK_CHECK_VERSION(3,0,0)
if (!options.data.fixed)
g_signal_connect (G_OBJECT (text), "size-allocate", G_CALLBACK (text_size_allocate_cb), NULL);
#endif
}
}
/* add main widget */
switch (options.mode)
{
case YAD_MODE_CALENDAR:
main_widget = calendar_create_widget (dlg);
break;
case YAD_MODE_COLOR:
main_widget = color_create_widget (dlg);
break;
case YAD_MODE_DND:
dnd_init (dlg);
break;
case YAD_MODE_ENTRY:
main_widget = entry_create_widget (dlg);
break;
case YAD_MODE_FILE:
main_widget = file_create_widget (dlg);
break;
case YAD_MODE_FONT:
main_widget = font_create_widget (dlg);
break;
case YAD_MODE_FORM:
main_widget = form_create_widget (dlg);
break;
#ifdef HAVE_HTML
case YAD_MODE_HTML:
main_widget = html_create_widget (dlg);
break;
#endif
case YAD_MODE_ICONS:
main_widget = icons_create_widget (dlg);
break;
case YAD_MODE_LIST:
main_widget = list_create_widget (dlg);
break;
case YAD_MODE_MULTI_PROGRESS:
main_widget = multi_progress_create_widget (dlg);
break;
case YAD_MODE_NOTEBOOK:
main_widget = notebook_create_widget (dlg);
break;
case YAD_MODE_PANED:
main_widget = paned_create_widget (dlg);
break;
case YAD_MODE_PROGRESS:
main_widget = progress_create_widget (dlg);
break;
case YAD_MODE_SCALE:
main_widget = scale_create_widget (dlg);
break;
case YAD_MODE_TEXTINFO:
main_widget = text_create_widget (dlg);
break;
default:
;
}
if (main_widget)
{
if (options.data.expander)
{
GtkWidget *exp;
exp = gtk_expander_new_with_mnemonic (options.data.expander);
gtk_expander_set_expanded (GTK_EXPANDER (exp), FALSE);
gtk_container_add (GTK_CONTAINER (exp), main_widget);
gtk_box_pack_start (GTK_BOX (vbox), exp, TRUE, TRUE, 2);
}
else
gtk_box_pack_start (GTK_BOX (vbox), main_widget, TRUE, TRUE, 2);
}
/* add buttons */
if (!options.data.no_buttons)
{
if (options.data.buttons)
{
GSList *tmp = options.data.buttons;
do
{
GtkWidget *btn;
YadButton *b = (YadButton *) tmp->data;
btn = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (btn), get_label (b->name, 2));
gtk_button_set_alignment (GTK_BUTTON (btn), 0.5, 0.5);
g_object_set_data (G_OBJECT (btn), "resp", GINT_TO_POINTER (b->response));
g_signal_connect (G_OBJECT (btn), "clicked", G_CALLBACK (btn_cb), b->cmd);
gtk_box_pack_start (GTK_BOX (bbox), btn, FALSE, FALSE, 0);
tmp = tmp->next;
}
while (tmp != NULL);
}
else
{
if (options.mode == YAD_MODE_PROGRESS || options.mode == YAD_MODE_MULTI_PROGRESS)
gtk_dialog_add_buttons (GTK_DIALOG (dlg), GTK_STOCK_CLOSE, YAD_RESPONSE_OK, NULL);
else
{
if (gtk_alternative_dialog_button_order (NULL))
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
GTK_STOCK_OK, YAD_RESPONSE_OK, GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, NULL);
else
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, GTK_STOCK_OK, YAD_RESPONSE_OK, NULL);
}
gtk_dialog_set_default_response (GTK_DIALOG (dlg), YAD_RESPONSE_OK);
}
gtk_button_box_set_layout (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dlg))),
options.data.buttons_layout);
}
/* show widgets */
gtk_widget_show_all (gtk_dialog_get_content_area (GTK_DIALOG (dlg)));
if (options.data.no_buttons)
gtk_widget_hide (bbox);
/* parse geometry, if given. must be after showing widget */
if (options.data.geometry && !options.data.maximized && !options.data.fullscreen)
{
gtk_widget_realize (dlg);
gtk_window_parse_geometry (GTK_WINDOW (dlg), options.data.geometry);
}
gtk_widget_show (dlg);
/* set maximized or fixed size after showing widget */
if (options.data.maximized)
gtk_window_maximize (GTK_WINDOW (dlg));
else if (options.data.fullscreen)
gtk_window_fullscreen (GTK_WINDOW (dlg));
else
{
gtk_window_set_resizable (GTK_WINDOW (dlg), !options.data.fixed);
if (options.data.fixed)
gtk_widget_set_size_request (dlg, options.data.width, options.data.height);
}
/* set timeout */
if (options.data.timeout)
{
g_timeout_add_seconds (options.data.timeout, timeout_cb, dlg);
g_timeout_add_seconds (1, timeout_indicator_cb, topb);
}
#ifndef G_OS_WIN32
/* print xid */
if (options.print_xid)
{
fprintf (stderr, "0x%lX", GDK_WINDOW_XID (gtk_widget_get_window (dlg)));
fflush (stderr);
}
#endif
return dlg;
}
Widget BolfView(){
GtkTooltips *Tooltips;
Tooltips=gtk_tooltips_new();
Widget Window, InputText, SearchButton, SelectType, Table, SelectText, Slider, News;
Widget NijiaM, KamerM, HipHop, AfricaM;
Widget MusicLabel, GameLabel, FunLabel, MovieLabel, SportLabel;
GtkWidget *pageLayoutExpander, *scrolledWindow;
pageLayoutExpander = gtk_expander_new_with_mnemonic("Page");
MusicLabel= gtk_label_new("Music");
GameLabel= gtk_label_new("Games");
FunLabel= gtk_label_new("Funny");
MovieLabel= gtk_label_new("Movies");
SportLabel= gtk_label_new("Sports");
// Warning = gtk_label_new("Click On Me \n If You wanna Quit \n Or Cancel if you dont");
//declaring the url entry;
UrlText=gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(UrlText),TRUE);
gtk_widget_set_size_request(UrlText,600,25);
gtk_entry_set_text (GTK_ENTRY(UrlText),"http://DONOT WRITE HERE!!!!!!");
gtk_tooltips_set_tip(Tooltips,UrlText,"This is to displace th current URL",NULL);
//declaring the search text
InputText=gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(InputText),TRUE);
gtk_widget_set_size_request(InputText,20,40);
gtk_tooltips_set_tip(Tooltips,InputText,"Enter Your Search Here!!!!",NULL);
/* create Webview */
web[count] = webkit_web_view_new();
//declaring the search button;
SearchButton=gtk_button_new();
SearchButton=ImageButton("pictures/search.jpeg");
gtk_widget_set_size_request(SearchButton,130,80);
gtk_tooltips_set_tip(Tooltips,SearchButton,"Search Button",NULL);
g_signal_connect(SearchButton, "clicked", G_CALLBACK(InputConnect), InputText);
//creating a slider
Slider=MyEvent("pictures/ani1.gif");
//gtk_widget_set_size_request(Slider,1000,3000);
gtk_tooltips_set_tip(Tooltips,Slider,"News",NULL);
g_signal_connect_swapped(Slider, "button_press_event", G_CALLBACK(Newso),NULL);
//creating news
News=MyEvent("pictures/ani2.gif");
//gtk_widget_set_size_request(News,400,150);
gtk_tooltips_set_tip(Tooltips,News,"News",NULL);
g_signal_connect_swapped(News, "button_press_event", G_CALLBACK(Newso),NULL);
//Music
NijiaM=MyEvent("pictures/concour.jpeg");
gtk_widget_set_size_request(NijiaM,175,80);
gtk_tooltips_set_tip(Tooltips,NijiaM,"Nijia Music",NULL);
g_signal_connect_swapped(NijiaM, "button_press_event", G_CALLBACK(NijiaMusic),NULL);
HipHop=MyEvent("pictures/hiphop.jpeg");
gtk_widget_set_size_request(HipHop,175,80);
gtk_tooltips_set_tip(Tooltips,HipHop,"Hip, HOp, R&B",NULL);
g_signal_connect_swapped(HipHop, "button_press_event", G_CALLBACK(HipHopMusic),NULL);
KamerM=MyEvent("pictures/camerhits.jpeg");
gtk_widget_set_size_request(KamerM,175,80);
gtk_tooltips_set_tip(Tooltips,KamerM,"Kamer Hits",NULL);
g_signal_connect_swapped(KamerM, "button_press_event", G_CALLBACK(KamerHits),NULL);
AfricaM=MyEvent("pictures/cam.jpeg");
gtk_widget_set_size_request(AfricaM,175,80);
gtk_tooltips_set_tip(Tooltips,AfricaM,"Africa Music",NULL);
g_signal_connect_swapped(AfricaM,"button_press_event",G_CALLBACK(AfricaMusic),NULL);
//Movies
Widget Nolly, Holly,Bolly, Horos;
Nolly=MyEvent("pictures/nollywood.jpeg");
gtk_widget_set_size_request(Nolly,175,80);
gtk_tooltips_set_tip(Tooltips,Nolly,"NollyWood(Nigeria Film Industry)",NULL);
g_signal_connect_swapped(Nolly, "button_press_event", G_CALLBACK(Nollywood),NULL);
Holly=MyEvent("pictures/hollywood.jpeg");
gtk_widget_set_size_request(Holly,175,80);
gtk_tooltips_set_tip(Tooltips,Holly,"Hollywood(America Film Industry)",NULL);
g_signal_connect_swapped(Holly, "button_press_event", G_CALLBACK(Hollywood),NULL);
Bolly=MyEvent("pictures/bollywood.jpeg");
gtk_widget_set_size_request(Bolly,175,80);
gtk_tooltips_set_tip(Tooltips,Bolly,"Bollywood(The Indians)",NULL);
g_signal_connect_swapped(Bolly, "button_press_event", G_CALLBACK(Bollywood),NULL);
Horos=MyEvent("pictures/horos.jpeg");
gtk_widget_set_size_request(Horos,175,80);
gtk_tooltips_set_tip(Tooltips,Horos,"Horos Movies",NULL);
g_signal_connect_swapped(Horos,"button_press_event",G_CALLBACK(Horosmov),NULL);
//funny movies
Widget African,American,Europe,Kids;
African=MyEvent("pictures/basket.jpeg");
gtk_widget_set_size_request(African,175,80);
gtk_tooltips_set_tip(Tooltips,African,"Africa Fun",NULL);
g_signal_connect_swapped(African, "button_press_event", G_CALLBACK(AfricaFun),NULL);
American=MyEvent("pictures/amerifun.jpeg");
gtk_widget_set_size_request(American,175,80);
gtk_tooltips_set_tip(Tooltips,American,"American Fun",NULL);
g_signal_connect_swapped(American, "button_press_event", G_CALLBACK(AmericaFun),NULL);
Europe=MyEvent("pictures/africanfunny.jpeg");
gtk_widget_set_size_request(Europe,175,80);
gtk_tooltips_set_tip(Tooltips,Europe,"General Fun",NULL);
g_signal_connect_swapped(Europe, "button_press_event", G_CALLBACK(NijiaBoys),NULL);
Kids=MyEvent("pictures/kids.jpeg");
gtk_widget_set_size_request(Kids,175,80);
gtk_tooltips_set_tip(Tooltips,Kids,"Kid Movies And Funs",NULL);
g_signal_connect_swapped(Kids,"button_press_event",G_CALLBACK(KidsMovies),NULL);
//Games
Widget Race,War,HerosGame,KidGame;
Race=MyEvent("pictures/race.jpeg");
gtk_widget_set_size_request(Race,175,80);
gtk_tooltips_set_tip(Tooltips,Race,"Racee Games",NULL);
g_signal_connect_swapped(Race, "button_press_event", G_CALLBACK(RaceGame),NULL);
War=MyEvent("pictures/war.jpeg");
gtk_widget_set_size_request(War,175,80);
gtk_tooltips_set_tip(Tooltips,War,"War Games",NULL);
g_signal_connect_swapped(War, "button_press_event", G_CALLBACK(WarGame),NULL);
HerosGame=MyEvent("pictures/horos2.jpeg");
gtk_widget_set_size_request(HerosGame,175,80);
gtk_tooltips_set_tip(Tooltips,HerosGame,"Horo Games",NULL);
g_signal_connect_swapped(HerosGame, "button_press_event", G_CALLBACK(HeroGame),NULL);
KidGame=MyEvent("pictures/kidgame.jpeg");
gtk_widget_set_size_request(KidGame,175,80);
gtk_tooltips_set_tip(Tooltips,KidGame,"Games For Children",NULL);
g_signal_connect_swapped(KidGame,"button_press_event",G_CALLBACK(KidGames),NULL);
//sports
Widget Foot,Basket,Resl,Others;
Foot=MyEvent("pictures/fifa.png");
gtk_widget_set_size_request(Foot,175,80);
gtk_tooltips_set_tip(Tooltips,Foot,"Football",NULL);
g_signal_connect(Foot, "button_press_event", G_CALLBACK(Football),UrlText);
Basket=MyEvent("pictures/basketball.jpeg");
gtk_widget_set_size_request(Basket,175,80);
gtk_tooltips_set_tip(Tooltips,Basket,"Basketball",NULL);
g_signal_connect(Basket, "button_press_event", G_CALLBACK(Basketball),UrlText);
Resl=MyEvent("pictures/resling.jpeg");
gtk_widget_set_size_request(Resl,175,80);
gtk_tooltips_set_tip(Tooltips,Resl,"Resling",NULL);
g_signal_connect(Resl, "button_press_event", G_CALLBACK(Resling),UrlText);
Others=MyEvent("pictures/games.jpeg");
gtk_widget_set_size_request(Others,175,80);
gtk_tooltips_set_tip(Tooltips,Others,"Rugby,Handball, MotoGP, Athletic and Other sports",NULL);
g_signal_connect(Others,"button_press_event",G_CALLBACK(OtherSports),UrlText);
//define the select type of entertianment;
SelectType=gtk_combo_new();
gtk_entry_set_text(GTK_ENTRY((GTK_COMBO(SelectType))-> entry),"Mp3 Music");
GList *list=NULL;
list=g_list_append(list," Music Vidios");
list=g_list_append(list,"Movies");
list=g_list_append(list,"Games");
list=g_list_append(list,"Funny Vidio");
list=g_list_append(list,"News");
gtk_combo_set_popdown_strings(GTK_COMBO(SelectType),list);
gtk_combo_set_case_sensitive(GTK_COMBO(SelectType),FALSE);
//gtk_widget_set_size_request(SelectType,100,300);
//getting the text from the combo
SelectText=gtk_label_new(gtk_entry_get_text(GTK_ENTRY((GTK_COMBO(SelectType))->entry)));
Widget back_button,forward_button,home_button,Iback,Iforward,Ihome;
Iback=gtk_image_new_from_stock(GTK_STOCK_GO_BACK,1);
Iforward=gtk_image_new_from_stock(GTK_STOCK_GO_FORWARD,1);
Ihome=gtk_image_new_from_stock(GTK_STOCK_HOME,1);
back_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(back_button),Iback);
gtk_widget_set_size_request(back_button,40,40);
gtk_tooltips_set_tip(Tooltips,back_button,"go back",NULL);
forward_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(forward_button),Iforward);
gtk_widget_set_size_request(forward_button,40,40);
gtk_tooltips_set_tip(Tooltips,forward_button,"go forward",NULL);
home_button=gtk_button_new();
gtk_container_add(GTK_CONTAINER(home_button),Ihome);
gtk_tooltips_set_tip(Tooltips,home_button,"Home",NULL);
//create a table and insert struffs.
Table=gtk_table_new(50,50,FALSE);
gtk_table_attach_defaults(GTK_TABLE(Table),UrlText,10,40,0,1);
gtk_table_attach(GTK_TABLE(Table),back_button,8,10,0,1,1,1,0,0);
gtk_table_attach(GTK_TABLE(Table),forward_button,40,42,0,1,1,1,0,0);
gtk_table_attach_defaults(GTK_TABLE(Table),home_button,46,48,0,1);
gtk_table_attach(GTK_TABLE(Table), Slider,12,25,12,14, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), News,30,35,12,14, 1, 1, 0, 0 );
//input search
gtk_table_attach_defaults(GTK_TABLE(Table),InputText,15,30,15,18);
gtk_table_attach_defaults(GTK_TABLE(Table),SelectType,30,32,15,18);
gtk_table_attach(GTK_TABLE(Table),SearchButton,32,36,15,17, 1, 1, 0, 0 );
//Labels
gtk_table_attach(GTK_TABLE(Table), MusicLabel,8,14,17,18, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), MovieLabel,16,22,17,18, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), FunLabel,24,30,17,18, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), GameLabel,32,38,17,18, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), SportLabel,40,46,17,18, 1, 1, 0, 0 );
//Music Search
gtk_table_attach(GTK_TABLE(Table), AfricaM,8,14,18,25, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), NijiaM,8,14,26,30, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), KamerM,8,14,31,35, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), HipHop,8,14,36,40, 1, 1, 0, 0 );
//movies Search
gtk_table_attach(GTK_TABLE(Table), Nolly,16,22,18,25, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), Holly,16,22,26,30, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), Bolly,16,22,31,35, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), Horos,16,22,36,40, 1, 1, 0, 0 );
//Funny Vidios
gtk_table_attach(GTK_TABLE(Table), African,24,30,18,25, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), American,24,30,26,30, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), Europe,24,30,31,35, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), Kids,24,30,36,40, 1, 1, 0, 0 );
//Game Search
gtk_table_attach(GTK_TABLE(Table), Race,32,38,18,25, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), War,32,38,26,30, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), HerosGame,32,38,31,35, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), KidGame,32,38,36,40, 1, 1, 0, 0 );
//Sports
gtk_table_attach(GTK_TABLE(Table), Foot,40,46,18,25, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), Basket,40,46,26,30, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), Resl,40,46,31,35, 1, 1, 0, 0 );
gtk_table_attach(GTK_TABLE(Table), Others,40,46,36,40, 1, 1, 0, 0 );
scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(scrolledWindow), web[count]);
gtk_widget_show_all(scrolledWindow);
gtk_container_add( GTK_CONTAINER(pageLayoutExpander), scrolledWindow);
gtk_table_attach_defaults(GTK_TABLE(Table), pageLayoutExpander,0,50,11,50);
g_signal_connect_swapped(WEBKIT_WEB_VIEW(web[count]),"load-finished",G_CALLBACK(viewSearchedPage),pageLayoutExpander);
g_signal_connect(InputText, "activate", G_CALLBACK(activate), web[count]);
g_signal_connect(WEBKIT_WEB_VIEW(web[count]),"load-progress-changed",G_CALLBACK(progress),UrlText);
g_signal_connect(WEBKIT_WEB_VIEW(web[count]),"load-finished",G_CALLBACK(finished),UrlText);
g_signal_connect_swapped(G_OBJECT(Window), "destroy",G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(back_button, "clicked", G_CALLBACK(back), web[count]);
g_signal_connect(forward_button, "clicked", G_CALLBACK(forward), web[count]);
g_signal_connect(home_button, "clicked", G_CALLBACK(Home), web[count]);
g_signal_connect(NijiaM, "button_press_event", G_CALLBACK(NijiaM), web[count]);
return Table;
}
static void gtk_assert_dialog_init(GtkAssertDialog* dlg)
{
GtkWidget *continuebtn;
{
GtkWidget *vbox, *hbox, *image;
/* start the main vbox */
gtk_widget_push_composite_child ();
vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER(vbox), 8);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))), vbox, true, true, 5);
/* add the icon+message hbox */
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* icon */
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX(hbox), image, FALSE, FALSE, 12);
{
GtkWidget *vbox2, *info;
/* message */
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
info = gtk_label_new ("An assertion failed!");
gtk_box_pack_start (GTK_BOX(vbox2), info, TRUE, TRUE, 8);
/* assert message */
dlg->message = gtk_label_new (NULL);
gtk_label_set_selectable (GTK_LABEL (dlg->message), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (dlg->message), TRUE);
gtk_label_set_justify (GTK_LABEL (dlg->message), GTK_JUSTIFY_LEFT);
gtk_widget_set_size_request (GTK_WIDGET(dlg->message), 450, -1);
gtk_box_pack_end (GTK_BOX(vbox2), GTK_WIDGET(dlg->message), TRUE, TRUE, 8);
}
/* add the expander */
dlg->expander = gtk_expander_new_with_mnemonic ("Back_trace:");
gtk_box_pack_start (GTK_BOX(vbox), dlg->expander, TRUE, TRUE, 0);
g_signal_connect (GTK_EXPANDER(dlg->expander), "activate",
G_CALLBACK(gtk_assert_dialog_expander_callback), dlg);
}
{
GtkWidget *hbox, *vbox, *button, *sw;
/* create expander's vbox */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (dlg->expander), vbox);
/* add a scrollable window under the expander */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX(vbox), sw, TRUE, TRUE, 8);
/* add the treeview to the scrollable window */
dlg->treeview = gtk_assert_dialog_create_backtrace_list_model ();
gtk_widget_set_size_request (GTK_WIDGET(dlg->treeview), -1, 180);
gtk_container_add (GTK_CONTAINER (sw), dlg->treeview);
/* create button's hbox */
hbox = gtk_hbutton_box_new ();
gtk_box_pack_end (GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
/* add the buttons */
button = gtk_assert_dialog_add_button_to (GTK_BOX(hbox), "Save to _file",
GTK_STOCK_SAVE);
g_signal_connect (button, "clicked",
G_CALLBACK(gtk_assert_dialog_save_backtrace_callback), dlg);
button = gtk_assert_dialog_add_button_to (GTK_BOX(hbox), "Copy to clip_board",
GTK_STOCK_COPY);
g_signal_connect (button, "clicked", G_CALLBACK(gtk_assert_dialog_copy_callback), dlg);
}
/* add the checkbutton */
dlg->shownexttime = gtk_check_button_new_with_mnemonic("Show this _dialog the next time");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(dlg->shownexttime), TRUE);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dlg))), dlg->shownexttime, false, true, 8);
/* add the stop button */
gtk_assert_dialog_add_button (dlg, "_Stop", GTK_STOCK_QUIT, GTK_ASSERT_DIALOG_STOP);
/* add the continue button */
continuebtn = gtk_assert_dialog_add_button (dlg, "_Continue", GTK_STOCK_YES, GTK_ASSERT_DIALOG_CONTINUE);
gtk_dialog_set_default_response (GTK_DIALOG (dlg), GTK_ASSERT_DIALOG_CONTINUE);
g_signal_connect (continuebtn, "clicked", G_CALLBACK(gtk_assert_dialog_continue_callback), dlg);
/* complete creation */
dlg->callback = NULL;
dlg->userdata = NULL;
/* the resizable property of this window is modified by the expander:
when it's collapsed, the window must be non-resizable! */
gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE);
gtk_widget_pop_composite_child ();
gtk_widget_show_all (GTK_WIDGET(dlg));
}
GtkWidget*
_gtk_error_dialog_new (GtkWindow *parent,
GtkDialogFlags flags,
GList *row_output,
const char *primary_text,
const char *secondary_text,
...)
{
GtkWidget *dialog;
GtkWidget *label;
GtkWidget *image;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *text_view;
GtkWidget *scrolled = NULL;
GtkWidget *expander;
GtkWidget *content_area;
GtkWidget *action_area;
GtkTextBuffer *text_buf;
GtkTextIter iter;
GList *scan;
char *escaped_message, *markup_text;
va_list args;
gboolean view_output = (row_output != NULL);
dialog = gtk_dialog_new_with_buttons ("",
parent,
flags,
"gtk-ok", GTK_RESPONSE_OK,
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog));
/* Add label and image */
image = gtk_image_new_from_icon_name ("dialog-error", GTK_ICON_SIZE_DIALOG);
gtk_widget_set_halign (image, GTK_ALIGN_CENTER);
gtk_widget_set_valign (image, GTK_ALIGN_START);
label = gtk_label_new ("");
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.0);
escaped_message = g_markup_escape_text (primary_text, -1);
if (secondary_text != NULL) {
char *secondary_message;
char *escaped_secondary_message;
va_start (args, secondary_text);
secondary_message = g_strdup_vprintf (secondary_text, args);
va_end (args);
escaped_secondary_message = g_markup_escape_text (secondary_message, -1);
markup_text = g_strdup_printf ("<span weight=\"bold\" size=\"larger\">%s</span>\n\n%s",
escaped_message,
escaped_secondary_message);
g_free (escaped_secondary_message);
g_free (secondary_message);
}
else
markup_text = g_strdup (escaped_message);
gtk_label_set_markup (GTK_LABEL (label), markup_text);
g_free (markup_text);
g_free (escaped_message);
if (view_output) {
gtk_widget_set_size_request (dialog, 500, -1);
/* Expander */
expander = gtk_expander_new_with_mnemonic (_("Command _Line Output"));
gtk_expander_set_expanded (GTK_EXPANDER (expander), secondary_text == NULL);
/* Add text */
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_ETCHED_IN);
gtk_widget_set_size_request (scrolled, -1, 200);
text_buf = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (text_buf, "monospace",
"family", "monospace", NULL);
gtk_text_buffer_get_iter_at_offset (text_buf, &iter, 0);
for (scan = row_output; scan; scan = scan->next) {
char *line = scan->data;
char *utf8_line;
gsize bytes_written;
utf8_line = g_locale_to_utf8 (line, -1, NULL, &bytes_written, NULL);
gtk_text_buffer_insert_with_tags_by_name (text_buf,
&iter,
utf8_line,
bytes_written,
"monospace", NULL);
g_free (utf8_line);
gtk_text_buffer_insert (text_buf, &iter, "\n", 1);
}
text_view = gtk_text_view_new_with_buffer (text_buf);
g_object_unref (text_buf);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (text_view), FALSE);
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
if (view_output) {
gtk_container_add (GTK_CONTAINER (scrolled), text_view);
gtk_container_add (GTK_CONTAINER (expander), scrolled);
gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 0);
}
gtk_box_pack_start (GTK_BOX (content_area), vbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_set_spacing (GTK_BOX (content_area), 14); /* 14 + 2 * 5 = 24 */
gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
gtk_box_set_spacing (GTK_BOX (action_area), 6);
gtk_widget_show_all (vbox);
return dialog;
}
int main( int argc, char **argv ) {
gtk_init( &argc, &argv );
GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( window ), "Using Multiple Containers" );
gtk_container_set_border_width( GTK_CONTAINER( window ), 10 );
gtk_widget_set_size_request( window, 640, 480 );
GtkWidget *notebook = gtk_notebook_new();
GtkWidget *one = gtk_label_new( "One" );
GtkWidget *two = gtk_label_new( "Two" );
GtkWidget *three = gtk_label_new( "Three" );
GtkWidget *four = gtk_label_new( "Four" );
GtkWidget *tag1 = gtk_label_new( "This is page one" );
GtkWidget *tag2 = gtk_label_new( "This is page TWO" );
GtkWidget *tag3 = gtk_label_new( "This is page THree" );
GtkWidget *tag4 = gtk_label_new( "This is page FouR" );
GtkWidget *next = gtk_button_new_with_label( "Next" );
GtkWidget *prev = gtk_button_new_with_label( "Prev" );
GtkWidget *exit = gtk_button_new_with_label( "Exit" );
GtkWidget *vpane = gtk_vpaned_new();
GtkWidget *hbox = gtk_hbox_new( TRUE, 10 );
GtkWidget *nvbox1 = gtk_vbox_new( TRUE, 5 );
GtkWidget *nvbox2 = gtk_vbox_new( TRUE, 5 );
GtkWidget *nvbox3 = gtk_vbox_new( TRUE, 5 );
GtkWidget *nvbox4 = gtk_vbox_new( TRUE, 5 );
GtkWidget *expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" );
gtk_container_add( GTK_CONTAINER( expander ), next );
gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
gtk_box_pack_start( GTK_BOX( nvbox1 ), tag1, FALSE, FALSE, 5 );
gtk_box_pack_start( GTK_BOX( nvbox1 ), expander, FALSE, FALSE, 5 );
expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" );
gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE );
next = gtk_button_new_with_label( "Next" );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
gtk_container_add( GTK_CONTAINER( expander ), next );
gtk_box_pack_start( GTK_BOX( nvbox2 ), tag2, FALSE, FALSE, 5 );
gtk_box_pack_start( GTK_BOX( nvbox2 ), expander, FALSE, FALSE, 5 );
expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" );
gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE );
next = gtk_button_new_with_label( "Next" );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
gtk_container_add( GTK_CONTAINER( expander ), next );
gtk_box_pack_start( GTK_BOX( nvbox3 ), tag3, FALSE, FALSE, 5 );
gtk_box_pack_start( GTK_BOX( nvbox3 ), expander, FALSE, FALSE, 5 );
expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" );
gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE );
next = gtk_button_new_with_label( "Next" );
g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook );
gtk_container_add( GTK_CONTAINER( expander ), next );
gtk_box_pack_start( GTK_BOX( nvbox4 ), tag4, FALSE, FALSE, 5 );
gtk_box_pack_start( GTK_BOX( nvbox4 ), expander, FALSE, FALSE, 5 );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox1, one );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox2, two );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox3, three );
gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox4, four );
gtk_notebook_set_tab_pos( GTK_NOTEBOOK( notebook ), GTK_POS_TOP );
gtk_notebook_set_show_tabs( GTK_NOTEBOOK( notebook ), TRUE );
g_signal_connect( G_OBJECT( prev ), "clicked", G_CALLBACK( prev_pressed ), (gpointer) notebook );
g_signal_connect( G_OBJECT( exit ), "clicked", G_CALLBACK( exit_pressed ), NULL );
gtk_box_pack_end( GTK_BOX( hbox ), exit, TRUE, FALSE, 5 );
gtk_box_pack_end( GTK_BOX( hbox ), prev, TRUE, FALSE, 5 );
gtk_paned_pack1( GTK_PANED( vpane ), notebook, TRUE, FALSE );
gtk_paned_pack2( GTK_PANED( vpane ), hbox, TRUE, FALSE );
g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( destroy ), NULL );
gtk_container_add( GTK_CONTAINER( window ), vpane );
gtk_widget_show_all( window );
gtk_main();
return 0;
}
static void
netselect_dlg_show()
{
struct netselect_dlg * dlg;
GtkWidget * main_vbox, * scrolled,
* button_box, * manual_hbox,
* hbox, * vbox, * frame, * settings_vbox;
GtkTreeViewColumn * column;
gchar * text;
if(main_netselect_dlg) {
/* dialog is shown already */
gtk_window_present(GTK_WINDOW(dlg->dlg_w));
return;
}
dlg = main_netselect_dlg = g_new(struct netselect_dlg, 1);
dlg->detect_timeout_id = 0;
dlg->dlg_w = gtk_dialog_new_with_buttons(
_("Network detection and configuration"), gui_get_main_window(), 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_signal_connect(G_OBJECT(dlg->dlg_w), "response",
G_CALLBACK(dlg_response), (gpointer)dlg);
g_signal_connect(G_OBJECT(dlg->dlg_w), "delete-event", G_CALLBACK(gtk_true), NULL);
/* upper vertical box for list and port range controls
*/
main_vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg->dlg_w)->vbox), main_vbox, TRUE, TRUE, 0);
frame = gtk_frame_new(_("Detected networks"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
gtk_box_pack_start(GTK_BOX(main_vbox), frame, TRUE, TRUE, 0);
dlg->list = gtk_list_store_new(
NETLISTCOL_NUM,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN);
dlg->tree_w = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dlg->list));
g_signal_connect(G_OBJECT(dlg->tree_w), "row-activated",
G_CALLBACK(list_row_activated), (gpointer)dlg);
g_signal_connect(G_OBJECT(dlg->tree_w), "cursor-changed",
G_CALLBACK(list_cursor_changed), (gpointer)dlg);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_TYPE),
gtk_cell_renderer_text_new(), "text", NETLISTCOL_TYPE_STR, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(dlg->tree_w), 0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_PORT),
gtk_cell_renderer_text_new(), "text", NETLISTCOL_PORT_STR, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(dlg->tree_w), 1);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(dlg->tree_w), -1, prefs_description(PREFS_NET_USE_MULTICAST),
gtk_cell_renderer_text_new(), "text", NETLISTCOL_USE_MULTICAST_STR, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(scrolled, -1, LIST_MIN_HEIGHT);
gtk_scrolled_window_set_policy(
GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), dlg->tree_w);
gtk_container_add(GTK_CONTAINER(frame), scrolled);
/* Make hbox for lower control frames */
manual_hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(main_vbox), manual_hbox, FALSE, FALSE, 0);
/*
* "Automatic scan" frame
*/
frame = gtk_frame_new(_("Automatic scan"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
gtk_box_pack_start(GTK_BOX(manual_hbox), frame, TRUE, TRUE, 0);
/* vbox inside the frame */
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* progress bar
*/
dlg->detect_progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), dlg->detect_progress, FALSE, FALSE, 0);
/* the 'reset' and 'refresh' buttons
*/
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
button_box = gtk_hbutton_box_new();
gtk_box_pack_end(GTK_BOX(hbox), button_box, FALSE, FALSE, 0);
dlg->detect_btn = gtk_button_new_from_stock(GTK_STOCK_REFRESH);
g_signal_connect(G_OBJECT(dlg->detect_btn), "clicked",
G_CALLBACK(detect_button_clicked), (gpointer)dlg);
gtk_box_pack_start(GTK_BOX(button_box), dlg->detect_btn, FALSE, FALSE, 0);
dlg->detect_stop_btn = gtk_button_new_from_stock(GTK_STOCK_STOP);
g_signal_connect(G_OBJECT(dlg->detect_stop_btn), "clicked",
G_CALLBACK(detect_button_clicked), (gpointer)dlg);
gtk_box_pack_start(GTK_BOX(button_box), dlg->detect_stop_btn, FALSE, FALSE, 0);
/* settings vbox */
settings_vbox = gtk_vbox_new(FALSE, 4);
/* port range start spin
*/
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_begin_spin = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_spin_button_set_value(
GTK_SPIN_BUTTON(dlg->detect_begin_spin), DEFAULT_DETECT_RANGE_BEGIN);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_begin_spin, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(_("Scan UDP ports from")), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(dlg->detect_begin_spin), "value-changed",
G_CALLBACK(detect_range_spin_value_changed), (gpointer)dlg);
/* port range end spin
*/
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_end_spin = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_spin_button_set_value(
GTK_SPIN_BUTTON(dlg->detect_end_spin), DEFAULT_DETECT_RANGE_END);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_end_spin, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new(_("to (including)")), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(dlg->detect_end_spin), "value-changed",
G_CALLBACK(detect_range_spin_value_changed), (gpointer)dlg);
/* broadcast mask */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_broadcast_mask_w = gtk_entry_new();
gtk_entry_set_text(
GTK_ENTRY(dlg->detect_broadcast_mask_w),
text = util_inet_ntoa(prefs_int(PREFS_NET_BROADCAST_MASK)));
g_free(text);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_broadcast_mask_w, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_BROADCAST_MASK)), FALSE, FALSE, 0);
/* multicast mask */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(settings_vbox), hbox, FALSE, FALSE, 0);
dlg->detect_multicast_addr_w = gtk_entry_new();
gtk_entry_set_text(
GTK_ENTRY(dlg->detect_multicast_addr_w),
text = util_inet_ntoa(prefs_int(PREFS_NET_MULTICAST_ADDR)));
g_free(text);
gtk_box_pack_end(GTK_BOX(hbox), dlg->detect_multicast_addr_w, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_MULTICAST_ADDR)), FALSE, FALSE, 0);
/* pack settings vbox in to the window (through the expander widget) */
#if(HAVE_EXPANDER_WIDGET)
dlg->detect_expander_w = gtk_expander_new_with_mnemonic(_("Detection settings"));
gtk_container_add(GTK_CONTAINER(dlg->detect_expander_w), settings_vbox);
gtk_box_pack_start(GTK_BOX(vbox), dlg->detect_expander_w, FALSE, FALSE, 0);
#else
gtk_box_pack_start(GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), settings_vbox, FALSE, FALSE, 0);
#endif
/*
* Manual port/network entry frame
*/
frame = gtk_frame_new(_("Network settings"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
gtk_box_pack_start(GTK_BOX(manual_hbox), frame, TRUE, TRUE, 0);
/* vbox inside the frame */
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* use multicast toggle */
dlg->net_use_multicast_w = gtk_check_button_new_with_label(
prefs_description(PREFS_NET_USE_MULTICAST));
gtk_widget_set_sensitive(
dlg->net_use_multicast_w, prefs_int(PREFS_NET_TYPE)==NET_TYPE_VYPRESS);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(dlg->net_use_multicast_w),
prefs_int(PREFS_NET_TYPE)==NET_TYPE_VYPRESS
? prefs_bool(PREFS_NET_USE_MULTICAST): FALSE);
/* network type option */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
dlg->net_type_option = util_net_type_option(
(util_option_changed_cb)dlg_net_type_option_changed, (gpointer)dlg);
gtk_box_pack_end(GTK_BOX(hbox), dlg->net_type_option, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_TYPE)), FALSE, FALSE, 0);
gtk_option_menu_set_history(
GTK_OPTION_MENU(dlg->net_type_option), prefs_int(PREFS_NET_TYPE));
/* network port number */
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
dlg->net_port_spin = gtk_spin_button_new_with_range(1024, 65535, 1);
gtk_box_pack_end(GTK_BOX(hbox), dlg->net_port_spin, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox),
gtk_label_new(prefs_description(PREFS_NET_PORT)), FALSE, FALSE, 0);
gtk_spin_button_set_value(
GTK_SPIN_BUTTON(dlg->net_port_spin),
prefs_int(PREFS_NET_PORT));
/* append the multicast toggle */
gtk_box_pack_start(GTK_BOX(vbox), dlg->net_use_multicast_w, FALSE, FALSE, 0);
/* show dialog to the user */
dlg_search_mode(dlg, FALSE);
gtk_widget_show_all(dlg->dlg_w);
gtk_window_present(GTK_WINDOW(dlg->dlg_w));
}
static void
caja_file_conflict_dialog_init (CajaFileConflictDialog *fcd)
{
GtkWidget *hbox, *vbox, *vbox2;
GtkWidget *widget, *dialog_area;
CajaFileConflictDialogPrivate *details;
GtkDialog *dialog;
details = fcd->details = caja_file_conflict_dialog_get_instance_private (fcd);
dialog = GTK_DIALOG (fcd);
/* Setup the main hbox */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
dialog_area = gtk_dialog_get_content_area (dialog);
gtk_box_pack_start (GTK_BOX (dialog_area), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
/* Setup the dialog image */
widget = gtk_image_new_from_icon_name ("dialog-warning",
GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_START);
/* Setup the vbox containing the dialog body */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
/* Setup the vbox for the dialog labels */
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
details->titles_vbox = widget;
/* Setup the hboxes to pack file infos into */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_widget_set_halign (vbox2, GTK_ALIGN_START);
gtk_widget_set_valign (vbox2, GTK_ALIGN_START);
gtk_widget_set_margin_start (vbox2, 12);
gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
details->first_hbox = hbox;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
details->second_hbox = hbox;
/* Setup the expander for the rename action */
details->expander = gtk_expander_new_with_mnemonic (_("Select a new name for the _destination"));
gtk_box_pack_start (GTK_BOX (vbox2), details->expander, FALSE, FALSE, 0);
g_signal_connect (details->expander, "activate",
G_CALLBACK (expander_activated_cb), dialog);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_add (GTK_CONTAINER (details->expander), hbox);
widget = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 6);
details->entry = widget;
g_signal_connect (widget, "changed",
G_CALLBACK (entry_text_changed_cb), dialog);
widget = gtk_button_new_with_label (_("Reset"));
gtk_button_set_image (GTK_BUTTON (widget),
gtk_image_new_from_icon_name ("edit-undo",
GTK_ICON_SIZE_MENU));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6);
g_signal_connect (widget, "clicked",
G_CALLBACK (reset_button_clicked_cb), dialog);
gtk_widget_show_all (vbox2);
/* Setup the diff button for text files */
details->diff_button = gtk_button_new_with_label (_("Differences..."));
gtk_button_set_image (GTK_BUTTON (details->diff_button),
gtk_image_new_from_icon_name ("edit-find",
GTK_ICON_SIZE_MENU));
gtk_box_pack_start (GTK_BOX (vbox), details->diff_button, FALSE, FALSE, 6);
g_signal_connect (details->diff_button, "clicked",
G_CALLBACK (diff_button_clicked_cb), dialog);
gtk_widget_hide (details->diff_button);
/* Setup the checkbox to apply the action to all files */
widget = gtk_check_button_new_with_mnemonic (_("Apply this action to all files and folders"));
gtk_box_pack_start (GTK_BOX (vbox),
widget, FALSE, FALSE, 0);
details->checkbox = widget;
g_signal_connect (widget, "toggled",
G_CALLBACK (checkbox_toggled_cb), dialog);
/* Add buttons */
eel_dialog_add_button (dialog,
_("_Cancel"),
"process-stop",
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (dialog,
_("_Skip"),
CONFLICT_RESPONSE_SKIP);
details->rename_button =
gtk_dialog_add_button (dialog,
_("Re_name"),
CONFLICT_RESPONSE_RENAME);
gtk_widget_hide (details->rename_button);
details->replace_button =
gtk_dialog_add_button (dialog,
_("Replace"),
CONFLICT_RESPONSE_REPLACE);
gtk_widget_grab_focus (details->replace_button);
/* Setup HIG properties */
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (dialog)), 14);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_widget_show_all (dialog_area);
}
static GtkWidget *
create_options_widget (FormatHandler *handler)
{
GtkWidget *table = gtk_table_new (4, 2, FALSE), *label = NULL,
*csv_options = gtk_expander_new_with_mnemonic (
_("A_dvanced options for the CSV format")),
*vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
CsvPluginData *d = handler->data;
d->delimiter_entry = gtk_entry_new ();
d->newline_entry = gtk_entry_new ();
d->quote_entry = gtk_entry_new ();
d->header_check = gtk_check_button_new_with_mnemonic (
_("Prepend a _header"));
/* Advanced CSV options */
gtk_entry_set_text (GTK_ENTRY (d->delimiter_entry), ", ");
gtk_entry_set_text (GTK_ENTRY (d->quote_entry), "\"");
gtk_entry_set_text (GTK_ENTRY (d->newline_entry), "\\n");
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
label = gtk_label_new_with_mnemonic (_("_Value delimiter:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), d->delimiter_entry);
gtk_table_attach (
GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_table_attach (
GTK_TABLE (table), d->delimiter_entry, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label = gtk_label_new_with_mnemonic (_("_Record delimiter:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), d->newline_entry);
gtk_table_attach (
GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_table_attach (
GTK_TABLE (table), d->newline_entry, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label = gtk_label_new_with_mnemonic (_("_Encapsulate values with:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), d->quote_entry);
gtk_table_attach (
GTK_TABLE (table), label, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_table_attach (
GTK_TABLE (table), d->quote_entry, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), d->header_check, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
gtk_widget_show_all (vbox);
gtk_container_add (GTK_CONTAINER (csv_options), vbox);
return csv_options;
}
void xa_create_open_with_dialog(gchar *filename,gchar *filenames,int nr)
{
Open_with_data *data = NULL;
GtkWidget *dialog_vbox1,*vbox1,*hbox1,*mime_icon,*open_text,*scrolledwindow1,*apps_treeview,*dialog_action_area1,
*custom_command_expander,*hbox_expander,*browse,*cancelbutton1,*okbutton1;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
gchar *text = NULL;
gchar *title;
const gchar *icon_name = NULL;
const gchar* const *desktop_dirs;
gint x = 0;
data = g_new0(Open_with_data,1);
data->file_list = filenames;
data->dialog1 = gtk_dialog_new ();
if (nr == 1)
title = _("Open With");
else
title = _("Open the selected files with");
gtk_window_set_title (GTK_WINDOW (data->dialog1),title);
gtk_window_set_position (GTK_WINDOW (data->dialog1), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal (GTK_WINDOW (data->dialog1), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (data->dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_transient_for(GTK_WINDOW(data->dialog1),GTK_WINDOW(xa_main_window));
gtk_dialog_set_has_separator (GTK_DIALOG (data->dialog1),FALSE);
gtk_container_set_border_width (GTK_CONTAINER (data->dialog1),5);
gtk_widget_set_size_request(data->dialog1,380,380);
dialog_vbox1 = GTK_DIALOG (data->dialog1)->vbox;
vbox1 = gtk_vbox_new (FALSE, 5);
gtk_box_pack_start (GTK_BOX (dialog_vbox1),vbox1,TRUE,TRUE,0);
hbox1 = gtk_hbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (vbox1),hbox1,FALSE,FALSE,0);
if (nr == 1)
{
icon_name = xa_get_stock_mime_icon(filename);
pixbuf = gtk_icon_theme_load_icon(icon_theme,icon_name,40,0,NULL);
mime_icon = gtk_image_new_from_pixbuf(pixbuf);
if (pixbuf)
g_object_unref(pixbuf);
gtk_box_pack_start (GTK_BOX (hbox1),mime_icon,FALSE,TRUE,0);
gtk_misc_set_alignment (GTK_MISC (mime_icon),0,0);
open_text = gtk_label_new("");
gtk_box_pack_start (GTK_BOX (hbox1),open_text,FALSE,FALSE,10);
text = g_strdup_printf(_("Open <i>%s</i> with:"),filename);
gtk_label_set_use_markup (GTK_LABEL (open_text),TRUE);
gtk_label_set_markup (GTK_LABEL (open_text),text);
g_free(text);
}
scrolledwindow1 = gtk_scrolled_window_new (NULL,NULL);
gtk_box_pack_start (GTK_BOX (vbox1),scrolledwindow1,TRUE,TRUE,0);
g_object_set (G_OBJECT (scrolledwindow1),"hscrollbar-policy",GTK_POLICY_AUTOMATIC,"shadow-type",GTK_SHADOW_IN,"vscrollbar-policy",GTK_POLICY_AUTOMATIC,NULL);
data->apps_liststore = gtk_list_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING);
apps_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(data->apps_liststore));
gtk_container_add (GTK_CONTAINER (scrolledwindow1),apps_treeview);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(apps_treeview),FALSE);
GtkTreeSelection *sel = gtk_tree_view_get_selection( GTK_TREE_VIEW (apps_treeview));
g_signal_connect ((gpointer) sel,"changed",G_CALLBACK (xa_open_with_dialog_selection_changed),data);
/* First column: icon + text */
column = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column,renderer, FALSE);
gtk_tree_view_column_set_attributes(column,renderer,"pixbuf",0,NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start(column,renderer, TRUE);
gtk_tree_view_column_set_attributes( column,renderer,"text",1,NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(data->apps_liststore),1,GTK_SORT_ASCENDING);
gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
/* Hidden column with the application executable name */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_visible(column,FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (apps_treeview), column);
custom_command_expander = gtk_expander_new_with_mnemonic(_("Use a custom command:"));
gtk_box_pack_start (GTK_BOX (vbox1),custom_command_expander,FALSE,FALSE,0);
hbox_expander = gtk_hbox_new(FALSE,5);
data->custom_command_entry = gtk_entry_new();
g_signal_connect (G_OBJECT (data->custom_command_entry),"activate",G_CALLBACK (xa_open_with_dialog_custom_entry_activated),data);
browse = gtk_button_new_with_label(_("Browse"));
g_signal_connect (G_OBJECT (browse),"clicked",G_CALLBACK (xa_open_with_dialog_browse_custom_command),data);
gtk_box_pack_start (GTK_BOX (hbox_expander),data->custom_command_entry,TRUE,TRUE,0);
gtk_box_pack_start (GTK_BOX (hbox_expander),browse,FALSE,TRUE,0);
gtk_container_add(GTK_CONTAINER(custom_command_expander),hbox_expander);
dialog_action_area1 = GTK_DIALOG (data->dialog1)->action_area;
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 (data->dialog1),cancelbutton1,GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
g_signal_connect_swapped (G_OBJECT (cancelbutton1),"clicked",G_CALLBACK (gtk_widget_destroy),G_OBJECT(data->dialog1));
okbutton1 = gtk_button_new_from_stock ("gtk-open");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (data->dialog1),okbutton1,GTK_RESPONSE_OK);
g_signal_connect (G_OBJECT (okbutton1),"clicked",G_CALLBACK (xa_open_with_dialog_execute_command),data);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
gtk_widget_show_all(data->dialog1);
/* Let's parse the desktop files in all the system data dirs */
desktop_dirs = g_get_system_data_dirs();
while (desktop_dirs[x])
{
xa_read_desktop_directories(data->apps_liststore,desktop_dirs[x]);
x++;
}
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->apps_liststore),&iter);
gtk_tree_selection_select_iter(gtk_tree_view_get_selection (GTK_TREE_VIEW (apps_treeview)),&iter);
g_signal_connect (G_OBJECT (apps_treeview), "row-activated",G_CALLBACK(xa_open_with_dialog_row_selected),data);
g_signal_connect (G_OBJECT (data->dialog1), "destroy", G_CALLBACK(xa_destroy_open_with_dialog),data);
}
PidginXferDialog *
pidgin_xfer_dialog_new(void)
{
PidginXferDialog *dialog;
GtkWidget *window;
GtkWidget *vbox1, *vbox2;
GtkWidget *sw;
GtkWidget *button;
GtkWidget *expander;
GtkWidget *table;
GtkWidget *checkbox;
dialog = g_new0(PidginXferDialog, 1);
dialog->keep_open =
purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/filetransfer/keep_open");
dialog->auto_clear =
purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/filetransfer/clear_finished");
/* Create the window. */
dialog->window = window = pidgin_create_dialog(_("File Transfers"), PIDGIN_HIG_BORDER, "file transfer", TRUE);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(delete_win_cb), dialog);
/* Create the parent vbox for everything. */
vbox1 = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(window), FALSE, PIDGIN_HIG_BORDER);
/* Create the main vbox for top half of the window. */
vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
gtk_box_pack_start(GTK_BOX(vbox1), vbox2, TRUE, TRUE, 0);
gtk_widget_show(vbox2);
/* Setup the listbox */
sw = setup_tree(dialog);
gtk_box_pack_start(GTK_BOX(vbox2), sw, TRUE, TRUE, 0);
gtk_widget_set_size_request(sw,-1, 140);
/* "Close this window when all transfers finish" */
checkbox = gtk_check_button_new_with_mnemonic(
_("Close this window when all transfers _finish"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox),
!dialog->keep_open);
g_signal_connect(G_OBJECT(checkbox), "toggled",
G_CALLBACK(toggle_keep_open_cb), dialog);
gtk_box_pack_start(GTK_BOX(vbox2), checkbox, FALSE, FALSE, 0);
gtk_widget_show(checkbox);
/* "Clear finished transfers" */
checkbox = gtk_check_button_new_with_mnemonic(
_("C_lear finished transfers"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox),
dialog->auto_clear);
g_signal_connect(G_OBJECT(checkbox), "toggled",
G_CALLBACK(toggle_clear_finished_cb), dialog);
gtk_box_pack_start(GTK_BOX(vbox2), checkbox, FALSE, FALSE, 0);
gtk_widget_show(checkbox);
/* "Download Details" arrow */
expander = gtk_expander_new_with_mnemonic(_("File transfer _details"));
dialog->expander = expander;
gtk_box_pack_start(GTK_BOX(vbox2), expander, FALSE, FALSE, 0);
gtk_widget_show(expander);
gtk_widget_set_sensitive(expander, FALSE);
/* The table of information. */
table = make_info_table(dialog);
gtk_container_add(GTK_CONTAINER(expander), table);
gtk_widget_show(table);
/* Open button */
button = pidgin_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_OPEN, G_CALLBACK(open_button_cb), dialog);
gtk_widget_set_sensitive(button, FALSE);
dialog->open_button = button;
/* Pause button */
button = pidgin_dialog_add_button(GTK_DIALOG(window), _("_Pause"), G_CALLBACK(pause_button_cb), dialog);
gtk_widget_set_sensitive(button, FALSE);
dialog->pause_button = button;
/* Resume button */
button = pidgin_dialog_add_button(GTK_DIALOG(window), _("_Resume"), G_CALLBACK(resume_button_cb), dialog);
gtk_widget_set_sensitive(button, FALSE);
dialog->resume_button = button;
/* Remove button */
button = pidgin_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_REMOVE, G_CALLBACK(remove_button_cb), dialog);
gtk_widget_hide(button);
dialog->remove_button = button;
/* Stop button */
button = pidgin_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_STOP, G_CALLBACK(stop_button_cb), dialog);
gtk_widget_set_sensitive(button, FALSE);
dialog->stop_button = button;
/* Close button */
button = pidgin_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_CLOSE, G_CALLBACK(close_button_cb), dialog);
dialog->close_button = button;
#ifdef _WIN32
g_signal_connect(G_OBJECT(dialog->window), "show",
G_CALLBACK(winpidgin_ensure_onscreen), dialog->window);
#endif
return dialog;
}
static void
polkit_mate_authentication_dialog_constructed (GObject *object)
{
PolkitMateAuthenticationDialog *dialog;
GtkWidget *hbox;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *table_alignment;
GtkWidget *table;
GtkWidget *details_expander;
GtkWidget *details_vbox;
GtkWidget *label;
GtkWidget *image;
GtkWidget *content_area;
GtkWidget *action_area;
gboolean have_user_combobox;
gchar *s;
guint rows;
dialog = POLKIT_MATE_AUTHENTICATION_DIALOG (object);
if (G_OBJECT_CLASS (polkit_mate_authentication_dialog_parent_class)->constructed != NULL)
G_OBJECT_CLASS (polkit_mate_authentication_dialog_parent_class)->constructed (object);
have_user_combobox = FALSE;
dialog->priv->cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
dialog->priv->auth_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
_("_Authenticate"),
GTK_RESPONSE_OK);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog));
#if !GTK_CHECK_VERSION(3, 0, 0)
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
#endif
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (content_area), 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
gtk_box_set_spacing (GTK_BOX (action_area), 6);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DIALOG_AUTHENTICATION);
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
image = get_image (dialog);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
main_vbox = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0);
/* main message */
label = gtk_label_new (NULL);
s = g_strdup_printf ("<big><b>%s</b></big>", dialog->priv->message);
gtk_label_set_markup (GTK_LABEL (label), s);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0);
/* secondary message */
label = gtk_label_new (NULL);
if (g_strv_length (dialog->priv->users) > 1)
{
gtk_label_set_markup (GTK_LABEL (label),
_("An application is attempting to perform an action that requires privileges. "
"Authentication as one of the users below is required to perform this action."));
}
else
{
if (strcmp (g_get_user_name (), dialog->priv->users[0]) == 0)
{
gtk_label_set_markup (GTK_LABEL (label),
_("An application is attempting to perform an action that requires privileges. "
"Authentication is required to perform this action."));
}
else
{
gtk_label_set_markup (GTK_LABEL (label),
_("An application is attempting to perform an action that requires privileges. "
"Authentication as the super user is required to perform this action."));
}
}
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0);
/* user combobox */
if (g_strv_length (dialog->priv->users) > 1)
{
dialog->priv->user_combobox = gtk_combo_box_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (dialog->priv->user_combobox), FALSE, FALSE, 0);
create_user_combobox (dialog);
have_user_combobox = TRUE;
}
else
{
dialog->priv->selected_user = g_strdup (dialog->priv->users[0]);
}
/* password entry */
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
table_alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
gtk_box_pack_start (GTK_BOX (vbox), table_alignment, FALSE, FALSE, 0);
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_add (GTK_CONTAINER (table_alignment), table);
dialog->priv->password_entry = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY (dialog->priv->password_entry), FALSE);
dialog->priv->prompt_label = add_row (table, 0, _("_Password:"******"activate",
G_CALLBACK (gtk_window_activate_default),
dialog);
dialog->priv->table_alignment = table_alignment;
/* initially never show the password entry stuff; we'll toggle it on/off so it's
* only shown when prompting for a password */
gtk_widget_set_no_show_all (dialog->priv->table_alignment, TRUE);
/* A label for showing PAM_TEXT_INFO and PAM_TEXT_ERROR messages */
label = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
dialog->priv->info_label = label;
/* Details */
details_expander = gtk_expander_new_with_mnemonic (_("<small><b>_Details</b></small>"));
gtk_expander_set_use_markup (GTK_EXPANDER (details_expander), TRUE);
gtk_box_pack_start (GTK_BOX (content_area), details_expander, FALSE, FALSE, 0);
details_vbox = gtk_vbox_new (FALSE, 10);
gtk_container_add (GTK_CONTAINER (details_expander), details_vbox);
table_alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
gtk_box_pack_start (GTK_BOX (details_vbox), table_alignment, FALSE, FALSE, 0);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_add (GTK_CONTAINER (table_alignment), table);
/* TODO: sort keys? */
rows = 0;
if (dialog->priv->details != NULL)
{
guint n;
gchar **keys;
keys = polkit_details_get_keys (dialog->priv->details);
for (n = 0; keys[n] != NULL; n++)
{
const gchar *key = keys[n];
const gchar *value;
value = polkit_details_lookup (dialog->priv->details, key);
label = gtk_label_new (NULL);
s = g_strdup_printf ("<small>%s</small>", value);
gtk_label_set_markup (GTK_LABEL (label), s);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (label), 0, 1.0);
s = g_strdup_printf ("<small><b>%s:</b></small>", key);
add_row (table, rows, s, label);
g_free (s);
rows++;
}
g_strfreev (keys);
}
/* --- */
label = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
s = g_strdup_printf ("<small><a href=\"%s\">%s</a></small>",
dialog->priv->action_id,
dialog->priv->action_id);
gtk_label_set_markup (GTK_LABEL (label), s);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (label), 0, 1.0);
add_row (table, rows++, _("<small><b>Action:</b></small>"), label);
g_signal_connect (label, "activate-link", G_CALLBACK (action_id_activated), NULL);
s = g_strdup_printf (_("Click to edit %s"), dialog->priv->action_id);
gtk_widget_set_tooltip_markup (label, s);
g_free (s);
/* --- */
label = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
s = g_strdup_printf ("<small><a href=\"%s\">%s</a></small>",
dialog->priv->vendor_url,
dialog->priv->vendor);
gtk_label_set_markup (GTK_LABEL (label), s);
g_free (s);
gtk_misc_set_alignment (GTK_MISC (label), 0, 1.0);
add_row (table, rows++, _("<small><b>Vendor:</b></small>"), label);
s = g_strdup_printf (_("Click to open %s"), dialog->priv->vendor_url);
gtk_widget_set_tooltip_markup (label, s);
g_free (s);
if (have_user_combobox)
{
/* ... and make the password entry and "Authenticate" button insensitive */
gtk_widget_set_sensitive (dialog->priv->prompt_label, FALSE);
gtk_widget_set_sensitive (dialog->priv->password_entry, FALSE);
gtk_widget_set_sensitive (dialog->priv->auth_button, FALSE);
}
else
{
}
gtk_widget_realize (GTK_WIDGET (dialog));
}
static GcrDisplayItem*
create_display_item (GcrDisplayView *self, GcrRenderer *renderer)
{
GcrDisplayItem *item;
GtkTextTagTable *tags;
GtkTextIter iter;
GtkWidget *widget;
GtkWidget *label;
GtkWidget *alignment;
item = g_new0 (GcrDisplayItem, 1);
item->display_view = self;
item->renderer = renderer;
tags = gtk_text_buffer_get_tag_table (self->pv->buffer);
g_assert (!item->field_tag);
item->field_width = 0;
item->field_tag = g_object_new (GTK_TYPE_TEXT_TAG,
"left-margin", item->field_width + FIELD_MARGIN,
"indent", item->field_width,
"pixels-below-lines", 3,
"wrap-mode", GTK_WRAP_WORD_CHAR,
NULL);
gtk_text_tag_table_add (tags, item->field_tag);
g_assert (!item->details_tag);
item->details_tag = g_object_new (GTK_TYPE_TEXT_TAG, NULL);
gtk_text_tag_table_add (tags, item->details_tag);
/* The mark that determines the beginning of this item, with left gravity. */
gtk_text_buffer_get_end_iter (self->pv->buffer, &iter);
item->beginning = gtk_text_buffer_create_mark (self->pv->buffer, NULL, &iter, TRUE);
g_object_ref (item->beginning);
/* The mark that determines the end of this item, with right gravity. */
gtk_text_buffer_get_end_iter (self->pv->buffer, &iter);
item->ending = gtk_text_buffer_create_mark (self->pv->buffer, NULL, &iter, FALSE);
g_object_ref (item->ending);
widget = gtk_expander_new_with_mnemonic ("");
label = gtk_expander_get_label_widget (GTK_EXPANDER (widget));
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), "<b>_Details</b>");
g_signal_connect (widget, "notify::expanded", G_CALLBACK (on_expander_expanded), item);
g_signal_connect (widget, "realize", G_CALLBACK (on_expander_realize), NULL);
item->expanded = gtk_expander_get_expanded (GTK_EXPANDER (widget));
alignment = gtk_alignment_new (0.5, 0.5, 0.5, 0.5);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 9, 0, 0);
gtk_container_add (GTK_CONTAINER (alignment), widget);
gtk_widget_show_all (alignment);
item->details_widget = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (item->details_widget), alignment);
g_signal_connect (item->details_widget, "realize", G_CALLBACK (on_expander_realize), NULL);
g_object_ref (item->details_widget);
if (gtk_widget_get_realized (GTK_WIDGET (self)))
style_display_item (GTK_WIDGET (self), item);
/* TODO: Initialize the rest of the fields */
return item;
}
static void
create_account_details_ui (GoaProvider *provider,
GtkDialog *dialog,
GtkBox *vbox,
gboolean new_account,
AddAccountData *data)
{
GtkWidget *grid0;
GtkWidget *grid1;
GtkWidget *grid2;
GtkWidget *hbox;
gint width;
goa_utils_set_dialog_title (provider, dialog, new_account);
grid0 = gtk_grid_new ();
gtk_container_set_border_width (GTK_CONTAINER (grid0), 5);
gtk_widget_set_margin_bottom (grid0, 6);
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid0), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid0), 12);
gtk_container_add (GTK_CONTAINER (vbox), grid0);
data->cluebar = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (data->cluebar), GTK_MESSAGE_ERROR);
gtk_widget_set_hexpand (data->cluebar, TRUE);
gtk_widget_set_no_show_all (data->cluebar, TRUE);
gtk_container_add (GTK_CONTAINER (grid0), data->cluebar);
data->cluebar_label = gtk_label_new ("");
gtk_label_set_line_wrap (GTK_LABEL (data->cluebar_label), TRUE);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (data->cluebar))),
data->cluebar_label);
grid1 = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid1), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid1), 12);
grid2 = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid2), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid2), 12);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), grid1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), grid2, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (grid0), hbox);
add_entry (grid1, grid2, _("_E-mail"), &data->email_address);
add_entry (grid1, grid2, _("_Password"), &data->password);
if (new_account)
{
data->expander = gtk_expander_new_with_mnemonic (_("_Custom"));
gtk_expander_set_expanded (GTK_EXPANDER (data->expander), FALSE);
gtk_expander_set_resize_toplevel (GTK_EXPANDER (data->expander), TRUE);
gtk_container_add (GTK_CONTAINER (grid0), data->expander);
grid1 = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid1), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid1), 12);
grid2 = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid2), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (grid2), 12);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), grid1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), grid2, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (data->expander), hbox);
add_entry (grid1, grid2, _("User_name"), &data->username);
add_entry (grid1, grid2, _("_Server"), &data->server);
}
gtk_entry_set_visibility (GTK_ENTRY (data->password), FALSE);
gtk_widget_grab_focus ((new_account) ? data->email_address : data->password);
g_signal_connect (data->email_address, "changed", G_CALLBACK (on_email_address_or_password_changed), data);
g_signal_connect (data->password, "changed", G_CALLBACK (on_email_address_or_password_changed), data);
data->spinner_button = goa_spinner_button_new_from_stock (GTK_STOCK_CONNECT);
gtk_dialog_add_action_widget (data->dialog, data->spinner_button, GTK_RESPONSE_OK);
gtk_dialog_set_default_response (data->dialog, GTK_RESPONSE_OK);
gtk_dialog_set_response_sensitive (data->dialog, GTK_RESPONSE_OK, FALSE);
gtk_window_get_size (GTK_WINDOW (data->dialog), &width, NULL);
gtk_widget_set_size_request (GTK_WIDGET (data->dialog), width, -1);
}
static void
caja_file_conflict_dialog_init (CajaFileConflictDialog *fcd)
{
GtkWidget *hbox, *vbox, *vbox2, *alignment;
GtkWidget *widget, *dialog_area;
CajaFileConflictDialogDetails *details;
GtkDialog *dialog;
details = fcd->details = CAJA_FILE_CONFLICT_DIALOG_GET_PRIVATE (fcd);
dialog = GTK_DIALOG (fcd);
/* Setup the main hbox */
hbox = gtk_hbox_new (FALSE, 12);
dialog_area = gtk_dialog_get_content_area (dialog);
gtk_box_pack_start (GTK_BOX (dialog_area), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
/* Setup the dialog image */
widget = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (widget), 0.5, 0.0);
/* Setup the vbox containing the dialog body */
vbox = gtk_vbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
/* Setup the vbox for the dialog labels */
widget = gtk_vbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
details->titles_vbox = widget;
/* Setup the hboxes to pack file infos into */
alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
g_object_set (alignment, "left-padding", 12, NULL);
vbox2 = gtk_vbox_new (FALSE, 12);
gtk_container_add (GTK_CONTAINER (alignment), vbox2);
gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
details->first_hbox = hbox;
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
details->second_hbox = hbox;
/* Setup the expander for the rename action */
details->expander = gtk_expander_new_with_mnemonic (_("_Select a new name for the destination"));
gtk_box_pack_start (GTK_BOX (vbox2), details->expander, FALSE, FALSE, 0);
g_signal_connect (details->expander, "activate",
G_CALLBACK (expander_activated_cb), dialog);
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (details->expander), hbox);
widget = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6);
details->entry = widget;
g_signal_connect (widget, "changed",
G_CALLBACK (entry_text_changed_cb), dialog);
widget = gtk_button_new_with_label (_("Reset"));
gtk_button_set_image (GTK_BUTTON (widget),
gtk_image_new_from_stock (GTK_STOCK_UNDO,
GTK_ICON_SIZE_MENU));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6);
g_signal_connect (widget, "clicked",
G_CALLBACK (reset_button_clicked_cb), dialog);
gtk_widget_show_all (alignment);
/* Setup the checkbox to apply the action to all files */
widget = gtk_check_button_new_with_mnemonic (_("Apply this action to all files"));
gtk_box_pack_start (GTK_BOX (vbox),
widget, FALSE, FALSE, 0);
details->checkbox = widget;
g_signal_connect (widget, "toggled",
G_CALLBACK (checkbox_toggled_cb), dialog);
/* Add buttons */
gtk_dialog_add_buttons (dialog,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
_("_Skip"),
CONFLICT_RESPONSE_SKIP,
NULL);
details->rename_button =
gtk_dialog_add_button (dialog,
_("Re_name"),
CONFLICT_RESPONSE_RENAME);
gtk_widget_hide (details->rename_button);
details->replace_button =
gtk_dialog_add_button (dialog,
_("Replace"),
CONFLICT_RESPONSE_REPLACE);
gtk_widget_grab_focus (details->replace_button);
/* Setup HIG properties */
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (dialog)), 14);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_dialog_set_has_separator (dialog, FALSE);
gtk_widget_show_all (dialog_area);
}
static gboolean sslcertwindow_ask_changed_cert(SSLCertificate *old_cert, SSLCertificate *new_cert)
{
GtkWidget *old_cert_widget = cert_presenter(old_cert);
GtkWidget *new_cert_widget = cert_presenter(new_cert);
GtkWidget *vbox;
gchar *buf, *sig_status;
GtkWidget *vbox2;
GtkWidget *label;
GtkWidget *button;
AlertValue val;
gchar *invalid_str = sslcertwindow_get_invalid_str(new_cert);
const gchar *title;
vbox = gtk_vbox_new(FALSE, 5);
label = gtk_label_new(_("New certificate:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_end(GTK_BOX(vbox), new_cert_widget, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), label, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), gtk_hseparator_new(), TRUE, TRUE, 0);
label = gtk_label_new(_("Known certificate:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_end(GTK_BOX(vbox), old_cert_widget, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), label, TRUE, TRUE, 0);
gtk_widget_show_all(vbox);
vbox2 = gtk_vbox_new(FALSE, 5);
buf = g_strdup_printf(_("Certificate for %s has changed.\n%sDo you want to accept it?"), new_cert->host, invalid_str);
g_free(invalid_str);
label = gtk_label_new(buf);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox2), label, TRUE, TRUE, 0);
g_free(buf);
sig_status = ssl_certificate_check_signer(new_cert->x509_cert, new_cert->status);
if (sig_status==NULL)
sig_status = g_strdup(_("Correct"));
buf = g_strdup_printf(_("Signature status: %s"), sig_status);
label = gtk_label_new(buf);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox2), label, TRUE, TRUE, 0);
g_free(buf);
g_free(sig_status);
button = gtk_expander_new_with_mnemonic(_("_View certificates"));
gtk_box_pack_start(GTK_BOX(vbox2), button, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(button), vbox);
if (!ssl_certificate_check_subject_cn(new_cert))
title = _("SSL certificate changed and is invalid");
else
title = _("SSL certificate changed");
val = alertpanel_full(title, NULL,
_("_Cancel connection"), _("_Accept and save"), NULL,
FALSE, vbox2, ALERT_WARNING, G_ALERTDEFAULT);
return (val == G_ALERTALTERNATE);
}
//This function returns a table containing the elements of the page arranged
GtkWidget * setPageLayout(GtkWidget* window, GtkWidget* browserForm){
GtkWidget * tableInitialing;
GtkWidget *image;
GtkWidget * mainSearchBox, *miniSearchBox, *centerSearchBox;
GtkWidget *searchMainBut, *searchMiniBut, *searchCenterBut, *exitButton , *goBackBut, *stopBut, *frontBut;
GtkWidget *scrolledWindow;
GtkWidget *webView;
GtkWidget *pageLayoutExpander;
webView = webkit_web_view_new();
pageLayoutExpander = gtk_expander_new_with_mnemonic("V_iew page");
//creates a table with 20 rows and 17 columns
tableInitialing = gtk_table_new( 30, 17, TRUE);
exitButton = gtk_button_new_with_mnemonic("E_xit One click browser");
g_signal_connect_swapped( G_OBJECT(exitButton), "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer) window);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), exitButton, 0, 17, 29,30);
//Start of expander setting
//declaration of variables involved in setting position of tabs
GtkWidget *settingExpander, *expanderVBox;
GtkWidget *setTapUpRadio, *setTapDownRadio, *clearHistoryBut, *viewHistoryBut;
GtkWidget *facebookLogo, *twitterLogo, *gmailLogo, *skypeLogo, *googleLogo;
GtkWidget *facebookEventBox, *twitterEventBox, *gmailEventBox, *skypeEventBox, *googleEventBox;
//Initialising variables
setTapUpRadio = gtk_radio_button_new_with_label(NULL,"Set tab position up");
setTapDownRadio = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(setTapUpRadio), "Set tab position down");
//Initialises the clearHistoryBut and associate a callback to it
clearHistoryBut = gtk_button_new_with_mnemonic("_Clear history");
g_signal_connect(G_OBJECT(clearHistoryBut), "clicked", G_CALLBACK(clearHistory), NULL);
viewHistoryBut = gtk_button_new_with_mnemonic("_View history");
g_signal_connect_swapped(G_OBJECT(viewHistoryBut),"clicked", G_CALLBACK(viewHistory), NULL);
//Initialises the expander and the vbox
settingExpander = gtk_expander_new_with_mnemonic("_Settings");
expanderVBox = gtk_vbox_new(TRUE, 0);
//Adds radio buttons to the vbox
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapUpRadio);
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapDownRadio);
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), clearHistoryBut);
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), viewHistoryBut);
//Linking signals of radio buttons to the respective callbacks
g_signal_connect_swapped( G_OBJECT(setTapUpRadio), "toggled", G_CALLBACK(setTapUp), browserForm);
g_signal_connect_swapped( G_OBJECT(setTapDownRadio), "toggled", G_CALLBACK(setTapDown), browserForm);
gtk_container_add( GTK_CONTAINER(settingExpander), expanderVBox);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing),settingExpander, 0,3,20,24);
//End of expander setting
goBackBut = gtk_button_new_with_label(" <-- ");
gtk_widget_set_size_request(goBackBut, 10, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), goBackBut, 1, 2, 1, 2);
g_signal_connect_swapped(goBackBut, "clicked", G_CALLBACK(back), webView);
stopBut = gtk_button_new_with_label(" X ");
gtk_widget_set_size_request(stopBut, 10, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), stopBut, 2, 3, 1, 2);
g_signal_connect_swapped(stopBut, "clicked", G_CALLBACK(stop), webView);
frontBut = gtk_button_new_with_label(" --> ");
gtk_widget_set_size_request(frontBut, 10, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), frontBut, 16, 17, 1, 2);
g_signal_connect_swapped(frontBut, "clicked", G_CALLBACK(forward), webView);
//This patch of code initiates autocompletion of the search box
GtkEntryCompletion *completion;
GtkTreeIter *iter;
GtkListStore *store_list;
FILE * historyPtr;
store_list = gtk_list_store_new(1,G_TYPE_STRING);
completion = gtk_entry_completion_new();
if( (historyPtr = fopen("History/History.htm","r+")) == NULL)
g_print("Error");
gchar historyString[100];
while( !feof(historyPtr)){
fscanf(historyPtr,"%s",historyString);
gtk_list_store_append(store_list, iter);
gtk_list_store_set(store_list, iter, 0, historyString, -1);
}
fclose(historyPtr);
gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(store_list));
gtk_entry_completion_set_text_column(completion, 0);
mainSearchBox = gtk_entry_new();
gtk_entry_set_completion(GTK_ENTRY(mainSearchBox), completion);
gtk_widget_set_size_request(mainSearchBox, 500, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), mainSearchBox, 3, 15, 1, 2 );
g_signal_connect_swapped(mainSearchBox, "activate", G_CALLBACK(activate), webView);
searchMainBut = gtk_button_new_with_mnemonic("Sear_ch");
gtk_widget_set_size_request(searchMainBut, 10,15);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), searchMainBut, 15, 16, 1, 2 );
g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(setUri), mainSearchBox);
g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(go), webView);
//g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(initialiseEntryCompletion), completion);
//Linking callbacks to signals emitted by webview widget
g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-progress-changed",G_CALLBACK(progress),mainSearchBox);
g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(finished),mainSearchBox);
scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(scrolledWindow), webView);
gtk_widget_show_all(scrolledWindow);
//PageLayout expander
//gtk_widget_set_sensitive(pageLayoutExpander, FALSE);
gtk_container_add( GTK_CONTAINER(pageLayoutExpander), scrolledWindow);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), pageLayoutExpander, 0, 17, 2, 29);
g_signal_connect_swapped(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(viewSearchedPage),pageLayoutExpander);
image = gtk_image_new_from_file("images/OneClickLogo.png");
GtkWidget* imageEventBox = initialiseEventBox(image);
g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(searchOneClick), webView);
g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(logoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), imageEventBox, 3, 14, 14, 24);
//Adding pictures of some social media to the browser's home page
facebookLogo = gtk_image_new_from_file("images/facebook.jpg");
skypeLogo = gtk_image_new_from_file("images/skype.jpg");
twitterLogo = gtk_image_new_from_file("images/twitter.jpg");
gmailLogo = gtk_image_new_from_file("images/gmail.jpg");
googleLogo = gtk_image_new_from_file("images/google.jpg");
//Adding event handlers to images
facebookEventBox = initialiseEventBox(facebookLogo);
g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(searchFacebook), webView);
g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(facebookLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), facebookEventBox, 4, 6, 24, 28 );
gmailEventBox = initialiseEventBox(gmailLogo);
g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(searchGmail), webView);
g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(gmailLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), gmailEventBox, 6, 8, 24, 28 );
twitterEventBox = initialiseEventBox(twitterLogo);
g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(searchTwitter), webView);
g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(twitterLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), twitterEventBox, 8, 10, 24, 28 );
skypeEventBox = initialiseEventBox(skypeLogo);
g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(searchSKype), webView);
g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(skypeLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), skypeEventBox, 10, 12, 24, 28 );
googleEventBox = initialiseEventBox(googleLogo);
g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(searchGoogle), webView);
g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(googleLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), googleEventBox, 12, 14, 24, 28 );
//This patch of code implements the file chooser button that opens files on the user's computer
GtkWidget *openFileChooser;
openFileChooser = gtk_file_chooser_button_new("Select an html document to open",GTK_FILE_CHOOSER_ACTION_OPEN);
g_signal_connect_swapped(G_OBJECT(openFileChooser), "selection_changed", G_CALLBACK(openFile), webView);
//gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(openFileChooser), g_get_home_dir());
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), openFileChooser, 4, 12, 0, 1 );
GtkFileFilter *filter;
filter = gtk_file_filter_new();
gtk_file_filter_set_name (filter, "HTML Files");
gtk_file_filter_add_pattern (filter, "*.html");
gtk_file_filter_add_pattern (filter, "*.htm");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (openFileChooser), filter);
return tableInitialing;
}
gboolean
save_dialog (void)
{
JpegSaveGui pg;
GtkWidget *dialog;
GtkWidget *vbox;
GtkObject *entry;
GtkWidget *table;
GtkWidget *table2;
GtkWidget *tabledefaults;
GtkWidget *expander;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *spinbutton;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *text_view;
GtkTextBuffer *text_buffer;
GtkWidget *scrolled_window;
GtkWidget *button;
gchar *text;
gint row;
dialog = gimp_export_dialog_new (_("JPEG"), PLUG_IN_BINARY, SAVE_PROC);
g_signal_connect (dialog, "response",
G_CALLBACK (save_dialog_response),
&pg);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
pg.quality = entry = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Quality:"),
SCALE_WIDTH, 0, jsvals.quality,
0.0, 100.0, 1.0, 10.0, 0,
TRUE, 0.0, 0.0,
_("JPEG quality parameter"),
"file-jpeg-save-quality");
g_signal_connect (entry, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&jsvals.quality);
g_signal_connect (entry, "value-changed",
G_CALLBACK (make_preview),
NULL);
preview_size = gtk_label_new (_("File size: unknown"));
gtk_misc_set_alignment (GTK_MISC (preview_size), 0.0, 0.5);
gtk_label_set_ellipsize (GTK_LABEL (preview_size), PANGO_ELLIPSIZE_END);
gimp_label_set_attributes (GTK_LABEL (preview_size),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1);
gtk_box_pack_start (GTK_BOX (vbox), preview_size, FALSE, FALSE, 0);
gtk_widget_show (preview_size);
gimp_help_set_help_data (preview_size,
_("Enable preview to obtain the file size."), NULL);
pg.preview = toggle =
gtk_check_button_new_with_mnemonic (_("Sho_w preview in image window"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.preview);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.preview);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
text = g_strdup_printf ("<b>%s</b>", _("_Advanced Options"));
expander = gtk_expander_new_with_mnemonic (text);
gtk_expander_set_use_markup (GTK_EXPANDER (expander), TRUE);
g_free (text);
gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 0);
gtk_widget_show (expander);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_add (GTK_CONTAINER (expander), vbox);
gtk_widget_show (vbox);
frame = gimp_frame_new ("<expander>");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (4, 8, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 12);
gtk_container_add (GTK_CONTAINER (frame), table);
table2 = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table2), 6);
gtk_table_attach (GTK_TABLE (table), table2,
2, 6, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (table2);
pg.smoothing = entry = gimp_scale_entry_new (GTK_TABLE (table2), 0, 0,
_("S_moothing:"),
100, 0, jsvals.smoothing,
0.0, 1.0, 0.01, 0.1, 2,
TRUE, 0.0, 0.0,
NULL,
"file-jpeg-save-smoothing");
g_signal_connect (entry, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
&jsvals.smoothing);
g_signal_connect (entry, "value-changed",
G_CALLBACK (make_preview),
NULL);
restart_markers_label = gtk_label_new (_("Interval (MCU rows):"));
gtk_misc_set_alignment (GTK_MISC (restart_markers_label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), restart_markers_label, 4, 5, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (restart_markers_label);
pg.scale_data = (GtkAdjustment *)
gtk_adjustment_new (((jsvals.restart == 0) ?
DEFAULT_RESTART_MCU_ROWS : jsvals.restart),
1.0, 64.0, 1.0, 1.0, 0);
pg.restart = restart_markers_scale = spinbutton =
gtk_spin_button_new (pg.scale_data, 1.0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_table_attach (GTK_TABLE (table), spinbutton, 5, 6, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (spinbutton);
pg.use_restart_markers = toggle =
gtk_check_button_new_with_mnemonic (_("Use _restart markers"));
gtk_table_attach (GTK_TABLE (table), toggle, 2, 4, 1, 2, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.restart);
gtk_widget_set_sensitive (restart_markers_label, jsvals.restart);
gtk_widget_set_sensitive (restart_markers_scale, jsvals.restart);
g_signal_connect (pg.scale_data, "value-changed",
G_CALLBACK (save_restart_update),
toggle);
pg.handler_id_restart = g_signal_connect_swapped (toggle, "toggled",
G_CALLBACK (save_restart_update),
pg.scale_data);
row = 0;
/* Optimize */
pg.optimize = toggle = gtk_check_button_new_with_mnemonic (_("_Optimize"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.optimize);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.optimize);
if (arithc_supported)
gtk_widget_set_sensitive (toggle, !jsvals.arithmetic_coding);
row++;
if (arithc_supported)
{
/* Arithmetic coding */
pg.arithmetic_coding = toggle = gtk_check_button_new_with_mnemonic
(_("Use arithmetic _coding"));
gtk_widget_set_tooltip_text
(toggle, _("Older software may have trouble opening "
"arithmetic-coded images"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.arithmetic_coding);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
g_signal_connect (toggle, "toggled",
G_CALLBACK (toggle_arithmetic_coding),
pg.optimize);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
jsvals.arithmetic_coding);
row++;
}
/* Progressive */
pg.progressive = toggle =
gtk_check_button_new_with_mnemonic (_("_Progressive"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.progressive);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
jsvals.progressive);
row++;
/* Save EXIF data */
pg.save_exif = toggle =
gtk_check_button_new_with_mnemonic (_("Save _Exif data"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_exif);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_exif);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_widget_set_sensitive (toggle, TRUE);
row++;
/* Save thumbnail */
pg.save_thumbnail = toggle =
gtk_check_button_new_with_mnemonic (_("Save _thumbnail"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_thumbnail);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_thumbnail);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
row++;
/* XMP metadata */
pg.save_xmp = toggle =
gtk_check_button_new_with_mnemonic (_("Save _XMP data"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_xmp);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_xmp);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_widget_set_sensitive (toggle, TRUE);
row++;
/* IPTC metadata */
pg.save_iptc = toggle =
gtk_check_button_new_with_mnemonic (_("Save _IPTC data"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), jsvals.save_iptc);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.save_iptc);
g_signal_connect (toggle, "toggled",
G_CALLBACK (make_preview),
NULL);
gtk_widget_set_sensitive (toggle, TRUE);
row++;
/* custom quantization tables - now used also for original quality */
pg.use_orig_quality = toggle =
gtk_check_button_new_with_mnemonic (_("_Use quality settings from original "
"image"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 4,
row, row + 1, GTK_FILL, 0, 0, 0);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("If the original image was loaded from a JPEG "
"file using non-standard quality settings "
"(quantization tables), enable this option to "
"get almost the same quality and file size."),
NULL);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&jsvals.use_orig_quality);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
jsvals.use_orig_quality
&& (orig_quality > 0));
gtk_widget_set_sensitive (toggle, (orig_quality > 0));
/* changing quality disables custom quantization tables, and vice-versa */
g_signal_connect (pg.quality, "value-changed",
G_CALLBACK (quality_changed),
pg.use_orig_quality);
g_signal_connect (pg.use_orig_quality, "toggled",
G_CALLBACK (use_orig_qual_changed),
pg.quality);
/* Subsampling */
label = gtk_label_new_with_mnemonic (_("Su_bsampling:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
pg.subsmp =
combo = gimp_int_combo_box_new (_("4:4:4 (best quality)"),
JPEG_SUBSAMPLING_1x1_1x1_1x1,
_("4:2:2 horizontal (chroma halved)"),
JPEG_SUBSAMPLING_2x1_1x1_1x1,
_("4:2:2 vertical (chroma halved)"),
JPEG_SUBSAMPLING_1x2_1x1_1x1,
_("4:2:0 (chroma quartered)"),
JPEG_SUBSAMPLING_2x2_1x1_1x1,
NULL);
gtk_table_attach (GTK_TABLE (table), combo, 3, 6, 2, 3,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
if (gimp_drawable_is_rgb (drawable_ID_global))
{
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
jsvals.subsmp,
G_CALLBACK (subsampling_changed),
entry);
g_signal_connect (pg.use_orig_quality, "toggled",
G_CALLBACK (use_orig_qual_changed2),
pg.subsmp);
}
else
{
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo),
JPEG_SUBSAMPLING_1x1_1x1_1x1);
gtk_widget_set_sensitive (combo, FALSE);
}
/* DCT method */
label = gtk_label_new_with_mnemonic (_("_DCT method:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
pg.dct = combo = gimp_int_combo_box_new (_("Fast Integer"), 1,
_("Integer"), 0,
_("Floating-Point"), 2,
NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), jsvals.dct);
gtk_table_attach (GTK_TABLE (table), combo, 3, 6, 3, 4,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
g_signal_connect (combo, "changed",
G_CALLBACK (gimp_int_combo_box_get_active),
&jsvals.dct);
g_signal_connect (combo, "changed",
G_CALLBACK (make_preview),
NULL);
frame = gimp_frame_new (_("Comment"));
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrolled_window, 250, 50);
gtk_container_add (GTK_CONTAINER (frame), scrolled_window);
gtk_widget_show (scrolled_window);
pg.text_buffer = text_buffer = gtk_text_buffer_new (NULL);
if (image_comment)
gtk_text_buffer_set_text (text_buffer, image_comment, -1);
text_view = gtk_text_view_new_with_buffer (text_buffer);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
gtk_widget_show (text_view);
g_object_unref (text_buffer);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
tabledefaults = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (tabledefaults), 6);
gtk_box_pack_start (GTK_BOX (vbox), tabledefaults, FALSE, FALSE, 0);
gtk_widget_show (tabledefaults);
button = gtk_button_new_with_mnemonic (_("_Load Defaults"));
gtk_table_attach (GTK_TABLE (tabledefaults),
button, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
gtk_widget_show (button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (load_gui_defaults),
&pg);
button = gtk_button_new_with_mnemonic (_("Sa_ve Defaults"));
gtk_table_attach (GTK_TABLE (tabledefaults),
button, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
gtk_widget_show (button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (save_defaults),
&pg);
gtk_widget_show (frame);
gtk_widget_show (table);
gtk_widget_show (dialog);
make_preview ();
pg.run = FALSE;
gtk_main ();
destroy_preview ();
return pg.run;
}
