diff options
Diffstat (limited to 'src/rcw.c')
| -rw-r--r-- | src/rcw.c | 4812 |
1 files changed, 4812 insertions, 0 deletions
diff --git a/src/rcw.c b/src/rcw.c new file mode 100644 index 0000000..8d00965 --- /dev/null +++ b/src/rcw.c @@ -0,0 +1,4812 @@ +/* + * Remmina - The GTK+ Remote Desktop Client + * Copyright (C) 2009-2011 Vic Lee + * Copyright (C) 2014-2015 Antenore Gatta, Fabio Castelli, Giovanni Panozzo + * Copyright (C) 2016-2023 Antenore Gatta, Giovanni Panozzo + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * In addition, as a special exception, the copyright holders give + * permission to link the code of portions of this program with the + * OpenSSL library under certain conditions as described in each + * individual source file, and distribute linked combinations + * including the two. + * You must obey the GNU General Public License in all respects + * for all of the code used other than OpenSSL. * If you modify + * file(s) with this exception, you may extend this exception to your + * version of the file(s), but you are not obligated to do so. * If you + * do not wish to do so, delete this exception statement from your + * version. * If you delete this exception statement from all source + * files in the program, then also delete it here. + * + */ + + +#include "config.h" + +#ifdef GDK_WINDOWING_X11 +#include <cairo/cairo-xlib.h> +#else +#include <cairo/cairo.h> +#endif +#include <gdk/gdk.h> +#include <gdk/gdkkeysyms.h> +#include <glib/gi18n.h> +#include <stdlib.h> + +#include "remmina.h" +#include "remmina_main.h" +#include "rcw.h" +#include "remmina_applet_menu_item.h" +#include "remmina_applet_menu.h" +#include "remmina_file.h" +#include "remmina_file_manager.h" +#include "remmina_log.h" +#include "remmina_message_panel.h" +#include "remmina_ext_exec.h" +#include "remmina_plugin_manager.h" +#include "remmina_pref.h" +#include "remmina_protocol_widget.h" +#include "remmina_public.h" +#include "remmina_scrolled_viewport.h" +#include "remmina_unlock.h" +#include "remmina_utils.h" +#include "remmina_widget_pool.h" +#include "remmina/remmina_trace_calls.h" + +#ifdef GDK_WINDOWING_WAYLAND +#include <gdk/gdkwayland.h> +#endif + + +#define DEBUG_KB_GRABBING 0 +#include "remmina_exec.h" + +gchar *remmina_pref_file; +RemminaPref remmina_pref; + +G_DEFINE_TYPE(RemminaConnectionWindow, rcw, GTK_TYPE_WINDOW) + +#define MOTION_TIME 100 + +/* default timeout used to hide the floating toolbar when switching profile */ +#define TB_HIDE_TIME_TIME 1500 + +#define FULL_SCREEN_TARGET_MONITOR_UNDEFINED -1 + +struct _RemminaConnectionWindowPriv { + GtkNotebook * notebook; + GtkWidget * floating_toolbar_widget; + GtkWidget * overlay; + GtkWidget * revealer; + GtkWidget * overlay_ftb_overlay; + GtkWidget * overlay_ftb_fr; + + GtkWidget * floating_toolbar_label; + gdouble floating_toolbar_opacity; + + /* Various delayed and timer event source ids */ + guint acs_eventsourceid; // timeout + guint spf_eventsourceid; // idle + guint grab_retry_eventsourceid; // timeout + guint delayed_grab_eventsourceid; + guint ftb_hide_eventsource; // timeout + guint tar_eventsource; // timeout + guint hidetb_eventsource; // timeout + guint dwp_eventsourceid; // timeout + + GtkWidget * toolbar; + GtkWidget * grid; + + /* Toolitems that need to be handled */ + GtkToolItem * toolitem_menu; + GtkToolItem * toolitem_autofit; + GtkToolItem * toolitem_fullscreen; + GtkToolItem * toolitem_switch_page; + GtkToolItem * toolitem_dynres; + GtkToolItem * toolitem_scale; + GtkToolItem * toolitem_grab; + GtkToolItem * toolitem_multimon; + GtkToolItem * toolitem_preferences; + GtkToolItem * toolitem_tools; + GtkToolItem * toolitem_new; + GtkToolItem * toolitem_duplicate; + GtkToolItem * toolitem_screenshot; + GtkWidget * fullscreen_option_button; + GtkWidget * fullscreen_scaler_button; + GtkWidget * scaler_option_button; + + GtkWidget * pin_button; + gboolean pin_down; + + gboolean sticky; + + /* Flag to turn off toolbar signal handling when toolbar is + * reconfiguring, usually due to a tab switch */ + gboolean toolbar_is_reconfiguring; + + /* This is the current view mode, i.e. VIEWPORT_FULLSCREEN_MODE, + * as saved on the "viwemode" profile preference file */ + gint view_mode; + + /* Status variables used when in fullscreen mode. Needed + * to restore a fullscreen mode after coming from scrolled */ + gint fss_view_mode; + /* Status variables used when in scrolled window mode. Needed + * to restore a scrolled window mode after coming from fullscreen */ + gint ss_width, ss_height; + gboolean ss_maximized; + + gboolean kbcaptured; + gboolean pointer_captured; + gboolean hostkey_activated; + gboolean hostkey_used; + + gboolean pointer_entered; + + RemminaConnectionWindowOnDeleteConfirmMode on_delete_confirm_mode; +}; + +typedef struct _RemminaConnectionObject { + RemminaConnectionWindow * cnnwin; + RemminaFile * remmina_file; + + GtkWidget * proto; + GtkWidget * aspectframe; + GtkWidget * viewport; + + GtkWidget * scrolled_container; + + gboolean plugin_can_scale; + + gboolean connected; + gboolean dynres_unlocked; + + gulong deferred_open_size_allocate_handler; +} RemminaConnectionObject; + +enum { + TOOLBARPLACE_SIGNAL, + LAST_SIGNAL +}; + +static guint rcw_signals[LAST_SIGNAL] = +{ 0 }; + +static RemminaConnectionWindow *rcw_create_scrolled(gint width, gint height, gboolean maximize); +static RemminaConnectionWindow *rcw_create_fullscreen(GtkWindow *old, gint view_mode); +static gboolean rcw_hostkey_func(RemminaProtocolWidget *gp, guint keyval, gboolean release); +static GtkWidget *rco_create_tab_page(RemminaConnectionObject *cnnobj); +static GtkWidget *rco_create_tab_label(RemminaConnectionObject *cnnobj); + +void rcw_grab_focus(RemminaConnectionWindow *cnnwin); +static GtkWidget *rcw_create_toolbar(RemminaConnectionWindow *cnnwin, gint mode); +static void rcw_place_toolbar(GtkToolbar *toolbar, GtkGrid *grid, GtkWidget *sibling, int toolbar_placement); +static void rco_update_toolbar(RemminaConnectionObject *cnnobj); +static void rcw_keyboard_grab(RemminaConnectionWindow *cnnwin); +static GtkWidget *rcw_append_new_page(RemminaConnectionWindow *cnnwin, RemminaConnectionObject *cnnobj); + + +static void rcw_ftb_drag_begin(GtkWidget *widget, GdkDragContext *context, gpointer user_data); + +static const GtkTargetEntry dnd_targets_ftb[] = +{ + { + (char *)"text/x-remmina-ftb", + GTK_TARGET_SAME_APP | GTK_TARGET_OTHER_WIDGET, + 0 + }, +}; + +static const GtkTargetEntry dnd_targets_tb[] = +{ + { + (char *)"text/x-remmina-tb", + GTK_TARGET_SAME_APP, + 0 + }, +}; + +static void rcw_class_init(RemminaConnectionWindowClass *klass) +{ + TRACE_CALL(__func__); + GtkCssProvider *provider; + + provider = gtk_css_provider_new(); + + /* It’s important to remove padding, border and shadow from GtkViewport or + * we will never know its internal area size, because GtkViweport::viewport_get_view_allocation, + * which returns the internal size of the GtkViewport, is private and we cannot access it */ + +#if GTK_CHECK_VERSION(3, 14, 0) + gtk_css_provider_load_from_data(provider, + "#remmina-cw-viewport, #remmina-cw-aspectframe {\n" + " padding:0;\n" + " border:0;\n" + " background-color: black;\n" + "}\n" + "GtkDrawingArea {\n" + "}\n" + "GtkToolbar {\n" + " -GtkWidget-window-dragging: 0;\n" + "}\n" + "#remmina-connection-window-fullscreen {\n" + " border-color: black;\n" + "}\n" + "#remmina-small-button {\n" + " outline-offset: 0;\n" + " outline-width: 0;\n" + " padding: 0;\n" + " border: 0;\n" + "}\n" + "#remmina-pin-button {\n" + " outline-offset: 0;\n" + " outline-width: 0;\n" + " padding: 2px;\n" + " border: 0;\n" + "}\n" + "#remmina-tab-page {\n" + " background-color: black;\n" + "}\n" + "#remmina-scrolled-container {\n" + "}\n" + "#remmina-scrolled-container.undershoot {\n" + " background: none;\n" + "}\n" + "#remmina-tab-page {\n" + "}\n" + "#ftbbox-upper {\n" + " background-color: white;\n" + " color: black;\n" + " border-style: none solid solid solid;\n" + " border-width: 1px;\n" + " border-radius: 4px;\n" + " padding: 0px;\n" + "}\n" + "#ftbbox-lower {\n" + " background-color: white;\n" + " color: black;\n" + " border-style: solid solid none solid;\n" + " border-width: 1px;\n" + " border-radius: 4px;\n" + " padding: 0px;\n" + "}\n" + "#ftb-handle {\n" + "}\n" + ".message_panel {\n" + " border: 0px solid;\n" + " padding: 20px 20px 20px 20px;\n" + "}\n" + ".message_panel entry {\n" + " background-image: none;\n" + " border-width: 4px;\n" + " border-radius: 8px;\n" + "}\n" + ".message_panel .title_label {\n" + " font-size: 2em; \n" + "}\n" + , -1, NULL); + +#else + gtk_css_provider_load_from_data(provider, + "#remmina-cw-viewport, #remmina-cw-aspectframe {\n" + " padding:0;\n" + " border:0;\n" + " background-color: black;\n" + "}\n" + "#remmina-cw-message-panel {\n" + "}\n" + "GtkDrawingArea {\n" + "}\n" + "GtkToolbar {\n" + " -GtkWidget-window-dragging: 0;\n" + "}\n" + "#remmina-connection-window-fullscreen {\n" + " border-color: black;\n" + "}\n" + "#remmina-small-button {\n" + " -GtkWidget-focus-padding: 0;\n" + " -GtkWidget-focus-line-width: 0;\n" + " padding: 0;\n" + " border: 0;\n" + "}\n" + "#remmina-pin-button {\n" + " -GtkWidget-focus-padding: 0;\n" + " -GtkWidget-focus-line-width: 0;\n" + " padding: 2px;\n" + " border: 0;\n" + "}\n" + "#remmina-scrolled-container {\n" + "}\n" + "#remmina-scrolled-container.undershoot {\n" + " background: none\n" + "}\n" + "#remmina-tab-page {\n" + "}\n" + "#ftbbox-upper {\n" + " border-style: none solid solid solid;\n" + " border-width: 1px;\n" + " border-radius: 4px;\n" + " padding: 0px;\n" + "}\n" + "#ftbbox-lower {\n" + " border-style: solid solid none solid;\n" + " border-width: 1px;\n" + " border-radius: 4px;\n" + " padding: 0px;\n" + "}\n" + "#ftb-handle {\n" + "}\n" + + , -1, NULL); +#endif + + gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), + GTK_STYLE_PROVIDER(provider), + GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); + + g_object_unref(provider); + + /* Define a signal used to notify all rcws of toolbar move */ + rcw_signals[TOOLBARPLACE_SIGNAL] = g_signal_new("toolbar-place", G_TYPE_FROM_CLASS(klass), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaConnectionWindowClass, toolbar_place), NULL, NULL, + g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); +} + +static RemminaConnectionObject *rcw_get_cnnobj_at_page(RemminaConnectionWindow *cnnwin, gint npage) +{ + GtkWidget *po; + + if (!cnnwin->priv->notebook) + return NULL; + po = gtk_notebook_get_nth_page(GTK_NOTEBOOK(cnnwin->priv->notebook), npage); + return g_object_get_data(G_OBJECT(po), "cnnobj"); +} + +static RemminaConnectionObject *rcw_get_visible_cnnobj(RemminaConnectionWindow *cnnwin) +{ + gint np; + + if (cnnwin != NULL && cnnwin->priv != NULL && cnnwin->priv->notebook != NULL) { + np = gtk_notebook_get_current_page(GTK_NOTEBOOK(cnnwin->priv->notebook)); + if (np < 0) + return NULL; + return rcw_get_cnnobj_at_page(cnnwin, np); + } else { + return NULL; + } +} + +static RemminaScaleMode get_current_allowed_scale_mode(RemminaConnectionObject *cnnobj, gboolean *dynres_avail, gboolean *scale_avail) +{ + TRACE_CALL(__func__); + RemminaScaleMode scalemode; + gboolean plugin_has_dynres, plugin_can_scale; + + scalemode = remmina_protocol_widget_get_current_scale_mode(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + + plugin_has_dynres = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + REMMINA_PROTOCOL_FEATURE_TYPE_DYNRESUPDATE); + + plugin_can_scale = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + REMMINA_PROTOCOL_FEATURE_TYPE_SCALE); + + /* Forbid scalemode REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES when not possible */ + if ((!plugin_has_dynres) && scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES) + scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE; + + /* Forbid scalemode REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED when not possible */ + if (!plugin_can_scale && scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED) + scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE; + + if (scale_avail) + *scale_avail = plugin_can_scale; + if (dynres_avail) + *dynres_avail = (plugin_has_dynres && cnnobj->dynres_unlocked); + + return scalemode; +} + +static void rco_disconnect_current_page(RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + + /* Disconnects the connection which is currently in view in the notebook */ + remmina_protocol_widget_close_connection(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); +} + +static void rcw_kp_ungrab(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + GdkDisplay *display; + +#if GTK_CHECK_VERSION(3, 20, 0) + GdkSeat *seat; +#else + GdkDeviceManager *manager; + GdkDevice *keyboard = NULL; +#endif + + if (cnnwin->priv->grab_retry_eventsourceid) { + g_source_remove(cnnwin->priv->grab_retry_eventsourceid); + cnnwin->priv->grab_retry_eventsourceid = 0; + } + if (cnnwin->priv->delayed_grab_eventsourceid) { + g_source_remove(cnnwin->priv->delayed_grab_eventsourceid); + cnnwin->priv->delayed_grab_eventsourceid = 0; + } + + display = gtk_widget_get_display(GTK_WIDGET(cnnwin)); +#if GTK_CHECK_VERSION(3, 20, 0) + seat = gdk_display_get_default_seat(display); + // keyboard = gdk_seat_get_pointer(seat); +#else + manager = gdk_display_get_device_manager(display); + keyboard = gdk_device_manager_get_client_pointer(manager); +#endif + + if (!cnnwin->priv->kbcaptured && !cnnwin->priv->pointer_captured) + return; + +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: --- ungrabbing\n"); +#endif + + + +#if GTK_CHECK_VERSION(3, 20, 0) + /* We can use gtk_seat_grab()/_ungrab() only after GTK 3.24 */ + gdk_seat_ungrab(seat); +#else + if (keyboard != NULL) { + if (gdk_device_get_source(keyboard) != GDK_SOURCE_KEYBOARD) + keyboard = gdk_device_get_associated_device(keyboard); + G_GNUC_BEGIN_IGNORE_DEPRECATIONS + gdk_device_ungrab(keyboard, GDK_CURRENT_TIME); + G_GNUC_END_IGNORE_DEPRECATIONS + } +#endif + cnnwin->priv->kbcaptured = FALSE; + cnnwin->priv->pointer_captured = FALSE; +} + +static gboolean rcw_keyboard_grab_retry(gpointer user_data) +{ + TRACE_CALL(__func__); + RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)user_data; + +#if DEBUG_KB_GRABBING + printf("%s retry grab\n", __func__); +#endif + rcw_keyboard_grab(cnnwin); + cnnwin->priv->grab_retry_eventsourceid = 0; + return G_SOURCE_REMOVE; +} + +static void rcw_pointer_ungrab(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); +#if GTK_CHECK_VERSION(3, 20, 0) + GdkSeat *seat; + GdkDisplay *display; + if (!cnnwin->priv->pointer_captured) + return; + + display = gtk_widget_get_display(GTK_WIDGET(cnnwin)); + seat = gdk_display_get_default_seat(display); + gdk_seat_ungrab(seat); +#endif +} + +static void rcw_pointer_grab(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + /* This function in Wayland is useless and generates a spurious leave-notify event. + * Should we remove it ? https://gitlab.gnome.org/GNOME/mutter/-/issues/2450#note_1588081 */ +#if GTK_CHECK_VERSION(3, 20, 0) + GdkSeat *seat; + GdkDisplay *display; + GdkGrabStatus ggs; + + + if (cnnwin->priv->pointer_captured) { +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: pointer_captured is true, it should not\n"); +#endif + return; + } + + display = gtk_widget_get_display(GTK_WIDGET(cnnwin)); + seat = gdk_display_get_default_seat(display); + ggs = gdk_seat_grab(seat, gtk_widget_get_window(GTK_WIDGET(cnnwin)), + GDK_SEAT_CAPABILITY_ALL_POINTING, TRUE, NULL, NULL, NULL, NULL); + if (ggs != GDK_GRAB_SUCCESS) { +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: GRAB of POINTER failed. GdkGrabStatus: %d\n", (int)ggs); +#endif + } else { + cnnwin->priv->pointer_captured = TRUE; + } + +#endif +} + +static void rcw_keyboard_grab(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + GdkDisplay *display; + +#if GTK_CHECK_VERSION(3, 20, 0) + GdkSeat *seat; +#else + GdkDeviceManager *manager; +#endif + GdkGrabStatus ggs; + GdkDevice *keyboard = NULL; + + if (cnnwin->priv->kbcaptured) { +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: %s not grabbing because already grabbed.\n", __func__); +#endif + return; + } + + display = gtk_widget_get_display(GTK_WIDGET(cnnwin)); +#if GTK_CHECK_VERSION(3, 20, 0) + seat = gdk_display_get_default_seat(display); + keyboard = gdk_seat_get_pointer(seat); +#else + manager = gdk_display_get_device_manager(display); + keyboard = gdk_device_manager_get_client_pointer(manager); +#endif + + if (keyboard != NULL) { + if (gdk_device_get_source(keyboard) != GDK_SOURCE_KEYBOARD) + keyboard = gdk_device_get_associated_device(keyboard); + + +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: profile asks for grabbing, let’s try.\n"); +#endif + /* Up to GTK version 3.20 we can grab the keyboard with gdk_device_grab(). + * in GTK 3.20 gdk_seat_grab() should be used instead of gdk_device_grab(). + * There is a bug in GTK up to 3.22: When gdk_device_grab() fails + * the widget is hidden: + * https://gitlab.gnome.org/GNOME/gtk/commit/726ad5a5ae7c4f167e8dd454cd7c250821c400ab + * The bugfix will be released with GTK 3.24. + * Also please note that the newer gdk_seat_grab() is still calling gdk_device_grab(). + * + * Warning: gdk_seat_grab() will call XGrabKeyboard() or XIGrabDevice() + * which in turn will generate a core X input event FocusOut and FocusIn + * but not Xinput2 events. + * In some cases, GTK is unable to neutralize FocusIn and FocusOut core + * events (ie: i3wm+Plasma with GDK_CORE_DEVICE_EVENTS=1 because detail=NotifyNonlinear + * instead of detail=NotifyAncestor/detail=NotifyInferior) + * Receiving a FocusOut event for Remmina at this time will cause an infinite loop. + * Therefore is important for GTK to use Xinput2 instead of core X events + * by unsetting GDK_CORE_DEVICE_EVENTS + */ +#if GTK_CHECK_VERSION(3, 20, 0) + ggs = gdk_seat_grab(seat, gtk_widget_get_window(GTK_WIDGET(cnnwin)), + GDK_SEAT_CAPABILITY_KEYBOARD, TRUE, NULL, NULL, NULL, NULL); +#else + ggs = gdk_device_grab(keyboard, gtk_widget_get_window(GTK_WIDGET(cnnwin)), GDK_OWNERSHIP_WINDOW, + TRUE, GDK_KEY_PRESS | GDK_KEY_RELEASE, NULL, GDK_CURRENT_TIME); +#endif + if (ggs != GDK_GRAB_SUCCESS) { +#if DEBUG_KB_GRABBING + printf("GRAB of keyboard failed.\n"); +#endif + /* Reschedule grabbing in half a second if not already done */ + if (cnnwin->priv->grab_retry_eventsourceid == 0) + cnnwin->priv->grab_retry_eventsourceid = g_timeout_add(500, (GSourceFunc)rcw_keyboard_grab_retry, cnnwin); + } else { +#if DEBUG_KB_GRABBING + printf("Keyboard grabbed\n"); +#endif + if (cnnwin->priv->grab_retry_eventsourceid != 0) { + g_source_remove(cnnwin->priv->grab_retry_eventsourceid); + cnnwin->priv->grab_retry_eventsourceid = 0; + } + cnnwin->priv->kbcaptured = TRUE; + } + } else { + rcw_kp_ungrab(cnnwin); + } +} + +static void rcw_close_all_connections(RemminaConnectionWindow *cnnwin) +{ + RemminaConnectionWindowPriv *priv = cnnwin->priv; + GtkNotebook *notebook = GTK_NOTEBOOK(priv->notebook); + GtkWidget *w; + RemminaConnectionObject *cnnobj; + gint i, n; + + if (GTK_IS_WIDGET(notebook)) { + n = gtk_notebook_get_n_pages(notebook); + for (i = n - 1; i >= 0; i--) { + w = gtk_notebook_get_nth_page(notebook, i); + cnnobj = (RemminaConnectionObject *)g_object_get_data(G_OBJECT(w), "cnnobj"); + /* Do close the connection on this tab */ + remmina_protocol_widget_close_connection(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + } + } +} + +gboolean rcw_delete(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + GtkNotebook *notebook = GTK_NOTEBOOK(priv->notebook); + GtkWidget *dialog; + gint i, n, nopen; + + if (!REMMINA_IS_CONNECTION_WINDOW(cnnwin)) + return TRUE; + + if (cnnwin->priv->on_delete_confirm_mode != RCW_ONDELETE_NOCONFIRM) { + n = gtk_notebook_get_n_pages(notebook); + nopen = 0; + /* count all non-closed connections */ + for(i = 0; i < n; i ++) { + RemminaConnectionObject *cnnobj = rcw_get_cnnobj_at_page(cnnwin, i); + if (!remmina_protocol_widget_is_closed((RemminaProtocolWidget *)cnnobj->proto)) + nopen ++; + } + if (nopen > 1) { + dialog = gtk_message_dialog_new(GTK_WINDOW(cnnwin), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, + GTK_BUTTONS_YES_NO, + _("Are you sure you want to close %i active connections in the current window?"), nopen); + i = gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); + if (i != GTK_RESPONSE_YES) + return FALSE; + } + else if (nopen == 1) { + if (remmina_pref.confirm_close) { + dialog = gtk_message_dialog_new(GTK_WINDOW(cnnwin), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, + GTK_BUTTONS_YES_NO, + _("Are you sure you want to close this last active connection?")); + i = gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); + if (i != GTK_RESPONSE_YES) + return FALSE; + } + } + } + rcw_close_all_connections(cnnwin); + + return TRUE; +} + +static gboolean rcw_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data) +{ + TRACE_CALL(__func__); + rcw_delete(RCW(widget)); + return TRUE; +} + +static void rcw_destroy(GtkWidget *widget, gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv; + RemminaConnectionWindow *cnnwin; + + if (!REMMINA_IS_CONNECTION_WINDOW(widget)) + return; + + cnnwin = (RemminaConnectionWindow *)widget; + priv = cnnwin->priv; + + if (priv->kbcaptured) + rcw_kp_ungrab(cnnwin); + + if (priv->acs_eventsourceid) { + g_source_remove(priv->acs_eventsourceid); + priv->acs_eventsourceid = 0; + } + if (priv->spf_eventsourceid) { + g_source_remove(priv->spf_eventsourceid); + priv->spf_eventsourceid = 0; + } + if (priv->grab_retry_eventsourceid) { + g_source_remove(priv->grab_retry_eventsourceid); + priv->grab_retry_eventsourceid = 0; + } + if (cnnwin->priv->delayed_grab_eventsourceid) { + g_source_remove(cnnwin->priv->delayed_grab_eventsourceid); + cnnwin->priv->delayed_grab_eventsourceid = 0; + } + if (priv->ftb_hide_eventsource) { + g_source_remove(priv->ftb_hide_eventsource); + priv->ftb_hide_eventsource = 0; + } + if (priv->tar_eventsource) { + g_source_remove(priv->tar_eventsource); + priv->tar_eventsource = 0; + } + if (priv->hidetb_eventsource) { + g_source_remove(priv->hidetb_eventsource); + priv->hidetb_eventsource = 0; + } + if (priv->dwp_eventsourceid) { + g_source_remove(priv->dwp_eventsourceid); + priv->dwp_eventsourceid = 0; + } + + /* There is no need to destroy priv->floating_toolbar_widget, + * because it’s our child and will be destroyed automatically */ + + cnnwin->priv = NULL; + g_free(priv); +} + +gboolean rcw_notify_widget_toolbar_placement(GtkWidget *widget, gpointer data) +{ + TRACE_CALL(__func__); + GType rcwtype; + + rcwtype = rcw_get_type(); + if (G_TYPE_CHECK_INSTANCE_TYPE(widget, rcwtype)) { + g_signal_emit_by_name(G_OBJECT(widget), "toolbar-place"); + return TRUE; + } + return FALSE; +} + +static gboolean rcw_tb_drag_failed(GtkWidget *widget, GdkDragContext *context, + GtkDragResult result, gpointer user_data) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv; + RemminaConnectionWindow *cnnwin; + + + cnnwin = (RemminaConnectionWindow *)user_data; + priv = cnnwin->priv; + + if (priv->toolbar) + gtk_widget_show(GTK_WIDGET(priv->toolbar)); + + return TRUE; +} + +static gboolean rcw_tb_drag_drop(GtkWidget *widget, GdkDragContext *context, + gint x, gint y, guint time, gpointer user_data) +{ + TRACE_CALL(__func__); + GtkAllocation wa; + gint new_toolbar_placement; + RemminaConnectionWindowPriv *priv; + RemminaConnectionWindow *cnnwin; + + cnnwin = (RemminaConnectionWindow *)user_data; + priv = cnnwin->priv; + + gtk_widget_get_allocation(widget, &wa); + + if (wa.width * y >= wa.height * x) { + if (wa.width * y > wa.height * (wa.width - x)) + new_toolbar_placement = TOOLBAR_PLACEMENT_BOTTOM; + else + new_toolbar_placement = TOOLBAR_PLACEMENT_LEFT; + } else { + if (wa.width * y > wa.height * (wa.width - x)) + new_toolbar_placement = TOOLBAR_PLACEMENT_RIGHT; + else + new_toolbar_placement = TOOLBAR_PLACEMENT_TOP; + } + + gtk_drag_finish(context, TRUE, TRUE, time); + + if (new_toolbar_placement != remmina_pref.toolbar_placement) { + /* Save new position */ + remmina_pref.toolbar_placement = new_toolbar_placement; + remmina_pref_save(); + + /* Signal all windows that the toolbar must be moved */ + remmina_widget_pool_foreach(rcw_notify_widget_toolbar_placement, NULL); + } + if (priv->toolbar) + gtk_widget_show(GTK_WIDGET(priv->toolbar)); + + return TRUE; +} + +static void rcw_tb_drag_begin(GtkWidget *widget, GdkDragContext *context, gpointer user_data) +{ + TRACE_CALL(__func__); + + cairo_surface_t *surface; + cairo_t *cr; + GtkAllocation wa; + double dashes[] = { 10 }; + + gtk_widget_get_allocation(widget, &wa); + + surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 16, 16); + cr = cairo_create(surface); + cairo_set_source_rgb(cr, 0.6, 0.6, 0.6); + cairo_set_line_width(cr, 4); + cairo_set_dash(cr, dashes, 1, 0); + cairo_rectangle(cr, 0, 0, 16, 16); + cairo_stroke(cr); + cairo_destroy(cr); + + gtk_widget_hide(widget); + + gtk_drag_set_icon_surface(context, surface); +} + +void rcw_update_toolbar_opacity(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + RemminaConnectionObject *cnnobj; + + cnnobj = rcw_get_visible_cnnobj(cnnwin); + if (!cnnobj) return; + + priv->floating_toolbar_opacity = (1.0 - TOOLBAR_OPACITY_MIN) / ((gdouble)TOOLBAR_OPACITY_LEVEL) + * ((gdouble)(TOOLBAR_OPACITY_LEVEL - remmina_file_get_int(cnnobj->remmina_file, "toolbar_opacity", 0))) + + TOOLBAR_OPACITY_MIN; + if (priv->floating_toolbar_widget) + gtk_widget_set_opacity(GTK_WIDGET(priv->overlay_ftb_overlay), priv->floating_toolbar_opacity); +} + +static gboolean rcw_floating_toolbar_make_invisible(gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = (RemminaConnectionWindowPriv *)data; + + gtk_widget_set_opacity(GTK_WIDGET(priv->overlay_ftb_overlay), 0.0); + priv->ftb_hide_eventsource = 0; + return G_SOURCE_REMOVE; +} + +static void rcw_floating_toolbar_show(RemminaConnectionWindow *cnnwin, gboolean show) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + + if (priv->floating_toolbar_widget == NULL) + return; + + if (show || priv->pin_down) { + /* Make the FTB no longer transparent, in case we have an hidden toolbar */ + rcw_update_toolbar_opacity(cnnwin); + /* Remove outstanding hide events, if not yet active */ + if (priv->ftb_hide_eventsource) { + g_source_remove(priv->ftb_hide_eventsource); + priv->ftb_hide_eventsource = 0; + } + } else { + /* If we are hiding and the toolbar must be made invisible, schedule + * a later toolbar hide */ + if (remmina_pref.fullscreen_toolbar_visibility == FLOATING_TOOLBAR_VISIBILITY_INVISIBLE) + if (priv->ftb_hide_eventsource == 0) + priv->ftb_hide_eventsource = g_timeout_add(1000, rcw_floating_toolbar_make_invisible, priv); + } + + gtk_revealer_set_reveal_child(GTK_REVEALER(priv->revealer), show || priv->pin_down); +} + +static void rco_get_desktop_size(RemminaConnectionObject *cnnobj, gint *width, gint *height) +{ + TRACE_CALL(__func__); + RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto); + + + *width = remmina_protocol_widget_get_width(gp); + *height = remmina_protocol_widget_get_height(gp); + if (*width == 0) { + /* Before connecting we do not have real remote width/height, + * so we ask profile values */ + *width = remmina_protocol_widget_get_profile_remote_width(gp); + *height = remmina_protocol_widget_get_profile_remote_height(gp); + } +} + +void rco_set_scrolled_policy(RemminaScaleMode scalemode, GtkScrolledWindow *scrolled_window) +{ + TRACE_CALL(__func__); + + gtk_scrolled_window_set_policy(scrolled_window, + scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED ? GTK_POLICY_NEVER : GTK_POLICY_AUTOMATIC, + scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED ? GTK_POLICY_NEVER : GTK_POLICY_AUTOMATIC); +} + +static GtkWidget *rco_create_scrolled_container(RemminaScaleMode scalemode, int view_mode) +{ + GtkWidget *scrolled_container; + + if (view_mode == VIEWPORT_FULLSCREEN_MODE) { + scrolled_container = remmina_scrolled_viewport_new(); + } else { + scrolled_container = gtk_scrolled_window_new(NULL, NULL); + rco_set_scrolled_policy(scalemode, GTK_SCROLLED_WINDOW(scrolled_container)); + gtk_container_set_border_width(GTK_CONTAINER(scrolled_container), 0); + gtk_widget_set_can_focus(scrolled_container, FALSE); + } + + gtk_widget_set_name(scrolled_container, "remmina-scrolled-container"); + gtk_widget_show(scrolled_container); + + return scrolled_container; +} + +gboolean rcw_toolbar_autofit_restore(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + + RemminaConnectionWindowPriv *priv = cnnwin->priv; + RemminaConnectionObject *cnnobj; + gint dwidth, dheight; + GtkAllocation nba, ca, ta; + + cnnwin->priv->tar_eventsource = 0; + + if (priv->toolbar_is_reconfiguring) + return G_SOURCE_REMOVE; + + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return FALSE; + + if (cnnobj->connected && GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) { + rco_get_desktop_size(cnnobj, &dwidth, &dheight); + gtk_widget_get_allocation(GTK_WIDGET(priv->notebook), &nba); + gtk_widget_get_allocation(cnnobj->scrolled_container, &ca); + gtk_widget_get_allocation(priv->toolbar, &ta); + if (remmina_pref.toolbar_placement == TOOLBAR_PLACEMENT_LEFT || + remmina_pref.toolbar_placement == TOOLBAR_PLACEMENT_RIGHT) + gtk_window_resize(GTK_WINDOW(cnnobj->cnnwin), MAX(1, dwidth + ta.width + nba.width - ca.width), + MAX(1, dheight + nba.height - ca.height)); + else + gtk_window_resize(GTK_WINDOW(cnnobj->cnnwin), MAX(1, dwidth + nba.width - ca.width), + MAX(1, dheight + ta.height + nba.height - ca.height)); + gtk_container_check_resize(GTK_CONTAINER(cnnobj->cnnwin)); + } + if (GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) { + RemminaScaleMode scalemode = get_current_allowed_scale_mode(cnnobj, NULL, NULL); + rco_set_scrolled_policy(scalemode, GTK_SCROLLED_WINDOW(cnnobj->scrolled_container)); + } + + return G_SOURCE_REMOVE; +} + +static void rcw_toolbar_autofit(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + if (GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) { + if ((gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(cnnwin))) & GDK_WINDOW_STATE_MAXIMIZED) != 0) + gtk_window_unmaximize(GTK_WINDOW(cnnwin)); + + /* It’s tricky to make the toolbars disappear automatically, while keeping scrollable. + * Please tell me if you know a better way to do this */ + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container), GTK_POLICY_NEVER, GTK_POLICY_NEVER); + + cnnwin->priv->tar_eventsource = g_timeout_add(200, (GSourceFunc)rcw_toolbar_autofit_restore, cnnwin); + } +} + +void rco_get_monitor_geometry(RemminaConnectionObject *cnnobj, GdkRectangle *sz) +{ + TRACE_CALL(__func__); + + /* Fill sz with the monitor (or workarea) size and position + * of the monitor (or workarea) where cnnobj->cnnwin is located */ + + GdkRectangle monitor_geometry; + + sz->x = sz->y = sz->width = sz->height = 0; + + if (!cnnobj) + return; + if (!cnnobj->cnnwin) + return; + if (!gtk_widget_is_visible(GTK_WIDGET(cnnobj->cnnwin))) + return; + +#if GTK_CHECK_VERSION(3, 22, 0) + GdkDisplay *display; + GdkMonitor *monitor; + display = gtk_widget_get_display(GTK_WIDGET(cnnobj->cnnwin)); + monitor = gdk_display_get_monitor_at_window(display, gtk_widget_get_window(GTK_WIDGET(cnnobj->cnnwin))); +#else + GdkScreen *screen; + gint monitor; + screen = gtk_window_get_screen(GTK_WINDOW(cnnobj->cnnwin)); + monitor = gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(GTK_WIDGET(cnnobj->cnnwin))); +#endif + +#if GTK_CHECK_VERSION(3, 22, 0) + gdk_monitor_get_workarea(monitor, &monitor_geometry); + /* Under Wayland, GTK 3.22, all values returned by gdk_monitor_get_geometry() + * and gdk_monitor_get_workarea() seem to have been divided by the + * gdk scale factor, so we need to adjust the returned rect + * undoing the division */ +#ifdef GDK_WINDOWING_WAYLAND + if (GDK_IS_WAYLAND_DISPLAY(display)) { + int monitor_scale_factor = gdk_monitor_get_scale_factor(monitor); + monitor_geometry.width *= monitor_scale_factor; + monitor_geometry.height *= monitor_scale_factor; + } +#endif +#elif gdk_screen_get_monitor_workarea + gdk_screen_get_monitor_workarea(screen, monitor, &monitor_geometry); +#else + gdk_screen_get_monitor_geometry(screen, monitor, &monitor_geometry); +#endif + *sz = monitor_geometry; +} + +static void rco_check_resize(RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + gboolean scroll_required = FALSE; + + GdkRectangle monitor_geometry; + gint rd_width, rd_height; + gint bordersz; + gint scalemode; + + scalemode = remmina_protocol_widget_get_current_scale_mode(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + + /* Get remote destkop size */ + rco_get_desktop_size(cnnobj, &rd_width, &rd_height); + + /* Get our monitor size */ + rco_get_monitor_geometry(cnnobj, &monitor_geometry); + + if (!remmina_protocol_widget_get_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)) && + (monitor_geometry.width < rd_width || monitor_geometry.height < rd_height) && + scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE) + scroll_required = TRUE; + + switch (cnnobj->cnnwin->priv->view_mode) { + case SCROLLED_FULLSCREEN_MODE: + gtk_window_resize(GTK_WINDOW(cnnobj->cnnwin), monitor_geometry.width, monitor_geometry.height); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container), + (scroll_required ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER), + (scroll_required ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER)); + break; + + case VIEWPORT_FULLSCREEN_MODE: + bordersz = scroll_required ? SCROLL_BORDER_SIZE : 0; + gtk_window_resize(GTK_WINDOW(cnnobj->cnnwin), monitor_geometry.width, monitor_geometry.height); + if (REMMINA_IS_SCROLLED_VIEWPORT(cnnobj->scrolled_container)) + /* Put a border around Notebook content (RemminaScrolledViewpord), so we can + * move the mouse over the border to scroll */ + gtk_container_set_border_width(GTK_CONTAINER(cnnobj->scrolled_container), bordersz); + + break; + + case SCROLLED_WINDOW_MODE: + if (remmina_file_get_int(cnnobj->remmina_file, "viewmode", UNDEFINED_MODE) == UNDEFINED_MODE) { + /* ToDo: is this really needed ? When ? */ + gtk_window_set_default_size(GTK_WINDOW(cnnobj->cnnwin), + MIN(rd_width, monitor_geometry.width), MIN(rd_height, monitor_geometry.height)); + if (rd_width >= monitor_geometry.width || rd_height >= monitor_geometry.height) { + gtk_window_maximize(GTK_WINDOW(cnnobj->cnnwin)); + remmina_file_set_int(cnnobj->remmina_file, "window_maximize", TRUE); + } else { + rcw_toolbar_autofit(NULL, cnnobj->cnnwin); + remmina_file_set_int(cnnobj->remmina_file, "window_maximize", FALSE); + } + } else { + if (remmina_file_get_int(cnnobj->remmina_file, "window_maximize", FALSE)) + gtk_window_maximize(GTK_WINDOW(cnnobj->cnnwin)); + } + break; + + default: + break; + } +} + +static void rcw_set_tooltip(GtkWidget *item, const gchar *tip, guint key1, guint key2) +{ + TRACE_CALL(__func__); + gchar *s1; + gchar *s2; + + if (remmina_pref.hostkey && key1) { + if (key2) + s1 = g_strdup_printf(" (%s + %s,%s)", gdk_keyval_name(remmina_pref.hostkey), + gdk_keyval_name(gdk_keyval_to_upper(key1)), gdk_keyval_name(gdk_keyval_to_upper(key2))); + else if (key1 == remmina_pref.hostkey) + s1 = g_strdup_printf(" (%s)", gdk_keyval_name(remmina_pref.hostkey)); + else + s1 = g_strdup_printf(" (%s + %s)", gdk_keyval_name(remmina_pref.hostkey), + gdk_keyval_name(gdk_keyval_to_upper(key1))); + } else { + s1 = NULL; + } + s2 = g_strdup_printf("%s%s", tip, s1 ? s1 : ""); + gtk_widget_set_tooltip_text(item, s2); + g_free(s2); + g_free(s1); +} + +static void remmina_protocol_widget_update_alignment(RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + RemminaScaleMode scalemode; + gboolean scaledexpandedmode; + int rdwidth, rdheight; + gfloat aratio; + + if (!cnnobj->plugin_can_scale) { + /* If we have a plugin that cannot scale, + * (i.e. SFTP plugin), then we expand proto */ + gtk_widget_set_halign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL); + gtk_widget_set_valign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL); + } else { + /* Plugin can scale */ + + scalemode = get_current_allowed_scale_mode(cnnobj, NULL, NULL); + scaledexpandedmode = remmina_protocol_widget_get_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + + /* Check if we need aspectframe and create/destroy it accordingly */ + if (scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED && !scaledexpandedmode) { + /* We need an aspectframe as a parent of proto */ + rdwidth = remmina_protocol_widget_get_width(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + rdheight = remmina_protocol_widget_get_height(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + aratio = (gfloat)rdwidth / (gfloat)rdheight; + if (!cnnobj->aspectframe) { + /* We need a new aspectframe */ + cnnobj->aspectframe = gtk_aspect_frame_new(NULL, 0.5, 0.5, aratio, FALSE); + gtk_widget_set_name(cnnobj->aspectframe, "remmina-cw-aspectframe"); + gtk_frame_set_shadow_type(GTK_FRAME(cnnobj->aspectframe), GTK_SHADOW_NONE); + g_object_ref(cnnobj->proto); + gtk_container_remove(GTK_CONTAINER(cnnobj->viewport), cnnobj->proto); + gtk_container_add(GTK_CONTAINER(cnnobj->viewport), cnnobj->aspectframe); + gtk_container_add(GTK_CONTAINER(cnnobj->aspectframe), cnnobj->proto); + g_object_unref(cnnobj->proto); + gtk_widget_show(cnnobj->aspectframe); + if (cnnobj != NULL && cnnobj->cnnwin != NULL && cnnobj->cnnwin->priv->notebook != NULL) + rcw_grab_focus(cnnobj->cnnwin); + } else { + gtk_aspect_frame_set(GTK_ASPECT_FRAME(cnnobj->aspectframe), 0.5, 0.5, aratio, FALSE); + } + } else { + /* We do not need an aspectframe as a parent of proto */ + if (cnnobj->aspectframe) { + /* We must remove the old aspectframe reparenting proto to viewport */ + g_object_ref(cnnobj->aspectframe); + g_object_ref(cnnobj->proto); + gtk_container_remove(GTK_CONTAINER(cnnobj->aspectframe), cnnobj->proto); + gtk_container_remove(GTK_CONTAINER(cnnobj->viewport), cnnobj->aspectframe); + g_object_unref(cnnobj->aspectframe); + cnnobj->aspectframe = NULL; + gtk_container_add(GTK_CONTAINER(cnnobj->viewport), cnnobj->proto); + g_object_unref(cnnobj->proto); + if (cnnobj != NULL && cnnobj->cnnwin != NULL && cnnobj->cnnwin->priv->notebook != NULL) + rcw_grab_focus(cnnobj->cnnwin); + } + } + + if (scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED || scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES) { + /* We have a plugin that can be scaled, and the scale button + * has been pressed. Give it the correct WxH maintaining aspect + * ratio of remote destkop size */ + gtk_widget_set_halign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL); + gtk_widget_set_valign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL); + } else { + /* Plugin can scale, but no scaling is active. Ensure that we have + * aspectframe with a ratio of 1 */ + gtk_widget_set_halign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_CENTER); + gtk_widget_set_valign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_CENTER); + } + } +} + +static void nb_set_current_page(GtkNotebook *notebook, GtkWidget *page) +{ + gint np, i; + + np = gtk_notebook_get_n_pages(notebook); + for (i = 0; i < np; i++) { + if (gtk_notebook_get_nth_page(notebook, i) == page) { + gtk_notebook_set_current_page(notebook, i); + break; + } + } +} + +static void nb_migrate_message_panels(GtkWidget *frompage, GtkWidget *topage) +{ + /* Migrate a single connection tab from a notebook to another one */ + GList *lst, *l; + + /* Reparent message panels */ + lst = gtk_container_get_children(GTK_CONTAINER(frompage)); + for (l = lst; l != NULL; l = l->next) { + if (REMMINA_IS_MESSAGE_PANEL(l->data)) { + g_object_ref(l->data); + gtk_container_remove(GTK_CONTAINER(frompage), GTK_WIDGET(l->data)); + gtk_container_add(GTK_CONTAINER(topage), GTK_WIDGET(l->data)); + g_object_unref(l->data); + gtk_box_reorder_child(GTK_BOX(topage), GTK_WIDGET(l->data), 0); + } + } + g_list_free(lst); + +} + +static void rcw_migrate(RemminaConnectionWindow *from, RemminaConnectionWindow *to) +{ + /* Migrate a complete notebook from a window to another */ + + gchar *tag; + gint cp, np, i; + GtkNotebook *from_notebook; + GtkWidget *frompage, *newpage, *old_scrolled_container; + RemminaConnectionObject *cnnobj; + RemminaScaleMode scalemode; + + /* Migrate TAG */ + tag = g_strdup((gchar *)g_object_get_data(G_OBJECT(from), "tag")); + g_object_set_data_full(G_OBJECT(to), "tag", tag, (GDestroyNotify)g_free); + + /* Migrate notebook content */ + from_notebook = from->priv->notebook; + if (from_notebook && GTK_IS_NOTEBOOK(from_notebook)) { + + cp = gtk_notebook_get_current_page(from_notebook); + np = gtk_notebook_get_n_pages(from_notebook); + /* Create pages on dest notebook and migrate + * page content */ + for (i = 0; i < np; i++) { + frompage = gtk_notebook_get_nth_page(from_notebook, i); + cnnobj = g_object_get_data(G_OBJECT(frompage), "cnnobj"); + + /* A scrolled container must be recreated, because it can be different on the new window/page + depending on view_mode */ + scalemode = get_current_allowed_scale_mode(cnnobj, NULL, NULL); + old_scrolled_container = cnnobj->scrolled_container; + cnnobj->scrolled_container = rco_create_scrolled_container(scalemode, to->priv->view_mode); + + newpage = rcw_append_new_page(to, cnnobj); + + nb_migrate_message_panels(frompage, newpage); + + /* Reparent the viewport (which is inside scrolled_container) to the new page */ + g_object_ref(cnnobj->viewport); + gtk_container_remove(GTK_CONTAINER(old_scrolled_container), cnnobj->viewport); + gtk_container_add(GTK_CONTAINER(cnnobj->scrolled_container), cnnobj->viewport); + g_object_unref(cnnobj->viewport); + + /* Destroy old scrolled_container. Not really needed, it will be destroyed + * when removing the page from the notepad */ + gtk_widget_destroy(old_scrolled_container); + + } + + /* Remove all the pages from source notebook */ + for (i = np - 1; i >= 0; i--) + gtk_notebook_remove_page(from_notebook, i); + gtk_notebook_set_current_page(to->priv->notebook, cp); + + } +} + +static void rcw_switch_viewmode(RemminaConnectionWindow *cnnwin, int newmode) +{ + GdkWindowState s; + RemminaConnectionWindow *newwin; + gint old_width, old_height; + int old_mode; + + old_mode = cnnwin->priv->view_mode; + if (old_mode == newmode) + return; + + if (newmode == VIEWPORT_FULLSCREEN_MODE || newmode == SCROLLED_FULLSCREEN_MODE) { + if (old_mode == SCROLLED_WINDOW_MODE) { + /* We are leaving SCROLLED_WINDOW_MODE, save W,H, and maximized + * status before self destruction of cnnwin */ + gtk_window_get_size(GTK_WINDOW(cnnwin), &old_width, &old_height); + s = gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(cnnwin))); + } + newwin = rcw_create_fullscreen(GTK_WINDOW(cnnwin), cnnwin->priv->fss_view_mode); + rcw_migrate(cnnwin, newwin); + if (old_mode == SCROLLED_WINDOW_MODE) { + newwin->priv->ss_maximized = (s & GDK_WINDOW_STATE_MAXIMIZED) ? TRUE : FALSE; + newwin->priv->ss_width = old_width; + newwin->priv->ss_height = old_height; + } + } else { + newwin = rcw_create_scrolled(cnnwin->priv->ss_width, cnnwin->priv->ss_height, + cnnwin->priv->ss_maximized); + rcw_migrate(cnnwin, newwin); + if (old_mode == VIEWPORT_FULLSCREEN_MODE || old_mode == SCROLLED_FULLSCREEN_MODE) + /* We are leaving a FULLSCREEN mode, save some parameters + * status before self destruction of cnnwin */ + newwin->priv->fss_view_mode = old_mode; + } + + /* Prevent unreleased hostkey from old window to be released here */ + newwin->priv->hostkey_used = TRUE; +} + + +static void rcw_toolbar_fullscreen(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + + RemminaConnectionObject *cnnobj; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto); + + if (remmina_protocol_widget_get_multimon(gp) >= 1) { + REMMINA_DEBUG("Fullscreen on all monitor"); + gdk_window_set_fullscreen_mode(gtk_widget_get_window(GTK_WIDGET(toggle)), GDK_FULLSCREEN_ON_ALL_MONITORS); + } else { + REMMINA_DEBUG("Fullscreen on one monitor"); + } + + if ((toggle != NULL && toggle == cnnwin->priv->toolitem_fullscreen)) { + if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle))) { + if (remmina_protocol_widget_get_multimon(gp) >= 1) + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnwin->priv->toolitem_multimon), TRUE); + rcw_switch_viewmode(cnnwin, cnnwin->priv->fss_view_mode); + } else { + rcw_switch_viewmode(cnnwin, SCROLLED_WINDOW_MODE); + } + } else + if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(cnnwin->priv->toolitem_multimon))) { + rcw_switch_viewmode(cnnwin, cnnwin->priv->fss_view_mode); + } else { + rcw_switch_viewmode(cnnwin, SCROLLED_WINDOW_MODE); + } +} + +static void rco_viewport_fullscreen_mode(GtkWidget *widget, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + RemminaConnectionWindow *newwin; + + if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) + return; + cnnobj->cnnwin->priv->fss_view_mode = VIEWPORT_FULLSCREEN_MODE; + newwin = rcw_create_fullscreen(GTK_WINDOW(cnnobj->cnnwin), VIEWPORT_FULLSCREEN_MODE); + rcw_migrate(cnnobj->cnnwin, newwin); +} + +static void rco_scrolled_fullscreen_mode(GtkWidget *widget, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + RemminaConnectionWindow *newwin; + + if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) + return; + cnnobj->cnnwin->priv->fss_view_mode = SCROLLED_FULLSCREEN_MODE; + newwin = rcw_create_fullscreen(GTK_WINDOW(cnnobj->cnnwin), SCROLLED_FULLSCREEN_MODE); + rcw_migrate(cnnobj->cnnwin, newwin); +} + +static void rcw_fullscreen_option_popdown(GtkWidget *widget, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + + priv->sticky = FALSE; + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->fullscreen_option_button), FALSE); + rcw_floating_toolbar_show(cnnwin, FALSE); +} + +void rcw_toolbar_fullscreen_option(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + GtkWidget *menu; + GtkWidget *menuitem; + GSList *group; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle))) + return; + + cnnwin->priv->sticky = TRUE; + + menu = gtk_menu_new(); + + menuitem = gtk_radio_menu_item_new_with_label(NULL, _("Viewport fullscreen mode")); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); + if (cnnwin->priv->view_mode == VIEWPORT_FULLSCREEN_MODE) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE); + g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(rco_viewport_fullscreen_mode), cnnobj); + + menuitem = gtk_radio_menu_item_new_with_label(group, _("Scrolled fullscreen")); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + if (cnnwin->priv->view_mode == SCROLLED_FULLSCREEN_MODE) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE); + g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(rco_scrolled_fullscreen_mode), cnnobj); + + g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_fullscreen_option_popdown), cnnwin); + +#if GTK_CHECK_VERSION(3, 22, 0) + gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle), + GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL); +#else + gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, cnnwin->priv->toolitem_fullscreen, 0, + gtk_get_current_event_time()); +#endif +} + + +static void rcw_scaler_option_popdown(GtkWidget *widget, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + + if (priv->toolbar_is_reconfiguring) + return; + priv->sticky = FALSE; + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->scaler_option_button), FALSE); + rcw_floating_toolbar_show(cnnwin, FALSE); +} + +static void rcw_scaler_expand(GtkWidget *widget, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) + return; + cnnobj = rcw_get_visible_cnnobj(cnnwin); + if (!cnnobj) + return; + remmina_protocol_widget_set_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), TRUE); + remmina_file_set_int(cnnobj->remmina_file, "scaler_expand", TRUE); + remmina_protocol_widget_update_alignment(cnnobj); +} +static void rcw_scaler_keep_aspect(GtkWidget *widget, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) + return; + cnnobj = rcw_get_visible_cnnobj(cnnwin); + if (!cnnobj) + return; + + remmina_protocol_widget_set_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), FALSE); + remmina_file_set_int(cnnobj->remmina_file, "scaler_expand", FALSE); + remmina_protocol_widget_update_alignment(cnnobj); +} + +static void rcw_toolbar_scaler_option(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv; + RemminaConnectionObject *cnnobj; + GtkWidget *menu; + GtkWidget *menuitem; + GSList *group; + gboolean scaler_expand; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + priv = cnnwin->priv; + + if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle))) + return; + + scaler_expand = remmina_protocol_widget_get_expand(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + + priv->sticky = TRUE; + + menu = gtk_menu_new(); + + menuitem = gtk_radio_menu_item_new_with_label(NULL, _("Keep aspect ratio when scaled")); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); + if (!scaler_expand) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE); + g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(rcw_scaler_keep_aspect), cnnwin); + + menuitem = gtk_radio_menu_item_new_with_label(group, _("Fill client window when scaled")); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + if (scaler_expand) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE); + g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(rcw_scaler_expand), cnnwin); + + g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_scaler_option_popdown), cnnwin); + +#if GTK_CHECK_VERSION(3, 22, 0) + gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle), + GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL); +#else + gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, priv->toolitem_scale, 0, + gtk_get_current_event_time()); +#endif +} + +void rco_switch_page_activate(GtkMenuItem *menuitem, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv; + gint page_num; + + page_num = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menuitem), "new-page-num")); + gtk_notebook_set_current_page(GTK_NOTEBOOK(priv->notebook), page_num); +} + +void rcw_toolbar_switch_page_popdown(GtkWidget *widget, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + + priv->sticky = FALSE; + + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_switch_page), FALSE); + rcw_floating_toolbar_show(cnnwin, FALSE); +} + +static void rcw_toolbar_switch_page(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + + RemminaConnectionWindowPriv *priv = cnnwin->priv; + RemminaConnectionObject *cnnobj; + + GtkWidget *menu; + GtkWidget *menuitem; + GtkWidget *image; + gint i, n; + + if (priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle))) + return; + + priv->sticky = TRUE; + + menu = gtk_menu_new(); + + n = gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook)); + for (i = 0; i < n; i++) { + cnnobj = rcw_get_cnnobj_at_page(cnnobj->cnnwin, i); + + menuitem = gtk_menu_item_new_with_label(remmina_file_get_string(cnnobj->remmina_file, "name")); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + + image = gtk_image_new_from_icon_name(remmina_file_get_icon_name(cnnobj->remmina_file), GTK_ICON_SIZE_MENU); + gtk_widget_show(image); + + g_object_set_data(G_OBJECT(menuitem), "new-page-num", GINT_TO_POINTER(i)); + g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(rco_switch_page_activate), cnnobj); + if (i == gtk_notebook_get_current_page(GTK_NOTEBOOK(priv->notebook))) + gtk_widget_set_sensitive(menuitem, FALSE); + } + + g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_toolbar_switch_page_popdown), + cnnwin); + +#if GTK_CHECK_VERSION(3, 22, 0) + gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle), + GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL); +#else + gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, widget, 0, gtk_get_current_event_time()); +#endif +} + +void rco_update_toolbar_autofit_button(RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv; + GtkToolItem *toolitem; + RemminaScaleMode sc; + + toolitem = priv->toolitem_autofit; + if (toolitem) { + if (priv->view_mode != SCROLLED_WINDOW_MODE) { + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE); + } else { + sc = get_current_allowed_scale_mode(cnnobj, NULL, NULL); + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), sc == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE); + } + } +} + +static void rco_change_scalemode(RemminaConnectionObject *cnnobj, gboolean bdyn, gboolean bscale) +{ + RemminaScaleMode scalemode; + RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv; + + if (bdyn) + scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES; + else if (bscale) + scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED; + else + scalemode = REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE; + + remmina_protocol_widget_set_current_scale_mode(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), scalemode); + remmina_file_set_int(cnnobj->remmina_file, "scale", scalemode); + gtk_widget_set_sensitive(GTK_WIDGET(priv->scaler_option_button), scalemode == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED); + rco_update_toolbar_autofit_button(cnnobj); + + remmina_protocol_widget_call_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + REMMINA_PROTOCOL_FEATURE_TYPE_SCALE, 0); + + if (cnnobj->cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE) + rco_check_resize(cnnobj); + if (GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) { + rco_set_scrolled_policy(scalemode, GTK_SCROLLED_WINDOW(cnnobj->scrolled_container)); + } +} + +static void rcw_toolbar_dynres(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + gboolean bdyn, bscale; + RemminaConnectionObject *cnnobj; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + if (cnnobj->connected) { + bdyn = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle)); + bscale = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_scale)); + + if (bdyn && bscale) { + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_scale), FALSE); + bscale = FALSE; + } + + rco_change_scalemode(cnnobj, bdyn, bscale); + } +} + +static void rcw_toolbar_scaled_mode(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + gboolean bdyn, bscale; + RemminaConnectionObject *cnnobj; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + bdyn = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_dynres)); + bscale = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle)); + + if (bdyn && bscale) { + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_dynres), FALSE); + bdyn = FALSE; + } + + rco_change_scalemode(cnnobj, bdyn, bscale); +} + +static void rcw_toolbar_multi_monitor_mode(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle))) { + REMMINA_DEBUG("Saving multimon as 1"); + remmina_file_set_int(cnnobj->remmina_file, "multimon", 1); + remmina_file_save(cnnobj->remmina_file); + remmina_protocol_widget_call_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + REMMINA_PROTOCOL_FEATURE_TYPE_MULTIMON, 0); + if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(cnnwin->priv->toolitem_fullscreen))) + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnwin->priv->toolitem_fullscreen), TRUE); + } else { + REMMINA_DEBUG("Saving multimon as 0"); + remmina_file_set_int(cnnobj->remmina_file, "multimon", 0); + remmina_file_save(cnnobj->remmina_file); + rcw_toolbar_fullscreen(NULL, cnnwin); + } +} + +static void rcw_toolbar_open_main(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + + remmina_exec_command(REMMINA_COMMAND_MAIN, NULL); +} + +static void rcw_toolbar_preferences_popdown(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + cnnobj->cnnwin->priv->sticky = FALSE; + + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(cnnobj->cnnwin->priv->toolitem_preferences), FALSE); + rcw_floating_toolbar_show(cnnwin, FALSE); +} + +void rcw_toolbar_menu_popdown(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + + if (priv->toolbar_is_reconfiguring) + return; + + priv->sticky = FALSE; + + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_menu), FALSE); + rcw_floating_toolbar_show(cnnwin, FALSE); +} + +void rcw_toolbar_tools_popdown(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + + if (priv->toolbar_is_reconfiguring) + return; + + priv->sticky = FALSE; + + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_tools), FALSE); + rcw_floating_toolbar_show(cnnwin, FALSE); +} + +static void rco_call_protocol_feature_radio(GtkMenuItem *menuitem, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + RemminaProtocolFeature *feature; + gpointer value; + + if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem))) { + feature = (RemminaProtocolFeature *)g_object_get_data(G_OBJECT(menuitem), "feature-type"); + value = g_object_get_data(G_OBJECT(menuitem), "feature-value"); + + remmina_file_set_string(cnnobj->remmina_file, (const gchar *)feature->opt2, (const gchar *)value); + remmina_protocol_widget_call_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature); + } +} + +static void rco_call_protocol_feature_check(GtkMenuItem *menuitem, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + RemminaProtocolFeature *feature; + gboolean value; + + feature = (RemminaProtocolFeature *)g_object_get_data(G_OBJECT(menuitem), "feature-type"); + value = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)); + remmina_file_set_int(cnnobj->remmina_file, (const gchar *)feature->opt2, value); + remmina_protocol_widget_call_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature); +} + +static void rco_call_protocol_feature_activate(GtkMenuItem *menuitem, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + RemminaProtocolFeature *feature; + + feature = (RemminaProtocolFeature *)g_object_get_data(G_OBJECT(menuitem), "feature-type"); + remmina_protocol_widget_call_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature); +} + +void rcw_toolbar_preferences_radio(RemminaConnectionObject *cnnobj, RemminaFile *remminafile, + GtkWidget *menu, const RemminaProtocolFeature *feature, const gchar *domain, gboolean enabled) +{ + TRACE_CALL(__func__); + GtkWidget *menuitem; + GSList *group; + gint i; + const gchar **list; + const gchar *value; + + group = NULL; + value = remmina_file_get_string(remminafile, (const gchar *)feature->opt2); + list = (const gchar **)feature->opt3; + for (i = 0; list[i]; i += 2) { + menuitem = gtk_radio_menu_item_new_with_label(group, g_dgettext(domain, list[i + 1])); + group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + + if (enabled) { + g_object_set_data(G_OBJECT(menuitem), "feature-type", (gpointer)feature); + g_object_set_data(G_OBJECT(menuitem), "feature-value", (gpointer)list[i]); + + if (value && g_strcmp0(list[i], value) == 0) + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE); + + g_signal_connect(G_OBJECT(menuitem), "toggled", + G_CALLBACK(rco_call_protocol_feature_radio), cnnobj); + } else { + gtk_widget_set_sensitive(menuitem, FALSE); + } + } +} + +void rcw_toolbar_preferences_check(RemminaConnectionObject *cnnobj, + GtkWidget *menu, const RemminaProtocolFeature *feature, + const gchar *domain, gboolean enabled) +{ + TRACE_CALL(__func__); + GtkWidget *menuitem; + + menuitem = gtk_check_menu_item_new_with_label(g_dgettext(domain, (const gchar *)feature->opt3)); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + + if (enabled) { + g_object_set_data(G_OBJECT(menuitem), "feature-type", (gpointer)feature); + + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), + remmina_file_get_int(cnnobj->remmina_file, (const gchar *)feature->opt2, FALSE)); + + g_signal_connect(G_OBJECT(menuitem), "toggled", + G_CALLBACK(rco_call_protocol_feature_check), cnnobj); + } else { + gtk_widget_set_sensitive(menuitem, FALSE); + } +} + +static void rcw_toolbar_preferences(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv; + RemminaConnectionObject *cnnobj; + const RemminaProtocolFeature *feature; + GtkWidget *menu; + GtkWidget *menuitem; + gboolean separator; + gchar *domain; + gboolean enabled; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + priv = cnnobj->cnnwin->priv; + + if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle))) + return; + + priv->sticky = TRUE; + + separator = FALSE; + + domain = remmina_protocol_widget_get_domain(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + menu = gtk_menu_new(); + for (feature = remmina_protocol_widget_get_features(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); feature && feature->type; + feature++) { + if (feature->type != REMMINA_PROTOCOL_FEATURE_TYPE_PREF) + continue; + + if (separator) { + menuitem = gtk_separator_menu_item_new(); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + separator = FALSE; + } + enabled = remmina_protocol_widget_query_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature); + switch (GPOINTER_TO_INT(feature->opt1)) { + case REMMINA_PROTOCOL_FEATURE_PREF_RADIO: + rcw_toolbar_preferences_radio(cnnobj, cnnobj->remmina_file, menu, feature, + domain, enabled); + separator = TRUE; + break; + case REMMINA_PROTOCOL_FEATURE_PREF_CHECK: + rcw_toolbar_preferences_check(cnnobj, menu, feature, + domain, enabled); + break; + } + } + + g_free(domain); + + g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_toolbar_preferences_popdown), cnnwin); + +#if GTK_CHECK_VERSION(3, 22, 0) + gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle), + GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL); +#else + gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, widget, 0, gtk_get_current_event_time()); +#endif +} + +static void rcw_toolbar_menu_on_launch_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem, gpointer data) +{ + TRACE_CALL(__func__); + gchar *s; + + switch (menuitem->item_type) { + case REMMINA_APPLET_MENU_ITEM_NEW: + remmina_exec_command(REMMINA_COMMAND_NEW, NULL); + break; + case REMMINA_APPLET_MENU_ITEM_FILE: + remmina_exec_command(REMMINA_COMMAND_CONNECT, menuitem->filename); + break; + case REMMINA_APPLET_MENU_ITEM_DISCOVERED: + s = g_strdup_printf("%s,%s", menuitem->protocol, menuitem->name); + remmina_exec_command(REMMINA_COMMAND_NEW, s); + g_free(s); + break; + } +} + +static void rcw_toolbar_menu(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv; + RemminaConnectionObject *cnnobj; + GtkWidget *menu; + GtkWidget *menuitem = NULL; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + priv = cnnobj->cnnwin->priv; + + if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle))) + return; + + priv->sticky = TRUE; + + menu = remmina_applet_menu_new(); + remmina_applet_menu_set_hide_count(REMMINA_APPLET_MENU(menu), remmina_pref.applet_hide_count); + remmina_applet_menu_populate(REMMINA_APPLET_MENU(menu)); + + g_signal_connect(G_OBJECT(menu), "launch-item", G_CALLBACK(rcw_toolbar_menu_on_launch_item), NULL); + //g_signal_connect(G_OBJECT(menu), "edit-item", G_CALLBACK(rcw_toolbar_menu_on_edit_item), NULL); + menuitem = gtk_separator_menu_item_new(); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); +#if GTK_CHECK_VERSION(3, 22, 0) + gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle), + GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL); +#else + gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, widget, 0, gtk_get_current_event_time()); +#endif + g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_toolbar_menu_popdown), cnnwin); +} + +static void rcw_toolbar_tools(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv; + RemminaConnectionObject *cnnobj; + const RemminaProtocolFeature *feature; + GtkWidget *menu; + GtkWidget *menuitem = NULL; + GtkMenu *submenu_keystrokes; + const gchar *domain; + gboolean enabled; + gchar **keystrokes; + gchar **keystroke_values; + gint i; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + priv = cnnobj->cnnwin->priv; + + if (!gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle))) + return; + + priv->sticky = TRUE; + + domain = remmina_protocol_widget_get_domain(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + menu = gtk_menu_new(); + for (feature = remmina_protocol_widget_get_features(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); feature && feature->type; + feature++) { + if (feature->type != REMMINA_PROTOCOL_FEATURE_TYPE_TOOL) + continue; + + if (feature->opt1) + menuitem = gtk_menu_item_new_with_label(g_dgettext(domain, (const gchar *)feature->opt1)); + if (feature->opt3) + rcw_set_tooltip(menuitem, "", GPOINTER_TO_UINT(feature->opt3), 0); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + + enabled = remmina_protocol_widget_query_feature_by_ref(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), feature); + if (enabled) { + g_object_set_data(G_OBJECT(menuitem), "feature-type", (gpointer)feature); + + g_signal_connect(G_OBJECT(menuitem), "activate", + G_CALLBACK(rco_call_protocol_feature_activate), cnnobj); + } else { + gtk_widget_set_sensitive(menuitem, FALSE); + } + } + + /* If the plugin accepts keystrokes include the keystrokes menu */ + if (remmina_protocol_widget_plugin_receives_keystrokes(REMMINA_PROTOCOL_WIDGET(cnnobj->proto))) { + /* Get the registered keystrokes list */ + keystrokes = g_strsplit(remmina_pref.keystrokes, STRING_DELIMITOR, -1); + if (g_strv_length(keystrokes)) { + /* Add a keystrokes submenu */ + menuitem = gtk_menu_item_new_with_label(_("Keystrokes")); + submenu_keystrokes = GTK_MENU(gtk_menu_new()); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), GTK_WIDGET(submenu_keystrokes)); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); + /* Add each registered keystroke */ + for (i = 0; i < g_strv_length(keystrokes); i++) { + keystroke_values = g_strsplit(keystrokes[i], STRING_DELIMITOR2, -1); + if (g_strv_length(keystroke_values) > 1) { + /* Add the keystroke if no description was available */ + menuitem = gtk_menu_item_new_with_label( + g_strdup(keystroke_values[strlen(keystroke_values[0]) ? 0 : 1])); + g_object_set_data(G_OBJECT(menuitem), "keystrokes", g_strdup(keystroke_values[1])); + g_signal_connect_swapped(G_OBJECT(menuitem), "activate", + G_CALLBACK(remmina_protocol_widget_send_keystrokes), + REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + gtk_widget_show(menuitem); + gtk_menu_shell_append(GTK_MENU_SHELL(submenu_keystrokes), menuitem); + } + g_strfreev(keystroke_values); + } + menuitem = gtk_menu_item_new_with_label(_("Send clipboard content as keystrokes")); + static gchar k_tooltip[] = + N_("CAUTION: Pasted text will be sent as a sequence of key-codes as if typed on your local keyboard.\n" + "\n" + " • For best results use same keyboard settings for both, client and server.\n" + "\n" + " • If client-keyboard is different from server-keyboard the received text can contain wrong or erroneous characters.\n" + "\n" + " • Unicode characters and other special characters that can't be translated to local key-codes won’t be sent to the server.\n" + "\n"); + gtk_widget_set_tooltip_text(menuitem, k_tooltip); + gtk_menu_shell_append(GTK_MENU_SHELL(submenu_keystrokes), menuitem); + g_signal_connect_swapped(G_OBJECT(menuitem), "activate", + G_CALLBACK(remmina_protocol_widget_send_clipboard), + REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + gtk_widget_show(menuitem); + } + g_strfreev(keystrokes); + } + + g_signal_connect(G_OBJECT(menu), "deactivate", G_CALLBACK(rcw_toolbar_tools_popdown), cnnwin); + +#if GTK_CHECK_VERSION(3, 22, 0) + gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(toggle), + GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_NORTH_WEST, NULL); +#else + gtk_menu_popup(GTK_MENU(menu), NULL, NULL, remmina_public_popup_position, widget, 0, gtk_get_current_event_time()); +#endif +} + +static void rcw_toolbar_duplicate(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + + RemminaConnectionObject *cnnobj; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + remmina_file_save(cnnobj->remmina_file); + + remmina_exec_command(REMMINA_COMMAND_CONNECT, cnnobj->remmina_file->filename); +} + +static void rcw_toolbar_screenshot(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + + GdkPixbuf *screenshot; + GdkWindow *active_window; + cairo_t *cr; + gint width, height; + GString *pngstr; + gchar *pngname; + GtkWidget *dialog; + RemminaProtocolWidget *gp; + RemminaPluginScreenshotData rpsd; + RemminaConnectionObject *cnnobj; + cairo_surface_t *srcsurface; + cairo_format_t cairo_format; + cairo_surface_t *surface; + int stride; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + GDateTime *date = g_date_time_new_now_utc(); + + // We will take a screenshot of the currently displayed RemminaProtocolWidget. + gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto); + + gchar *denyclip = remmina_pref_get_value("deny_screenshot_clipboard"); + + REMMINA_DEBUG("deny_screenshot_clipboard is set to %s", denyclip); + + GtkClipboard *c = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); + + // Ask the plugin if it can give us a screenshot + if (remmina_protocol_widget_plugin_screenshot(gp, &rpsd)) { + // Good, we have a screenshot from the plugin ! + + REMMINA_DEBUG("Screenshot from plugin: w=%d h=%d bpp=%d bytespp=%d\n", + rpsd.width, rpsd.height, rpsd.bitsPerPixel, rpsd.bytesPerPixel); + + width = rpsd.width; + height = rpsd.height; + + if (rpsd.bitsPerPixel == 32) + cairo_format = CAIRO_FORMAT_ARGB32; + else if (rpsd.bitsPerPixel == 24) + cairo_format = CAIRO_FORMAT_RGB24; + else + cairo_format = CAIRO_FORMAT_RGB16_565; + + stride = cairo_format_stride_for_width(cairo_format, width); + + srcsurface = cairo_image_surface_create_for_data(rpsd.buffer, cairo_format, width, height, stride); + // Transfer the PixBuf in the main clipboard selection + if (denyclip && (g_strcmp0(denyclip, "true"))) + gtk_clipboard_set_image(c, gdk_pixbuf_get_from_surface( + srcsurface, 0, 0, width, height)); + surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height); + cr = cairo_create(surface); + cairo_set_source_surface(cr, srcsurface, 0, 0); + cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); + cairo_paint(cr); + cairo_surface_destroy(srcsurface); + + free(rpsd.buffer); + } else { + // The plugin is not releasing us a screenshot, just try to catch one via GTK + + /* Warn the user if image is distorted */ + if (cnnobj->plugin_can_scale && + get_current_allowed_scale_mode(cnnobj, NULL, NULL) == REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED) { + dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, + _("Turn off scaling to avoid screenshot distortion.")); + g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL); + gtk_widget_show(dialog); + } + + // Get the screenshot. + active_window = gtk_widget_get_window(GTK_WIDGET(gp)); + // width = gdk_window_get_width(gtk_widget_get_window(GTK_WIDGET(cnnobj->cnnwin))); + width = gdk_window_get_width(active_window); + // height = gdk_window_get_height(gtk_widget_get_window(GTK_WIDGET(cnnobj->cnnwin))); + height = gdk_window_get_height(active_window); + + screenshot = gdk_pixbuf_get_from_window(active_window, 0, 0, width, height); + if (screenshot == NULL) + g_print("gdk_pixbuf_get_from_window failed\n"); + + // Transfer the PixBuf in the main clipboard selection + if (denyclip && (g_strcmp0(denyclip, "true"))) + gtk_clipboard_set_image(c, screenshot); + // Prepare the destination Cairo surface. + surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height); + cr = cairo_create(surface); + + // Copy the source pixbuf to the surface and paint it. + gdk_cairo_set_source_pixbuf(cr, screenshot, 0, 0); + cairo_paint(cr); + + // Deallocate screenshot pixbuf + g_object_unref(screenshot); + } + + //home/antenore/Pictures/remmina_%p_%h_%Y %m %d-%H%M%S.png pngname + //home/antenore/Pictures/remmina_st_ _2018 9 24-151958.240374.png + + pngstr = g_string_new(g_strdup_printf("%s/%s.png", + remmina_pref.screenshot_path, + remmina_pref.screenshot_name)); + remmina_utils_string_replace_all(pngstr, "%p", + remmina_file_get_string(cnnobj->remmina_file, "name")); + remmina_utils_string_replace_all(pngstr, "%h", + remmina_file_get_string(cnnobj->remmina_file, "server")); + remmina_utils_string_replace_all(pngstr, "%Y", + g_strdup_printf("%d", g_date_time_get_year(date))); + remmina_utils_string_replace_all(pngstr, "%m", g_strdup_printf("%02d", + g_date_time_get_month(date))); + remmina_utils_string_replace_all(pngstr, "%d", + g_strdup_printf("%02d", g_date_time_get_day_of_month(date))); + remmina_utils_string_replace_all(pngstr, "%H", + g_strdup_printf("%02d", g_date_time_get_hour(date))); + remmina_utils_string_replace_all(pngstr, "%M", + g_strdup_printf("%02d", g_date_time_get_minute(date))); + remmina_utils_string_replace_all(pngstr, "%S", + g_strdup_printf("%02d", g_date_time_get_second(date))); + g_date_time_unref(date); + pngname = g_string_free(pngstr, FALSE); + + cairo_surface_write_to_png(surface, pngname); + + /* send a desktop notification */ + if (g_file_test(pngname, G_FILE_TEST_EXISTS)) + remmina_public_send_notification("remmina-screenshot-is-ready-id", _("Screenshot taken"), pngname); + + //Clean up and return. + cairo_destroy(cr); + cairo_surface_destroy(surface); +} + +static void rcw_toolbar_minimize(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + + rcw_floating_toolbar_show(cnnwin, FALSE); + gtk_window_iconify(GTK_WINDOW(cnnwin)); +} + +static void rcw_toolbar_disconnect(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + rco_disconnect_current_page(cnnobj); +} + +static void rcw_toolbar_grab(GtkToolItem *toggle, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + gboolean capture; + RemminaConnectionObject *cnnobj; + + if (cnnwin->priv->toolbar_is_reconfiguring) + return; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + capture = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toggle)); + + if (cnnobj->connected){ + remmina_file_set_int(cnnobj->remmina_file, "keyboard_grab", capture); + } + + if (capture && cnnobj->connected) { + +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: Grabbing for button\n"); +#endif + rcw_keyboard_grab(cnnobj->cnnwin); + if (cnnobj->cnnwin->priv->pointer_entered) + rcw_pointer_grab(cnnobj->cnnwin); + } else { + rcw_kp_ungrab(cnnobj->cnnwin); + } + + rco_update_toolbar(cnnobj); +} + +static GtkWidget * +rcw_create_toolbar(RemminaConnectionWindow *cnnwin, gint mode) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + RemminaConnectionObject *cnnobj; + GtkWidget *toolbar; + GtkToolItem *toolitem; + GtkWidget *widget; + GtkWidget *arrow; + + GdkDisplay *display; + gint n_monitors; + + display = gdk_display_get_default(); + n_monitors = gdk_display_get_n_monitors(display); + + cnnobj = rcw_get_visible_cnnobj(cnnwin); + + priv->toolbar_is_reconfiguring = TRUE; + + toolbar = gtk_toolbar_new(); + gtk_widget_show(toolbar); + gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); + + /* Main actions */ + + /* Menu */ + toolitem = gtk_toggle_tool_button_new(); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "view-more-symbolic"); + gtk_tool_button_set_label(GTK_TOOL_BUTTON(toolitem), _("_Menu")); + gtk_tool_item_set_tooltip_text(toolitem, _("Menu")); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_menu), cnnwin); + priv->toolitem_menu = toolitem; + + /* Open Main window */ + toolitem = gtk_tool_button_new(NULL, "Open Remmina Main window"); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "go-home-symbolic"); + gtk_tool_item_set_tooltip_text(toolitem, _("Open the Remmina main window")); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_open_main), cnnwin); + + priv->toolitem_new = toolitem; + + /* Duplicate session */ + toolitem = gtk_tool_button_new(NULL, "Duplicate connection"); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-duplicate-symbolic"); + gtk_tool_item_set_tooltip_text(toolitem, _("Duplicate current connection")); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_duplicate), cnnwin); + if (!cnnobj) + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE); + + priv->toolitem_duplicate = toolitem; + + /* Separator */ + toolitem = gtk_separator_tool_item_new(); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + + /* Auto-Fit */ + toolitem = gtk_tool_button_new(NULL, NULL); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-fit-window-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Resize the window to fit in remote resolution"), + remmina_pref.shortcutkey_autofit, 0); + g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_autofit), cnnwin); + priv->toolitem_autofit = toolitem; + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + + + /* Fullscreen toggle */ + toolitem = gtk_toggle_tool_button_new(); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-fullscreen-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Toggle fullscreen mode"), + remmina_pref.shortcutkey_fullscreen, 0); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + priv->toolitem_fullscreen = toolitem; + if (kioskmode) { + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem), FALSE); + } else { + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem), mode != SCROLLED_WINDOW_MODE); + g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_fullscreen), cnnwin); + } + + /* Fullscreen drop-down options */ + toolitem = gtk_tool_item_new(); + gtk_widget_show(GTK_WIDGET(toolitem)); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + widget = gtk_toggle_button_new(); + gtk_widget_show(widget); + gtk_container_set_border_width(GTK_CONTAINER(widget), 0); + gtk_button_set_relief(GTK_BUTTON(widget), GTK_RELIEF_NONE); +#if GTK_CHECK_VERSION(3, 20, 0) + gtk_widget_set_focus_on_click(GTK_WIDGET(widget), FALSE); + if (remmina_pref.small_toolbutton) + gtk_widget_set_name(widget, "remmina-small-button"); + +#else + gtk_button_set_focus_on_click(GTK_BUTTON(widget), FALSE); +#endif + gtk_container_add(GTK_CONTAINER(toolitem), widget); + +#if GTK_CHECK_VERSION(3, 14, 0) + arrow = gtk_image_new_from_icon_name("org.remmina.Remmina-pan-down-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR); +#else + arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE); +#endif + gtk_widget_show(arrow); + gtk_container_add(GTK_CONTAINER(widget), arrow); + g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(rcw_toolbar_fullscreen_option), cnnwin); + priv->fullscreen_option_button = widget; + if (mode == SCROLLED_WINDOW_MODE) + gtk_widget_set_sensitive(GTK_WIDGET(widget), FALSE); + + /* Multi monitor */ + if (n_monitors > 1) { + toolitem = gtk_toggle_tool_button_new(); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-multi-monitor-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Multi monitor"), + remmina_pref.shortcutkey_multimon, 0); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_multi_monitor_mode), cnnwin); + priv->toolitem_multimon = toolitem; + if (!cnnobj) + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE); + else + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem), + remmina_file_get_int(cnnobj->remmina_file, "multimon", FALSE)); + } + + /* Dynamic Resolution Update */ + toolitem = gtk_toggle_tool_button_new(); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-dynres-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Toggle dynamic resolution update"), + remmina_pref.shortcutkey_dynres, 0); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_dynres), cnnwin); + priv->toolitem_dynres = toolitem; + + /* Scaler button */ + toolitem = gtk_toggle_tool_button_new(); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-scale-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Toggle scaled mode"), remmina_pref.shortcutkey_scale, 0); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_scaled_mode), cnnwin); + priv->toolitem_scale = toolitem; + + /* Scaler aspect ratio dropdown menu */ + toolitem = gtk_tool_item_new(); + gtk_widget_show(GTK_WIDGET(toolitem)); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + widget = gtk_toggle_button_new(); + gtk_widget_show(widget); + gtk_container_set_border_width(GTK_CONTAINER(widget), 0); + gtk_button_set_relief(GTK_BUTTON(widget), GTK_RELIEF_NONE); +#if GTK_CHECK_VERSION(3, 20, 0) + gtk_widget_set_focus_on_click(GTK_WIDGET(widget), FALSE); +#else + gtk_button_set_focus_on_click(GTK_BUTTON(widget), FALSE); +#endif + if (remmina_pref.small_toolbutton) + gtk_widget_set_name(widget, "remmina-small-button"); + gtk_container_add(GTK_CONTAINER(toolitem), widget); +#if GTK_CHECK_VERSION(3, 14, 0) + arrow = gtk_image_new_from_icon_name("org.remmina.Remmina-pan-down-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR); +#else + arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE); +#endif + gtk_widget_show(arrow); + gtk_container_add(GTK_CONTAINER(widget), arrow); + g_signal_connect(G_OBJECT(widget), "toggled", G_CALLBACK(rcw_toolbar_scaler_option), cnnwin); + priv->scaler_option_button = widget; + + /* Separator */ + toolitem = gtk_separator_tool_item_new(); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + + /* Switch tabs */ + toolitem = gtk_toggle_tool_button_new(); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-switch-page-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Switch tab pages"), remmina_pref.shortcutkey_prevtab, + remmina_pref.shortcutkey_nexttab); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_switch_page), cnnwin); + priv->toolitem_switch_page = toolitem; + + /* Grab keyboard button */ + toolitem = gtk_toggle_tool_button_new(); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-keyboard-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Grab all keyboard events"), + remmina_pref.shortcutkey_grab, 0); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_grab), cnnwin); + priv->toolitem_grab = toolitem; + if (!cnnobj) + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE); + else { + const gchar *protocol = remmina_file_get_string(cnnobj->remmina_file, "protocol"); + if (g_strcmp0(protocol, "SFTP") == 0 || g_strcmp0(protocol, "SSH") == 0) + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE); + } + + /* Preferences */ + toolitem = gtk_toggle_tool_button_new(); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-preferences-system-symbolic"); + gtk_tool_item_set_tooltip_text(toolitem, _("Preferences")); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_preferences), cnnwin); + priv->toolitem_preferences = toolitem; + + /* Tools */ + toolitem = gtk_toggle_tool_button_new(); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-system-run-symbolic"); + gtk_tool_button_set_label(GTK_TOOL_BUTTON(toolitem), _("_Tools")); + gtk_tool_item_set_tooltip_text(toolitem, _("Tools")); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "toggled", G_CALLBACK(rcw_toolbar_tools), cnnwin); + priv->toolitem_tools = toolitem; + + /* Separator */ + toolitem = gtk_separator_tool_item_new(); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + + toolitem = gtk_tool_button_new(NULL, "_Screenshot"); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-camera-photo-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Screenshot"), remmina_pref.shortcutkey_screenshot, 0); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_screenshot), cnnwin); + priv->toolitem_screenshot = toolitem; + + /* Separator */ + toolitem = gtk_separator_tool_item_new(); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + + /* Minimize */ + toolitem = gtk_tool_button_new(NULL, "_Bottom"); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-go-bottom-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Minimize window"), remmina_pref.shortcutkey_minimize, 0); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_minimize), cnnwin); + if (kioskmode) + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE); + + /* Disconnect */ + toolitem = gtk_tool_button_new(NULL, "_Disconnect"); + gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), "org.remmina.Remmina-disconnect-symbolic"); + rcw_set_tooltip(GTK_WIDGET(toolitem), _("Disconnect"), remmina_pref.shortcutkey_disconnect, 0); + gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); + gtk_widget_show(GTK_WIDGET(toolitem)); + g_signal_connect(G_OBJECT(toolitem), "clicked", G_CALLBACK(rcw_toolbar_disconnect), cnnwin); + + priv->toolbar_is_reconfiguring = FALSE; + return toolbar; +} + +static void rcw_place_toolbar(GtkToolbar *toolbar, GtkGrid *grid, GtkWidget *sibling, int toolbar_placement) +{ + /* Place the toolbar inside the grid and set its orientation */ + + if (toolbar_placement == TOOLBAR_PLACEMENT_LEFT || toolbar_placement == TOOLBAR_PLACEMENT_RIGHT) + gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_VERTICAL); + else + gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL); + + + switch (toolbar_placement) { + case TOOLBAR_PLACEMENT_TOP: + gtk_widget_set_hexpand(GTK_WIDGET(toolbar), TRUE); + gtk_widget_set_vexpand(GTK_WIDGET(toolbar), FALSE); + gtk_grid_attach_next_to(GTK_GRID(grid), GTK_WIDGET(toolbar), sibling, GTK_POS_TOP, 1, 1); + break; + case TOOLBAR_PLACEMENT_RIGHT: + gtk_widget_set_vexpand(GTK_WIDGET(toolbar), TRUE); + gtk_widget_set_hexpand(GTK_WIDGET(toolbar), FALSE); + gtk_grid_attach_next_to(GTK_GRID(grid), GTK_WIDGET(toolbar), sibling, GTK_POS_RIGHT, 1, 1); + break; + case TOOLBAR_PLACEMENT_BOTTOM: + gtk_widget_set_hexpand(GTK_WIDGET(toolbar), TRUE); + gtk_widget_set_vexpand(GTK_WIDGET(toolbar), FALSE); + gtk_grid_attach_next_to(GTK_GRID(grid), GTK_WIDGET(toolbar), sibling, GTK_POS_BOTTOM, 1, 1); + break; + case TOOLBAR_PLACEMENT_LEFT: + gtk_widget_set_vexpand(GTK_WIDGET(toolbar), TRUE); + gtk_widget_set_hexpand(GTK_WIDGET(toolbar), FALSE); + gtk_grid_attach_next_to(GTK_GRID(grid), GTK_WIDGET(toolbar), sibling, GTK_POS_LEFT, 1, 1); + break; + } +} + +static void rco_update_toolbar(RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv; + GtkToolItem *toolitem; + gboolean bval, dynres_avail, scale_avail; + gboolean test_floating_toolbar; + RemminaScaleMode scalemode; + + priv->toolbar_is_reconfiguring = TRUE; + + rco_update_toolbar_autofit_button(cnnobj); + + toolitem = priv->toolitem_switch_page; + if (kioskmode) + bval = FALSE; + else + bval = (gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook)) > 1); + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), bval); + + if (cnnobj->remmina_file->filename) + gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_duplicate), TRUE); + else + gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_duplicate), FALSE); + + scalemode = get_current_allowed_scale_mode(cnnobj, &dynres_avail, &scale_avail); + gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_dynres), dynres_avail && cnnobj->connected); + gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_scale), scale_avail && cnnobj->connected); + + switch (scalemode) { + case REMMINA_PROTOCOL_WIDGET_SCALE_MODE_NONE: + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_dynres), FALSE); + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_scale), FALSE); + gtk_widget_set_sensitive(GTK_WIDGET(priv->scaler_option_button), FALSE); + break; + case REMMINA_PROTOCOL_WIDGET_SCALE_MODE_SCALED: + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_dynres), FALSE); + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_scale), TRUE); + gtk_widget_set_sensitive(GTK_WIDGET(priv->scaler_option_button), TRUE && cnnobj->connected); + break; + case REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES: + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_dynres), TRUE); + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_scale), FALSE); + gtk_widget_set_sensitive(GTK_WIDGET(priv->scaler_option_button), FALSE); + break; + } + + /* REMMINA_PROTOCOL_FEATURE_TYPE_MULTIMON */ + toolitem = priv->toolitem_multimon; + if (toolitem) { + gint hasmultimon = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + REMMINA_PROTOCOL_FEATURE_TYPE_MULTIMON); + + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), cnnobj->connected); + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem), + remmina_file_get_int(cnnobj->remmina_file, "multimon", FALSE)); + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), hasmultimon); + } + + toolitem = priv->toolitem_grab; + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), cnnobj->connected); + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem), + remmina_file_get_int(cnnobj->remmina_file, "keyboard_grab", FALSE)); + const gchar *protocol = remmina_file_get_string(cnnobj->remmina_file, "protocol"); + if (g_strcmp0(protocol, "SFTP") == 0 || g_strcmp0(protocol, "SSH") == 0) { + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE); + gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolitem), FALSE); + remmina_file_set_int(cnnobj->remmina_file, "keyboard_grab", FALSE); + } + + toolitem = priv->toolitem_preferences; + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), cnnobj->connected); + bval = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + REMMINA_PROTOCOL_FEATURE_TYPE_PREF); + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), bval && cnnobj->connected); + + toolitem = priv->toolitem_tools; + bval = remmina_protocol_widget_query_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + REMMINA_PROTOCOL_FEATURE_TYPE_TOOL); + gtk_widget_set_sensitive(GTK_WIDGET(toolitem), bval && cnnobj->connected); + + gtk_widget_set_sensitive(GTK_WIDGET(priv->toolitem_screenshot), cnnobj->connected); + + gtk_window_set_title(GTK_WINDOW(cnnobj->cnnwin), remmina_file_get_string(cnnobj->remmina_file, "name")); + + test_floating_toolbar = (priv->floating_toolbar_widget != NULL); + + if (test_floating_toolbar) { + const gchar *str = remmina_file_get_string(cnnobj->remmina_file, "name"); + const gchar *format; + GdkRGBA rgba; + gchar *bg; + + bg = g_strdup(remmina_pref.grab_color); + if (!gdk_rgba_parse(&rgba, bg)) { + REMMINA_DEBUG("%s cannot be parsed as a color", bg); + bg = g_strdup("#00FF00"); + } else { + REMMINA_DEBUG("Using %s as background color", bg); + } + + if (remmina_file_get_int(cnnobj->remmina_file, "keyboard_grab", FALSE)) { + if (remmina_pref_get_boolean("grab_color_switch")) { + gtk_widget_override_background_color(priv->overlay_ftb_fr, GTK_STATE_NORMAL, &rgba); + format = g_strconcat("<span bgcolor=\"", bg, "\" size=\"large\"><b>(G: ON) - \%s</b></span>", NULL); + } else { + gtk_widget_override_background_color(priv->overlay_ftb_fr, GTK_STATE_NORMAL, NULL); + format = "<big><b>(G: ON) - \%s</b></big>"; + } + } else { + gtk_widget_override_background_color(priv->overlay_ftb_fr, GTK_STATE_NORMAL, NULL); + format = "<big><b>(G:OFF) - \%s</b></big>"; + } + gchar *markup; + + markup = g_markup_printf_escaped(format, str); + gtk_label_set_markup(GTK_LABEL(priv->floating_toolbar_label), markup); + g_free(markup); + g_free(bg); + } + + priv->toolbar_is_reconfiguring = FALSE; +} + +static void rcw_set_toolbar_visibility(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + + if (priv->view_mode == SCROLLED_WINDOW_MODE) { + if (remmina_pref.hide_connection_toolbar) + gtk_widget_hide(priv->toolbar); + else + gtk_widget_show(priv->toolbar); + } +} + +#if DEBUG_KB_GRABBING +static void print_crossing_event(GdkEventCrossing *event) { + printf("DEBUG_KB_GRABBING: --- Crossing event detail: "); + switch (event->detail) { + case GDK_NOTIFY_ANCESTOR: printf("GDK_NOTIFY_ANCESTOR"); break; + case GDK_NOTIFY_VIRTUAL: printf("GDK_NOTIFY_VIRTUAL"); break; + case GDK_NOTIFY_NONLINEAR: printf("GDK_NOTIFY_NONLINEAR"); break; + case GDK_NOTIFY_NONLINEAR_VIRTUAL: printf("GDK_NOTIFY_NONLINEAR_VIRTUAL"); break; + case GDK_NOTIFY_UNKNOWN: printf("GDK_NOTIFY_UNKNOWN"); break; + case GDK_NOTIFY_INFERIOR: printf("GDK_NOTIFY_INFERIOR"); break; + default: printf("unknown"); + } + printf("\n"); + printf("DEBUG_KB_GRABBING: --- Crossing event mode="); + switch (event->mode) { + case GDK_CROSSING_NORMAL: printf("GDK_CROSSING_NORMAL"); break; + case GDK_CROSSING_GRAB: printf("GDK_CROSSING_GRAB"); break; + case GDK_CROSSING_UNGRAB: printf("GDK_CROSSING_UNGRAB"); break; + case GDK_CROSSING_GTK_GRAB: printf("GDK_CROSSING_GTK_GRAB"); break; + case GDK_CROSSING_GTK_UNGRAB: printf("GDK_CROSSING_GTK_UNGRAB"); break; + case GDK_CROSSING_STATE_CHANGED: printf("GDK_CROSSING_STATE_CHANGED"); break; + case GDK_CROSSING_TOUCH_BEGIN: printf("GDK_CROSSING_TOUCH_BEGIN"); break; + case GDK_CROSSING_TOUCH_END: printf("GDK_CROSSING_TOUCH_END"); break; + case GDK_CROSSING_DEVICE_SWITCH: printf("GDK_CROSSING_DEVICE_SWITCH"); break; + default: printf("unknown"); + } + printf("\n"); +} +#endif + +static gboolean rcw_floating_toolbar_on_enter(GtkWidget *widget, GdkEventCrossing *event, + RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + rcw_floating_toolbar_show(cnnwin, TRUE); + return TRUE; +} + +static gboolean rcw_floating_toolbar_on_leave(GtkWidget *widget, GdkEventCrossing *event, + RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + if (event->detail != GDK_NOTIFY_INFERIOR) + rcw_floating_toolbar_show(cnnwin, FALSE); + return TRUE; +} + + +static gboolean rcw_on_enter_notify_event(GtkWidget *widget, GdkEventCrossing *event, + gpointer user_data) +{ + TRACE_CALL(__func__); +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: enter-notify-event on rcw received\n"); + print_crossing_event(event); +#endif + return FALSE; +} + + + +static gboolean rcw_on_leave_notify_event(GtkWidget *widget, GdkEventCrossing *event, + gpointer user_data) +{ + TRACE_CALL(__func__); + RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)widget; + +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: leave-notify-event on rcw received\n"); + print_crossing_event(event); +#endif + + if (event->mode != GDK_CROSSING_NORMAL && event->mode != GDK_CROSSING_UNGRAB) { +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: ignored because mode is not GDK_CROSSING_NORMAL GDK_CROSSING_UNGRAB\n"); +#endif + return FALSE; + } + + if (cnnwin->priv->delayed_grab_eventsourceid) { + g_source_remove(cnnwin->priv->delayed_grab_eventsourceid); + cnnwin->priv->delayed_grab_eventsourceid = 0; + } + + /* Workaround for https://gitlab.gnome.org/GNOME/mutter/-/issues/2450#note_1586570 */ + if (event->mode != GDK_CROSSING_UNGRAB) { + rcw_kp_ungrab(cnnwin); + rcw_pointer_ungrab(cnnwin); + } else { +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: not ungrabbing, this event seems to be an unwanted event from GTK\n"); +#endif + } + + return FALSE; +} + + +static gboolean rco_leave_protocol_widget(GtkWidget *widget, GdkEventCrossing *event, + RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: received leave event on RCO.\n"); + print_crossing_event(event); +#endif + + if (cnnobj->cnnwin->priv->delayed_grab_eventsourceid) { + g_source_remove(cnnobj->cnnwin->priv->delayed_grab_eventsourceid); + cnnobj->cnnwin->priv->delayed_grab_eventsourceid = 0; + } + + cnnobj->cnnwin->priv->pointer_entered = FALSE; + + /* Ungrab only if the leave is due to normal mouse motion and not to an inferior */ + if (event->mode == GDK_CROSSING_NORMAL && event->detail != GDK_NOTIFY_INFERIOR) + rcw_kp_ungrab(cnnobj->cnnwin); + + return FALSE; +} + + +gboolean rco_enter_protocol_widget(GtkWidget *widget, GdkEventCrossing *event, + RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + gboolean active; + +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: %s: enter on protocol widget event received\n", __func__); + print_crossing_event(event); +#endif + + RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv; + if (!priv->sticky && event->mode == GDK_CROSSING_NORMAL) + rcw_floating_toolbar_show(cnnobj->cnnwin, FALSE); + + priv->pointer_entered = TRUE; + + if (event->mode == GDK_CROSSING_UNGRAB) { + // Someone steal our grab, take note and do not attempt to regrab + cnnobj->cnnwin->priv->kbcaptured = FALSE; + cnnobj->cnnwin->priv->pointer_captured = FALSE; + return FALSE; + } + + /* Check if we need grabbing */ + active = gtk_window_is_active(GTK_WINDOW(cnnobj->cnnwin)); + if (remmina_file_get_int(cnnobj->remmina_file, "keyboard_grab", FALSE) && active) { + rcw_keyboard_grab(cnnobj->cnnwin); + rcw_pointer_grab(cnnobj->cnnwin); + } + + return FALSE; +} + +static gboolean focus_in_delayed_grab(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: %s\n", __func__); +#endif + if (cnnwin->priv->pointer_entered) { +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: delayed requesting kb and pointer grab, because of pointer inside\n"); +#endif + rcw_keyboard_grab(cnnwin); + rcw_pointer_grab(cnnwin); + } +#if DEBUG_KB_GRABBING + else { + printf("DEBUG_KB_GRABBING: %s not grabbing because pointer_entered is false\n", __func__); + } +#endif + cnnwin->priv->delayed_grab_eventsourceid = 0; + return G_SOURCE_REMOVE; +} + +static void rcw_focus_in(RemminaConnectionWindow *cnnwin) +{ + /* This function is the default signal handler for focus-in-event, + * but can also be called after a window focus state change event + * from rcw_state_event(). So expect to be called twice + * when cnnwin gains the focus */ + + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + if (cnnobj && cnnobj->connected && remmina_file_get_int(cnnobj->remmina_file, "keyboard_grab", FALSE)) { +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: Received focus in on rcw, grabbing enabled: requesting kb grab, delayed\n"); +#endif + if (cnnwin->priv->delayed_grab_eventsourceid == 0) + cnnwin->priv->delayed_grab_eventsourceid = g_timeout_add(300, (GSourceFunc)focus_in_delayed_grab, cnnwin); + } +#if DEBUG_KB_GRABBING + else { + printf("DEBUG_KB_GRABBING: Received focus in on rcw, but a condition will prevent to grab\n"); + } +#endif +} + +static void rcw_focus_out(RemminaConnectionWindow *cnnwin) +{ + /* This function is the default signal handler for focus-out-event, + * but can also be called after a window focus state change event + * from rcw_state_event(). So expect to be called twice + * when cnnwin loses the focus */ + + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + rcw_kp_ungrab(cnnwin); + + cnnwin->priv->hostkey_activated = FALSE; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + if (REMMINA_IS_SCROLLED_VIEWPORT(cnnobj->scrolled_container)) + remmina_scrolled_viewport_remove_motion(REMMINA_SCROLLED_VIEWPORT(cnnobj->scrolled_container)); + + if (cnnobj->proto && cnnobj->scrolled_container) + remmina_protocol_widget_call_feature_by_type(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + REMMINA_PROTOCOL_FEATURE_TYPE_UNFOCUS, 0); +} + +static gboolean +rcw_floating_toolbar_hide(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + + priv->hidetb_eventsource = 0; + rcw_floating_toolbar_show(cnnwin, FALSE); + return G_SOURCE_REMOVE; +} + +static gboolean rcw_floating_toolbar_on_scroll(GtkWidget *widget, GdkEventScroll *event, + RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + int opacity; + + cnnobj = rcw_get_visible_cnnobj(cnnwin); + if (!cnnobj) + return TRUE; + + opacity = remmina_file_get_int(cnnobj->remmina_file, "toolbar_opacity", 0); + switch (event->direction) { + case GDK_SCROLL_UP: + if (opacity > 0) { + remmina_file_set_int(cnnobj->remmina_file, "toolbar_opacity", opacity - 1); + rcw_update_toolbar_opacity(cnnwin); + return TRUE; + } + break; + case GDK_SCROLL_DOWN: + if (opacity < TOOLBAR_OPACITY_LEVEL) { + remmina_file_set_int(cnnobj->remmina_file, "toolbar_opacity", opacity + 1); + rcw_update_toolbar_opacity(cnnwin); + return TRUE; + } + break; +#if GTK_CHECK_VERSION(3, 4, 0) + case GDK_SCROLL_SMOOTH: + if (event->delta_y < 0 && opacity > 0) { + remmina_file_set_int(cnnobj->remmina_file, "toolbar_opacity", opacity - 1); + rcw_update_toolbar_opacity(cnnwin); + return TRUE; + } + if (event->delta_y > 0 && opacity < TOOLBAR_OPACITY_LEVEL) { + remmina_file_set_int(cnnobj->remmina_file, "toolbar_opacity", opacity + 1); + rcw_update_toolbar_opacity(cnnwin); + return TRUE; + } + break; +#endif + default: + break; + } + return TRUE; +} + +static gboolean rcw_after_configure_scrolled(gpointer user_data) +{ + TRACE_CALL(__func__); + gint width, height; + GdkWindowState s; + gint ipg, npages; + RemminaConnectionWindow *cnnwin; + + cnnwin = (RemminaConnectionWindow *)user_data; + + if (!cnnwin || !cnnwin->priv) + return FALSE; + + s = gdk_window_get_state(gtk_widget_get_window(GTK_WIDGET(cnnwin))); + + + /* Changed window_maximize, window_width and window_height for all + * connections inside the notebook */ + npages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(cnnwin->priv->notebook)); + for (ipg = 0; ipg < npages; ipg++) { + RemminaConnectionObject *cnnobj; + cnnobj = g_object_get_data( + G_OBJECT(gtk_notebook_get_nth_page(GTK_NOTEBOOK(cnnwin->priv->notebook), ipg)), + "cnnobj"); + if (s & GDK_WINDOW_STATE_MAXIMIZED) { + remmina_file_set_int(cnnobj->remmina_file, "window_maximize", TRUE); + } else { + gtk_window_get_size(GTK_WINDOW(cnnobj->cnnwin), &width, &height); + remmina_file_set_int(cnnobj->remmina_file, "window_width", width); + remmina_file_set_int(cnnobj->remmina_file, "window_height", height); + remmina_file_set_int(cnnobj->remmina_file, "window_maximize", FALSE); + } + } + cnnwin->priv->acs_eventsourceid = 0; + return FALSE; +} + +static gboolean rcw_on_configure(GtkWidget *widget, GdkEventConfigure *event, + gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionWindow *cnnwin; + RemminaConnectionObject *cnnobj; + + if (!REMMINA_IS_CONNECTION_WINDOW(widget)) + return FALSE; + + cnnwin = (RemminaConnectionWindow *)widget; + + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return FALSE; + + if (cnnwin->priv->acs_eventsourceid) { + g_source_remove(cnnwin->priv->acs_eventsourceid); + cnnwin->priv->acs_eventsourceid = 0; + } + + if (gtk_widget_get_window(GTK_WIDGET(cnnwin)) + && cnnwin->priv->view_mode == SCROLLED_WINDOW_MODE) + /* Under GNOME Shell we receive this configure_event BEFORE a window + * is really unmaximized, so we must read its new state and dimensions + * later, not now */ + cnnwin->priv->acs_eventsourceid = g_timeout_add(500, rcw_after_configure_scrolled, cnnwin); + + if (cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE) + /* Notify window of change so that scroll border can be hidden or shown if needed */ + rco_check_resize(cnnobj); + return FALSE; +} + +static void rcw_update_pin(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + if (cnnwin->priv->pin_down) + gtk_button_set_image(GTK_BUTTON(cnnwin->priv->pin_button), + gtk_image_new_from_icon_name("org.remmina.Remmina-pin-down-symbolic", GTK_ICON_SIZE_MENU)); + else + gtk_button_set_image(GTK_BUTTON(cnnwin->priv->pin_button), + gtk_image_new_from_icon_name("org.remmina.Remmina-pin-up-symbolic", GTK_ICON_SIZE_MENU)); +} + +static void rcw_toolbar_pin(GtkWidget *widget, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + remmina_pref.toolbar_pin_down = cnnwin->priv->pin_down = !cnnwin->priv->pin_down; + remmina_pref_save(); + rcw_update_pin(cnnwin); +} + +static void rcw_create_floating_toolbar(RemminaConnectionWindow *cnnwin, gint mode) +{ + TRACE_CALL(__func__); + + RemminaConnectionWindowPriv *priv = cnnwin->priv; + GtkWidget *ftb_widget; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *label; + GtkWidget *pinbutton; + GtkWidget *tb; + + + /* A widget to be used for GtkOverlay for GTK >= 3.10 */ + ftb_widget = gtk_event_box_new(); + + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); + gtk_widget_show(vbox); + + gtk_container_add(GTK_CONTAINER(ftb_widget), vbox); + + tb = rcw_create_toolbar(cnnwin, mode); + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); + gtk_widget_show(hbox); + + + /* The pin button */ + pinbutton = gtk_button_new(); + gtk_widget_show(pinbutton); + gtk_box_pack_start(GTK_BOX(hbox), pinbutton, FALSE, FALSE, 0); + gtk_button_set_relief(GTK_BUTTON(pinbutton), GTK_RELIEF_NONE); +#if GTK_CHECK_VERSION(3, 20, 0) + gtk_widget_set_focus_on_click(GTK_WIDGET(pinbutton), FALSE); +#else + gtk_button_set_focus_on_click(GTK_BUTTON(pinbutton), FALSE); +#endif + gtk_widget_set_name(pinbutton, "remmina-pin-button"); + g_signal_connect(G_OBJECT(pinbutton), "clicked", G_CALLBACK(rcw_toolbar_pin), cnnwin); + priv->pin_button = pinbutton; + priv->pin_down = remmina_pref.toolbar_pin_down; + rcw_update_pin(cnnwin); + + + label = gtk_label_new(""); + gtk_label_set_max_width_chars(GTK_LABEL(label), 50); + gtk_widget_show(label); + + gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); + + priv->floating_toolbar_label = label; + + if (remmina_pref.floating_toolbar_placement == FLOATING_TOOLBAR_PLACEMENT_BOTTOM) { + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(vbox), tb, FALSE, FALSE, 0); + } else { + gtk_box_pack_start(GTK_BOX(vbox), tb, FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); + } + + priv->floating_toolbar_widget = ftb_widget; + gtk_widget_show(ftb_widget); +} + +static void rcw_toolbar_place_signal(RemminaConnectionWindow *cnnwin, gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv; + + priv = cnnwin->priv; + /* Detach old toolbar widget and reattach in new position in the grid */ + if (priv->toolbar && priv->grid) { + g_object_ref(priv->toolbar); + gtk_container_remove(GTK_CONTAINER(priv->grid), priv->toolbar); + rcw_place_toolbar(GTK_TOOLBAR(priv->toolbar), GTK_GRID(priv->grid), GTK_WIDGET(priv->notebook), remmina_pref.toolbar_placement); + g_object_unref(priv->toolbar); + } +} + + +static void rcw_init(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv; + + priv = g_new0(RemminaConnectionWindowPriv, 1); + cnnwin->priv = priv; + + priv->view_mode = SCROLLED_WINDOW_MODE; + if (kioskmode && kioskmode == TRUE) + priv->view_mode = VIEWPORT_FULLSCREEN_MODE; + + priv->floating_toolbar_opacity = 1.0; + priv->kbcaptured = FALSE; + priv->pointer_captured = FALSE; + priv->pointer_entered = FALSE; + priv->fss_view_mode = VIEWPORT_FULLSCREEN_MODE; + priv->ss_width = 640; + priv->ss_height = 480; + priv->ss_maximized = FALSE; + + remmina_widget_pool_register(GTK_WIDGET(cnnwin)); +} + +static gboolean rcw_focus_in_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data) +{ + TRACE_CALL(__func__); +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: RCW focus-in-event received\n"); +#endif + rcw_focus_in((RemminaConnectionWindow *)widget); + return FALSE; +} + +static gboolean rcw_focus_out_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data) +{ + TRACE_CALL(__func__); +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: RCW focus-out-event received\n"); +#endif + rcw_focus_out((RemminaConnectionWindow *)widget); + return FALSE; +} + + +static gboolean rcw_state_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data) +{ + TRACE_CALL(__func__); + + if (!REMMINA_IS_CONNECTION_WINDOW(widget)) + return FALSE; + +#if DEBUG_KB_GRABBING + printf("DEBUG_KB_GRABBING: window-state-event received\n"); +#endif + + if (event->changed_mask & GDK_WINDOW_STATE_FOCUSED) { + if (event->new_window_state & GDK_WINDOW_STATE_FOCUSED) + rcw_focus_in((RemminaConnectionWindow *)widget); + else + rcw_focus_out((RemminaConnectionWindow *)widget); + } + + return FALSE; +} + +static gboolean rcw_map_event(GtkWidget *widget, GdkEvent *event, gpointer data) +{ + TRACE_CALL(__func__); + + + + RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)widget; + RemminaConnectionObject *cnnobj; + RemminaProtocolWidget *gp; + + if (cnnwin->priv->toolbar_is_reconfiguring) return FALSE; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return FALSE; + + gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto); + REMMINA_DEBUG("Mapping: %s", gtk_widget_get_name(widget)); + if (remmina_protocol_widget_map_event(gp)) + REMMINA_DEBUG("Called plugin mapping function"); + return FALSE; +} + +static gboolean rcw_unmap_event(GtkWidget *widget, GdkEvent *event, gpointer data) +{ + TRACE_CALL(__func__); + + RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)widget; + RemminaConnectionObject *cnnobj; + RemminaProtocolWidget *gp; + + if (cnnwin->priv->toolbar_is_reconfiguring) return FALSE; + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return FALSE; + + gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto); + REMMINA_DEBUG("Unmapping: %s", gtk_widget_get_name(widget)); + if (remmina_protocol_widget_unmap_event(gp)) + REMMINA_DEBUG("Called plugin mapping function"); + return FALSE; +} + +static gboolean rcw_map_event_fullscreen(GtkWidget *widget, GdkEvent *event, gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + gint target_monitor; + + REMMINA_DEBUG("Mapping: %s", gtk_widget_get_name(widget)); + + if (!REMMINA_IS_CONNECTION_WINDOW(widget)) { + REMMINA_DEBUG("Remmina Connection Window undefined, cannot go fullscreen"); + return FALSE; + } + + //RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)data; + cnnobj = rcw_get_visible_cnnobj((RemminaConnectionWindow *)widget); + //cnnobj = g_object_get_data(G_OBJECT(widget), "cnnobj"); + if (!cnnobj) { + REMMINA_DEBUG("Remmina Connection Object undefined, cannot go fullscreen"); + return FALSE; + } + + RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto); + + if (!gp) + REMMINA_DEBUG("Remmina Protocol Widget undefined, cannot go fullscreen"); + + if (remmina_protocol_widget_get_multimon(gp) >= 1) { + REMMINA_DEBUG("Fullscreen on all monitor"); + gdk_window_set_fullscreen_mode(gtk_widget_get_window(widget), GDK_FULLSCREEN_ON_ALL_MONITORS); + gdk_window_fullscreen(gtk_widget_get_window(widget)); + return TRUE; + } else { + REMMINA_DEBUG("Fullscreen on one monitor"); + } + + target_monitor = GPOINTER_TO_INT(data); + +#if GTK_CHECK_VERSION(3, 18, 0) + if (remmina_pref.fullscreen_on_auto) { + if (target_monitor == FULL_SCREEN_TARGET_MONITOR_UNDEFINED) + gtk_window_fullscreen(GTK_WINDOW(widget)); + else + gtk_window_fullscreen_on_monitor(GTK_WINDOW(widget), gtk_window_get_screen(GTK_WINDOW(widget)), + target_monitor); + } else { + REMMINA_DEBUG("Fullscreen managed by WM or by the user, as per settings"); + gtk_window_fullscreen(GTK_WINDOW(widget)); + } +#else + REMMINA_DEBUG("Cannot fullscreen on a specific monitor, feature available from GTK 3.18"); + gtk_window_fullscreen(GTK_WINDOW(widget)); +#endif + + if (remmina_protocol_widget_map_event(gp)) + REMMINA_DEBUG("Called plugin mapping function"); + + return FALSE; +} + +static RemminaConnectionWindow * +rcw_new(gboolean fullscreen, int full_screen_target_monitor) +{ + TRACE_CALL(__func__); + RemminaConnectionWindow *cnnwin; + + cnnwin = RCW(g_object_new(REMMINA_TYPE_CONNECTION_WINDOW, NULL)); + cnnwin->priv->on_delete_confirm_mode = RCW_ONDELETE_CONFIRM_IF_2_OR_MORE; + + if (fullscreen) + /* Put the window in fullscreen after it is mapped to have it appear on the same monitor */ + g_signal_connect(G_OBJECT(cnnwin), "map-event", G_CALLBACK(rcw_map_event_fullscreen), GINT_TO_POINTER(full_screen_target_monitor)); + else + g_signal_connect(G_OBJECT(cnnwin), "map-event", G_CALLBACK(rcw_map_event), NULL); + g_signal_connect(G_OBJECT(cnnwin), "unmap-event", G_CALLBACK(rcw_unmap_event), NULL); + + gtk_container_set_border_width(GTK_CONTAINER(cnnwin), 0); + g_signal_connect(G_OBJECT(cnnwin), "toolbar-place", G_CALLBACK(rcw_toolbar_place_signal), NULL); + + g_signal_connect(G_OBJECT(cnnwin), "delete-event", G_CALLBACK(rcw_delete_event), NULL); + g_signal_connect(G_OBJECT(cnnwin), "destroy", G_CALLBACK(rcw_destroy), NULL); + + /* Under Xorg focus-in-event and focus-out-event don’t work when keyboard is grabbed + * via gdk_device_grab. So we listen for window-state-event to detect focus in and focus out. + * But we must also listen focus-in-event and focus-out-event because some + * window managers missing _NET_WM_STATE_FOCUSED hint, does not update the window state + * in case of focus change */ + g_signal_connect(G_OBJECT(cnnwin), "window-state-event", G_CALLBACK(rcw_state_event), NULL); + g_signal_connect(G_OBJECT(cnnwin), "focus-in-event", G_CALLBACK(rcw_focus_in_event), NULL); + g_signal_connect(G_OBJECT(cnnwin), "focus-out-event", G_CALLBACK(rcw_focus_out_event), NULL); + + g_signal_connect(G_OBJECT(cnnwin), "enter-notify-event", G_CALLBACK(rcw_on_enter_notify_event), NULL); + g_signal_connect(G_OBJECT(cnnwin), "leave-notify-event", G_CALLBACK(rcw_on_leave_notify_event), NULL); + + + g_signal_connect(G_OBJECT(cnnwin), "configure_event", G_CALLBACK(rcw_on_configure), NULL); + + return cnnwin; +} + +/* This function will be called for the first connection. A tag is set to the window so that + * other connections can determine if whether a new tab should be append to the same window + */ +static void rcw_update_tag(RemminaConnectionWindow *cnnwin, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + gchar *tag; + + switch (remmina_pref.tab_mode) { + case REMMINA_TAB_BY_GROUP: + tag = g_strdup(remmina_file_get_string(cnnobj->remmina_file, "group")); + break; + case REMMINA_TAB_BY_PROTOCOL: + tag = g_strdup(remmina_file_get_string(cnnobj->remmina_file, "protocol")); + break; + default: + tag = NULL; + break; + } + g_object_set_data_full(G_OBJECT(cnnwin), "tag", tag, (GDestroyNotify)g_free); +} + +void rcw_grab_focus(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + if (!(cnnobj = rcw_get_visible_cnnobj(cnnwin))) return; + + if (GTK_IS_WIDGET(cnnobj->proto)) + remmina_protocol_widget_grab_focus(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); +} + +static GtkWidget *nb_find_page_by_cnnobj(GtkNotebook *notebook, RemminaConnectionObject *cnnobj) +{ + gint i, np; + GtkWidget *found_page, *pg; + + if (cnnobj == NULL || cnnobj->cnnwin == NULL || cnnobj->cnnwin->priv == NULL) + return NULL; + found_page = NULL; + np = gtk_notebook_get_n_pages(cnnobj->cnnwin->priv->notebook); + for (i = 0; i < np; i++) { + pg = gtk_notebook_get_nth_page(cnnobj->cnnwin->priv->notebook, i); + if (g_object_get_data(G_OBJECT(pg), "cnnobj") == cnnobj) { + found_page = pg; + break; + } + } + + return found_page; +} + + +void rco_closewin(RemminaProtocolWidget *gp) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj = gp->cnnobj; + GtkWidget *page_to_remove; + + + if (cnnobj && cnnobj->scrolled_container && REMMINA_IS_SCROLLED_VIEWPORT(cnnobj->scrolled_container)) { + REMMINA_DEBUG("deleting motion"); + remmina_scrolled_viewport_remove_motion(REMMINA_SCROLLED_VIEWPORT(cnnobj->scrolled_container)); + } + + if (cnnobj && cnnobj->cnnwin) { + page_to_remove = nb_find_page_by_cnnobj(cnnobj->cnnwin->priv->notebook, cnnobj); + if (page_to_remove) { + gtk_notebook_remove_page( + cnnobj->cnnwin->priv->notebook, + gtk_notebook_page_num(cnnobj->cnnwin->priv->notebook, page_to_remove)); + /* Invalidate pointers to objects destroyed by page removal */ + cnnobj->aspectframe = NULL; + cnnobj->viewport = NULL; + cnnobj->scrolled_container = NULL; + /* we cannot invalidate cnnobj->proto, because it can be already been + * detached from the widget hierarchy in rco_on_disconnect() */ + } + } + if (cnnobj) { + cnnobj->remmina_file = NULL; + g_free(cnnobj); + gp->cnnobj = NULL; + } + + remmina_application_condexit(REMMINA_CONDEXIT_ONDISCONNECT); +} + +void rco_on_close_button_clicked(GtkButton *button, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + if (REMMINA_IS_PROTOCOL_WIDGET(cnnobj->proto)) { + if (!remmina_protocol_widget_is_closed((RemminaProtocolWidget *)cnnobj->proto)) + remmina_protocol_widget_close_connection(REMMINA_PROTOCOL_WIDGET(cnnobj->proto)); + else + rco_closewin((RemminaProtocolWidget *)cnnobj->proto); + } +} + +static GtkWidget *rco_create_tab_label(RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + GtkWidget *hbox; + GtkWidget *widget; + GtkWidget *button; + + hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); + gtk_widget_show(hbox); + + widget = gtk_image_new_from_icon_name(remmina_file_get_icon_name(cnnobj->remmina_file), GTK_ICON_SIZE_MENU); + gtk_widget_show(widget); + gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0); + + widget = gtk_label_new(remmina_file_get_string(cnnobj->remmina_file, "name")); + gtk_widget_set_valign(widget, GTK_ALIGN_CENTER); + gtk_widget_set_halign(widget, GTK_ALIGN_CENTER); + + gtk_widget_show(widget); + gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0); + + button = gtk_button_new(); // The "x" to close the tab + gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); +#if GTK_CHECK_VERSION(3, 20, 0) + gtk_widget_set_focus_on_click(GTK_WIDGET(widget), FALSE); +#else + gtk_button_set_focus_on_click(GTK_BUTTON(button), FALSE); +#endif + gtk_widget_set_name(button, "remmina-small-button"); + gtk_widget_show(button); + + widget = gtk_image_new_from_icon_name("window-close", GTK_ICON_SIZE_MENU); + gtk_widget_show(widget); + gtk_container_add(GTK_CONTAINER(button), widget); + + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); + + g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(rco_on_close_button_clicked), cnnobj); + + + return hbox; +} + +static GtkWidget *rco_create_tab_page(RemminaConnectionObject *cnnobj) +{ + GtkWidget *page; + + page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); + gtk_widget_set_name(page, "remmina-tab-page"); + + + return page; +} + +static GtkWidget *rcw_append_new_page(RemminaConnectionWindow *cnnwin, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + GtkWidget *page, *label; + GtkNotebook *notebook; + + notebook = cnnwin->priv->notebook; + + page = rco_create_tab_page(cnnobj); + g_object_set_data(G_OBJECT(page), "cnnobj", cnnobj); + label = rco_create_tab_label(cnnobj); + + cnnobj->cnnwin = cnnwin; + + gtk_notebook_append_page(notebook, page, label); + gtk_notebook_set_tab_reorderable(notebook, page, TRUE); + gtk_notebook_set_tab_detachable(notebook, page, TRUE); + /* This trick prevents the tab label from being focused */ + gtk_widget_set_can_focus(gtk_widget_get_parent(label), FALSE); + + if (gtk_widget_get_parent(cnnobj->scrolled_container) != NULL) + printf("REMMINA WARNING in %s: scrolled_container already has a parent\n", __func__); + gtk_box_pack_start(GTK_BOX(page), cnnobj->scrolled_container, TRUE, TRUE, 0); + + gtk_widget_show(page); + + return page; +} + + +static void rcw_update_notebook(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + GtkNotebook *notebook; + gint n; + + notebook = GTK_NOTEBOOK(cnnwin->priv->notebook); + + switch (cnnwin->priv->view_mode) { + case SCROLLED_WINDOW_MODE: + n = gtk_notebook_get_n_pages(notebook); + gtk_notebook_set_show_tabs(notebook, remmina_pref.always_show_tab ? TRUE : n > 1); + gtk_notebook_set_show_border(notebook, remmina_pref.always_show_tab ? TRUE : n > 1); + break; + default: + gtk_notebook_set_show_tabs(notebook, FALSE); + gtk_notebook_set_show_border(notebook, FALSE); + break; + } +} + +static gboolean rcw_on_switch_page_finalsel(gpointer user_data) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv; + RemminaConnectionObject *cnnobj; + + if (!user_data) + return FALSE; + + cnnobj = (RemminaConnectionObject *)user_data; + if (!cnnobj->cnnwin) + return FALSE; + + priv = cnnobj->cnnwin->priv; + + if (GTK_IS_WIDGET(cnnobj->cnnwin)) { + rcw_floating_toolbar_show(cnnobj->cnnwin, TRUE); + if (!priv->hidetb_eventsource) + priv->hidetb_eventsource = g_timeout_add(TB_HIDE_TIME_TIME, (GSourceFunc) + rcw_floating_toolbar_hide, cnnobj->cnnwin); + rco_update_toolbar(cnnobj); + rcw_grab_focus(cnnobj->cnnwin); + if (priv->view_mode != SCROLLED_WINDOW_MODE) + rco_check_resize(cnnobj); + } + priv->spf_eventsourceid = 0; + return FALSE; +} + +static void rcw_on_switch_page(GtkNotebook *notebook, GtkWidget *newpage, guint page_num, + RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + RemminaConnectionWindowPriv *priv = cnnwin->priv; + RemminaConnectionObject *cnnobj_newpage; + + cnnobj_newpage = g_object_get_data(G_OBJECT(newpage), "cnnobj"); + if (priv->spf_eventsourceid) + g_source_remove(priv->spf_eventsourceid); + priv->spf_eventsourceid = g_idle_add(rcw_on_switch_page_finalsel, cnnobj_newpage); +} + +static void rcw_on_page_added(GtkNotebook *notebook, GtkWidget *child, guint page_num, + RemminaConnectionWindow *cnnwin) +{ + if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(cnnwin->priv->notebook)) > 0) + rcw_update_notebook(cnnwin); +} + +static void rcw_on_page_removed(GtkNotebook *notebook, GtkWidget *child, guint page_num, + RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + + if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(cnnwin->priv->notebook)) <= 0) + gtk_widget_destroy(GTK_WIDGET(cnnwin)); + +} + +static GtkNotebook * +rcw_on_notebook_create_window(GtkNotebook *notebook, GtkWidget *page, gint x, gint y, gpointer data) +{ + /* This signal callback is called by GTK when a detachable tab is dropped on the root window + * or in an existing window */ + + TRACE_CALL(__func__); + RemminaConnectionWindow *srccnnwin; + RemminaConnectionWindow *dstcnnwin; + RemminaConnectionObject *cnnobj; + GdkWindow *window; + gchar *srctag; + gint width, height; + +#if GTK_CHECK_VERSION(3, 20, 0) + GdkSeat *seat; +#else + GdkDeviceManager *manager; +#endif + GdkDevice *device = NULL; + +#if GTK_CHECK_VERSION(3, 20, 0) + seat = gdk_display_get_default_seat(gdk_display_get_default()); + device = gdk_seat_get_pointer(seat); +#else + manager = gdk_display_get_device_manager(gdk_display_get_default()); + device = gdk_device_manager_get_client_pointer(manager); +#endif + + window = gdk_device_get_window_at_position(device, &x, &y); + srccnnwin = RCW(gtk_widget_get_toplevel(GTK_WIDGET(notebook))); + dstcnnwin = RCW(remmina_widget_pool_find_by_window(REMMINA_TYPE_CONNECTION_WINDOW, window)); + + if (srccnnwin == dstcnnwin) + return NULL; + + if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(srccnnwin->priv->notebook)) == 1 && !dstcnnwin) + return NULL; + + cnnobj = (RemminaConnectionObject *)g_object_get_data(G_OBJECT(page), "cnnobj"); + + if (!dstcnnwin) { + /* Drop is directed to a new rcw: create a new scrolled window to accommodate + * the dropped connectionand move our cnnobj there. Width and + * height of the new window are cloned from the current window */ + srctag = (gchar *)g_object_get_data(G_OBJECT(srccnnwin), "tag"); + gtk_window_get_size(GTK_WINDOW(srccnnwin), &width, &height); + dstcnnwin = rcw_create_scrolled(width, height, FALSE); // New dropped window is never maximized + g_object_set_data_full(G_OBJECT(dstcnnwin), "tag", g_strdup(srctag), (GDestroyNotify)g_free); + /* when returning, GTK will move the whole tab to the new notebook. + * Prepare cnnobj to be hosted in the new cnnwin */ + cnnobj->cnnwin = dstcnnwin; + } else { + cnnobj->cnnwin = dstcnnwin; + } + + remmina_protocol_widget_set_hostkey_func(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + (RemminaHostkeyFunc)rcw_hostkey_func); + + return GTK_NOTEBOOK(cnnobj->cnnwin->priv->notebook); +} + +static GtkNotebook * +rcw_create_notebook(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + GtkNotebook *notebook; + + notebook = GTK_NOTEBOOK(gtk_notebook_new()); + + gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE); + gtk_widget_show(GTK_WIDGET(notebook)); + + g_signal_connect(G_OBJECT(notebook), "create-window", G_CALLBACK(rcw_on_notebook_create_window), NULL); + g_signal_connect(G_OBJECT(notebook), "switch-page", G_CALLBACK(rcw_on_switch_page), cnnwin); + g_signal_connect(G_OBJECT(notebook), "page-added", G_CALLBACK(rcw_on_page_added), cnnwin); + g_signal_connect(G_OBJECT(notebook), "page-removed", G_CALLBACK(rcw_on_page_removed), cnnwin); + gtk_widget_set_can_focus(GTK_WIDGET(notebook), FALSE); + + return notebook; +} + +/* Create a scrolled toplevel window */ +static RemminaConnectionWindow *rcw_create_scrolled(gint width, gint height, gboolean maximize) +{ + TRACE_CALL(__func__); + RemminaConnectionWindow *cnnwin; + GtkWidget *grid; + GtkWidget *toolbar; + GtkNotebook *notebook; + GtkSettings *settings = gtk_settings_get_default(); + + cnnwin = rcw_new(FALSE, 0); + gtk_widget_realize(GTK_WIDGET(cnnwin)); + + gtk_window_set_default_size(GTK_WINDOW(cnnwin), width, height); + g_object_set(settings, "gtk-application-prefer-dark-theme", remmina_pref.dark_theme, NULL); + + /* Create the toolbar */ + toolbar = rcw_create_toolbar(cnnwin, SCROLLED_WINDOW_MODE); + + /* Create the notebook */ + notebook = rcw_create_notebook(cnnwin); + + /* Create the grid container for toolbars+notebook and populate it */ + grid = gtk_grid_new(); + + + gtk_grid_attach(GTK_GRID(grid), GTK_WIDGET(notebook), 0, 0, 1, 1); + + gtk_widget_set_hexpand(GTK_WIDGET(notebook), TRUE); + gtk_widget_set_vexpand(GTK_WIDGET(notebook), TRUE); + + rcw_place_toolbar(GTK_TOOLBAR(toolbar), GTK_GRID(grid), GTK_WIDGET(notebook), remmina_pref.toolbar_placement); + + gtk_container_add(GTK_CONTAINER(cnnwin), grid); + + /* Add drag capabilities to the toolbar */ + gtk_drag_source_set(GTK_WIDGET(toolbar), GDK_BUTTON1_MASK, + dnd_targets_tb, sizeof dnd_targets_tb / sizeof *dnd_targets_tb, GDK_ACTION_MOVE); + g_signal_connect_after(GTK_WIDGET(toolbar), "drag-begin", G_CALLBACK(rcw_tb_drag_begin), NULL); + g_signal_connect(GTK_WIDGET(toolbar), "drag-failed", G_CALLBACK(rcw_tb_drag_failed), cnnwin); + + /* Add drop capabilities to the drop/dest target for the toolbar (the notebook) */ + gtk_drag_dest_set(GTK_WIDGET(notebook), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT, + dnd_targets_tb, sizeof dnd_targets_tb / sizeof *dnd_targets_tb, GDK_ACTION_MOVE); + gtk_drag_dest_set_track_motion(GTK_WIDGET(notebook), TRUE); + g_signal_connect(GTK_WIDGET(notebook), "drag-drop", G_CALLBACK(rcw_tb_drag_drop), cnnwin); + + cnnwin->priv->view_mode = SCROLLED_WINDOW_MODE; + cnnwin->priv->toolbar = toolbar; + cnnwin->priv->grid = grid; + cnnwin->priv->notebook = notebook; + cnnwin->priv->ss_width = width; + cnnwin->priv->ss_height = height; + cnnwin->priv->ss_maximized = maximize; + + /* The notebook and all its child must be realized now, or a reparent will + * call unrealize() and will destroy a GtkSocket */ + gtk_widget_show(grid); + gtk_widget_show(GTK_WIDGET(cnnwin)); + GtkWindowGroup *wingrp = gtk_window_group_new(); + + gtk_window_group_add_window(wingrp, GTK_WINDOW(cnnwin)); + gtk_window_set_transient_for(GTK_WINDOW(cnnwin), NULL); + + if (maximize) + gtk_window_maximize(GTK_WINDOW(cnnwin)); + + + rcw_set_toolbar_visibility(cnnwin); + + return cnnwin; +} + +static void rcw_create_overlay_ftb_overlay(RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + + GtkWidget *revealer; + RemminaConnectionWindowPriv *priv; + + priv = cnnwin->priv; + + if (priv->overlay_ftb_overlay != NULL) { + gtk_widget_destroy(priv->overlay_ftb_overlay); + priv->overlay_ftb_overlay = NULL; + priv->revealer = NULL; + } + if (priv->overlay_ftb_fr != NULL) { + gtk_widget_destroy(priv->overlay_ftb_fr); + priv->overlay_ftb_fr = NULL; + } + + rcw_create_floating_toolbar(cnnwin, priv->fss_view_mode); + + priv->overlay_ftb_overlay = gtk_event_box_new(); + + GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); + + gtk_container_set_border_width(GTK_CONTAINER(vbox), 0); + + GtkWidget *handle = gtk_drawing_area_new(); + + gtk_widget_set_size_request(handle, 4, 4); + gtk_widget_set_name(handle, "ftb-handle"); + + revealer = gtk_revealer_new(); + + gtk_widget_set_halign(GTK_WIDGET(priv->overlay_ftb_overlay), GTK_ALIGN_CENTER); + + if (remmina_pref.floating_toolbar_placement == FLOATING_TOOLBAR_PLACEMENT_BOTTOM) { + gtk_box_pack_start(GTK_BOX(vbox), handle, FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(vbox), revealer, FALSE, FALSE, 0); + gtk_revealer_set_transition_type(GTK_REVEALER(revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP); + gtk_widget_set_valign(GTK_WIDGET(priv->overlay_ftb_overlay), GTK_ALIGN_END); + } else { + gtk_box_pack_start(GTK_BOX(vbox), revealer, FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(vbox), handle, FALSE, FALSE, 0); + gtk_revealer_set_transition_type(GTK_REVEALER(revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN); + gtk_widget_set_valign(GTK_WIDGET(priv->overlay_ftb_overlay), GTK_ALIGN_START); + } + + + gtk_container_add(GTK_CONTAINER(revealer), priv->floating_toolbar_widget); + gtk_widget_set_halign(GTK_WIDGET(revealer), GTK_ALIGN_CENTER); + gtk_widget_set_valign(GTK_WIDGET(revealer), GTK_ALIGN_START); + + priv->revealer = revealer; + + GtkWidget *fr; + + fr = gtk_frame_new(NULL); + priv->overlay_ftb_fr = fr; + gtk_container_add(GTK_CONTAINER(priv->overlay_ftb_overlay), fr); + gtk_container_add(GTK_CONTAINER(fr), vbox); + + gtk_widget_show(vbox); + gtk_widget_show(revealer); + gtk_widget_show(handle); + gtk_widget_show(priv->overlay_ftb_overlay); + gtk_widget_show(fr); + + if (remmina_pref.floating_toolbar_placement == FLOATING_TOOLBAR_PLACEMENT_BOTTOM) + gtk_widget_set_name(fr, "ftbbox-lower"); + else + gtk_widget_set_name(fr, "ftbbox-upper"); + + gtk_overlay_add_overlay(GTK_OVERLAY(priv->overlay), priv->overlay_ftb_overlay); + + rcw_floating_toolbar_show(cnnwin, TRUE); + + g_signal_connect(G_OBJECT(priv->overlay_ftb_overlay), "enter-notify-event", G_CALLBACK(rcw_floating_toolbar_on_enter), cnnwin); + g_signal_connect(G_OBJECT(priv->overlay_ftb_overlay), "leave-notify-event", G_CALLBACK(rcw_floating_toolbar_on_leave), cnnwin); + g_signal_connect(G_OBJECT(priv->overlay_ftb_overlay), "scroll-event", G_CALLBACK(rcw_floating_toolbar_on_scroll), cnnwin); + gtk_widget_add_events( + GTK_WIDGET(priv->overlay_ftb_overlay), + GDK_SCROLL_MASK +#if GTK_CHECK_VERSION(3, 4, 0) + | GDK_SMOOTH_SCROLL_MASK +#endif + ); + + /* Add drag and drop capabilities to the source */ + gtk_drag_source_set(GTK_WIDGET(priv->overlay_ftb_overlay), GDK_BUTTON1_MASK, + dnd_targets_ftb, sizeof dnd_targets_ftb / sizeof *dnd_targets_ftb, GDK_ACTION_MOVE); + g_signal_connect_after(GTK_WIDGET(priv->overlay_ftb_overlay), "drag-begin", G_CALLBACK(rcw_ftb_drag_begin), cnnwin); + + if (remmina_pref.fullscreen_toolbar_visibility == FLOATING_TOOLBAR_VISIBILITY_DISABLE) + /* toolbar in fullscreenmode disabled, hide everything */ + gtk_widget_hide(fr); +} + + +static gboolean rcw_ftb_drag_drop(GtkWidget *widget, GdkDragContext *context, + gint x, gint y, guint time, RemminaConnectionWindow *cnnwin) +{ + TRACE_CALL(__func__); + GtkAllocation wa; + gint new_floating_toolbar_placement; + RemminaConnectionObject *cnnobj; + + gtk_widget_get_allocation(widget, &wa); + + if (y >= wa.height / 2) + new_floating_toolbar_placement = FLOATING_TOOLBAR_PLACEMENT_BOTTOM; + else + new_floating_toolbar_placement = FLOATING_TOOLBAR_PLACEMENT_TOP; + + gtk_drag_finish(context, TRUE, TRUE, time); + + if (new_floating_toolbar_placement != remmina_pref.floating_toolbar_placement) { + /* Destroy and recreate the FTB */ + remmina_pref.floating_toolbar_placement = new_floating_toolbar_placement; + remmina_pref_save(); + rcw_create_overlay_ftb_overlay(cnnwin); + cnnobj = rcw_get_visible_cnnobj(cnnwin); + if (cnnobj) rco_update_toolbar(cnnobj); + } + + return TRUE; +} + +static void rcw_ftb_drag_begin(GtkWidget *widget, GdkDragContext *context, gpointer user_data) +{ + TRACE_CALL(__func__); + + cairo_surface_t *surface; + cairo_t *cr; + GtkAllocation wa; + double dashes[] = { 10 }; + + gtk_widget_get_allocation(widget, &wa); + + surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, wa.width, wa.height); + cr = cairo_create(surface); + cairo_set_source_rgb(cr, 0.6, 0.6, 0.6); + cairo_set_line_width(cr, 2); + cairo_set_dash(cr, dashes, 1, 0); + cairo_rectangle(cr, 0, 0, wa.width, wa.height); + cairo_stroke(cr); + cairo_destroy(cr); + + gtk_drag_set_icon_surface(context, surface); +} + +RemminaConnectionWindow *rcw_create_fullscreen(GtkWindow *old, gint view_mode) +{ + TRACE_CALL(__func__); + RemminaConnectionWindow *cnnwin; + GtkNotebook *notebook; + +#if GTK_CHECK_VERSION(3, 22, 0) + gint n_monitors; + gint i; + GdkMonitor *old_monitor; + GdkDisplay *old_display; + GdkWindow *old_window; +#endif + gint full_screen_target_monitor; + + full_screen_target_monitor = FULL_SCREEN_TARGET_MONITOR_UNDEFINED; + if (old) { +#if GTK_CHECK_VERSION(3, 22, 0) + old_window = gtk_widget_get_window(GTK_WIDGET(old)); + old_display = gdk_window_get_display(old_window); + old_monitor = gdk_display_get_monitor_at_window(old_display, old_window); + n_monitors = gdk_display_get_n_monitors(old_display); + for (i = 0; i < n_monitors; ++i) { + if (gdk_display_get_monitor(old_display, i) == old_monitor) { + full_screen_target_monitor = i; + break; + } + } +#else + full_screen_target_monitor = gdk_screen_get_monitor_at_window( + gdk_screen_get_default(), + gtk_widget_get_window(GTK_WIDGET(old))); +#endif + } + + cnnwin = rcw_new(TRUE, full_screen_target_monitor); + gtk_widget_set_name(GTK_WIDGET(cnnwin), "remmina-connection-window-fullscreen"); + gtk_widget_realize(GTK_WIDGET(cnnwin)); + + if (!view_mode) + view_mode = VIEWPORT_FULLSCREEN_MODE; + + notebook = rcw_create_notebook(cnnwin); + + cnnwin->priv->overlay = gtk_overlay_new(); + gtk_container_add(GTK_CONTAINER(cnnwin), cnnwin->priv->overlay); + gtk_container_add(GTK_CONTAINER(cnnwin->priv->overlay), GTK_WIDGET(notebook)); + gtk_widget_show(GTK_WIDGET(cnnwin->priv->overlay)); + + cnnwin->priv->notebook = notebook; + cnnwin->priv->view_mode = view_mode; + cnnwin->priv->fss_view_mode = view_mode; + + /* Create the floating toolbar */ + rcw_create_overlay_ftb_overlay(cnnwin); + /* Add drag and drop capabilities to the drop/dest target for floating toolbar */ + gtk_drag_dest_set(GTK_WIDGET(cnnwin->priv->overlay), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT, + dnd_targets_ftb, sizeof dnd_targets_ftb / sizeof *dnd_targets_ftb, GDK_ACTION_MOVE); + gtk_drag_dest_set_track_motion(GTK_WIDGET(cnnwin->priv->notebook), TRUE); + g_signal_connect(GTK_WIDGET(cnnwin->priv->overlay), "drag-drop", G_CALLBACK(rcw_ftb_drag_drop), cnnwin); + + gtk_widget_show(GTK_WIDGET(cnnwin)); + GtkWindowGroup *wingrp = gtk_window_group_new(); + gtk_window_group_add_window(wingrp, GTK_WINDOW(cnnwin)); + gtk_window_set_transient_for(GTK_WINDOW(cnnwin), NULL); + + return cnnwin; +} + +static gboolean rcw_hostkey_func(RemminaProtocolWidget *gp, guint keyval, gboolean release) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj = gp->cnnobj; + RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv; + const RemminaProtocolFeature *feature; + gint i; + + if (release) { + if (remmina_pref.hostkey && keyval == remmina_pref.hostkey) { + priv->hostkey_activated = FALSE; + if (priv->hostkey_used) + /* hostkey pressed + something else */ + return TRUE; + } + /* If hostkey is released without pressing other keys, we should execute the + * shortcut key which is the same as hostkey. Be default, this is grab/ungrab + * keyboard */ + else if (priv->hostkey_activated) { + /* Trap all key releases when hostkey is pressed */ + /* hostkey pressed + something else */ + return TRUE; + } else { + /* Any key pressed, no hostkey */ + return FALSE; + } + } else if (remmina_pref.hostkey && keyval == remmina_pref.hostkey) { + /** @todo Add callback for hostname transparent overlay #832 */ + priv->hostkey_activated = TRUE; + priv->hostkey_used = FALSE; + return TRUE; + } else if (!priv->hostkey_activated) { + /* Any key pressed, no hostkey */ + return FALSE; + } + + priv->hostkey_used = TRUE; + keyval = gdk_keyval_to_lower(keyval); + if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Down + || keyval == GDK_KEY_Left || keyval == GDK_KEY_Right) { + GtkAdjustment *adjust; + int pos; + + if (cnnobj->connected && GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container)) { + if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Down) + adjust = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container)); + else + adjust = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container)); + + if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Left) + pos = 0; + else + pos = gtk_adjustment_get_upper(adjust); + + gtk_adjustment_set_value(adjust, pos); + if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Down) + gtk_scrolled_window_set_vadjustment(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container), adjust); + else + gtk_scrolled_window_set_hadjustment(GTK_SCROLLED_WINDOW(cnnobj->scrolled_container), adjust); + } else if (REMMINA_IS_SCROLLED_VIEWPORT(cnnobj->scrolled_container)) { + RemminaScrolledViewport *gsv; + GtkWidget *child; + GdkWindow *gsvwin; + gint sz; + GtkAdjustment *adj; + gdouble value; + + if (!GTK_IS_BIN(cnnobj->scrolled_container)) + return FALSE; + + gsv = REMMINA_SCROLLED_VIEWPORT(cnnobj->scrolled_container); + child = gtk_bin_get_child(GTK_BIN(gsv)); + if (!GTK_IS_VIEWPORT(child)) + return FALSE; + + gsvwin = gtk_widget_get_window(GTK_WIDGET(gsv)); + if (!gsv) + return FALSE; + + if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Down) { + sz = gdk_window_get_height(gsvwin) + 2; // Add 2px of black scroll border + adj = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(child)); + } else { + sz = gdk_window_get_width(gsvwin) + 2; // Add 2px of black scroll border + adj = gtk_scrollable_get_hadjustment(GTK_SCROLLABLE(child)); + } + + if (keyval == GDK_KEY_Up || keyval == GDK_KEY_Left) + value = 0; + else + value = gtk_adjustment_get_upper(GTK_ADJUSTMENT(adj)) - (gdouble)sz + 2.0; + + gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), value); + } + } + + if (keyval == remmina_pref.shortcutkey_fullscreen && !extrahardening) { + switch (priv->view_mode) { + case SCROLLED_WINDOW_MODE: + rcw_switch_viewmode(cnnobj->cnnwin, priv->fss_view_mode); + break; + case SCROLLED_FULLSCREEN_MODE: + case VIEWPORT_FULLSCREEN_MODE: + rcw_switch_viewmode(cnnobj->cnnwin, SCROLLED_WINDOW_MODE); + break; + default: + break; + } + } else if (keyval == remmina_pref.shortcutkey_autofit && !extrahardening) { + if (priv->toolitem_autofit && gtk_widget_is_sensitive(GTK_WIDGET(priv->toolitem_autofit))) + rcw_toolbar_autofit(GTK_TOOL_ITEM(gp), cnnobj->cnnwin); + } else if (keyval == remmina_pref.shortcutkey_nexttab && !extrahardening) { + i = gtk_notebook_get_current_page(GTK_NOTEBOOK(priv->notebook)) + 1; + if (i >= gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook))) + i = 0; + gtk_notebook_set_current_page(GTK_NOTEBOOK(priv->notebook), i); + } else if (keyval == remmina_pref.shortcutkey_prevtab && !extrahardening) { + i = gtk_notebook_get_current_page(GTK_NOTEBOOK(priv->notebook)) - 1; + if (i < 0) + i = gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->notebook)) - 1; + gtk_notebook_set_current_page(GTK_NOTEBOOK(priv->notebook), i); + } else if (keyval == remmina_pref.shortcutkey_clipboard && !extrahardening) { + if (remmina_protocol_widget_plugin_receives_keystrokes(REMMINA_PROTOCOL_WIDGET(cnnobj->proto))) { + remmina_protocol_widget_send_clipboard((RemminaProtocolWidget*)cnnobj->proto, G_OBJECT(cnnobj->proto)); + } + } else if (keyval == remmina_pref.shortcutkey_scale && !extrahardening) { + if (gtk_widget_is_sensitive(GTK_WIDGET(priv->toolitem_scale))) { + gtk_toggle_tool_button_set_active( + GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_scale), + !gtk_toggle_tool_button_get_active( + GTK_TOGGLE_TOOL_BUTTON( + priv->toolitem_scale))); + } + } else if (keyval == remmina_pref.shortcutkey_grab && !extrahardening) { + gtk_toggle_tool_button_set_active( + GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_grab), + !gtk_toggle_tool_button_get_active( + GTK_TOGGLE_TOOL_BUTTON( + priv->toolitem_grab))); + } else if (keyval == remmina_pref.shortcutkey_minimize && !extrahardening) { + rcw_toolbar_minimize(GTK_TOOL_ITEM(gp), + cnnobj->cnnwin); + } else if (keyval == remmina_pref.shortcutkey_viewonly && !extrahardening) { + remmina_file_set_int(cnnobj->remmina_file, "viewonly", + (remmina_file_get_int(cnnobj->remmina_file, "viewonly", 0) + == 0) ? 1 : 0); + } else if (keyval == remmina_pref.shortcutkey_screenshot && !extrahardening) { + rcw_toolbar_screenshot(GTK_TOOL_ITEM(gp), + cnnobj->cnnwin); + } else if (keyval == remmina_pref.shortcutkey_disconnect && !extrahardening) { + rco_disconnect_current_page(cnnobj); + } else if (keyval == remmina_pref.shortcutkey_toolbar && !extrahardening) { + if (priv->view_mode == SCROLLED_WINDOW_MODE) { + remmina_pref.hide_connection_toolbar = + !remmina_pref.hide_connection_toolbar; + rcw_set_toolbar_visibility(cnnobj->cnnwin); + } + } else { + for (feature = + remmina_protocol_widget_get_features( + REMMINA_PROTOCOL_WIDGET( + cnnobj->proto)); + feature && feature->type; + feature++) { + if (feature->type + == REMMINA_PROTOCOL_FEATURE_TYPE_TOOL + && GPOINTER_TO_UINT( + feature->opt3) + == keyval) { + remmina_protocol_widget_call_feature_by_ref( + REMMINA_PROTOCOL_WIDGET( + cnnobj->proto), + feature); + break; + } + } + } + /* If a keypress makes the current cnnobj to move to another window, + * priv is now invalid. So we can no longer use priv here */ + cnnobj->cnnwin->priv->hostkey_activated = FALSE; + + /* Trap all keypresses when hostkey is pressed */ + return TRUE; +} + +static RemminaConnectionWindow *rcw_find(RemminaFile *remminafile) +{ + TRACE_CALL(__func__); + const gchar *tag; + + switch (remmina_pref.tab_mode) { + case REMMINA_TAB_BY_GROUP: + tag = remmina_file_get_string(remminafile, "group"); + break; + case REMMINA_TAB_BY_PROTOCOL: + tag = remmina_file_get_string(remminafile, "protocol"); + break; + case REMMINA_TAB_ALL: + tag = NULL; + break; + case REMMINA_TAB_NONE: + default: + return NULL; + } + return RCW(remmina_widget_pool_find(REMMINA_TYPE_CONNECTION_WINDOW, tag)); +} + +gboolean rcw_delayed_window_present(gpointer user_data) +{ + RemminaConnectionWindow *cnnwin = (RemminaConnectionWindow *)user_data; + + if (cnnwin) { + gtk_window_present_with_time(GTK_WINDOW(cnnwin), (guint32)(g_get_monotonic_time() / 1000)); + rcw_grab_focus(cnnwin); + } + cnnwin->priv->dwp_eventsourceid = 0; + return G_SOURCE_REMOVE; +} + +void rco_on_connect(RemminaProtocolWidget *gp, RemminaConnectionObject *cnnobj) +{ + TRACE_CALL(__func__); + + REMMINA_DEBUG("Connect signal emitted"); + + /* This signal handler is called by a plugin when it’s correctly connected + * (and authenticated) */ + + cnnobj->connected = TRUE; + + remmina_protocol_widget_set_hostkey_func(REMMINA_PROTOCOL_WIDGET(cnnobj->proto), + (RemminaHostkeyFunc)rcw_hostkey_func); + + /** Remember recent list for quick connect, and save the current date + * in the last_used field. + */ + if (remmina_file_get_filename(cnnobj->remmina_file) == NULL) + remmina_pref_add_recent(remmina_file_get_string(cnnobj->remmina_file, "protocol"), + remmina_file_get_string(cnnobj->remmina_file, "server")); + REMMINA_DEBUG("We save the last successful connection date"); + //remmina_file_set_string(cnnobj->remmina_file, "last_success", last_success); + remmina_file_state_last_success(cnnobj->remmina_file); + //REMMINA_DEBUG("Last connection made on %s.", last_success); + + REMMINA_DEBUG("Saving credentials"); + /* Save credentials */ + remmina_file_save(cnnobj->remmina_file); + + if (cnnobj->cnnwin->priv->floating_toolbar_widget) + gtk_widget_show(cnnobj->cnnwin->priv->floating_toolbar_widget); + + rco_update_toolbar(cnnobj); + + REMMINA_DEBUG("Trying to present the window"); + /* Try to present window */ + cnnobj->cnnwin->priv->dwp_eventsourceid = g_timeout_add(200, rcw_delayed_window_present, (gpointer)cnnobj->cnnwin); +} + +static void cb_lasterror_confirmed(void *cbdata, int btn) +{ + TRACE_CALL(__func__); + rco_closewin((RemminaProtocolWidget *)cbdata); +} + +void rco_on_disconnect(RemminaProtocolWidget *gp, gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj = gp->cnnobj; + RemminaConnectionWindowPriv *priv = cnnobj->cnnwin->priv; + GtkWidget *pparent; + + REMMINA_DEBUG("Disconnect signal received on RemminaProtocolWidget"); + /* Detach the protocol widget from the notebook now, or we risk that a + * window delete will destroy cnnobj->proto before we complete disconnection. + */ + pparent = gtk_widget_get_parent(cnnobj->proto); + if (pparent != NULL) { + g_object_ref(cnnobj->proto); + gtk_container_remove(GTK_CONTAINER(pparent), cnnobj->proto); + } + + cnnobj->connected = FALSE; + + if (remmina_pref.save_view_mode) { + if (cnnobj->cnnwin) + remmina_file_set_int(cnnobj->remmina_file, "viewmode", cnnobj->cnnwin->priv->view_mode); + remmina_file_save(cnnobj->remmina_file); + } + + rcw_kp_ungrab(cnnobj->cnnwin); + gtk_toggle_tool_button_set_active( + GTK_TOGGLE_TOOL_BUTTON(priv->toolitem_grab), + FALSE); + + if (remmina_protocol_widget_has_error(gp)) { + /* We cannot close window immediately, but we must show a message panel */ + RemminaMessagePanel *mp; + /* Destroy scrolled_container (and viewport) and all its children the plugin created + * on it, so they will not receive GUI signals */ + if (cnnobj->scrolled_container) { + gtk_widget_destroy(cnnobj->scrolled_container); + cnnobj->scrolled_container = NULL; + } + cnnobj->viewport = NULL; + mp = remmina_message_panel_new(); + remmina_message_panel_setup_message(mp, remmina_protocol_widget_get_error_message(gp), cb_lasterror_confirmed, gp); + rco_show_message_panel(gp->cnnobj, mp); + REMMINA_DEBUG("Could not disconnect"); + } else { + rco_closewin(gp); + REMMINA_DEBUG("Disconnected"); + } +} + +void rco_on_desktop_resize(RemminaProtocolWidget *gp, gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj = gp->cnnobj; + + if (cnnobj && cnnobj->cnnwin && cnnobj->cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE) + rco_check_resize(cnnobj); +} + +void rco_on_update_align(RemminaProtocolWidget *gp, gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj = gp->cnnobj; + + remmina_protocol_widget_update_alignment(cnnobj); +} + +void rco_on_lock_dynres(RemminaProtocolWidget *gp, gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj = gp->cnnobj; + + cnnobj->dynres_unlocked = FALSE; + rco_update_toolbar(cnnobj); +} + +void rco_on_unlock_dynres(RemminaProtocolWidget *gp, gpointer data) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj = gp->cnnobj; + + cnnobj->dynres_unlocked = TRUE; + rco_update_toolbar(cnnobj); +} + +gboolean rcw_open_from_filename(const gchar *filename) +{ + TRACE_CALL(__func__); + RemminaFile *remminafile; + GtkWidget *dialog; + + remminafile = remmina_file_manager_load_file(filename); + if (remminafile) { + if (remmina_file_get_int (remminafile, "profile-lock", FALSE) + && remmina_unlock_new(remmina_main_get_window()) == 0) + return FALSE; + rcw_open_from_file(remminafile); + return TRUE; + } else { + dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, + _("The file “%s” is corrupted, unreadable, or could not be found."), filename); + g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL); + gtk_widget_show(dialog); + remmina_widget_pool_register(dialog); + return FALSE; + } +} + +static gboolean open_connection_last_stage(gpointer user_data) +{ + RemminaProtocolWidget *gp = (RemminaProtocolWidget *)user_data; + + /* Now we have an allocated size for our RemminaProtocolWidget. We can proceed with the connection */ + remmina_protocol_widget_update_remote_resolution(gp); + remmina_protocol_widget_open_connection(gp); + rco_check_resize(gp->cnnobj); + + return FALSE; +} + +static void rpw_size_allocated_on_connection(GtkWidget *w, GdkRectangle *allocation, gpointer user_data) +{ + RemminaProtocolWidget *gp = (RemminaProtocolWidget *)w; + + /* Disconnect signal handler to avoid to be called again after a normal resize */ + g_signal_handler_disconnect(w, gp->cnnobj->deferred_open_size_allocate_handler); + + /* Allow extra 100 ms for size allocation (do we really need it?) */ + g_timeout_add(100, open_connection_last_stage, gp); + + return; +} + +void rcw_open_from_file(RemminaFile *remminafile) +{ + TRACE_CALL(__func__); + rcw_open_from_file_full(remminafile, NULL, NULL, NULL); +} + +static void set_label_selectable(gpointer data, gpointer user_data) +{ + TRACE_CALL(__func__); + GtkWidget *widget = GTK_WIDGET(data); + + if (GTK_IS_LABEL(widget)) + gtk_label_set_selectable(GTK_LABEL(widget), TRUE); +} + +/** + * @brief These define the response id's of the + * gtksocket-is-not-available-warning-dialog buttons. + */ +enum GTKSOCKET_NOT_AVAIL_RESPONSE_TYPE { + GTKSOCKET_NOT_AVAIL_RESPONSE_OPEN_BROWSER = 0, + GTKSOCKET_NOT_AVAIL_RESPONSE_NUM +}; + +/** + * @brief Gets called if the user interacts with the + * gtksocket-is-not-available-warning-dialog + */ +static void rcw_gtksocket_not_available_dialog_response(GtkDialog * self, + gint response_id, + RemminaConnectionObject * cnnobj) +{ + TRACE_CALL(__func__); + + GError *error = NULL; + + if (response_id == GTKSOCKET_NOT_AVAIL_RESPONSE_OPEN_BROWSER) { + gtk_show_uri_on_window( + NULL, + // TRANSLATORS: This should be a link to the Remmina wiki page: + // TRANSLATORS: 'GtkSocket feature is not available'. + _("https://gitlab.com/Remmina/Remmina/-/wikis/GtkSocket-feature-is-not-available-in-a-Wayland-session"), + GDK_CURRENT_TIME, &error + ); + } + + // Close the current page since it's useless without GtkSocket. + // The user would need to manually click the close button. + if (cnnobj) rco_disconnect_current_page(cnnobj); + + gtk_widget_destroy(GTK_WIDGET(self)); +} + +GtkWidget *rcw_open_from_file_full(RemminaFile *remminafile, GCallback disconnect_cb, gpointer data, guint *handler) +{ + TRACE_CALL(__func__); + RemminaConnectionObject *cnnobj; + + gint ret; + GtkWidget *dialog; + GtkWidget *newpage; + gint width, height; + gboolean maximize; + gint view_mode; + const gchar *msg; + RemminaScaleMode scalemode; + + if (disconnect_cb) { + g_print("disconnect_cb is deprecated inside rcw_open_from_file_full() and should be null\n"); + return NULL; + } + + + /* Create the RemminaConnectionObject */ + cnnobj = g_new0(RemminaConnectionObject, 1); + cnnobj->remmina_file = remminafile; + + /* Create the RemminaProtocolWidget */ + cnnobj->proto = remmina_protocol_widget_new(); + remmina_protocol_widget_setup((RemminaProtocolWidget *)cnnobj->proto, remminafile, cnnobj); + if (remmina_protocol_widget_has_error((RemminaProtocolWidget *)cnnobj->proto)) { + GtkWindow *wparent; + wparent = remmina_main_get_window(); + msg = remmina_protocol_widget_get_error_message((RemminaProtocolWidget *)cnnobj->proto); + dialog = gtk_message_dialog_new(wparent, GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", msg); + gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); + /* We should destroy cnnobj->proto and cnnobj now… TODO: Fix this leak */ + return NULL; + } + + + + /* Set a name for the widget, for CSS selector */ + gtk_widget_set_name(GTK_WIDGET(cnnobj->proto), "remmina-protocol-widget"); + + gtk_widget_set_halign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL); + gtk_widget_set_valign(GTK_WIDGET(cnnobj->proto), GTK_ALIGN_FILL); + + if (data) + g_object_set_data(G_OBJECT(cnnobj->proto), "user-data", data); + + view_mode = remmina_file_get_int(cnnobj->remmina_file, "viewmode", 0); + if (kioskmode) + view_mode = VIEWPORT_FULLSCREEN_MODE; + gint ismultimon = remmina_file_get_int(cnnobj->remmina_file, "multimon", 0); + + if (ismultimon) + view_mode = VIEWPORT_FULLSCREEN_MODE; + + if (fullscreen) + view_mode = VIEWPORT_FULLSCREEN_MODE; + + /* Create the viewport to make the RemminaProtocolWidget scrollable */ + cnnobj->viewport = gtk_viewport_new(NULL, NULL); + gtk_widget_set_name(cnnobj->viewport, "remmina-cw-viewport"); + gtk_widget_show(cnnobj->viewport); + gtk_container_set_border_width(GTK_CONTAINER(cnnobj->viewport), 0); + gtk_viewport_set_shadow_type(GTK_VIEWPORT(cnnobj->viewport), GTK_SHADOW_NONE); + + /* Create the scrolled container */ + scalemode = get_current_allowed_scale_mode(cnnobj, NULL, NULL); + cnnobj->scrolled_container = rco_create_scrolled_container(scalemode, view_mode); + + gtk_container_add(GTK_CONTAINER(cnnobj->scrolled_container), cnnobj->viewport); + + /* Determine whether the plugin can scale or not. If the plugin can scale and we do + * not want to expand, then we add a GtkAspectFrame to maintain aspect ratio during scaling */ + cnnobj->plugin_can_scale = remmina_plugin_manager_query_feature_by_type(REMMINA_PLUGIN_TYPE_PROTOCOL, + remmina_file_get_string(remminafile, "protocol"), + REMMINA_PROTOCOL_FEATURE_TYPE_SCALE); + + cnnobj->aspectframe = NULL; + gtk_container_add(GTK_CONTAINER(cnnobj->viewport), cnnobj->proto); + + /* Determine whether this connection will be put on a new window + * or in an existing one */ + cnnobj->cnnwin = rcw_find(remminafile); + if (!cnnobj->cnnwin) { + /* Connection goes on a new toplevel window */ + switch (view_mode) { + case SCROLLED_FULLSCREEN_MODE: + case VIEWPORT_FULLSCREEN_MODE: + cnnobj->cnnwin = rcw_create_fullscreen(NULL, view_mode); + break; + case SCROLLED_WINDOW_MODE: + default: + width = remmina_file_get_int(cnnobj->remmina_file, "window_width", 640); + height = remmina_file_get_int(cnnobj->remmina_file, "window_height", 480); + maximize = remmina_file_get_int(cnnobj->remmina_file, "window_maximize", FALSE) ? TRUE : FALSE; + cnnobj->cnnwin = rcw_create_scrolled(width, height, maximize); + break; + } + rcw_update_tag(cnnobj->cnnwin, cnnobj); + rcw_append_new_page(cnnobj->cnnwin, cnnobj); + } else { + newpage = rcw_append_new_page(cnnobj->cnnwin, cnnobj); + gtk_window_present(GTK_WINDOW(cnnobj->cnnwin)); + nb_set_current_page(cnnobj->cnnwin->priv->notebook, newpage); + } + + // Do not call remmina_protocol_widget_update_alignment(cnnobj); here or cnnobj->proto will not fill its parent size + // and remmina_protocol_widget_update_remote_resolution() cannot autodetect available space + + gtk_widget_show(cnnobj->proto); + g_signal_connect(G_OBJECT(cnnobj->proto), "connect", G_CALLBACK(rco_on_connect), cnnobj); + g_signal_connect(G_OBJECT(cnnobj->proto), "disconnect", G_CALLBACK(rco_on_disconnect), NULL); + g_signal_connect(G_OBJECT(cnnobj->proto), "desktop-resize", G_CALLBACK(rco_on_desktop_resize), NULL); + g_signal_connect(G_OBJECT(cnnobj->proto), "update-align", G_CALLBACK(rco_on_update_align), NULL); + g_signal_connect(G_OBJECT(cnnobj->proto), "lock-dynres", G_CALLBACK(rco_on_lock_dynres), NULL); + g_signal_connect(G_OBJECT(cnnobj->proto), "unlock-dynres", G_CALLBACK(rco_on_unlock_dynres), NULL); + g_signal_connect(G_OBJECT(cnnobj->proto), "enter-notify-event", G_CALLBACK(rco_enter_protocol_widget), cnnobj); + g_signal_connect(G_OBJECT(cnnobj->proto), "leave-notify-event", G_CALLBACK(rco_leave_protocol_widget), cnnobj); + + if (!remmina_pref.save_view_mode) + remmina_file_set_int(cnnobj->remmina_file, "viewmode", remmina_pref.default_mode); + + + /* If it is a GtkSocket plugin and X11 is not available, we inform the + * user and close the connection */ + ret = remmina_plugin_manager_query_feature_by_type(REMMINA_PLUGIN_TYPE_PROTOCOL, + remmina_file_get_string(remminafile, "protocol"), + REMMINA_PROTOCOL_FEATURE_TYPE_GTKSOCKET); + if (ret && !remmina_gtksocket_available()) { + gchar *title = _("Warning: This plugin requires GtkSocket, but this " + "feature is unavailable in a Wayland session."); + + gchar *err_msg = + // TRANSLATORS: This should be a link to the Remmina wiki page: + // 'GtkSocket feature is not available'. + _("Plugins relying on GtkSocket can't run in a " + "Wayland session.\nFor more info and a possible " + "workaround, please visit the Remmina wiki at:\n\n" + "https://gitlab.com/Remmina/Remmina/-/wikis/GtkSocket-feature-is-not-available-in-a-Wayland-session"); + + dialog = gtk_message_dialog_new( + GTK_WINDOW(cnnobj->cnnwin), + GTK_DIALOG_MODAL, + GTK_MESSAGE_WARNING, + GTK_BUTTONS_OK, + "%s", title); + + gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s", + err_msg); + gtk_dialog_add_button(GTK_DIALOG(dialog), _("Open in web browser"), + GTKSOCKET_NOT_AVAIL_RESPONSE_OPEN_BROWSER); + + REMMINA_CRITICAL(g_strdup_printf("%s\n%s", title, err_msg)); + + g_signal_connect(G_OBJECT(dialog), + "response", + G_CALLBACK(rcw_gtksocket_not_available_dialog_response), + cnnobj); + + // Make Text selectable. Usefull because of the link in the text. + GtkWidget *area = gtk_message_dialog_get_message_area( + GTK_MESSAGE_DIALOG(dialog)); + GtkContainer *box = (GtkContainer *)area; + + GList *children = gtk_container_get_children(box); + g_list_foreach(children, set_label_selectable, NULL); + g_list_free(children); + + gtk_widget_show(dialog); + + return NULL; /* Should we destroy something before returning? */ + } + + if (cnnobj->cnnwin->priv->floating_toolbar_widget) + gtk_widget_show(cnnobj->cnnwin->priv->floating_toolbar_widget); + + if (remmina_protocol_widget_has_error((RemminaProtocolWidget *)cnnobj->proto)) { + printf("OK, an error occurred in initializing the protocol plugin before connecting. The error is %s.\n" + "TODO: Put this string as an error to show", remmina_protocol_widget_get_error_message((RemminaProtocolWidget *)cnnobj->proto)); + return cnnobj->proto; + } + + + /* GTK window setup is done here, and we are almost ready to call remmina_protocol_widget_open_connection(). + * But size has not yet been allocated by GTK + * to the widgets. If we are in RES_USE_INITIAL_WINDOW_SIZE resolution mode or scale is REMMINA_PROTOCOL_WIDGET_SCALE_MODE_DYNRES, + * we should wait for a size allocation from GTK for cnnobj->proto + * before connecting */ + + cnnobj->deferred_open_size_allocate_handler = g_signal_connect(G_OBJECT(cnnobj->proto), "size-allocate", G_CALLBACK(rpw_size_allocated_on_connection), NULL); + + return cnnobj->proto; +} + +GtkWindow *rcw_get_gtkwindow(RemminaConnectionObject *cnnobj) +{ + return &cnnobj->cnnwin->window; +} +GtkWidget *rcw_get_gtkviewport(RemminaConnectionObject *cnnobj) +{ + return cnnobj->viewport; +} + +void rcw_set_delete_confirm_mode(RemminaConnectionWindow *cnnwin, RemminaConnectionWindowOnDeleteConfirmMode mode) +{ + TRACE_CALL(__func__); + cnnwin->priv->on_delete_confirm_mode = mode; +} + +/** + * Deletes a RemminaMessagePanel from the current cnnobj + * and if it was visible, make visible the last remaining one. + */ +void rco_destroy_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp) +{ + TRACE_CALL(__func__); + GList *childs, *cc; + RemminaMessagePanel *lastPanel; + gboolean was_visible; + GtkWidget *page; + + page = nb_find_page_by_cnnobj(cnnobj->cnnwin->priv->notebook, cnnobj); + childs = gtk_container_get_children(GTK_CONTAINER(page)); + cc = g_list_first(childs); + while (cc != NULL) { + if ((RemminaMessagePanel *)cc->data == mp) + break; + cc = g_list_next(cc); + } + g_list_free(childs); + + if (cc == NULL) { + printf("Remmina: Warning. There was a request to destroy a RemminaMessagePanel that is not on the page\n"); + return; + } + was_visible = gtk_widget_is_visible(GTK_WIDGET(mp)); + gtk_widget_destroy(GTK_WIDGET(mp)); + + /* And now, show the last remaining message panel, if needed */ + if (was_visible) { + childs = gtk_container_get_children(GTK_CONTAINER(page)); + cc = g_list_first(childs); + lastPanel = NULL; + while (cc != NULL) { + if (G_TYPE_CHECK_INSTANCE_TYPE(cc->data, REMMINA_TYPE_MESSAGE_PANEL)) + lastPanel = (RemminaMessagePanel *)cc->data; + cc = g_list_next(cc); + } + g_list_free(childs); + if (lastPanel) + gtk_widget_show(GTK_WIDGET(lastPanel)); + } +} + +/** + * Each cnnobj->page can have more than one RemminaMessagePanel, but 0 or 1 are visible. + * + * This function adds a RemminaMessagePanel to cnnobj->page, move it to top, + * and makes it the only visible one. + */ +void rco_show_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp) +{ + TRACE_CALL(__func__); + GList *childs, *cc; + GtkWidget *page; + + /* Hides all RemminaMessagePanels childs of cnnobj->page */ + page = nb_find_page_by_cnnobj(cnnobj->cnnwin->priv->notebook, cnnobj); + childs = gtk_container_get_children(GTK_CONTAINER(page)); + cc = g_list_first(childs); + while (cc != NULL) { + if (G_TYPE_CHECK_INSTANCE_TYPE(cc->data, REMMINA_TYPE_MESSAGE_PANEL)) + gtk_widget_hide(GTK_WIDGET(cc->data)); + cc = g_list_next(cc); + } + g_list_free(childs); + + /* Add the new message panel at the top of cnnobj->page */ + gtk_box_pack_start(GTK_BOX(page), GTK_WIDGET(mp), FALSE, FALSE, 0); + gtk_box_reorder_child(GTK_BOX(page), GTK_WIDGET(mp), 0); + + /* Show the message panel */ + gtk_widget_show_all(GTK_WIDGET(mp)); + + /* Focus the correct field of the RemminaMessagePanel */ + remmina_message_panel_focus_auth_entry(mp); +} |