static void
ag_app_import_cb(GSimpleAction *action, GVariant *parameter, gpointer user_data)
{
gint response;
GtkWidget *fs;
GtkFileFilter *filter;
GSList *filenames = NULL;
const gchar *target_type = g_variant_get_string(parameter, NULL);
AgAppImportType type = AG_APP_IMPORT_NONE;
AgApp *app = AG_APP(user_data);
if (strncmp("agc", target_type, 3) == 0) {
type = AG_APP_IMPORT_AGC;
filter = filter_chart;
} else if (strncmp("hor", target_type, 3) == 0) {
type = AG_APP_IMPORT_HOR;
filter = filter_hor;
} else {
g_error("Unknown import type!");
}
fs = gtk_file_chooser_dialog_new(
_("Select charts"),
gtk_application_get_active_window(GTK_APPLICATION(app)),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Import"), GTK_RESPONSE_ACCEPT,
NULL
);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fs), filter_all);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fs), filter);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fs), filter);
gtk_dialog_set_default_response(GTK_DIALOG(fs), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(fs), TRUE);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(fs), FALSE);
response = gtk_dialog_run(GTK_DIALOG(fs));
if (response == GTK_RESPONSE_ACCEPT) {
filenames = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(fs));
}
if (filenames != NULL) {
GSList *l;
for (l = filenames; l; l = g_slist_next(l)) {
GFile *file;
char *data = l->data;
if (data == NULL) {
continue;
}
file = g_file_new_for_commandline_arg(data);
ag_app_import_file(AG_APP(user_data), file, type);
}
}
gtk_widget_destroy(fs);
}
static void
ide_application_actions_help (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdeApplication *self = user_data;
GtkWindow *focused_window= NULL;
GdkScreen *screen = NULL;
GError *err = NULL;
g_assert (IDE_IS_APPLICATION (self));
focused_window = gtk_application_get_active_window (GTK_APPLICATION (self));
screen = gtk_window_get_screen (focused_window);
gtk_show_uri (screen,
"help:gnome-builder",
gtk_get_current_event_time (),
&err);
if (err)
{
g_message ("Unable to open help: %s\n", err->message);
g_error_free (err);
}
}
static GtkWidget *
ag_app_get_usable_window(AgApp *app)
{
GtkWidget *window;
GList *l;
// Favour current window
window = GTK_WIDGET(gtk_application_get_active_window(GTK_APPLICATION(app)));
if (AG_IS_WINDOW(window) && ag_window_is_usable(AG_WINDOW(window))) {
return window;
}
// Otherwise, let’s use the first existing, usable window
for (
l = gtk_application_get_windows(GTK_APPLICATION(app));
l;
l = g_list_next(l)
) {
if (AG_IS_WINDOW(l->data) && ag_window_is_usable(AG_WINDOW(l->data))) {
return l->data;
}
}
// If we are still here, no usable windows were found. Let’s create one
window = ag_app_create_window(app);
return window;
}
static void
pdf_load_job_openoffice_missing_unoconv (PdfLoadJob *job)
{
GApplication *app = g_application_get_default ();
GtkWidget *widget = GTK_WIDGET (gtk_application_get_active_window (GTK_APPLICATION (app)));
GDBusConnection *connection = g_application_get_dbus_connection (app);
guint xid = 0;
GdkWindow *gdk_window;
const gchar *unoconv_path[2];
gdk_window = gtk_widget_get_window (widget);
if (gdk_window != NULL)
xid = GDK_WINDOW_XID (gdk_window);
unoconv_path[0] = "/usr/bin/unoconv";
unoconv_path[1] = NULL;
g_dbus_connection_call (connection,
"org.freedesktop.PackageKit",
"/org/freedesktop/PackageKit",
"org.freedesktop.PackageKit.Modify",
"InstallProvideFiles",
g_variant_new ("(u^ass)",
xid,
unoconv_path,
"hide-confirm-deps"),
NULL, G_DBUS_CALL_FLAGS_NONE,
G_MAXINT,
job->cancellable,
openoffice_missing_unoconv_ready_cb,
job);
}
static void
action_help (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkWindow *window;
GtkWidget *dialog;
GtkApplication *application = user_data;
GError *error = NULL;
window = gtk_application_get_active_window (application);
gtk_show_uri (window ?
gtk_window_get_screen (GTK_WINDOW (window)) :
gdk_screen_get_default (),
"help:gnome-help/files",
gtk_get_current_event_time (), &error);
if (error) {
dialog = gtk_message_dialog_new (window ? GTK_WINDOW (window) : NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("There was an error displaying help: \n%s"),
error->message);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_widget_show (dialog);
g_error_free (error);
}
}
static void
activate_about (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *app = user_data;
const gchar *authors[] = {
"Andrea Cimitan",
"Cosimo Cecchi",
NULL
};
gchar *version;
version = g_strdup_printf ("%s\nRunning against GTK+ %d.%d.%d",
PACKAGE_VERSION,
gtk_get_major_version (),
gtk_get_minor_version (),
gtk_get_micro_version ());
gtk_show_about_dialog (GTK_WINDOW (gtk_application_get_active_window (app)),
"program-name", "GTK+ Widget Factory",
"version", version,
"copyright", "(C) 1997-2013 The GTK+ Team",
"license-type", GTK_LICENSE_LGPL_2_1,
"website", "http://www.gtk.org",
"comments", "Program to demonstrate GTK+ themes and widgets",
"authors", authors,
"logo-icon-name", "gtk3-widget-factory",
"title", "About GTK+ Widget Factory",
NULL);
g_free (version);
}
static void
about_cb (GSimpleAction *action,
GVariant *parameter,
gpointer app)
{
const gchar *authors[] = {
"Gabor Karsay <*****@*****.**>",
_("Including code from other projects:"),
"Buzztrax team <*****@*****.**>",
"Philip Withnall <*****@*****.**>",
NULL
};
const gchar *artists[] = {
"GNOME Project http://www.gnome.org",
"Gabor Karsay <*****@*****.**>",
NULL
};
gtk_show_about_dialog (
gtk_application_get_active_window (app),
"program_name", _("Parlatype"),
"version", PACKAGE_VERSION,
"copyright", "© Gabor Karsay 2016",
"comments", _("A basic transcription utility"),
"logo-icon-name", "parlatype",
"authors", authors,
"artists", artists,
"translator-credits", _("translator-credits"),
"license-type", GTK_LICENSE_GPL_3_0,
"website", "https://github.com/gkarsay/parlatype",
NULL);
}
static void
libreoffice_missing (NemoPreviewPdfLoader *self)
{
GApplication *app = g_application_get_default ();
GtkWidget *widget = GTK_WIDGET (gtk_application_get_active_window (GTK_APPLICATION (app)));
GDBusConnection *connection = g_application_get_dbus_connection (app);
guint xid = 0;
GdkWindow *gdk_window;
const gchar *libreoffice_path[2];
gdk_window = gtk_widget_get_window (widget);
if (gdk_window != NULL)
xid = GDK_WINDOW_XID (gdk_window);
libreoffice_path[0] = "/usr/bin/libreoffice";
libreoffice_path[1] = NULL;
g_dbus_connection_call (connection,
"org.freedesktop.PackageKit",
"/org/freedesktop/PackageKit",
"org.freedesktop.PackageKit.Modify",
"InstallProvideFiles",
g_variant_new ("(u^ass)",
xid,
libreoffice_path,
"hide-confirm-deps"),
NULL, G_DBUS_CALL_FLAGS_NONE,
G_MAXINT, NULL,
libreoffice_missing_ready_cb,
self);
}
static void
action_preferences (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *application = user_data;
nautilus_file_management_properties_dialog_show (gtk_application_get_active_window (application));
}
static void
preferences_activated(GSimpleAction *action,
GVariant *parameter,
gpointer data)
{
GtkApplication *app = GTK_APPLICATION(data);
show_config_list_dialog(GTK_WINDOW(gtk_application_get_active_window(app)));
}
static void
preferences_cb(GSimpleAction *action, GVariant *parameter, gpointer user_data)
{
AgApp *app = AG_APP(user_data);
ag_preferences_show_dialog(
gtk_application_get_active_window(GTK_APPLICATION(app))
);
}
static void
action_about (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *application = user_data;
nautilus_window_show_about_dialog (NAUTILUS_WINDOW (gtk_application_get_active_window (application)));
}
static void
prefs_cb (GSimpleAction *action,
GVariant *parameter,
gpointer app)
{
GtkWindow *win;
win = gtk_application_get_active_window (app);
pt_show_preferences_dialog (win);
}
static void preferences_activated(GSimpleAction *action, GVariant *parameter,
gpointer app)
{
Code0AppPrefs *prefs;
GtkWindow *win;
win = gtk_application_get_active_window(GTK_APPLICATION(app));
prefs = example_app_prefs_new(EXAMPLE_APP_WINDOW(win));
gtk_window_present(GTK_WINDOW(prefs));
}
static void
action_bookmarks (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *application = user_data;
nautilus_application_edit_bookmarks (NAUTILUS_APPLICATION (application),
NAUTILUS_WINDOW (gtk_application_get_active_window (application)));
}
static void
recent_cb (GSimpleAction *action,
GVariant *parameter,
gpointer app)
{
GtkWidget *dialog;
GtkWindow *win;
GtkRecentInfo *info;
GtkRecentChooser *chooser;
GtkRecentFilter *filter;
GtkRecentFilter *filter_all;
const gchar *uri = NULL;
win = gtk_application_get_active_window (app);
dialog = gtk_recent_chooser_dialog_new (
_("Recent Files"),
win,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (dialog), GTK_RECENT_SORT_MRU); /* Most Recently Used first */
gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (dialog), TRUE);
filter = gtk_recent_filter_new ();
gtk_recent_filter_set_name (filter, _("Parlatype"));
gtk_recent_filter_add_application (filter, "parlatype");
gtk_recent_filter_add_mime_type (filter, "audio/*");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (dialog), filter);
filter_all = gtk_recent_filter_new ();
gtk_recent_filter_set_name (filter_all, _("All files"));
gtk_recent_filter_add_pattern (filter_all, "*");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (dialog), filter_all);
gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (dialog), filter);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
chooser = GTK_RECENT_CHOOSER (dialog);
info = gtk_recent_chooser_get_current_item (chooser);
uri = gtk_recent_info_get_uri (info);
}
gtk_widget_destroy (dialog);
if (uri) {
/* GStreamer has problems with uris from recent chooser,
as a workaround use GFile magic */
GFile *file = g_file_new_for_uri (uri);
gchar *tmp = g_file_get_uri (file);
pt_window_open_file (PT_WINDOW (win), tmp);
g_free (tmp);
g_object_unref (file);
gtk_recent_info_unref (info);
}
}
/*
* GdauiDsnEditor class implementation
*/
static void
_changed_cb (GdauiDsnEditor *config)
{
gboolean can_save = FALSE;
can_save = gdaui_dsn_editor_has_been_changed (config);
GtkWindow *win;
win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ()));
GAction *action;
action = g_action_map_lookup_action (G_ACTION_MAP (win), "DSNReset");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_save);
}
static void
about_activated (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *app;
GeditWindow *window;
app = GTK_APPLICATION (user_data);
window = GEDIT_WINDOW (gtk_application_get_active_window (app));
_gedit_cmd_help_about (NULL, window);
}
static void
preferences_activated (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *app;
GeditWindow *window;
app = GTK_APPLICATION (user_data);
window = GEDIT_WINDOW (gtk_application_get_active_window (app));
gedit_show_preferences_dialog (window);
}
static void
gbp_greeter_application_addin_activate (IdeApplicationAddin *addin,
IdeApplication *app)
{
GtkWindow *window;
g_assert (IDE_IS_MAIN_THREAD ());
g_assert (GBP_IS_GREETER_APPLICATION_ADDIN (addin));
g_assert (IDE_IS_APPLICATION (app));
if (!(window = gtk_application_get_active_window (GTK_APPLICATION (app))))
present_greeter_with_surface (NULL, NULL, addin);
}
static void
action_enter_location (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *application = user_data;
NautilusWindow *window;
GtkWindow *cur_window;
cur_window = gtk_application_get_active_window (application);
window = NAUTILUS_WINDOW (cur_window);
nautilus_window_ensure_location_entry (window);
}
static void
app_menu_quit_cb (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *application = user_data;
GtkWindow *window;
window = gtk_application_get_active_window (application);
if (TERMINAL_IS_WINDOW (window))
terminal_window_request_close (TERMINAL_WINDOW (window));
else /* a dialogue */
gtk_widget_destroy (GTK_WIDGET (window));
}
static void
app_menu_preferences_cb (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
TerminalApp *app = user_data;
GtkWindow *window;
window = gtk_application_get_active_window (GTK_APPLICATION (app));
if (!TERMINAL_IS_WINDOW (window))
return;
terminal_app_edit_preferences (app, window);
}
static void
open_cb (GSimpleAction *action,
GVariant *parameter,
gpointer app)
{
GtkWidget *dialog;
GtkWindow *win;
const char *home_path;
GFile *home;
GtkFileFilter *filter_audio;
GtkFileFilter *filter_all;
gchar *uri = NULL;
win = gtk_application_get_active_window (app);
dialog = gtk_file_chooser_dialog_new (
_("Open Audio File"),
win,
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
/* Set current folder to user's home directory */
home_path = g_get_home_dir ();
home = g_file_new_for_path (home_path);
gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (dialog), home, NULL);
filter_audio = gtk_file_filter_new ();
filter_all = gtk_file_filter_new ();
gtk_file_filter_set_name (filter_audio, _("Audio files"));
gtk_file_filter_set_name (filter_all, _("All files"));
gtk_file_filter_add_mime_type (filter_audio, "audio/*");
gtk_file_filter_add_pattern (filter_all, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_audio);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_all);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter_audio);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
}
g_object_unref (home);
gtk_widget_destroy (dialog);
if (uri) {
pt_window_open_file (PT_WINDOW (win), uri);
g_free (uri);
}
}
static void
action_new_window (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *application = user_data;
NautilusWindow *window;
GtkWindow *cur_window;
cur_window = gtk_application_get_active_window (application);
window = nautilus_application_create_window (NAUTILUS_APPLICATION (application),
cur_window ?
gtk_window_get_screen (cur_window) :
gdk_screen_get_default ());
nautilus_window_slot_go_home (nautilus_window_get_active_slot (window), 0);
}
static void
action_search (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *application = user_data;
const gchar *string, *uri;
NautilusQuery *query;
NautilusDirectory *directory;
gchar *search_uri;
NautilusWindow *window;
GtkWindow *cur_window;
GFile *location;
g_variant_get (parameter, "(ss)", &uri, &string);
if (strlen (string) == 0 ||
strlen (uri) == 0) {
return;
}
query = nautilus_query_new ();
nautilus_query_set_location (query, uri);
nautilus_query_set_text (query, string);
search_uri = nautilus_search_directory_generate_new_uri ();
location = g_file_new_for_uri (search_uri);
g_free (search_uri);
directory = nautilus_directory_get (location);
nautilus_search_directory_set_query (NAUTILUS_SEARCH_DIRECTORY (directory), query);
cur_window = gtk_application_get_active_window (application);
window = nautilus_application_create_window (NAUTILUS_APPLICATION (application),
cur_window ?
gtk_window_get_screen (cur_window) :
gdk_screen_get_default ());
nautilus_window_slot_open_location (nautilus_window_get_active_slot (window), location, 0);
nautilus_directory_unref (directory);
g_object_unref (query);
g_object_unref (location);
}
static gboolean
ide_terminal_button_press_event (GtkWidget *widget,
GdkEventButton *button)
{
IdeTerminal *self = (IdeTerminal *)widget;
g_assert (IDE_IS_TERMINAL (self));
g_assert (button != NULL);
if ((button->type == GDK_BUTTON_PRESS) && (button->button == GDK_BUTTON_SECONDARY))
{
if (!gtk_widget_has_focus (GTK_WIDGET (self)))
gtk_widget_grab_focus (GTK_WIDGET (self));
ide_terminal_do_popup (self, (GdkEvent *)button);
return GDK_EVENT_STOP;
}
else if ((button->type == GDK_BUTTON_PRESS) && (button->button == GDK_BUTTON_PRIMARY)
&& ((button->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK))
{
g_autofree gchar *pattern = NULL;
pattern = vte_terminal_match_check_event (VTE_TERMINAL (self), (GdkEvent *)button, NULL);
if (pattern != NULL)
{
GtkApplication *app;
GtkWindow *focused_window;
if (NULL != (app = GTK_APPLICATION (g_application_get_default ())) &&
NULL != (focused_window = gtk_application_get_active_window (app)))
gtk_show_uri_on_window (focused_window,
pattern,
gtk_get_current_event_time (),
NULL);
}
return GDK_EVENT_STOP;
}
return GTK_WIDGET_CLASS (ide_terminal_parent_class)->button_press_event (widget, button);
}
static void
ag_app_import_file(AgApp *app, GFile *file, AgAppImportType type)
{
GtkWidget *window;
AgChart *chart;
GError *err = NULL;
switch (type) {
case AG_APP_IMPORT_AGC:
chart = ag_chart_load_from_agc(file, &err);
break;
case AG_APP_IMPORT_HOR:
chart = ag_chart_load_from_placidus_file(file, &err);
break;
default:
g_error("Unknown import type!");
break;
}
if (chart == NULL) {
ag_app_message_dialog(
gtk_application_get_active_window(GTK_APPLICATION(app)),
GTK_MESSAGE_ERROR,
"Error while loading: %s",
err->message
);
return;
}
window = ag_app_get_usable_window(app);
ag_window_set_chart(AG_WINDOW(window), chart);
ag_window_update_from_chart(AG_WINDOW(window));
g_action_group_activate_action(G_ACTION_GROUP(window), "save", NULL);
ag_window_change_tab(AG_WINDOW(window), "chart");
gtk_window_present(GTK_WINDOW(window));
}
static void
pt_app_open (GApplication *app,
GFile **files,
gint n_files,
const gchar *hint)
{
GtkWindow *win;
gchar *uri;
pt_app_activate (app);
win = gtk_application_get_active_window (GTK_APPLICATION (app));
if (n_files > 1) {
g_print (_("Warning: Parlatype handles only one file at a time. The other files are ignored.\n"));
}
uri = g_file_get_uri (files[0]);
pt_window_open_file (PT_WINDOW (win), uri);
g_free (uri);
}
static void
on_connect_server_response (GtkDialog *dialog,
int response,
GtkApplication *application)
{
if (response == GTK_RESPONSE_OK) {
GFile *location;
NautilusWindow *window = NAUTILUS_WINDOW (gtk_application_get_active_window (application));
location = nautilus_connect_server_dialog_get_location (NAUTILUS_CONNECT_SERVER_DIALOG (dialog));
if (location != NULL) {
nautilus_window_slot_open_location_full (nautilus_window_get_active_slot (window),
location,
NAUTILUS_WINDOW_OPEN_FLAG_USE_DEFAULT_LOCATION,
NULL, go_to_server_cb, application);
}
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}