Go to the documentation of this file.

 /*
  * 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 *                 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 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);
     }
 }
 
 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"))
                 format = g_strconcat("<span bgcolor=\"", bg, "\" size=\"large\"><b>(G:ON) - \%s</b></span>", NULL);
             else
                 format = "<big><b>(G:ON) - \%s</b></big>";
         } else {
             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;
     }
 
     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);
     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) {
         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_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);
 
     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);
 }
 
 enum GTKSOCKET_NOT_AVAIL_RESPONSE_TYPE {
     GTKSOCKET_NOT_AVAIL_RESPONSE_OPEN_BROWSER = 0,
     GTKSOCKET_NOT_AVAIL_RESPONSE_NUM
 };
 
 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;
 }
 
 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));
     }
 }
 
 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);
 }

-
+
-
+
@@ -98,8 +98,8 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
-
+
+
@@ -110,7 +110,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
@@ -118,11 +118,11 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
-
+
@@ -140,12 +140,12 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
-
+
@@ -162,7 +162,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
@@ -181,19 +181,19 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
-
+
-
-
+
+
-
+
@@ -216,7 +216,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
@@ -224,11 +224,11 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
-
+
@@ -249,7 +249,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
@@ -259,7 +259,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
@@ -293,7 +293,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
@@ -304,17 +304,17 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
-
+
-
+
-
+
@@ -327,7 +327,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
@@ -340,7 +340,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
@@ -359,14 +359,14 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
-
+
@@ -389,7 +389,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
@@ -399,7 +399,7 @@ $(document).ready(function(){initNavTree('rcw_8c_source.html','');});
 
-
+
diff --git a/public/remmina__masterthread__exec_8c_source.html b/public/remmina__masterthread__exec_8c_source.html
index 1d41f0133..e8056c319 100644
--- a/public/remmina__masterthread__exec_8c_source.html
+++ b/public/remmina__masterthread__exec_8c_source.html
@@ -88,8 +88,8 @@ $(document).ready(function(){initNavTree('remmina__masterthread__exec_8c_source.
 Go to the documentation of this file. /*
  * 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.
  *
  */
 
 /* Support for execution on main thread of some GTK related
  * functions (due to threads deprecations in GTK) */
 
 #include <gtk/gtk.h>
 
 #include "remmina_masterthread_exec.h"
 
 static pthread_t gMainThreadID;
 
 static gboolean remmina_masterthread_exec_callback(RemminaMTExecData *d)
 {
 
     /* This function is called on main GTK Thread via gdk_threads_add_idlde()
      * from remmina_masterthread_exec_and_wait() */
 
     if (!d->cancelled) {
         switch (d->func) {
         case FUNC_INIT_SAVE_CRED:
             remmina_protocol_widget_save_cred(d->p.init_save_creds.gp);
             break;
         case FUNC_CHAT_RECEIVE:
             remmina_protocol_widget_chat_receive(d->p.chat_receive.gp, d->p.chat_receive.text);
             break;
         case FUNC_FILE_GET_STRING:
             d->p.file_get_string.retval = remmina_file_get_string( d->p.file_get_string.remminafile, d->p.file_get_string.setting );
             break;
         case FUNC_FILE_SET_STRING:
             remmina_file_set_string( d->p.file_set_string.remminafile, d->p.file_set_string.setting, d->p.file_set_string.value );
             break;
         case FUNC_GTK_LABEL_SET_TEXT:
             gtk_label_set_text( d->p.gtk_label_set_text.label, d->p.gtk_label_set_text.str );
             break;
         case FUNC_FTP_CLIENT_UPDATE_TASK:
             remmina_ftp_client_update_task( d->p.ftp_client_update_task.client, d->p.ftp_client_update_task.task );
             break;
         case FUNC_FTP_CLIENT_GET_WAITING_TASK:
             d->p.ftp_client_get_waiting_task.retval = remmina_ftp_client_get_waiting_task( d->p.ftp_client_get_waiting_task.client );
             break;
         case FUNC_PROTOCOLWIDGET_EMIT_SIGNAL:
             remmina_protocol_widget_emit_signal(d->p.protocolwidget_emit_signal.gp, d->p.protocolwidget_emit_signal.signal_name);
             break;
         case FUNC_PROTOCOLWIDGET_MPPROGRESS:
             d->p.protocolwidget_mpprogress.ret_mp = remmina_protocol_widget_mpprogress(d->p.protocolwidget_mpprogress.cnnobj, d->p.protocolwidget_mpprogress.message,
                 d->p.protocolwidget_mpprogress.response_callback, d->p.protocolwidget_mpprogress.response_callback_data);
             break;
         case FUNC_PROTOCOLWIDGET_MPDESTROY:
             remmina_protocol_widget_mpdestroy(d->p.protocolwidget_mpdestroy.cnnobj, d->p.protocolwidget_mpdestroy.mp);
             break;
         case FUNC_PROTOCOLWIDGET_MPSHOWRETRY:
             remmina_protocol_widget_panel_show_retry(d->p.protocolwidget_mpshowretry.gp);
             break;
         case FUNC_PROTOCOLWIDGET_PANELSHOWLISTEN:
             remmina_protocol_widget_panel_show_listen(d->p.protocolwidget_panelshowlisten.gp, d->p.protocolwidget_panelshowlisten.port);
             break;
         case FUNC_SFTP_CLIENT_CONFIRM_RESUME:
 #ifdef HAVE_LIBSSH
             d->p.sftp_client_confirm_resume.retval = remmina_sftp_client_confirm_resume( d->p.sftp_client_confirm_resume.client,
                 d->p.sftp_client_confirm_resume.path );
 #endif
             break;
         case FUNC_VTE_TERMINAL_SET_ENCODING_AND_PTY:
 #if defined (HAVE_LIBSSH) && defined (HAVE_LIBVTE)
             remmina_plugin_ssh_vte_terminal_set_encoding_and_pty( d->p.vte_terminal_set_encoding_and_pty.terminal,
                 d->p.vte_terminal_set_encoding_and_pty.codeset,
                 d->p.vte_terminal_set_encoding_and_pty.master,
                 d->p.vte_terminal_set_encoding_and_pty.slave);
 #endif
             break;
 
         }
         pthread_mutex_lock(&d->pt_mutex);
         d->complete = TRUE;
         pthread_cond_signal(&d->pt_cond);
         pthread_mutex_unlock(&d->pt_mutex);
     }else  {
         /* thread has been cancelled, so we must free d memory here */
         g_free(d);
     }
     return G_SOURCE_REMOVE;
 }
 
 static void remmina_masterthread_exec_cleanup_handler(gpointer data)
 {
     RemminaMTExecData *d = data;
 
     d->cancelled = TRUE;
 }
 
 void remmina_masterthread_exec_and_wait(RemminaMTExecData *d)
 {
     d->cancelled = FALSE;
     d->complete = FALSE;
     pthread_cleanup_push(remmina_masterthread_exec_cleanup_handler, (void*)d);
     pthread_mutex_init(&d->pt_mutex, NULL);
     pthread_cond_init(&d->pt_cond, NULL);
     gdk_threads_add_idle((GSourceFunc)remmina_masterthread_exec_callback, (gpointer)d);
     pthread_mutex_lock(&d->pt_mutex);
     while (!d->complete)
         pthread_cond_wait(&d->pt_cond, &d->pt_mutex);
     pthread_cleanup_pop(0);
     pthread_mutex_destroy(&d->pt_mutex);
     pthread_cond_destroy(&d->pt_cond);
 }
 
 void remmina_masterthread_exec_save_main_thread_id()
 {
     /* To be called from main thread at startup */
     gMainThreadID = pthread_self();
 }
 
 gboolean remmina_masterthread_exec_is_main_thread()
 {
     return pthread_equal(gMainThreadID, pthread_self()) != 0;
 }
 

-
-
+
+
@@ -102,22 +102,22 @@ $(document).ready(function(){initNavTree('remmina__masterthread__exec_8c_source.
 
-
+
-
+
-
-
+
+
-
+
diff --git a/public/remmina__plugin__manager_8c_source.html b/public/remmina__plugin__manager_8c_source.html
index ada58c214..f04d8bdce 100644
--- a/public/remmina__plugin__manager_8c_source.html
+++ b/public/remmina__plugin__manager_8c_source.html
@@ -86,47 +86,47 @@ $(document).ready(function(){initNavTree('remmina__plugin__manager_8c_source.htm
 remmina_plugin_manager.c

-Go to the documentation of this file. /*
  * Remmina - The GTK+ Remote Desktop Client
  * Copyright (C) 2010-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"
 
 
 #include <gtk/gtk.h>
 #include <glib/gi18n.h>
 #include <gmodule.h>
 #include <gio/gio.h>
 #include <string.h>
 #ifdef GDK_WINDOWING_X11
 #include <gdk/gdkx.h>
 #elif defined(GDK_WINDOWING_WAYLAND)
 #include <gdk/gdkwayland.h>
 #endif
 #include "remmina_public.h"
 #include "remmina_main.h"
 #include "remmina_file_manager.h"
 #include "remmina_pref.h"
 #include "remmina_protocol_widget.h"
 #include "remmina_log.h"
 #include "remmina_widget_pool.h"
 #include "rcw.h"
 #include "remmina_plugin_manager.h"
 #include "remmina_plugin_native.h"
 #include "remmina_public.h"
 #include "remmina_masterthread_exec.h"
 #include "remmina/remmina_trace_calls.h"
 
 static GPtrArray* remmina_plugin_table = NULL;
 
 /* A GHashTable of GHashTables where to store the names of the encrypted settings */
 static GHashTable *encrypted_settings_cache = NULL;
 
 /* There can be only one secret plugin loaded */
 static RemminaSecretPlugin *remmina_secret_plugin = NULL;
 
 // TRANSLATORS: "Language Wrapper" is a wrapper for plugins written in other programmin languages (Python in this context)
 static const gchar *remmina_plugin_type_name[] =
 { N_("Protocol"), N_("Entry"), N_("File"), N_("Tool"), N_("Preference"), N_("Secret"), N_("Language Wrapper"), NULL };
 
 static gint remmina_plugin_manager_compare_func(RemminaPlugin **a, RemminaPlugin **b)
 {
     TRACE_CALL(__func__);
     return g_strcmp0((*a)->name, (*b)->name);
 }
 
 static void htdestroy(gpointer ht)
 {
     g_hash_table_unref(ht);
 }
 
 static void init_settings_cache(RemminaPlugin *plugin)
 {
     TRACE_CALL(__func__);
     RemminaProtocolPlugin *protocol_plugin;
     const RemminaProtocolSetting* setting_iter;
     GHashTable *pht;
 
     /* This code make a encrypted setting cache only for protocol plugins */
 
     if (plugin->type != REMMINA_PLUGIN_TYPE_PROTOCOL) {
         return;
     }
 
     if (encrypted_settings_cache == NULL)
         encrypted_settings_cache = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, htdestroy);
 
     if (!(pht = g_hash_table_lookup(encrypted_settings_cache, plugin->name))) {
         pht = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
         g_hash_table_insert(encrypted_settings_cache, g_strdup(plugin->name), pht);
     }
 
     /* Some settings are encrypted "by name" */
     /* g_hash_table_insert(pht, g_strdup("proxy_password"), (gpointer)TRUE); */
 
     g_hash_table_insert(pht, g_strdup("ssh_tunnel_password"), (gpointer)TRUE);
     g_hash_table_insert(pht, g_strdup("ssh_tunnel_passphrase"), (gpointer)TRUE);
 
     /* ssh_password is no longer used starting from remmina 1.4.
      * But we MUST mark it as encrypted setting, or the migration procedure will fail */
     g_hash_table_insert(pht, g_strdup("ssh_password"), (gpointer)TRUE);
 
     /* Other settings are encrypted because of their type */
     protocol_plugin = (RemminaProtocolPlugin *)plugin;
     setting_iter = protocol_plugin->basic_settings;
     if (setting_iter) {
         while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
             if (setting_iter->type == REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD)
                 g_hash_table_insert(pht, g_strdup(remmina_plugin_manager_get_canonical_setting_name(setting_iter)), (gpointer)TRUE);
             setting_iter++;
         }
     }
     setting_iter = protocol_plugin->advanced_settings;
     if (setting_iter) {
         while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
             if (setting_iter->type == REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD)
                 g_hash_table_insert(pht, g_strdup(remmina_plugin_manager_get_canonical_setting_name(setting_iter)), (gpointer)TRUE);
             setting_iter++;
         }
     }
 
 }
 
 static gboolean remmina_plugin_manager_register_plugin(RemminaPlugin *plugin)
 {
     TRACE_CALL(__func__);
     if (plugin->type == REMMINA_PLUGIN_TYPE_SECRET) {
         g_print("Remmina plugin %s (type=%s) has been registered, but is not yet initialized/activated. "
             "The initialization order is %d.\n", plugin->name,
             _(remmina_plugin_type_name[plugin->type]),
             ((RemminaSecretPlugin*)plugin)->init_order);
     }
     init_settings_cache(plugin);
 
     g_ptr_array_add(remmina_plugin_table, plugin);
     g_ptr_array_sort(remmina_plugin_table, (GCompareFunc)remmina_plugin_manager_compare_func);
     return TRUE;
 }
 
 gboolean remmina_gtksocket_available()
 {
     GdkDisplayManager* dm;
     GdkDisplay* d;
     gboolean available;
 
     dm = gdk_display_manager_get();
     d = gdk_display_manager_get_default_display(dm);
     available = FALSE;
 
 #ifdef GDK_WINDOWING_X11
     if (GDK_IS_X11_DISPLAY(d)) {
         /* GtkSocket support is available only under X.Org */
         available = TRUE;
     }
 #endif
     return available;
 }
 
 RemminaPluginService remmina_plugin_manager_service =
 {
     remmina_plugin_manager_register_plugin,
     remmina_protocol_widget_get_width,
     remmina_protocol_widget_set_width,
     remmina_protocol_widget_get_height,
     remmina_protocol_widget_set_height,
     remmina_protocol_widget_get_current_scale_mode,
     remmina_protocol_widget_get_expand,
     remmina_protocol_widget_set_expand,
     remmina_protocol_widget_has_error,
     remmina_protocol_widget_set_error,
     remmina_protocol_widget_is_closed,
     remmina_protocol_widget_get_file,
     remmina_protocol_widget_emit_signal,
     remmina_protocol_widget_register_hostkey,
     remmina_protocol_widget_start_direct_tunnel,
     remmina_protocol_widget_start_reverse_tunnel,
     remmina_protocol_widget_start_xport_tunnel,
     remmina_protocol_widget_set_display,
     remmina_protocol_widget_signal_connection_closed,
     remmina_protocol_widget_signal_connection_opened,
     remmina_protocol_widget_update_align,
     remmina_protocol_widget_lock_dynres,
     remmina_protocol_widget_unlock_dynres,
     remmina_protocol_widget_desktop_resize,
     remmina_protocol_widget_panel_auth,
     remmina_protocol_widget_panel_new_certificate,
     remmina_protocol_widget_panel_changed_certificate,
     remmina_protocol_widget_get_username,
     remmina_protocol_widget_get_password,
     remmina_protocol_widget_get_domain,
     remmina_protocol_widget_get_savepassword,
     remmina_protocol_widget_panel_authx509,
     remmina_protocol_widget_get_cacert,
     remmina_protocol_widget_get_cacrl,
     remmina_protocol_widget_get_clientcert,
     remmina_protocol_widget_get_clientkey,
     remmina_protocol_widget_save_cred,
     remmina_protocol_widget_panel_show_listen,
     remmina_protocol_widget_panel_show_retry,
     remmina_protocol_widget_panel_show,
     remmina_protocol_widget_panel_hide,
     remmina_protocol_widget_ssh_exec,
     remmina_protocol_widget_chat_open,
     remmina_protocol_widget_chat_close,
     remmina_protocol_widget_chat_receive,
     remmina_protocol_widget_send_keys_signals,
 
     remmina_file_get_datadir,
 
     remmina_file_new,
     remmina_file_get_filename,
     remmina_file_set_string,
     remmina_file_get_string,
     remmina_file_get_secret,
     remmina_file_set_int,
     remmina_file_get_int,
     remmina_file_get_double,
     remmina_file_unsave_passwords,
 
     remmina_pref_set_value,
     remmina_pref_get_value,
     remmina_pref_get_scale_quality,
     remmina_pref_get_sshtunnel_port,
     remmina_pref_get_ssh_loglevel,
     remmina_pref_get_ssh_parseconfig,
     remmina_pref_keymap_get_table,
     remmina_pref_keymap_get_keyval,
 
     _remmina_info,
     _remmina_message,
     _remmina_debug,
     _remmina_warning,
     _remmina_audit,
     _remmina_error,
     _remmina_critical,
     remmina_log_print,
     remmina_log_printf,
 
     remmina_widget_pool_register,
 
     rcw_open_from_file_full,
     remmina_public_open_unix_sock,
     remmina_public_get_server_port,
     remmina_masterthread_exec_is_main_thread,
     remmina_gtksocket_available,
     remmina_protocol_widget_get_profile_remote_width,
     remmina_protocol_widget_get_profile_remote_height,
     remmina_protocol_widget_get_name,
     remmina_protocol_widget_get_width,
     remmina_protocol_widget_get_height,
     remmina_protocol_widget_set_width,
     remmina_protocol_widget_set_height,
     remmina_protocol_widget_get_current_scale_mode,
     remmina_protocol_widget_get_expand,
     remmina_protocol_widget_set_expand,
     remmina_protocol_widget_set_error,
     remmina_protocol_widget_has_error,
     remmina_protocol_widget_gtkviewport,
     remmina_protocol_widget_is_closed,
     remmina_protocol_widget_get_file,
     remmina_protocol_widget_panel_auth,
     remmina_protocol_widget_register_hostkey,
     remmina_protocol_widget_start_direct_tunnel,
     remmina_protocol_widget_start_reverse_tunnel,
     remmina_protocol_widget_send_keys_signals,
     remmina_protocol_widget_chat_receive,
     remmina_protocol_widget_panel_hide,
     remmina_protocol_widget_chat_open,
     remmina_protocol_widget_ssh_exec,
     remmina_protocol_widget_panel_show,
     remmina_protocol_widget_panel_show_retry,
     remmina_protocol_widget_start_xport_tunnel,
     remmina_protocol_widget_set_display,
     remmina_protocol_widget_signal_connection_closed,
     remmina_protocol_widget_signal_connection_opened,
     remmina_protocol_widget_update_align,
     remmina_protocol_widget_unlock_dynres,
     remmina_protocol_widget_desktop_resize,
     remmina_protocol_widget_panel_new_certificate,
     remmina_protocol_widget_panel_changed_certificate,
     remmina_protocol_widget_get_username,
     remmina_protocol_widget_get_password,
     remmina_protocol_widget_get_domain,
     remmina_protocol_widget_get_savepassword,
     remmina_protocol_widget_panel_authx509,
     remmina_protocol_widget_get_cacert,
     remmina_protocol_widget_get_cacrl,
     remmina_protocol_widget_get_clientcert,
     remmina_protocol_widget_get_clientkey,
     remmina_protocol_widget_save_cred,
     remmina_protocol_widget_panel_show_listen,
     remmina_widget_pool_register,
     rcw_open_from_file_full,
     remmina_main_show_dialog,
     remmina_main_get_window,
 };
 
 const char *get_filename_ext(const char *filename) {
     const char* last = strrchr(filename, '/');
     const char *dot = strrchr(last, '.');
     if(!dot || dot == filename) return "";
     return dot + 1;
 }
 
 static gint compare_secret_plugin_init_order(gconstpointer a, gconstpointer b)
 {
     RemminaSecretPlugin *sa, *sb;
 
     sa = (RemminaSecretPlugin*)a;
     sb = (RemminaSecretPlugin*)b;
 
     if (sa->init_order > sb->init_order)
         return 1;
     else if (sa->init_order < sb->init_order)
         return -1;
     return 0;
 }
 
 void remmina_plugin_manager_init()
 {
     TRACE_CALL(__func__);
     GDir *dir;
     const gchar *name, *ptr;
     gchar *fullpath;
     RemminaPlugin *plugin;
     RemminaSecretPlugin *sp;
     int i, j;
     GSList *secret_plugins;
     GSList *sple;
     GPtrArray *alternative_language_plugins;
 
     remmina_plugin_table = g_ptr_array_new();
     alternative_language_plugins = g_ptr_array_new();
 
     if (!g_module_supported()) {
         g_print("Dynamic loading of plugins is not supported on this platform!\n");
         return;
     }
 
     g_print("Load modules from %s\n", REMMINA_RUNTIME_PLUGINDIR);
     dir = g_dir_open(REMMINA_RUNTIME_PLUGINDIR, 0, NULL);
 
     if (dir == NULL)
         return;
     while ((name = g_dir_read_name(dir)) != NULL) {
         if ((ptr = strrchr(name, '.')) == NULL)
             continue;
         ptr++;
         fullpath = g_strdup_printf(REMMINA_RUNTIME_PLUGINDIR "/%s", name);
         if (!remmina_plugin_manager_loader_supported(ptr)) {
             g_ptr_array_add(alternative_language_plugins, g_strdup_printf(REMMINA_RUNTIME_PLUGINDIR "/%s", name));
             g_free(fullpath);
             continue;
         }
         remmina_plugin_native_load(&remmina_plugin_manager_service, fullpath);
         g_free(fullpath);
     }
     g_dir_close(dir);
 
     while (alternative_language_plugins->len > 0) {
         gboolean has_loaded = FALSE;
         gchar* name = (gchar*)g_ptr_array_remove_index(alternative_language_plugins, 0);
         const gchar* ext = get_filename_ext(name);
 
         for (j = 0; j < remmina_plugin_table->len && !has_loaded; j++) {
             plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, j);
             if (plugin->type == REMMINA_PLUGIN_TYPE_LANGUAGE_WRAPPER) {
                 RemminaLanguageWrapperPlugin* wrapper_plugin = (RemminaLanguageWrapperPlugin*)plugin;
                 const gchar** supported_extention = wrapper_plugin->supported_extentions;
                 while (*supported_extention) {
                     if (g_str_equal(*supported_extention, ext)) {
                         has_loaded = wrapper_plugin->load(wrapper_plugin, name);
                         if (has_loaded) {
                             break;
                         }
                     }
                     supported_extention++;
                 }
                 if (has_loaded) break;
             }
         }
 
         if (!has_loaded) {
             g_print("%s: Skip unsupported file type '%s'\n", name, ext);
         }
 
         g_free(name);
     }
 
     /* Now all secret plugins needs to initialize, following their init_order.
      * The 1st plugin which will initialize correctly will be
      * the default remmina_secret_plugin */
 
     if (remmina_secret_plugin)
         g_print("Internal ERROR: remmina_secret_plugin must be null here\n");
 
     secret_plugins = NULL;
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
         if (plugin->type == REMMINA_PLUGIN_TYPE_SECRET) {
             secret_plugins = g_slist_insert_sorted(secret_plugins, (gpointer)plugin, compare_secret_plugin_init_order);
         }
     }
 
     sple = secret_plugins;
     while(sple != NULL) {
         sp = (RemminaSecretPlugin*)sple->data;
         if (sp->init(sp)) {
             g_print("The %s secret plugin has been initialized and it will be your default secret plugin\n",
                 sp->name);
             remmina_secret_plugin = sp;
             break;
         }
         sple = sple->next;
     }
 
     g_slist_free(secret_plugins);
     g_ptr_array_free(alternative_language_plugins, TRUE);
 }
 
 gboolean remmina_plugin_manager_loader_supported(const char *filetype) {
     TRACE_CALL(__func__);
     return g_str_equal(G_MODULE_SUFFIX, filetype);
 }
 
 RemminaPlugin* remmina_plugin_manager_get_plugin(RemminaPluginType type, const gchar *name)
 {
     TRACE_CALL(__func__);
     RemminaPlugin *plugin;
     gint i;
 
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
         if (plugin->type == type && g_strcmp0(plugin->name, name) == 0) {
             return plugin;
         }
     }
     return NULL;
 }
 
 const gchar *remmina_plugin_manager_get_canonical_setting_name(const RemminaProtocolSetting* setting)
 {
     if (setting->name == NULL) {
         if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_SERVER)
             return "server";
         if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD)
             return "password";
         if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_RESOLUTION)
             return "resolution";
         if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_ASSISTANCE)
             return "assistance_mode";
         return "missing_setting_name_into_plugin_RemminaProtocolSetting";
     }
     return setting->name;
 }
 
 void remmina_plugin_manager_for_each_plugin(RemminaPluginType type, RemminaPluginFunc func, gpointer data)
 {
     TRACE_CALL(__func__);
     RemminaPlugin *plugin;
     gint i;
 
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
         if (plugin->type == type) {
             func((gchar*)plugin->name, plugin, data);
         }
     }
 }
 
 /* A copy of remmina_plugin_manager_show and remmina_plugin_manager_show_for_each
  * This is because we want to print the list of plugins, and their versions, to the standard output
  * with the remmina command line option --full-version instead of using the plugins widget
  ** @todo Investigate to use only GListStore and than pass the elements to be shown to 2 separate
  *       functions
  * WARNING: GListStore is supported only from GLib 2.44 */
 static gboolean remmina_plugin_manager_show_for_each_stdout(RemminaPlugin *plugin)
 {
     TRACE_CALL(__func__);
 
     g_print("%-20s%-16s%-64s%-10s\n", plugin->name,
         _(remmina_plugin_type_name[plugin->type]),
         g_dgettext(plugin->domain, plugin->description),
         plugin->version);
     return FALSE;
 }
 
 void remmina_plugin_manager_show_stdout()
 {
     TRACE_CALL(__func__);
     g_print("%-20s%-16s%-64s%-10s\n", "NAME", "TYPE", "DESCRIPTION", "PLUGIN AND LIBRARY VERSION");
     g_ptr_array_foreach(remmina_plugin_table, (GFunc)remmina_plugin_manager_show_for_each_stdout, NULL);
 }
 
 static gboolean remmina_plugin_manager_show_for_each(RemminaPlugin *plugin, GtkListStore *store)
 {
     TRACE_CALL(__func__);
     GtkTreeIter iter;
 
     gtk_list_store_append(store, &iter);
     gtk_list_store_set(store, &iter, 0, plugin->name, 1, _(remmina_plugin_type_name[plugin->type]), 2,
         g_dgettext(plugin->domain, plugin->description), 3, plugin->version, -1);
     return FALSE;
 }
 
 void remmina_plugin_manager_show(GtkWindow *parent)
 {
     TRACE_CALL(__func__);
     GtkWidget *dialog;
     GtkWidget *scrolledwindow;
     GtkWidget *tree;
     GtkCellRenderer *renderer;
     GtkTreeViewColumn *column;
     GtkListStore *store;
 
     dialog = gtk_dialog_new_with_buttons(_("Plugins"), parent, GTK_DIALOG_MODAL, _("_OK"), GTK_RESPONSE_ACCEPT, NULL);
     g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), dialog);
     gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 350);
 
     scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
     gtk_widget_show(scrolledwindow);
     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
     gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), scrolledwindow, TRUE, TRUE, 0);
 
     tree = gtk_tree_view_new();
     gtk_container_add(GTK_CONTAINER(scrolledwindow), tree);
     gtk_widget_show(tree);
 
     store = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
     g_ptr_array_foreach(remmina_plugin_table, (GFunc)remmina_plugin_manager_show_for_each, store);
     gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(store));
 
     renderer = gtk_cell_renderer_text_new();
     column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", 0, NULL);
     gtk_tree_view_column_set_resizable(column, TRUE);
     gtk_tree_view_column_set_sort_column_id(column, 0);
     gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
 
     renderer = gtk_cell_renderer_text_new();
     column = gtk_tree_view_column_new_with_attributes(_("Type"), renderer, "text", 1, NULL);
     gtk_tree_view_column_set_resizable(column, TRUE);
     gtk_tree_view_column_set_sort_column_id(column, 1);
     gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
 
     renderer = gtk_cell_renderer_text_new();
     column = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", 2, NULL);
     gtk_tree_view_column_set_resizable(column, TRUE);
     gtk_tree_view_column_set_sort_column_id(column, 2);
     gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
 
     renderer = gtk_cell_renderer_text_new();
     column = gtk_tree_view_column_new_with_attributes(_("Version"), renderer, "text", 3, NULL);
     gtk_tree_view_column_set_resizable(column, TRUE);
     gtk_tree_view_column_set_sort_column_id(column, 3);
     gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
 
     gtk_widget_show(dialog);
 }
 
 RemminaFilePlugin* remmina_plugin_manager_get_import_file_handler(const gchar *file)
 {
     TRACE_CALL(__func__);
     RemminaFilePlugin *plugin;
     gint i;
 
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaFilePlugin*)g_ptr_array_index(remmina_plugin_table, i);
 
         if (plugin->type != REMMINA_PLUGIN_TYPE_FILE)
             continue;
 
         if (plugin->import_test_func(plugin, file)) {
             return plugin;
         }
     }
     return NULL;
 }
 
 RemminaFilePlugin* remmina_plugin_manager_get_export_file_handler(RemminaFile *remminafile)
 {
     TRACE_CALL(__func__);
     RemminaFilePlugin *plugin;
     gint i;
 
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaFilePlugin*)g_ptr_array_index(remmina_plugin_table, i);
         if (plugin->type != REMMINA_PLUGIN_TYPE_FILE)
             continue;
         if (plugin->export_test_func(plugin, remminafile)) {
             return plugin;
         }
     }
     return NULL;
 }
 
 RemminaSecretPlugin* remmina_plugin_manager_get_secret_plugin(void)
 {
     TRACE_CALL(__func__);
     return remmina_secret_plugin;
 }
 
 gboolean remmina_plugin_manager_query_feature_by_type(RemminaPluginType ptype, const gchar* name, RemminaProtocolFeatureType ftype)
 {
     TRACE_CALL(__func__);
     const RemminaProtocolFeature *feature;
     RemminaProtocolPlugin* plugin;
 
     plugin = (RemminaProtocolPlugin*)remmina_plugin_manager_get_plugin(ptype, name);
 
     if (plugin == NULL) {
         return FALSE;
     }
 
     for (feature = plugin->features; feature && feature->type; feature++) {
         if (feature->type == ftype)
             return TRUE;
     }
     return FALSE;
 }
 
 gboolean remmina_plugin_manager_is_encrypted_setting(RemminaProtocolPlugin *pp, const char *setting)
 {
     TRACE_CALL(__func__);
     GHashTable *pht;
 
     if (encrypted_settings_cache == NULL)
         return FALSE;
 
     if (!(pht = g_hash_table_lookup(encrypted_settings_cache, pp->name)))
         return FALSE;
 
     if (!g_hash_table_lookup(pht, setting))
         return FALSE;
 
     return TRUE;
 }

-
+Go to the documentation of this file. /*
  * Remmina - The GTK+ Remote Desktop Client
  * Copyright (C) 2010-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"
 
 
 #include <gtk/gtk.h>
 #include <glib/gi18n.h>
 #include <gmodule.h>
 #include <gio/gio.h>
 #include <string.h>
 #ifdef GDK_WINDOWING_X11
 #include <gdk/gdkx.h>
 #elif defined(GDK_WINDOWING_WAYLAND)
 #include <gdk/gdkwayland.h>
 #endif
 #include "remmina_public.h"
 #include "remmina_main.h"
 #include "remmina_file_manager.h"
 #include "remmina_pref.h"
 #include "remmina_protocol_widget.h"
 #include "remmina_log.h"
 #include "remmina_widget_pool.h"
 #include "rcw.h"
 #include "remmina_plugin_manager.h"
 #include "remmina_plugin_native.h"
 #include "remmina_public.h"
 #include "remmina_masterthread_exec.h"
 #include "remmina/remmina_trace_calls.h"
 
 static GPtrArray* remmina_plugin_table = NULL;
 
 /* A GHashTable of GHashTables where to store the names of the encrypted settings */
 static GHashTable *encrypted_settings_cache = NULL;
 
 /* There can be only one secret plugin loaded */
 static RemminaSecretPlugin *remmina_secret_plugin = NULL;
 
 // TRANSLATORS: "Language Wrapper" is a wrapper for plugins written in other programmin languages (Python in this context)
 static const gchar *remmina_plugin_type_name[] =
 { N_("Protocol"), N_("Entry"), N_("File"), N_("Tool"), N_("Preference"), N_("Secret"), N_("Language Wrapper"), NULL };
 
 static gint remmina_plugin_manager_compare_func(RemminaPlugin **a, RemminaPlugin **b)
 {
     TRACE_CALL(__func__);
     return g_strcmp0((*a)->name, (*b)->name);
 }
 
 static void htdestroy(gpointer ht)
 {
     g_hash_table_unref(ht);
 }
 
 static void init_settings_cache(RemminaPlugin *plugin)
 {
     TRACE_CALL(__func__);
     RemminaProtocolPlugin *protocol_plugin;
     const RemminaProtocolSetting* setting_iter;
     GHashTable *pht;
 
     /* This code make a encrypted setting cache only for protocol plugins */
 
     if (plugin->type != REMMINA_PLUGIN_TYPE_PROTOCOL) {
         return;
     }
 
     if (encrypted_settings_cache == NULL)
         encrypted_settings_cache = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, htdestroy);
 
     if (!(pht = g_hash_table_lookup(encrypted_settings_cache, plugin->name))) {
         pht = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
         g_hash_table_insert(encrypted_settings_cache, g_strdup(plugin->name), pht);
     }
 
     /* Some settings are encrypted "by name" */
     /* g_hash_table_insert(pht, g_strdup("proxy_password"), (gpointer)TRUE); */
 
     g_hash_table_insert(pht, g_strdup("ssh_tunnel_password"), (gpointer)TRUE);
     g_hash_table_insert(pht, g_strdup("ssh_tunnel_passphrase"), (gpointer)TRUE);
 
     /* ssh_password is no longer used starting from remmina 1.4.
      * But we MUST mark it as encrypted setting, or the migration procedure will fail */
     g_hash_table_insert(pht, g_strdup("ssh_password"), (gpointer)TRUE);
 
     /* Other settings are encrypted because of their type */
     protocol_plugin = (RemminaProtocolPlugin *)plugin;
     setting_iter = protocol_plugin->basic_settings;
     if (setting_iter) {
         while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
             if (setting_iter->type == REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD)
                 g_hash_table_insert(pht, g_strdup(remmina_plugin_manager_get_canonical_setting_name(setting_iter)), (gpointer)TRUE);
             setting_iter++;
         }
     }
     setting_iter = protocol_plugin->advanced_settings;
     if (setting_iter) {
         while (setting_iter->type != REMMINA_PROTOCOL_SETTING_TYPE_END) {
             if (setting_iter->type == REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD)
                 g_hash_table_insert(pht, g_strdup(remmina_plugin_manager_get_canonical_setting_name(setting_iter)), (gpointer)TRUE);
             setting_iter++;
         }
     }
 
 }
 
 static gboolean remmina_plugin_manager_register_plugin(RemminaPlugin *plugin)
 {
     TRACE_CALL(__func__);
     if (plugin->type == REMMINA_PLUGIN_TYPE_SECRET) {
         g_print("Remmina plugin %s (type=%s) has been registered, but is not yet initialized/activated. "
             "The initialization order is %d.\n", plugin->name,
             _(remmina_plugin_type_name[plugin->type]),
             ((RemminaSecretPlugin*)plugin)->init_order);
     }
     init_settings_cache(plugin);
 
     g_ptr_array_add(remmina_plugin_table, plugin);
     g_ptr_array_sort(remmina_plugin_table, (GCompareFunc)remmina_plugin_manager_compare_func);
     return TRUE;
 }
 
 gboolean remmina_gtksocket_available()
 {
     GdkDisplayManager* dm;
     GdkDisplay* d;
     gboolean available;
 
     dm = gdk_display_manager_get();
     d = gdk_display_manager_get_default_display(dm);
     available = FALSE;
 
 #ifdef GDK_WINDOWING_X11
     if (GDK_IS_X11_DISPLAY(d)) {
         /* GtkSocket support is available only under X.Org */
         available = TRUE;
     }
 #endif
     return available;
 }
 
 RemminaPluginService remmina_plugin_manager_service =
 {
     remmina_plugin_manager_register_plugin,
     remmina_protocol_widget_get_width,
     remmina_protocol_widget_set_width,
     remmina_protocol_widget_get_height,
     remmina_protocol_widget_set_height,
     remmina_protocol_widget_get_current_scale_mode,
     remmina_protocol_widget_get_expand,
     remmina_protocol_widget_set_expand,
     remmina_protocol_widget_has_error,
     remmina_protocol_widget_set_error,
     remmina_protocol_widget_is_closed,
     remmina_protocol_widget_get_file,
     remmina_protocol_widget_emit_signal,
     remmina_protocol_widget_register_hostkey,
     remmina_protocol_widget_start_direct_tunnel,
     remmina_protocol_widget_start_reverse_tunnel,
     remmina_protocol_widget_start_xport_tunnel,
     remmina_protocol_widget_set_display,
     remmina_protocol_widget_signal_connection_closed,
     remmina_protocol_widget_signal_connection_opened,
     remmina_protocol_widget_update_align,
     remmina_protocol_widget_lock_dynres,
     remmina_protocol_widget_unlock_dynres,
     remmina_protocol_widget_desktop_resize,
     remmina_protocol_widget_panel_auth,
     remmina_protocol_widget_panel_new_certificate,
     remmina_protocol_widget_panel_changed_certificate,
     remmina_protocol_widget_get_username,
     remmina_protocol_widget_get_password,
     remmina_protocol_widget_get_domain,
     remmina_protocol_widget_get_savepassword,
     remmina_protocol_widget_panel_authx509,
     remmina_protocol_widget_get_cacert,
     remmina_protocol_widget_get_cacrl,
     remmina_protocol_widget_get_clientcert,
     remmina_protocol_widget_get_clientkey,
     remmina_protocol_widget_save_cred,
     remmina_protocol_widget_panel_show_listen,
     remmina_protocol_widget_panel_show_retry,
     remmina_protocol_widget_panel_show,
     remmina_protocol_widget_panel_hide,
     remmina_protocol_widget_ssh_exec,
     remmina_protocol_widget_chat_open,
     remmina_protocol_widget_chat_close,
     remmina_protocol_widget_chat_receive,
     remmina_protocol_widget_send_keys_signals,
 
     remmina_file_get_datadir,
 
     remmina_file_new,
     remmina_file_get_filename,
     remmina_file_set_string,
     remmina_file_get_string,
     remmina_file_get_secret,
     remmina_file_set_int,
     remmina_file_get_int,
     remmina_file_get_double,
     remmina_file_unsave_passwords,
 
     remmina_pref_set_value,
     remmina_pref_get_value,
     remmina_pref_get_scale_quality,
     remmina_pref_get_sshtunnel_port,
     remmina_pref_get_ssh_loglevel,
     remmina_pref_get_ssh_parseconfig,
     remmina_pref_keymap_get_table,
     remmina_pref_keymap_get_keyval,
 
     _remmina_info,
     _remmina_message,
     _remmina_debug,
     _remmina_warning,
     _remmina_audit,
     _remmina_error,
     _remmina_critical,
     remmina_log_print,
     remmina_log_printf,
 
     remmina_widget_pool_register,
 
     rcw_open_from_file_full,
     remmina_public_open_unix_sock,
     remmina_public_get_server_port,
     remmina_masterthread_exec_is_main_thread,
     remmina_gtksocket_available,
     remmina_protocol_widget_get_profile_remote_width,
     remmina_protocol_widget_get_profile_remote_height,
     remmina_protocol_widget_get_name,
     remmina_protocol_widget_get_width,
     remmina_protocol_widget_get_height,
     remmina_protocol_widget_set_width,
     remmina_protocol_widget_set_height,
     remmina_protocol_widget_get_current_scale_mode,
     remmina_protocol_widget_get_expand,
     remmina_protocol_widget_set_expand,
     remmina_protocol_widget_set_error,
     remmina_protocol_widget_has_error,
     remmina_protocol_widget_gtkviewport,
     remmina_protocol_widget_is_closed,
     remmina_protocol_widget_get_file,
     remmina_protocol_widget_panel_auth,
     remmina_protocol_widget_register_hostkey,
     remmina_protocol_widget_start_direct_tunnel,
     remmina_protocol_widget_start_reverse_tunnel,
     remmina_protocol_widget_send_keys_signals,
     remmina_protocol_widget_chat_receive,
     remmina_protocol_widget_panel_hide,
     remmina_protocol_widget_chat_open,
     remmina_protocol_widget_ssh_exec,
     remmina_protocol_widget_panel_show,
     remmina_protocol_widget_panel_show_retry,
     remmina_protocol_widget_start_xport_tunnel,
     remmina_protocol_widget_set_display,
     remmina_protocol_widget_signal_connection_closed,
     remmina_protocol_widget_signal_connection_opened,
     remmina_protocol_widget_update_align,
     remmina_protocol_widget_unlock_dynres,
     remmina_protocol_widget_desktop_resize,
     remmina_protocol_widget_panel_new_certificate,
     remmina_protocol_widget_panel_changed_certificate,
     remmina_protocol_widget_get_username,
     remmina_protocol_widget_get_password,
     remmina_protocol_widget_get_domain,
     remmina_protocol_widget_get_savepassword,
     remmina_protocol_widget_panel_authx509,
     remmina_protocol_widget_get_cacert,
     remmina_protocol_widget_get_cacrl,
     remmina_protocol_widget_get_clientcert,
     remmina_protocol_widget_get_clientkey,
     remmina_protocol_widget_save_cred,
     remmina_protocol_widget_panel_show_listen,
     remmina_widget_pool_register,
     rcw_open_from_file_full,
     remmina_main_show_dialog,
     remmina_main_get_window,
 };
 
 const char *get_filename_ext(const char *filename) {
     const char* last = strrchr(filename, '/');
     const char *dot = strrchr(last, '.');
     if(!dot || dot == filename) return "";
     return dot + 1;
 }
 
 static gint compare_secret_plugin_init_order(gconstpointer a, gconstpointer b)
 {
     RemminaSecretPlugin *sa, *sb;
 
     sa = (RemminaSecretPlugin*)a;
     sb = (RemminaSecretPlugin*)b;
 
     if (sa->init_order > sb->init_order)
         return 1;
     else if (sa->init_order < sb->init_order)
         return -1;
     return 0;
 }
 
 void remmina_plugin_manager_init()
 {
     TRACE_CALL(__func__);
     GDir *dir;
     const gchar *name, *ptr;
     gchar *fullpath;
     RemminaPlugin *plugin;
     RemminaSecretPlugin *sp;
     int i, j;
     GSList *secret_plugins;
     GSList *sple;
     GPtrArray *alternative_language_plugins;
 
     remmina_plugin_table = g_ptr_array_new();
     alternative_language_plugins = g_ptr_array_new();
 
     if (!g_module_supported()) {
         g_print("Dynamic loading of plugins is not supported on this platform!\n");
         return;
     }
 
     g_print("Load modules from %s\n", REMMINA_RUNTIME_PLUGINDIR);
     dir = g_dir_open(REMMINA_RUNTIME_PLUGINDIR, 0, NULL);
 
     if (dir == NULL)
         return;
     while ((name = g_dir_read_name(dir)) != NULL) {
         if ((ptr = strrchr(name, '.')) == NULL)
             continue;
         ptr++;
         fullpath = g_strdup_printf(REMMINA_RUNTIME_PLUGINDIR "/%s", name);
         if (!remmina_plugin_manager_loader_supported(ptr)) {
             g_ptr_array_add(alternative_language_plugins, g_strdup_printf(REMMINA_RUNTIME_PLUGINDIR "/%s", name));
             g_free(fullpath);
             continue;
         }
         remmina_plugin_native_load(&remmina_plugin_manager_service, fullpath);
         g_free(fullpath);
     }
     g_dir_close(dir);
 
     while (alternative_language_plugins->len > 0) {
         gboolean has_loaded = FALSE;
         gchar* name = (gchar*)g_ptr_array_remove_index(alternative_language_plugins, 0);
         const gchar* ext = get_filename_ext(name);
 
         for (j = 0; j < remmina_plugin_table->len && !has_loaded; j++) {
             plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, j);
             if (plugin->type == REMMINA_PLUGIN_TYPE_LANGUAGE_WRAPPER) {
                 RemminaLanguageWrapperPlugin* wrapper_plugin = (RemminaLanguageWrapperPlugin*)plugin;
                 const gchar** supported_extention = wrapper_plugin->supported_extentions;
                 while (*supported_extention) {
                     if (g_str_equal(*supported_extention, ext)) {
                         has_loaded = wrapper_plugin->load(wrapper_plugin, name);
                         if (has_loaded) {
                             break;
                         }
                     }
                     supported_extention++;
                 }
                 if (has_loaded) break;
             }
         }
 
         if (!has_loaded) {
             g_print("%s: Skip unsupported file type '%s'\n", name, ext);
         }
 
         g_free(name);
     }
 
     /* Now all secret plugins needs to initialize, following their init_order.
      * The 1st plugin which will initialize correctly will be
      * the default remmina_secret_plugin */
 
     if (remmina_secret_plugin)
         g_print("Internal ERROR: remmina_secret_plugin must be null here\n");
 
     secret_plugins = NULL;
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
         if (plugin->type == REMMINA_PLUGIN_TYPE_SECRET) {
             secret_plugins = g_slist_insert_sorted(secret_plugins, (gpointer)plugin, compare_secret_plugin_init_order);
         }
     }
 
     sple = secret_plugins;
     while(sple != NULL) {
         sp = (RemminaSecretPlugin*)sple->data;
         if (sp->init(sp)) {
             g_print("The %s secret plugin has been initialized and it will be your default secret plugin\n",
                 sp->name);
             remmina_secret_plugin = sp;
             break;
         }
         sple = sple->next;
     }
 
     g_slist_free(secret_plugins);
     g_ptr_array_free(alternative_language_plugins, TRUE);
 }
 
 gboolean remmina_plugin_manager_loader_supported(const char *filetype) {
     TRACE_CALL(__func__);
     return g_str_equal(G_MODULE_SUFFIX, filetype);
 }
 
 RemminaPlugin* remmina_plugin_manager_get_plugin(RemminaPluginType type, const gchar *name)
 {
     TRACE_CALL(__func__);
     RemminaPlugin *plugin;
     gint i;
 
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
         if (plugin->type == type && g_strcmp0(plugin->name, name) == 0) {
             return plugin;
         }
     }
     return NULL;
 }
 
 const gchar *remmina_plugin_manager_get_canonical_setting_name(const RemminaProtocolSetting* setting)
 {
     if (setting->name == NULL) {
         if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_SERVER)
             return "server";
         if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_PASSWORD)
             return "password";
         if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_RESOLUTION)
             return "resolution";
         if (setting->type == REMMINA_PROTOCOL_SETTING_TYPE_ASSISTANCE)
             return "assistance_mode";
         return "missing_setting_name_into_plugin_RemminaProtocolSetting";
     }
     return setting->name;
 }
 
 void remmina_plugin_manager_for_each_plugin(RemminaPluginType type, RemminaPluginFunc func, gpointer data)
 {
     TRACE_CALL(__func__);
     RemminaPlugin *plugin;
     gint i;
 
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaPlugin*)g_ptr_array_index(remmina_plugin_table, i);
         if (plugin->type == type) {
             func((gchar*)plugin->name, plugin, data);
         }
     }
 }
 
 /* A copy of remmina_plugin_manager_show and remmina_plugin_manager_show_for_each
  * This is because we want to print the list of plugins, and their versions, to the standard output
  * with the remmina command line option --full-version instead of using the plugins widget
  ** @todo Investigate to use only GListStore and than pass the elements to be shown to 2 separate
  *       functions
  * WARNING: GListStore is supported only from GLib 2.44 */
 static gboolean remmina_plugin_manager_show_for_each_stdout(RemminaPlugin *plugin)
 {
     TRACE_CALL(__func__);
 
     g_print("%-20s%-16s%-64s%-10s\n", plugin->name,
         _(remmina_plugin_type_name[plugin->type]),
         g_dgettext(plugin->domain, plugin->description),
         plugin->version);
     return FALSE;
 }
 
 void remmina_plugin_manager_show_stdout()
 {
     TRACE_CALL(__func__);
     g_print("%-20s%-16s%-64s%-10s\n", "NAME", "TYPE", "DESCRIPTION", "PLUGIN AND LIBRARY VERSION");
     g_ptr_array_foreach(remmina_plugin_table, (GFunc)remmina_plugin_manager_show_for_each_stdout, NULL);
 }
 
 static gboolean remmina_plugin_manager_show_for_each(RemminaPlugin *plugin, GtkListStore *store)
 {
     TRACE_CALL(__func__);
     GtkTreeIter iter;
 
     gtk_list_store_append(store, &iter);
     gtk_list_store_set(store, &iter, 0, plugin->name, 1, _(remmina_plugin_type_name[plugin->type]), 2,
         g_dgettext(plugin->domain, plugin->description), 3, plugin->version, -1);
     return FALSE;
 }
 
 void remmina_plugin_manager_show(GtkWindow *parent)
 {
     TRACE_CALL(__func__);
     GtkWidget *dialog;
     GtkWidget *scrolledwindow;
     GtkWidget *tree;
     GtkCellRenderer *renderer;
     GtkTreeViewColumn *column;
     GtkListStore *store;
 
     dialog = gtk_dialog_new_with_buttons(_("Plugins"), parent, GTK_DIALOG_MODAL, _("_OK"), GTK_RESPONSE_ACCEPT, NULL);
     g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), dialog);
     gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 350);
 
     scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
     gtk_widget_show(scrolledwindow);
     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
     gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), scrolledwindow, TRUE, TRUE, 0);
 
     tree = gtk_tree_view_new();
     gtk_container_add(GTK_CONTAINER(scrolledwindow), tree);
     gtk_widget_show(tree);
 
     store = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
     g_ptr_array_foreach(remmina_plugin_table, (GFunc)remmina_plugin_manager_show_for_each, store);
     gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(store));
 
     renderer = gtk_cell_renderer_text_new();
     column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", 0, NULL);
     gtk_tree_view_column_set_resizable(column, TRUE);
     gtk_tree_view_column_set_sort_column_id(column, 0);
     gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
 
     renderer = gtk_cell_renderer_text_new();
     column = gtk_tree_view_column_new_with_attributes(_("Type"), renderer, "text", 1, NULL);
     gtk_tree_view_column_set_resizable(column, TRUE);
     gtk_tree_view_column_set_sort_column_id(column, 1);
     gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
 
     renderer = gtk_cell_renderer_text_new();
     column = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", 2, NULL);
     gtk_tree_view_column_set_resizable(column, TRUE);
     gtk_tree_view_column_set_sort_column_id(column, 2);
     gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
 
     renderer = gtk_cell_renderer_text_new();
     column = gtk_tree_view_column_new_with_attributes(_("Version"), renderer, "text", 3, NULL);
     gtk_tree_view_column_set_resizable(column, TRUE);
     gtk_tree_view_column_set_sort_column_id(column, 3);
     gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
 
     gtk_widget_show(dialog);
 }
 
 RemminaFilePlugin* remmina_plugin_manager_get_import_file_handler(const gchar *file)
 {
     TRACE_CALL(__func__);
     RemminaFilePlugin *plugin;
     gint i;
 
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaFilePlugin*)g_ptr_array_index(remmina_plugin_table, i);
 
         if (plugin->type != REMMINA_PLUGIN_TYPE_FILE)
             continue;
 
         if (plugin->import_test_func(plugin, file)) {
             return plugin;
         }
     }
     return NULL;
 }
 
 RemminaFilePlugin* remmina_plugin_manager_get_export_file_handler(RemminaFile *remminafile)
 {
     TRACE_CALL(__func__);
     RemminaFilePlugin *plugin;
     gint i;
 
     for (i = 0; i < remmina_plugin_table->len; i++) {
         plugin = (RemminaFilePlugin*)g_ptr_array_index(remmina_plugin_table, i);
         if (plugin->type != REMMINA_PLUGIN_TYPE_FILE)
             continue;
         if (plugin->export_test_func(plugin, remminafile)) {
             return plugin;
         }
     }
     return NULL;
 }
 
 RemminaSecretPlugin* remmina_plugin_manager_get_secret_plugin(void)
 {
     TRACE_CALL(__func__);
     return remmina_secret_plugin;
 }
 
 gboolean remmina_plugin_manager_query_feature_by_type(RemminaPluginType ptype, const gchar* name, RemminaProtocolFeatureType ftype)
 {
     TRACE_CALL(__func__);
     const RemminaProtocolFeature *feature;
     RemminaProtocolPlugin* plugin;
 
     plugin = (RemminaProtocolPlugin*)remmina_plugin_manager_get_plugin(ptype, name);
 
     if (plugin == NULL) {
         return FALSE;
     }
 
     for (feature = plugin->features; feature && feature->type; feature++) {
         if (feature->type == ftype)
             return TRUE;
     }
     return FALSE;
 }
 
 gboolean remmina_plugin_manager_is_encrypted_setting(RemminaProtocolPlugin *pp, const char *setting)
 {
     TRACE_CALL(__func__);
     GHashTable *pht;
 
     if (encrypted_settings_cache == NULL)
         return FALSE;
 
     if (!(pht = g_hash_table_lookup(encrypted_settings_cache, pp->name)))
         return FALSE;
 
     if (!g_hash_table_lookup(pht, setting))
         return FALSE;
 
     return TRUE;
 }

+
-
+
-
+
-
+
-
-
+
+
-
+
-
+
-
+
-
-
+
+
-
+
-
-
+
+
-
+
@@ -144,14 +144,14 @@ $(document).ready(function(){initNavTree('remmina__plugin__manager_8c_source.htm
 
-
-
-
+
+
+
-
-
+
+
-
+
@@ -159,95 +159,95 @@ $(document).ready(function(){initNavTree('remmina__plugin__manager_8c_source.htm
 
-
-
+
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
-
+
+
-
+
-
+
-
-
+
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+
-
+

diff --git a/public/remmina__protocol__widget_8c.html b/public/remmina__protocol__widget_8c.html
index d0373b12c..9cc1e599f 100644
--- a/public/remmina__protocol__widget_8c.html
+++ b/public/remmina__protocol__widget_8c.html
@@ -139,6 +139,8 @@ Functions
  
 void remmina_protocol_widget_open_connection (RemminaProtocolWidget *gp)
  
+static gboolean conn_closed_real (gpointer data, int button)
+ 
 static gboolean conn_closed (gpointer data)
  
 void remmina_protocol_widget_signal_connection_closed (RemminaProtocolWidget *gp)
@@ -380,7 +382,7 @@ Variables
 RPWDT_AUTHX509 
 
 
-Definition at line 104 of file remmina_protocol_widget.c.

+Definition at line 105 of file remmina_protocol_widget.c.

@@ -419,7 +421,7 @@ Variables

◆ conn_closed_real()

◆ user_disconnect

Detailed Description

Field Documentation

◆ gp

Detailed Description

Field Documentation

◆ destroyed

Detailed Description

Field Documentation

◆ called_from_subthread