static void
rejilla_status_dialog_joliet_rename_cb (RejillaTrackData *track,
RejillaStatusDialog *dialog)
{
GtkResponseType answer;
GtkWindow *transient_win;
GtkWidget *message;
gchar *secondary;
g_signal_emit (dialog,
rejilla_status_dialog_signals [USER_INTERACTION],
0);
gtk_widget_hide (GTK_WIDGET (dialog));
transient_win = gtk_window_get_transient_for (GTK_WINDOW (dialog));
message = gtk_message_dialog_new (transient_win,
GTK_DIALOG_DESTROY_WITH_PARENT|
GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_NONE,
"%s",
_("Should files be renamed to be fully Windows-compatible?"));
if (gtk_window_get_icon_name (GTK_WINDOW (dialog)))
gtk_window_set_icon_name (GTK_WINDOW (message),
gtk_window_get_icon_name (GTK_WINDOW (dialog)));
else if (transient_win)
gtk_window_set_icon_name (GTK_WINDOW (message),
gtk_window_get_icon_name (transient_win));
secondary = g_strdup_printf ("%s\n%s",
_("Some files don't have a suitable name for a fully Windows-compatible CD."),
_("Those names should be changed and truncated to 64 characters."));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message), "%s", secondary);
g_free (secondary);
gtk_dialog_add_button (GTK_DIALOG (message),
_("_Disable Full Windows Compatibility"),
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (message),
_("_Rename for Full Windows Compatibility"),
GTK_RESPONSE_YES);
answer = gtk_dialog_run (GTK_DIALOG (message));
gtk_widget_destroy (message);
if (answer != GTK_RESPONSE_YES)
rejilla_track_data_rm_fs (track, REJILLA_IMAGE_FS_JOLIET);
else
rejilla_track_data_add_fs (track, REJILLA_IMAGE_FS_JOLIET);
gtk_widget_show (GTK_WIDGET (dialog));
}
static void cm_button_delete_all_clicked_cb(GtkToolButton *button, CookieManagerPage *cmp)
{
GtkWidget *dialog;
const gchar *filter_text;
MidoriBrowser *toplevel = midori_browser_get_for_widget(GTK_WIDGET(button));
CookieManagerPagePrivate *priv = cmp->priv;
dialog = gtk_message_dialog_new(GTK_WINDOW(toplevel),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
_("Do you really want to delete all cookies?"));
gtk_window_set_title(GTK_WINDOW(dialog), _("Question"));
/* steal Midori's icon :) */
if (toplevel != NULL)
gtk_window_set_icon_name(GTK_WINDOW(dialog), gtk_window_get_icon_name(GTK_WINDOW(toplevel)));
if (!g_object_get_data (G_OBJECT (priv->filter_entry), "sokoke_has_default"))
{
filter_text = gtk_entry_get_text(GTK_ENTRY(priv->filter_entry));
if (*filter_text != '\0')
{
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
_("Only cookies which match the filter will be deleted."));
}
}
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES)
cm_delete_all_cookies_real(cmp);
gtk_widget_destroy(dialog);
}
JNIEXPORT jstring JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1get_1icon_1name
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
const gchar* result;
jstring _result;
GtkWindow* self;
// convert parameter self
self = (GtkWindow*) _self;
// call function
result = gtk_window_get_icon_name(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jstring) bindings_java_newString(env, result);
// and finally
return _result;
}
/* nemo_window_slot_update_icon:
*
* Re-calculate the slot icon
* Called when the location or view or icon set has changed.
* @slot: The NemoWindowSlot in question.
*/
void
nemo_window_slot_update_icon (NemoWindowSlot *slot)
{
NemoWindow *window;
NemoIconInfo *info;
const char *icon_name;
GdkPixbuf *pixbuf;
window = nemo_window_slot_get_window (slot);
info = NEMO_WINDOW_CLASS (G_OBJECT_GET_CLASS (window))->get_icon (window, slot);
icon_name = NULL;
if (info) {
icon_name = nemo_icon_info_get_used_name (info);
if (icon_name != NULL) {
/* Gtk+ doesn't short circuit this (yet), so avoid lots of work
* if we're setting to the same icon. This happens a lot e.g. when
* the trash directory changes due to the file count changing.
*/
if (g_strcmp0 (icon_name, gtk_window_get_icon_name (GTK_WINDOW (window))) != 0) {
gtk_window_set_icon_name (GTK_WINDOW (window), icon_name);
}
} else {
pixbuf = nemo_icon_info_get_pixbuf_nodefault (info);
if (pixbuf) {
gtk_window_set_icon (GTK_WINDOW (window), pixbuf);
g_object_unref (pixbuf);
}
}
g_object_unref (info);
}
}
static void
tool_dialog_run (BraseroToolDialog *dialog,
GtkWindow *toplevel,
NautilusMenuItem *item)
{
char *device_path;
BraseroDrive *drive;
BraseroMediumMonitor *monitor;
device_path = g_object_get_data (G_OBJECT (item), "drive_device_path");
if (!device_path) {
g_warning ("Drive device path not specified");
return;
}
monitor = brasero_medium_monitor_get_default ();
drive = brasero_medium_monitor_get_drive (monitor, device_path);
g_object_unref (monitor);
if (drive) {
brasero_tool_dialog_set_medium (BRASERO_TOOL_DIALOG (dialog),
brasero_drive_get_medium (drive));
g_object_unref (drive);
}
/* Get the icon for the window */
if (toplevel)
gtk_window_set_icon_name (GTK_WINDOW (dialog), gtk_window_get_icon_name (toplevel));
else
gtk_window_set_icon_name (GTK_WINDOW (dialog), "brasero");
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (GTK_WIDGET (dialog));
}
NS_IMETHODIMP Icon::Init(nsIDOMWindow *aWindow, const nsString& aTitle)
{
nsresult rv;
nsCOMPtr<nsIBaseWindow> baseWindow;
rv = GetBaseWindow(aWindow, getter_AddRefs(baseWindow));
NS_ENSURE_SUCCESS(rv, rv);
nativeWindow native = 0;
rv = baseWindow->GetParentNativeWindow(&native);
NS_ENSURE_SUCCESS(rv, rv);
// Get the window
mGdkWindow = gdk_window_get_toplevel(reinterpret_cast<GdkWindow*>(native));
if (!mGdkWindow) {
return NS_ERROR_UNEXPECTED;
}
// Get the widget and gtk window
GtkWidget *widget;
gdk_window_get_user_data(mGdkWindow, reinterpret_cast<gpointer*>(&widget));
widget = gtk_widget_get_toplevel(widget);
mGtkWindow = reinterpret_cast<GtkWindow*>(widget);
// Set up tray icon
mStatusIcon = gtk_status_icon_new();
// Get the window icon and set it
GdkPixbuf *buf = gtk_window_get_icon(mGtkWindow);
if (buf) {
gtk_status_icon_set_from_pixbuf(mStatusIcon, buf);
} else {
const gchar *iconname = gtk_window_get_icon_name(mGtkWindow);
if (iconname)
gtk_status_icon_set_from_icon_name(mStatusIcon, iconname);
}
// Get and set the title
if (aTitle.IsEmpty()) {
gtk_status_icon_set_tooltip_text(mStatusIcon, gtk_window_get_title(mGtkWindow));
gtk_widget_add_events(widget, GDK_PROPERTY_CHANGE_MASK);
propertyEventId = g_signal_connect(mGtkWindow, "property-notify-event", G_CALLBACK(gtkPropertyEvent), this);
}
else {
NS_ConvertUTF16toUTF8 titleUTF8(aTitle);
gtk_status_icon_set_tooltip_text(mStatusIcon, reinterpret_cast<const char*>(titleUTF8.get()));
propertyEventId = 0;
}
// Add signals
g_signal_connect(G_OBJECT(mStatusIcon), "button-press-event", G_CALLBACK(gtkButtonEvent), this);
g_signal_connect(G_OBJECT(mStatusIcon), "button-release-event", G_CALLBACK(gtkButtonEvent), this);
// Make visible
gtk_status_icon_set_visible(mStatusIcon, 1);
return NS_OK;
}
static void
launch_brasero_on_window_session (BraseroSessionCfg *session,
const gchar *dialog_title,
GtkWidget *options,
GtkWindow *window)
{
GtkResponseType result;
const gchar *icon_name;
GtkWidget *dialog;
/* Get the icon for the window */
if (window)
icon_name = gtk_window_get_icon_name (window);
else
icon_name = "brasero";
/* run option dialog */
dialog = brasero_burn_options_new (session);
gtk_window_set_icon_name (GTK_WINDOW (dialog), icon_name);
if (dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), dialog_title);
if (options)
brasero_burn_options_add_options (BRASERO_BURN_OPTIONS (dialog), options);
gtk_widget_show (GTK_WIDGET (dialog));
result = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (result != GTK_RESPONSE_OK
&& result != GTK_RESPONSE_ACCEPT)
return;
/* now run burn dialog */
dialog = brasero_burn_dialog_new ();
gtk_window_set_icon_name (GTK_WINDOW (dialog), icon_name);
if (dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), dialog_title);
brasero_session_cfg_disable (session);
gtk_widget_show (dialog);
gtk_window_present (GTK_WINDOW (dialog));
if (result == GTK_RESPONSE_OK)
brasero_burn_dialog_run (BRASERO_BURN_DIALOG (dialog),
BRASERO_BURN_SESSION (session));
else
brasero_burn_dialog_run_multi (BRASERO_BURN_DIALOG (dialog),
BRASERO_BURN_SESSION (session));
gtk_widget_destroy (dialog);
}
int show_event_config_dialog(const char *event_name, GtkWindow *parent)
{
event_config_t *event = get_event_config(event_name);
GtkWindow *parent_window = parent ? parent : g_event_list_window;
GtkWidget *dialog = gtk_dialog_new_with_buttons(
/*title:*/ec_get_screen_name(event) ? ec_get_screen_name(event) : event_name,
parent_window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_APPLY,
NULL);
/* Allow resize?
* W/o resize, e.g. upload configuration hint looks awfully
* line wrapped.
* With resize, there are some somewhat not nice effects:
* for one, opening an expander will enlarge window,
* but won't contract it back when expander is closed.
*/
gtk_window_set_resizable(GTK_WINDOW(dialog), true);
gtk_window_set_default_size(GTK_WINDOW(dialog), 450, -1);
if (parent_window != NULL)
{
gtk_window_set_icon_name(GTK_WINDOW(dialog),
gtk_window_get_icon_name(parent_window));
}
GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
content = cdialog_get_widget(create_event_config_dialog_content(event, content));
gtk_widget_show_all(content);
int result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_APPLY)
{
dehydrate_config_dialog(g_option_list);
const char *const store_passwords_s = get_user_setting("store_passwords");
save_event_config_data_to_user_storage(event_name,
get_event_config(event_name),
!(store_passwords_s && !strcmp(store_passwords_s, "no")));
}
//else if (result == GTK_RESPONSE_CANCEL)
// log("log");
gtk_widget_destroy(dialog);
return result;
}
config_dialog_t *create_workflow_config_dialog(const char *workflow_name, GtkWindow *parent)
{
workflow_t *workflow = get_workflow(workflow_name);
GList *events = wf_get_event_list(workflow);
GtkWindow *parent_window = parent ? parent : g_parent_window;
GtkWidget *dialog = gtk_dialog_new_with_buttons(
/*title:*/ wf_get_screen_name(workflow) ? wf_get_screen_name(workflow) : workflow_name,
parent_window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_APPLY,
NULL);
gtk_window_set_resizable(GTK_WINDOW(dialog), true);
gtk_window_set_default_size(GTK_WINDOW(dialog), 450, 450);
if (parent_window != NULL)
{
gtk_window_set_icon_name(GTK_WINDOW(dialog),
gtk_window_get_icon_name(parent_window));
}
GtkWidget *scrolled = gtk_scrolled_window_new(NULL, NULL);
GtkWidget *content = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#if ((GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION < 7) || (GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION == 7 && GTK_MICRO_VERSION < 8))
/* http://developer.gnome.org/gtk3/unstable/GtkScrolledWindow.html#gtk-scrolled-window-add-with-viewport */
/* gtk_scrolled_window_add_with_viewport has been deprecated since version 3.8 and should not be used in newly-written code. */
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), content);
#else
/* gtk_container_add() will now automatically add a GtkViewport if the child doesn't implement GtkScrollable. */
gtk_container_add(GTK_CONTAINER(scrolled), content);
#endif
GtkWidget *dialog_box = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(dialog_box), scrolled, false, true, 0);
g_events_options = NULL;
g_list_foreach(events, (GFunc)create_event_config_dialog_content_cb, content);
gtk_widget_show_all(GTK_WIDGET(scrolled));
config_dialog_t *cdialog = new_config_dialog(dialog,
g_events_options,
(config_save_fun_t)save_data_from_worfklow_dialog);
return cdialog;
}
static gboolean
rejilla_burn_options_not_ready_dialog_show_cb (gpointer data)
{
RejillaBurnOptionsPrivate *priv;
priv = REJILLA_BURN_OPTIONS_PRIVATE (data);
/* icon should be set by now */
gtk_window_set_icon_name (GTK_WINDOW (priv->status_dialog),
gtk_window_get_icon_name (GTK_WINDOW (data)));
gtk_widget_show (priv->status_dialog);
priv->not_ready_id = 0;
return FALSE;
}
config_dialog_t *create_event_config_dialog(const char *event_name, GtkWindow *parent)
{
event_config_t *event = get_event_config(event_name);
if(!ec_is_configurable(event))
return NULL;
GtkWindow *parent_window = parent ? parent : g_event_list_window;
GtkWidget *dialog = gtk_dialog_new_with_buttons(
/*title:*/ec_get_screen_name(event) ? ec_get_screen_name(event) : event_name,
parent_window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_APPLY,
NULL);
/* Allow resize?
* W/o resize, e.g. upload configuration hint looks awfully
* line wrapped.
* With resize, there are some somewhat not nice effects:
* for one, opening an expander will enlarge window,
* but won't contract it back when expander is closed.
*/
gtk_window_set_resizable(GTK_WINDOW(dialog), true);
gtk_window_set_default_size(GTK_WINDOW(dialog), 450, -1);
if (parent_window != NULL)
{
gtk_window_set_icon_name(GTK_WINDOW(dialog),
gtk_window_get_icon_name(parent_window));
}
GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
config_dialog_t *cdialog = create_event_config_dialog_content(event, content);
cdialog_set_widget(cdialog, dialog);
return cdialog;
}
static gboolean
rejilla_tool_dialog_cancel_dialog (GtkWidget *toplevel)
{
gint result;
GtkWidget *button;
GtkWidget *message;
message = gtk_message_dialog_new (GTK_WINDOW (toplevel),
GTK_DIALOG_DESTROY_WITH_PARENT|
GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_NONE,
_("Do you really want to quit?"));
gtk_window_set_icon_name (GTK_WINDOW (message),
gtk_window_get_icon_name (GTK_WINDOW (toplevel)));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message),
_("Interrupting the process may make disc unusable."));
gtk_dialog_add_buttons (GTK_DIALOG (message),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
button = rejilla_utils_make_button (_("_Continue"),
GTK_STOCK_OK,
NULL,
GTK_ICON_SIZE_BUTTON);
gtk_widget_show_all (button);
gtk_dialog_add_action_widget (GTK_DIALOG (message),
button, GTK_RESPONSE_OK);
result = gtk_dialog_run (GTK_DIALOG (message));
gtk_widget_destroy (message);
if (result != GTK_RESPONSE_OK)
return TRUE;
return FALSE;
}
config_dialog_t *create_workflow_config_dialog(const char *workflow_name, GtkWindow *parent)
{
workflow_t *workflow = get_workflow(workflow_name);
GList *events = wf_get_event_list(workflow);
GtkWindow *parent_window = parent ? parent : g_parent_window;
GtkWidget *dialog = gtk_dialog_new_with_buttons(
/*title:*/ wf_get_screen_name(workflow) ? wf_get_screen_name(workflow) : workflow_name,
parent_window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_APPLY,
NULL);
gtk_window_set_resizable(GTK_WINDOW(dialog), true);
gtk_window_set_default_size(GTK_WINDOW(dialog), 450, -1);
if (parent_window != NULL)
{
gtk_window_set_icon_name(GTK_WINDOW(dialog),
gtk_window_get_icon_name(parent_window));
}
GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
g_events_options = NULL;
g_list_foreach(events, (GFunc)create_event_config_dialog_content_cb, content);
config_dialog_t *cdialog = new_config_dialog(dialog,
g_events_options,
(config_save_fun_t)save_data_from_worfklow_dialog);
return cdialog;
}
static gboolean
rejilla_status_dialog_deep_directory_cb (RejillaTrackDataCfg *project,
const gchar *name,
RejillaStatusDialog *dialog)
{
gint answer;
gchar *string;
GtkWidget *message;
GtkWindow *transient_win;
RejillaStatusDialogPrivate *priv;
priv = REJILLA_STATUS_DIALOG_PRIVATE (dialog);
if (priv->accept_deep_files)
return TRUE;
if (priv->reject_deep_files)
return FALSE;
g_signal_emit (dialog,
rejilla_status_dialog_signals [USER_INTERACTION],
0);
gtk_widget_hide (GTK_WIDGET (dialog));
string = g_strdup_printf (_("Do you really want to add \"%s\" to the selection?"), name);
transient_win = gtk_window_get_transient_for (GTK_WINDOW (dialog));
message = gtk_message_dialog_new (transient_win,
GTK_DIALOG_DESTROY_WITH_PARENT|
GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_NONE,
"%s",
string);
g_free (string);
if (gtk_window_get_icon_name (GTK_WINDOW (dialog)))
gtk_window_set_icon_name (GTK_WINDOW (message),
gtk_window_get_icon_name (GTK_WINDOW (dialog)));
else if (transient_win)
gtk_window_set_icon_name (GTK_WINDOW (message),
gtk_window_get_icon_name (transient_win));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message),
_("The children of this directory will have 7 parent directories."
"\nRejilla can create an image of such a file hierarchy and burn it but the disc may not be readable on all operating systems."
"\nNote: Such a file hierarchy is known to work on Linux."));
gtk_dialog_add_button (GTK_DIALOG (message), _("Ne_ver Add Such File"), GTK_RESPONSE_REJECT);
gtk_dialog_add_button (GTK_DIALOG (message), _("Al_ways Add Such File"), GTK_RESPONSE_ACCEPT);
answer = gtk_dialog_run (GTK_DIALOG (message));
gtk_widget_destroy (message);
gtk_widget_show (GTK_WIDGET (dialog));
priv->accept_deep_files = (answer == GTK_RESPONSE_ACCEPT);
priv->reject_deep_files = (answer == GTK_RESPONSE_REJECT);
return (answer != GTK_RESPONSE_YES && answer != GTK_RESPONSE_ACCEPT);
}
static RejillaBurnResult
rejilla_status_dialog_uri_has_image (RejillaTrackDataCfg *track,
const gchar *uri,
RejillaBurnOptions *self)
{
gint answer;
gchar *name;
GtkWidget *button;
GtkWidget *dialog;
gboolean was_visible = FALSE;
gboolean was_not_ready = FALSE;
RejillaTrackImageCfg *track_img;
RejillaBurnOptionsPrivate *priv;
priv = REJILLA_BURN_OPTIONS_PRIVATE (self);
dialog = gtk_message_dialog_new (GTK_WINDOW (self),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"%s",
_("Do you want to create a disc from the contents of the image or with the image file inside?"));
gtk_window_set_title (GTK_WINDOW (dialog), "");
gtk_window_set_icon_name (GTK_WINDOW (dialog),
gtk_window_get_icon_name (GTK_WINDOW (self)));
name = rejilla_utils_get_uri_name (uri);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
/* Translators: %s is the name of the image */
_("There is only one selected file (\"%s\"). "
"It is the image of a disc and its contents can be burned."),
name);
g_free (name);
gtk_dialog_add_button (GTK_DIALOG (dialog), _("Burn as _File"), GTK_RESPONSE_NO);
button = rejilla_utils_make_button (_("Burn _Contents…"),
NULL,
"media-optical-burn",
GTK_ICON_SIZE_BUTTON);
gtk_widget_show (button);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
button,
GTK_RESPONSE_YES);
if (!priv->not_ready_id && priv->status_dialog) {
was_visible = TRUE;
gtk_widget_hide (GTK_WIDGET (priv->status_dialog));
}
else if (priv->not_ready_id) {
g_source_remove (priv->not_ready_id);
priv->not_ready_id = 0;
was_not_ready = TRUE;
}
gtk_widget_show_all (dialog);
answer = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (answer != GTK_RESPONSE_YES) {
if (was_not_ready)
priv->not_ready_id = g_timeout_add_seconds (1,
rejilla_burn_options_not_ready_dialog_show_cb,
self);
if (was_visible)
gtk_widget_show (GTK_WIDGET (priv->status_dialog));
return REJILLA_BURN_OK;
}
/* Setup a new track and add it to session */
track_img = rejilla_track_image_cfg_new ();
rejilla_track_image_cfg_set_source (track_img, uri);
rejilla_burn_session_add_track (REJILLA_BURN_SESSION (priv->session),
REJILLA_TRACK (track_img),
NULL);
return REJILLA_BURN_CANCEL;
}
static void
gnome_control_center_init (GnomeControlCenter *self)
{
GError *err = NULL;
GnomeControlCenterPrivate *priv;
GdkScreen *screen;
priv = self->priv = CONTROL_CENTER_PRIVATE (self);
#ifdef HAVE_CHEESE
if (gtk_clutter_init (NULL, NULL) != CLUTTER_INIT_SUCCESS)
{
g_critical ("Clutter-GTK init failed");
return;
}
#endif /* HAVE_CHEESE */
priv->monitor_num = -1;
self->priv->small_screen = SMALL_SCREEN_UNSET;
/* load the user interface */
priv->builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (priv->builder, UIDIR "/shell.ui", &err))
{
g_critical ("Could not build interface: %s", err->message);
g_error_free (err);
return;
}
/* connect various signals */
priv->window = W (priv->builder, "main-window");
gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (priv->window), TRUE);
screen = gtk_widget_get_screen (priv->window);
g_signal_connect (screen, "monitors-changed", G_CALLBACK (monitors_changed_cb), self);
g_signal_connect (priv->window, "configure-event", G_CALLBACK (main_window_configure_cb), self);
g_signal_connect (priv->window, "notify::application", G_CALLBACK (application_set_cb), self);
g_signal_connect_swapped (priv->window, "delete-event", G_CALLBACK (g_object_unref), self);
g_signal_connect_after (priv->window, "key_press_event",
G_CALLBACK (window_key_press_event), self);
priv->notebook = W (priv->builder, "notebook");
/* Main scrolled window */
priv->scrolled_window = W (priv->builder, "scrolledwindow1");
gtk_widget_set_size_request (priv->scrolled_window, FIXED_WIDTH, -1);
priv->main_vbox = W (priv->builder, "main-vbox");
g_signal_connect (priv->notebook, "notify::page",
G_CALLBACK (notebook_page_notify_cb), priv);
g_signal_connect (gtk_builder_get_object (priv->builder, "home-button"),
"clicked", G_CALLBACK (home_button_clicked_cb), self);
/* keep a list of custom widgets to unload on panel change */
priv->custom_widgets = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
/* load the available settings panels */
setup_model (self);
/* load the panels that are implemented as plugins */
load_panel_plugins (self);
/* setup search functionality */
setup_search (self);
setup_lock (self);
/* store default window title and name */
priv->default_window_title = g_strdup (gtk_window_get_title (GTK_WINDOW (priv->window)));
priv->default_window_icon = g_strdup (gtk_window_get_icon_name (GTK_WINDOW (priv->window)));
notebook_page_notify_cb (GTK_NOTEBOOK (priv->notebook), NULL, priv);
}
/* Object initialization
* Create private structure and set up default values
*/
static void nojs_preferences_init(NoJSPreferences *self)
{
NoJSPreferencesPrivate *priv;
GtkTreeSortable *sortableList;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *widget;
gchar *dialogTitle;
GtkWidget *scrolled;
GtkWidget *vbox;
GtkWidget *hbox;
gint width, height;
GtkListStore *list;
GtkTreeIter listIter;
priv=self->priv=NOJS_PREFERENCES_GET_PRIVATE(self);
/* Set up default values */
priv->manager=NULL;
/* Get content area to add gui controls to */
priv->contentArea=gtk_dialog_get_content_area(GTK_DIALOG(self));
#if GTK_CHECK_VERSION (3, 0, 0)
vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE);
#else
vbox=gtk_vbox_new(FALSE, 0);
#endif
/* Set up dialog */
dialogTitle=_("Configure NoJS");
gtk_window_set_title(GTK_WINDOW(self), dialogTitle);
gtk_window_set_icon_name(GTK_WINDOW(self), GTK_STOCK_PROPERTIES);
sokoke_widget_get_text_size(GTK_WIDGET(self), "M", &width, &height);
gtk_window_set_default_size(GTK_WINDOW(self), width*52, -1);
widget=sokoke_xfce_header_new(gtk_window_get_icon_name(GTK_WINDOW(self)), dialogTitle);
if(widget) gtk_box_pack_start(GTK_BOX(priv->contentArea), widget, FALSE, FALSE, 0);
gtk_dialog_add_button(GTK_DIALOG(self), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
/* Set up description */
widget=gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(widget),
_("Below is a list of all web sites and the policy set for them. "
"You can delete policies by marking the entries and clicking on <i>Delete</i>."));
gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 4);
/* Set up domain list */
priv->listStore=gtk_list_store_new(N_COLUMN,
G_TYPE_STRING, /* DOMAIN_COLUMN */
G_TYPE_STRING /* POLICY_COLUMN */);
sortableList=GTK_TREE_SORTABLE(priv->listStore);
gtk_tree_sortable_set_sort_func(sortableList,
DOMAIN_COLUMN,
(GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback,
GINT_TO_POINTER(DOMAIN_COLUMN),
NULL);
gtk_tree_sortable_set_sort_func(sortableList,
POLICY_COLUMN,
(GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback,
GINT_TO_POINTER(POLICY_COLUMN),
NULL);
gtk_tree_sortable_set_sort_column_id(sortableList, DOMAIN_COLUMN, GTK_SORT_ASCENDING);
/* Set up domain addition widgets */
#ifdef HAVE_GTK3
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE);
#else
hbox=gtk_hbox_new(FALSE, 0);
#endif
priv->addDomainEntry=gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(priv->addDomainEntry), 64);
gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainEntry);
g_signal_connect_swapped(priv->addDomainEntry, "changed", G_CALLBACK(_nojs_preferences_on_add_domain_entry_changed), self);
list=gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING);
gtk_list_store_append(list, &listIter);
gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_ACCEPT, 1, _("Accept"), -1);
gtk_list_store_append(list, &listIter);
gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_ACCEPT_TEMPORARILY, 1, _("Accept for session"), -1);
gtk_list_store_append(list, &listIter);
gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_BLOCK, 1, _("Block"), -1);
priv->addDomainPolicyCombo=gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->addDomainPolicyCombo), 0);
gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainPolicyCombo);
renderer=gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, TRUE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, "text", 1);
priv->addDomainButton=gtk_button_new_from_stock(GTK_STOCK_ADD);
gtk_widget_set_sensitive(priv->addDomainButton, FALSE);
gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainButton);
g_signal_connect_swapped(priv->addDomainButton, "clicked", G_CALLBACK(_nojs_preferences_on_add_domain_clicked), self);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5);
/* Set up domain list view */
priv->list=gtk_tree_view_new_with_model(GTK_TREE_MODEL(priv->listStore));
#if !GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_size_request(priv->list, -1, 300);
#endif
priv->listSelection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->list));
gtk_tree_selection_set_mode(priv->listSelection, GTK_SELECTION_MULTIPLE);
g_signal_connect_swapped(priv->listSelection, "changed", G_CALLBACK(_nojs_preferences_changed_selection), self);
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(_("Domain"),
renderer,
"text", DOMAIN_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, DOMAIN_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column);
renderer=gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(renderer), "model", list, "text-column", 1, "has-entry", false, "editable", true, NULL);
g_signal_connect_swapped(renderer, "editing-started", G_CALLBACK(_nojs_preferences_on_policy_editing_started), self);
g_signal_connect_swapped(renderer, "editing-canceled", G_CALLBACK(_nojs_preferences_on_policy_editing_canceled), self);
g_signal_connect_swapped(renderer, "edited", G_CALLBACK(_nojs_preferences_on_policy_edited), self);
column=gtk_tree_view_column_new_with_attributes(_("Policy"),
renderer,
"text", POLICY_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, POLICY_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column);
scrolled=gtk_scrolled_window_new(NULL, NULL);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), height*10);
#endif
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrolled), priv->list);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 5);
/* Set up JavaScript domain list management buttons */
#if GTK_CHECK_VERSION (3, 0, 0)
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE);
#else
hbox=gtk_hbox_new(FALSE, 0);
#endif
priv->deleteButton=gtk_button_new_from_stock(GTK_STOCK_DELETE);
gtk_widget_set_sensitive(priv->deleteButton, FALSE);
gtk_container_add(GTK_CONTAINER(hbox), priv->deleteButton);
g_signal_connect_swapped(priv->deleteButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_selection), self);
priv->deleteAllButton=gtk_button_new_with_mnemonic(_("Delete _all"));
gtk_button_set_image(GTK_BUTTON(priv->deleteAllButton), gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON));
gtk_widget_set_sensitive(priv->deleteAllButton, FALSE);
gtk_container_add(GTK_CONTAINER(hbox), priv->deleteAllButton);
g_signal_connect_swapped(priv->deleteAllButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_all), self);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5);
/* Add "allow-all-sites" checkbox */
priv->allowAllSitesCheckbox=gtk_check_button_new_with_mnemonic(_("A_llow scripts at all sites"));
priv->signalAllowAllSitesToggledID=g_signal_connect_swapped(priv->allowAllSitesCheckbox,
"toggled",
G_CALLBACK(_nojs_preferences_on_allow_all_sites_changed),
self);
gtk_box_pack_start(GTK_BOX(vbox), priv->allowAllSitesCheckbox, FALSE, TRUE, 5);
/* Add "block-unknown-domains" checkbox */
priv->blockUnknownDomainsCheckbox=gtk_check_button_new_with_mnemonic(_("Bloc_k scripts at unknown domains by default"));
priv->signalBlockUnknownDomainsToggledID=g_signal_connect_swapped(priv->blockUnknownDomainsCheckbox,
"toggled",
G_CALLBACK(_nojs_preferences_on_block_unknown_domains_changed),
self);
gtk_box_pack_start(GTK_BOX(vbox), priv->blockUnknownDomainsCheckbox, FALSE, TRUE, 5);
/* Add "check-second-level-only" checkbox */
priv->checkSecondLevelOnlyCheckbox=gtk_check_button_new_with_mnemonic(_("S_et permissions on second-level domain"));
priv->signalCheckSecondLevelOnlyToggledID=g_signal_connect_swapped(priv->checkSecondLevelOnlyCheckbox,
"toggled",
G_CALLBACK(_nojs_preferences_on_check_second_level_only_changed),
self);
gtk_box_pack_start(GTK_BOX(vbox), priv->checkSecondLevelOnlyCheckbox, FALSE, TRUE, 5);
/* Finalize setup of content area */
gtk_box_pack_start(GTK_BOX(priv->contentArea), vbox, TRUE, TRUE, 0);
}
static GtkWidget*
shortcuts_get_preferences_dialog (MidoriExtension* extension)
{
MidoriApp* app;
GtkWidget* browser;
const gchar* dialog_title;
GtkWidget* dialog;
gint width, height;
GtkWidget* xfce_heading;
GtkWidget* hbox;
GtkListStore* liststore;
GtkTreeModel* model;
GtkWidget* treeview;
GtkTreeViewColumn* column;
GtkCellRenderer* renderer;
GtkWidget* scrolled;
GtkActionGroup* action_group;
GList* actions;
guint i;
GtkAction* action;
#if HAVE_OSX
GtkWidget* icon;
#endif
app = midori_extension_get_app (extension);
browser = katze_object_get_object (app, "browser");
dialog_title = _("Customize Keyboard shortcuts");
dialog = gtk_dialog_new_with_buttons (dialog_title, GTK_WINDOW (browser),
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
#if !HAVE_OSX
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
#endif
NULL);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed), &dialog);
gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_PROPERTIES);
sokoke_widget_get_text_size (dialog, "M", &width, &height);
gtk_window_set_default_size (GTK_WINDOW (dialog), width * 52, height * 24);
g_signal_connect (dialog, "response",
G_CALLBACK (shortcuts_preferences_response_cb), NULL);
if ((xfce_heading = sokoke_xfce_header_new (
gtk_window_get_icon_name (GTK_WINDOW (dialog)), dialog_title)))
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
xfce_heading, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
TRUE, TRUE, 12);
liststore = gtk_list_store_new (7,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN,
G_TYPE_STRING, GTK_TYPE_ACTION);
model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (liststore));
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "text", 0);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_accel_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-key", 1);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-mods", 2);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-mode", 3);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "sensitive", 4);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "editable", 4);
g_signal_connect (renderer, "accel-edited",
G_CALLBACK (shortcuts_accel_edited_cb), model);
g_signal_connect (renderer, "accel-cleared",
G_CALLBACK (shortcuts_accel_cleared_cb), model);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled), treeview);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), scrolled, TRUE, TRUE, 5);
action_group = midori_browser_get_action_group (MIDORI_BROWSER (browser));
actions = gtk_action_group_list_actions (action_group);
i = 0;
/* FIXME: Catch added and removed actions */
while ((action = g_list_nth_data (actions, i++)))
{
gchar* label = shortcuts_label_for_action (action);
GtkAccelKey key;
gboolean has_hotkey = shortcuts_hotkey_for_action (action, &key);
gtk_list_store_insert_with_values (GTK_LIST_STORE (liststore),
NULL, G_MAXINT, 0, label, 1, key.accel_key, 2, key.accel_mods,
3, GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
4, has_hotkey, 6, action, -1);
g_free (label);
}
g_list_free (actions);
g_object_unref (liststore);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
0, GTK_SORT_ASCENDING);
g_object_unref (model);
gtk_widget_show_all (GTK_DIALOG (dialog)->vbox);
g_object_unref (browser);
return dialog;
}
static gboolean
rejilla_status_dialog_2G_file_cb (RejillaTrackDataCfg *track,
const gchar *name,
RejillaStatusDialog *dialog)
{
gint answer;
gchar *string;
GtkWidget *message;
GtkWindow *transient_win;
RejillaStatusDialogPrivate *priv;
priv = REJILLA_STATUS_DIALOG_PRIVATE (dialog);
if (priv->accept_2G_files)
return TRUE;
if (priv->reject_2G_files)
return FALSE;
g_signal_emit (dialog,
rejilla_status_dialog_signals [USER_INTERACTION],
0);
gtk_widget_hide (GTK_WIDGET (dialog));
string = g_strdup_printf (_("Do you really want to add \"%s\" to the selection and use the third version of the ISO9660 standard to support it?"), name);
transient_win = gtk_window_get_transient_for (GTK_WINDOW (dialog));
message = gtk_message_dialog_new (transient_win,
GTK_DIALOG_DESTROY_WITH_PARENT|
GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_NONE,
"%s",
string);
g_free (string);
if (gtk_window_get_icon_name (GTK_WINDOW (dialog)))
gtk_window_set_icon_name (GTK_WINDOW (message),
gtk_window_get_icon_name (GTK_WINDOW (dialog)));
else if (transient_win)
gtk_window_set_icon_name (GTK_WINDOW (message),
gtk_window_get_icon_name (transient_win));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message),
_("The size of the file is over 2 GiB. Files larger than 2 GiB are not supported by the ISO9660 standard in its first and second versions (the most widespread ones)."
"\nIt is recommended to use the third version of the ISO9660 standard, which is supported by most operating systems, including Linux and all versions of Windows™."
"\nHowever, Mac OS X cannot read images created with version 3 of the ISO9660 standard."));
gtk_dialog_add_button (GTK_DIALOG (message), _("Ne_ver Add Such File"), GTK_RESPONSE_REJECT);
gtk_dialog_add_button (GTK_DIALOG (message), _("Al_ways Add Such File"), GTK_RESPONSE_ACCEPT);
answer = gtk_dialog_run (GTK_DIALOG (message));
gtk_widget_destroy (message);
gtk_widget_show (GTK_WIDGET (dialog));
priv->accept_2G_files = (answer == GTK_RESPONSE_ACCEPT);
priv->reject_2G_files = (answer == GTK_RESPONSE_REJECT);
return (answer != GTK_RESPONSE_YES && answer != GTK_RESPONSE_ACCEPT);
}
