Code cleaning

39 files changed, 965 insertions, 1063 deletions

diff --git a/src/include/remmina/plugin.h b/src/include/remmina/plugin.h
index f5a14cbe1..bf7836d7a 100644
--- a/src/include/remmina/plugin.h
+++ b/src/include/remmina/plugin.h
@@ -51,183 +51,177 @@ typedef enum {
 } RemminaPluginType;
 
 typedef struct _RemminaPlugin {
-	RemminaPluginType type;
-	const gchar *name;
-	const gchar *description;
-	const gchar *domain;
-	const gchar *version;
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
 } RemminaPlugin;
 
 typedef struct _RemminaProtocolPlugin {
-	RemminaPluginType type;
-	const gchar *name;
-	const gchar *description;
-	const gchar *domain;
-	const gchar *version;
-
-	const gchar *icon_name;
-	const gchar *icon_name_ssh;
-	const RemminaProtocolSetting *basic_settings;
-	const RemminaProtocolSetting *advanced_settings;
-	RemminaProtocolSSHSetting ssh_setting;
-	const RemminaProtocolFeature *features;
-
-	void (* init)(RemminaProtocolWidget *gp);
-	gboolean (* open_connection)(RemminaProtocolWidget *gp);
-	gboolean (* close_connection)(RemminaProtocolWidget *gp);
-	gboolean (* query_feature)(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature);
-	void (* call_feature)(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature);
-	void (* send_keystrokes)(RemminaProtocolWidget *gp, const guint keystrokes[], const gint keylen);
-	gboolean (* get_plugin_screenshot)(RemminaProtocolWidget *gp, RemminaPluginScreenshotData *rpsd);
+	RemminaPluginType		type;
+	const gchar *			name;
+	const gchar *			description;
+	const gchar *			domain;
+	const gchar *			version;
+
+	const gchar *			icon_name;
+	const gchar *			icon_name_ssh;
+	const RemminaProtocolSetting *	basic_settings;
+	const RemminaProtocolSetting *	advanced_settings;
+	RemminaProtocolSSHSetting	ssh_setting;
+	const RemminaProtocolFeature *	features;
+
+	void (*init)(RemminaProtocolWidget *gp);
+	gboolean (*open_connection)(RemminaProtocolWidget *gp);
+	gboolean (*close_connection)(RemminaProtocolWidget *gp);
+	gboolean (*query_feature)(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature);
+	void (*call_feature)(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature);
+	void (*send_keystrokes)(RemminaProtocolWidget *gp, const guint keystrokes[], const gint keylen);
+	gboolean (*get_plugin_screenshot)(RemminaProtocolWidget *gp, RemminaPluginScreenshotData *rpsd);
 } RemminaProtocolPlugin;
 
 typedef struct _RemminaEntryPlugin {
-	RemminaPluginType type;
-	const gchar *name;
-	const gchar *description;
-	const gchar *domain;
-	const gchar *version;
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
 
-	void (* entry_func)(void);
+	void (*entry_func)(void);
 } RemminaEntryPlugin;
 
 typedef struct _RemminaFilePlugin {
-	RemminaPluginType type;
-	const gchar *name;
-	const gchar *description;
-	const gchar *domain;
-	const gchar *version;
-
-	gboolean (* import_test_func)(const gchar *from_file);
-	RemminaFile* (*import_func)(const gchar * from_file);
-	gboolean (* export_test_func)(RemminaFile *file);
-	gboolean (* export_func)(RemminaFile *file, const gchar *to_file);
-	const gchar *export_hints;
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+
+	gboolean (*import_test_func)(const gchar *from_file);
+	RemminaFile * (*import_func)(const gchar * from_file);
+	gboolean (*export_test_func)(RemminaFile *file);
+	gboolean (*export_func)(RemminaFile *file, const gchar *to_file);
+	const gchar *		export_hints;
 } RemminaFilePlugin;
 
 typedef struct _RemminaToolPlugin {
-	RemminaPluginType type;
-	const gchar *name;
-	const gchar *description;
-	const gchar *domain;
-	const gchar *version;
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
 
-	void (* exec_func)(void);
+	void (*exec_func)(void);
 } RemminaToolPlugin;
 
 typedef struct _RemminaPrefPlugin {
-	RemminaPluginType type;
-	const gchar *name;
-	const gchar *description;
-	const gchar *domain;
-	const gchar *version;
-
-	const gchar *pref_label;
-	GtkWidget* (*get_pref_body)(void);
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+
+	const gchar *		pref_label;
+	GtkWidget * (*get_pref_body)(void);
 } RemminaPrefPlugin;
 
 typedef struct _RemminaSecretPlugin {
-	RemminaPluginType type;
-	const gchar *name;
-	const gchar *description;
-	const gchar *domain;
-	const gchar *version;
-	int init_order;
-
-	gboolean (* init)(void);
-	gboolean (* is_service_available)(void);
-	void (* store_password)(RemminaFile *remminafile, const gchar *key, const gchar *password);
-	gchar* (*get_password)(RemminaFile * remminafile, const gchar * key);
-	void (* delete_password)(RemminaFile *remminafile, const gchar *key);
-
+	RemminaPluginType	type;
+	const gchar *		name;
+	const gchar *		description;
+	const gchar *		domain;
+	const gchar *		version;
+	int			init_order;
+
+	gboolean (*init)(void);
+	gboolean (*is_service_available)(void);
+	void (*store_password)(RemminaFile *remminafile, const gchar *key, const gchar *password);
+	gchar * (*get_password)(RemminaFile * remminafile, const gchar *key);
+	void (*delete_password)(RemminaFile *remminafile, const gchar *key);
 } RemminaSecretPlugin;
 
 /* Plugin Service is a struct containing a list of function pointers,
  * which is passed from Remmina main program to the plugin module
  * through the plugin entry function remmina_plugin_entry() */
 typedef struct _RemminaPluginService {
-	gboolean (* register_plugin)(RemminaPlugin *plugin);
-
-	gint (* protocol_plugin_get_width)(RemminaProtocolWidget *gp);
-	void (* protocol_plugin_set_width)(RemminaProtocolWidget *gp, gint width);
-	gint (* protocol_plugin_get_height)(RemminaProtocolWidget *gp);
-	void (* protocol_plugin_set_height)(RemminaProtocolWidget *gp, gint height);
-	RemminaScaleMode (* remmina_protocol_widget_get_current_scale_mode)(RemminaProtocolWidget *gp);
-	gboolean (* protocol_plugin_get_expand)(RemminaProtocolWidget *gp);
-	void (* protocol_plugin_set_expand)(RemminaProtocolWidget *gp, gboolean expand);
-	gboolean (* protocol_plugin_has_error)(RemminaProtocolWidget *gp);
-	void (* protocol_plugin_set_error)(RemminaProtocolWidget *gp, const gchar *fmt, ...);
-	gboolean (* protocol_plugin_is_closed)(RemminaProtocolWidget *gp);
-	RemminaFile* (*protocol_plugin_get_file)(RemminaProtocolWidget * gp);
-	void (* protocol_plugin_emit_signal)(RemminaProtocolWidget *gp, const gchar *signal_name);
-	void (* protocol_plugin_register_hostkey)(RemminaProtocolWidget *gp, GtkWidget *widget);
-	gchar*       (*protocol_plugin_start_direct_tunnel)(RemminaProtocolWidget * gp, gint default_port, gboolean port_plus);
-	gboolean (* protocol_plugin_start_reverse_tunnel)(RemminaProtocolWidget *gp, gint local_port);
-	gboolean (* protocol_plugin_start_xport_tunnel)(RemminaProtocolWidget *gp, RemminaXPortTunnelInitFunc init_func);
-	void (* protocol_plugin_set_display)(RemminaProtocolWidget *gp, gint display);
-	void (* protocol_plugin_signal_connection_closed)(RemminaProtocolWidget *gp);
-    void (* protocol_plugin_signal_connection_opened)(RemminaProtocolWidget *gp);
-    void (* protocol_plugin_update_align)(RemminaProtocolWidget *gp);
-    void (* protocol_plugin_unlock_dynres)(RemminaProtocolWidget *gp);
-    void (* protocol_plugin_desktop_resize)(RemminaProtocolWidget *gp);
-	gint (* protocol_plugin_init_auth)(RemminaProtocolWidget *gp, RemminaMessagePanelFlags pflags, const gchar *title, const gchar *default_username, const gchar *default_password,
-		const gchar *default_domain, const gchar *password_prompt);
-	gint (* protocol_plugin_init_certificate)(RemminaProtocolWidget *gp, const gchar* subject, const gchar* issuer, const gchar* fingerprint);
-	gint (* protocol_plugin_changed_certificate)(RemminaProtocolWidget *gp, const gchar* subject, const gchar* issuer, const gchar* new_fingerprint, const gchar* old_fingerprint);
-	gchar*       (*protocol_plugin_init_get_username)(RemminaProtocolWidget * gp);
-	gchar*       (*protocol_plugin_init_get_password)(RemminaProtocolWidget * gp);
-	gchar*       (*protocol_plugin_init_get_domain)(RemminaProtocolWidget * gp);
-	gboolean (* protocol_plugin_init_get_savepassword)(RemminaProtocolWidget *gp);
-	gint (* protocol_plugin_init_authx509)(RemminaProtocolWidget *gp);
-	gchar*       (*protocol_plugin_init_get_cacert)(RemminaProtocolWidget * gp);
-	gchar*       (*protocol_plugin_init_get_cacrl)(RemminaProtocolWidget * gp);
-	gchar*       (*protocol_plugin_init_get_clientcert)(RemminaProtocolWidget * gp);
-	gchar*       (*protocol_plugin_init_get_clientkey)(RemminaProtocolWidget * gp);
-	void (* protocol_plugin_init_save_cred)(RemminaProtocolWidget *gp);
-	void (* protocol_plugin_init_show_listen)(RemminaProtocolWidget *gp, gint port);
-	void (* protocol_plugin_init_show_retry)(RemminaProtocolWidget *gp);
-	void (* protocol_plugin_init_show)(RemminaProtocolWidget *gp);
-	void (* protocol_plugin_init_hide)(RemminaProtocolWidget *gp);
-	gboolean (* protocol_plugin_ssh_exec)(RemminaProtocolWidget *gp, gboolean wait, const gchar *fmt, ...);
-	void (* protocol_plugin_chat_open)(RemminaProtocolWidget *gp, const gchar *name,
-					   void (*on_send)(RemminaProtocolWidget *gp, const gchar *text),
-					   void (*on_destroy)(RemminaProtocolWidget *gp));
-	void (* protocol_plugin_chat_close)(RemminaProtocolWidget *gp);
-	void (* protocol_plugin_chat_receive)(RemminaProtocolWidget *gp, const gchar *text);
-	void (* protocol_plugin_send_keys_signals)(GtkWidget *widget, const guint *keyvals, int length, GdkEventType action);
-
-	gchar*       (*file_get_user_datadir)(void);
-
-	RemminaFile* (*file_new)(void);
-	const gchar* (*file_get_path)(RemminaFile * remminafile);
-	void (* file_set_string)(RemminaFile *remminafile, const gchar *setting, const gchar *value);
-	const gchar* (*file_get_string)(RemminaFile * remminafile, const gchar * setting);
-	gchar*       (*file_get_secret)(RemminaFile * remminafile, const gchar * setting);
-	void (* file_set_int)(RemminaFile *remminafile, const gchar *setting, gint value);
-	gint (* file_get_int)(RemminaFile *remminafile, const gchar *setting, gint default_value);
-	void (* file_unsave_passwords)(RemminaFile *remminafile);
-
-	void (* pref_set_value)(const gchar *key, const gchar *value);
-	gchar*       (*pref_get_value)(const gchar * key);
-	gint (* pref_get_scale_quality)(void);
-	gint (* pref_get_sshtunnel_port)(void);
-	gint (* pref_get_ssh_loglevel)(void);
-	gboolean (* pref_get_ssh_parseconfig)(void);
-	guint (* pref_keymap_get_keyval)(const gchar *keymap, guint keyval);
-
-	void (* log_print)(const gchar *text);
-	void (* log_printf)(const gchar *fmt, ...);
-
-	void (* ui_register)(GtkWidget *widget);
-
-	GtkWidget*   (*open_connection)(RemminaFile * remminafile, GCallback disconnect_cb, gpointer data, guint * handler);
-	void (* get_server_port)(const gchar *server, gint defaultport, gchar **host, gint *port);
-	gboolean (* is_main_thread)(void);
-	gboolean (* gtksocket_available)(void);
-	gint (* get_profile_remote_width)(RemminaProtocolWidget *gp);
-	gint (* get_profile_remote_height)(RemminaProtocolWidget *gp);
-
-
+	gboolean (*register_plugin)(RemminaPlugin *plugin);
+
+	gint (*protocol_plugin_get_width)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_set_width)(RemminaProtocolWidget *gp, gint width);
+	gint (*protocol_plugin_get_height)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_set_height)(RemminaProtocolWidget *gp, gint height);
+	RemminaScaleMode (*remmina_protocol_widget_get_current_scale_mode)(RemminaProtocolWidget *gp);
+	gboolean (*protocol_plugin_get_expand)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_set_expand)(RemminaProtocolWidget *gp, gboolean expand);
+	gboolean (*protocol_plugin_has_error)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_set_error)(RemminaProtocolWidget *gp, const gchar *fmt, ...);
+	gboolean (*protocol_plugin_is_closed)(RemminaProtocolWidget *gp);
+	RemminaFile * (*protocol_plugin_get_file)(RemminaProtocolWidget * gp);
+	void (*protocol_plugin_emit_signal)(RemminaProtocolWidget *gp, const gchar *signal_name);
+	void (*protocol_plugin_register_hostkey)(RemminaProtocolWidget *gp, GtkWidget *widget);
+	gchar *       (*protocol_plugin_start_direct_tunnel)(RemminaProtocolWidget * gp, gint default_port, gboolean port_plus);
+	gboolean (*protocol_plugin_start_reverse_tunnel)(RemminaProtocolWidget *gp, gint local_port);
+	gboolean (*protocol_plugin_start_xport_tunnel)(RemminaProtocolWidget *gp, RemminaXPortTunnelInitFunc init_func);
+	void (*protocol_plugin_set_display)(RemminaProtocolWidget *gp, gint display);
+	void (*protocol_plugin_signal_connection_closed)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_signal_connection_opened)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_update_align)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_unlock_dynres)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_desktop_resize)(RemminaProtocolWidget *gp);
+	gint (*protocol_plugin_init_auth)(RemminaProtocolWidget *gp, RemminaMessagePanelFlags pflags, const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain, const gchar *password_prompt);
+	gint (*protocol_plugin_init_certificate)(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *fingerprint);
+	gint (*protocol_plugin_changed_certificate)(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *new_fingerprint, const gchar *old_fingerprint);
+	gchar *       (*protocol_plugin_init_get_username)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_password)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_domain)(RemminaProtocolWidget * gp);
+	gboolean (*protocol_plugin_init_get_savepassword)(RemminaProtocolWidget *gp);
+	gint (*protocol_plugin_init_authx509)(RemminaProtocolWidget *gp);
+	gchar *       (*protocol_plugin_init_get_cacert)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_cacrl)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_clientcert)(RemminaProtocolWidget * gp);
+	gchar *       (*protocol_plugin_init_get_clientkey)(RemminaProtocolWidget * gp);
+	void (*protocol_plugin_init_save_cred)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_init_show_listen)(RemminaProtocolWidget *gp, gint port);
+	void (*protocol_plugin_init_show_retry)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_init_show)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_init_hide)(RemminaProtocolWidget *gp);
+	gboolean (*protocol_plugin_ssh_exec)(RemminaProtocolWidget *gp, gboolean wait, const gchar *fmt, ...);
+	void (*protocol_plugin_chat_open)(RemminaProtocolWidget *gp, const gchar *name, void (*on_send)(RemminaProtocolWidget *gp, const gchar *text), void (*on_destroy)(RemminaProtocolWidget *gp));
+	void (*protocol_plugin_chat_close)(RemminaProtocolWidget *gp);
+	void (*protocol_plugin_chat_receive)(RemminaProtocolWidget *gp, const gchar *text);
+	void (*protocol_plugin_send_keys_signals)(GtkWidget *widget, const guint *keyvals, int length, GdkEventType action);
+
+	gchar *       (*file_get_user_datadir)(void);
+
+	RemminaFile * (*file_new)(void);
+	const gchar * (*file_get_path)(RemminaFile * remminafile);
+	void (*file_set_string)(RemminaFile *remminafile, const gchar *setting, const gchar *value);
+	const gchar * (*file_get_string)(RemminaFile * remminafile, const gchar *setting);
+	gchar *       (*file_get_secret)(RemminaFile * remminafile, const gchar *setting);
+	void (*file_set_int)(RemminaFile *remminafile, const gchar *setting, gint value);
+	gint (*file_get_int)(RemminaFile *remminafile, const gchar *setting, gint default_value);
+	void (*file_unsave_passwords)(RemminaFile *remminafile);
+
+	void (*pref_set_value)(const gchar *key, const gchar *value);
+	gchar *       (*pref_get_value)(const gchar * key);
+	gint (*pref_get_scale_quality)(void);
+	gint (*pref_get_sshtunnel_port)(void);
+	gint (*pref_get_ssh_loglevel)(void);
+	gboolean (*pref_get_ssh_parseconfig)(void);
+	guint (*pref_keymap_get_keyval)(const gchar *keymap, guint keyval);
+
+	void (*log_print)(const gchar *text);
+	void (*log_printf)(const gchar *fmt, ...);
+
+	void (*ui_register)(GtkWidget *widget);
+
+	GtkWidget *   (*open_connection)(RemminaFile * remminafile, GCallback disconnect_cb, gpointer data, guint *handler);
+	void (*get_server_port)(const gchar *server, gint defaultport, gchar **host, gint *port);
+	gboolean (*is_main_thread)(void);
+	gboolean (*gtksocket_available)(void);
+	gint (*get_profile_remote_width)(RemminaProtocolWidget *gp);
+	gint (*get_profile_remote_height)(RemminaProtocolWidget *gp);
 } RemminaPluginService;
 
 /* "Prototype" of the plugin entry function */
diff --git a/src/include/remmina/remmina_trace_calls.h b/src/include/remmina/remmina_trace_calls.h
index b88814e0a..e6cfea591 100644
--- a/src/include/remmina/remmina_trace_calls.h
+++ b/src/include/remmina/remmina_trace_calls.h
@@ -51,4 +51,3 @@
 #else
 #define TRACE_CALL(text)
 #endif  /* _WITH_TRACE_CALLS_ */
-
diff --git a/src/include/remmina/types.h b/src/include/remmina/types.h
index f7a9e03de..4c5ba392f 100644
--- a/src/include/remmina/types.h
+++ b/src/include/remmina/types.h
@@ -54,27 +54,26 @@ typedef enum {
 #define REMMINA_PROTOCOL_FEATURE_PREF_CHECK 2
 
 typedef struct _RemminaProtocolFeature {
-	RemminaProtocolFeatureType type;
-	gint id;
-	gpointer opt1;
-	gpointer opt2;
-	gpointer opt3;
+	RemminaProtocolFeatureType	type;
+	gint				id;
+	gpointer			opt1;
+	gpointer			opt2;
+	gpointer			opt3;
 } RemminaProtocolFeature;
 
 typedef struct _RemminaPluginScreenshotData {
-	unsigned char* buffer;
-	int bitsPerPixel;
-	int bytesPerPixel;
-	int width;
-	int height;
+	unsigned char * buffer;
+	int		bitsPerPixel;
+	int		bytesPerPixel;
+	int		width;
+	int		height;
 } RemminaPluginScreenshotData;
 
 
 typedef struct _RemminaProtocolWidgetClass RemminaProtocolWidgetClass;
 typedef struct _RemminaProtocolWidget RemminaProtocolWidget;
 typedef gpointer RemminaTunnelInitFunc;
-typedef gboolean (*RemminaXPortTunnelInitFunc) (RemminaProtocolWidget *gp,
-						gint remotedisplay, const gchar *server, gint port);
+typedef gboolean (*RemminaXPortTunnelInitFunc) (RemminaProtocolWidget *gp, gint remotedisplay, const gchar *server, gint port);
 
 typedef enum {
 	REMMINA_PROTOCOL_SETTING_TYPE_END,
@@ -93,12 +92,12 @@ typedef enum {
 } RemminaProtocolSettingType;
 
 typedef struct _RemminaProtocolSetting {
-	RemminaProtocolSettingType type;
-	const gchar *name;
-	const gchar *label;
-	gboolean compact;
-	const gpointer opt1;
-	const gpointer opt2;
+	RemminaProtocolSettingType	type;
+	const gchar *			name;
+	const gchar *			label;
+	gboolean			compact;
+	const gpointer			opt1;
+	const gpointer			opt2;
 } RemminaProtocolSetting;
 
 typedef enum {
@@ -122,19 +121,17 @@ typedef enum {
 } RemminaScaleMode;
 
 typedef enum {
-	RES_INVALID = -1,
-	RES_USE_CUSTOM = 0,
-	RES_USE_CLIENT = 1,
-	RES_USE_INITIAL_WINDOW_SIZE = 2
+	RES_INVALID			= -1,
+	RES_USE_CUSTOM			= 0,
+	RES_USE_CLIENT			= 1,
+	RES_USE_INITIAL_WINDOW_SIZE	= 2
 } RemminaProtocolWidgetResolutionMode;
 
 /* pflags field for remmina_protocol_widget_panel_auth() */
 typedef enum {
-	REMMINA_MESSAGE_PANEL_FLAG_USERNAME = 1, /* require username in auth panel */
-	REMMINA_MESSAGE_PANEL_FLAG_DOMAIN = 2, /* require domain in auth panel */
-	REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD = 4 /* require savepassword switch in auth panel */
+	REMMINA_MESSAGE_PANEL_FLAG_USERNAME	= 1,    /* require username in auth panel */
+	REMMINA_MESSAGE_PANEL_FLAG_DOMAIN	= 2,    /* require domain in auth panel */
+	REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD = 4     /* require savepassword switch in auth panel */
 } RemminaMessagePanelFlags;
 
 G_END_DECLS
-
-
diff --git a/src/rcw.c b/src/rcw.c
index 875c745ba..0ae801874 100644
--- a/src/rcw.c
+++ b/src/rcw.c
@@ -367,14 +367,14 @@ static RemminaConnectionObject *rcw_get_visible_cnnobj(RemminaConnectionWindow *
 {
 	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;
+	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)
@@ -1521,7 +1521,6 @@ static void rco_change_scalemode(RemminaConnectionObject *cnnobj, gboolean bdyn,
 		rco_check_resize(cnnobj);
 	if (GTK_IS_SCROLLED_WINDOW(cnnobj->scrolled_container))
 		rco_set_scrolled_policy(cnnobj, GTK_SCROLLED_WINDOW(cnnobj->scrolled_container));
-
 }
 
 static void rcw_toolbar_dynres(GtkWidget *widget, RemminaConnectionWindow *cnnwin)
@@ -1860,7 +1859,6 @@ static void rcw_toolbar_duplicate(GtkWidget *widget, RemminaConnectionWindow *cn
 	//gp = REMMINA_PROTOCOL_WIDGET(cnnobj->proto);
 
 	remmina_exec_command(REMMINA_COMMAND_CONNECT, cnnobj->remmina_file->filename);
-
 }
 static void rcw_toolbar_screenshot(GtkWidget *widget, RemminaConnectionWindow *cnnwin)
 {
@@ -2404,7 +2402,6 @@ static void rcw_focus_out(RemminaConnectionWindow *cnnwin)
 	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_focus_out_event(GtkWidget *widget, GdkEvent *event, gpointer data)
@@ -2454,10 +2451,9 @@ static gboolean rcw_on_enter(GtkWidget *widget, GdkEventCrossing *event, gpointe
 	}
 	printf("\n");
 #endif
-	if (gtk_window_is_active(GTK_WINDOW(cnnobj->cnnwin))) {
+	if (gtk_window_is_active(GTK_WINDOW(cnnobj->cnnwin)))
 		if (cnnobj->connected && remmina_file_get_int(cnnobj->remmina_file, "keyboard_grab", FALSE))
 			rcw_keyboard_grab(cnnwin);
-	}
 	return FALSE;
 }
 
@@ -2742,7 +2738,6 @@ static void rcw_init(RemminaConnectionWindow *cnnwin)
 	priv->ss_maximized = FALSE;
 
 	remmina_widget_pool_register(GTK_WIDGET(cnnwin));
-
 }
 
 static gboolean rcw_state_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data)
@@ -2775,12 +2770,11 @@ static gboolean rcw_map_event_fullscreen(GtkWidget *widget, GdkEvent *event, gpo
 
 #if GTK_CHECK_VERSION(3, 18, 0)
 	if (remmina_pref.fullscreen_on_auto) {
-		if (target_monitor == FULL_SCREEN_TARGET_MONITOR_UNDEFINED) {
+		if (target_monitor == FULL_SCREEN_TARGET_MONITOR_UNDEFINED)
 			gtk_window_fullscreen(GTK_WINDOW(widget));
-		} else {
+		else
 			gtk_window_fullscreen_on_monitor(GTK_WINDOW(widget), gtk_window_get_screen(GTK_WINDOW(widget)),
-				target_monitor);
-		}
+							 target_monitor);
 	} else {
 		remmina_log_print("Fullscreen managed by WM or by the user, as per settings");
 		gtk_window_fullscreen(GTK_WINDOW(widget));
@@ -2802,10 +2796,9 @@ rcw_new(gboolean fullscreen, int full_screen_target_monitor)
 	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) {
+	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));
-	}
 
 	gtk_container_set_border_width(GTK_CONTAINER(cnnwin), 0);
 	g_signal_connect(G_OBJECT(cnnwin), "toolbar-place", G_CALLBACK(rcw_toolbar_place_signal), NULL);
@@ -3077,7 +3070,6 @@ static void rcw_on_page_removed(GtkNotebook *notebook, GtkWidget *child, guint p
 
 	if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(cnnwin->priv->notebook)) <= 0)
 		gtk_widget_destroy(GTK_WIDGET(cnnwin));
-
 }
 
 static GtkNotebook *
@@ -3371,30 +3363,30 @@ RemminaConnectionWindow *rcw_create_fullscreen(GtkWindow *old, gint view_mode)
 #if GTK_CHECK_VERSION(3, 22, 0)
 	gint n_monitors;
 	gint i;
-	GdkMonitor* old_monitor;
-	GdkDisplay* old_display;
-	GdkWindow* old_window;
+	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;
-				}
+	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
+		}
+#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);
diff --git a/src/rcw.h b/src/rcw.h
index ce3a0a376..984bc9a5b 100644
--- a/src/rcw.h
+++ b/src/rcw.h
@@ -51,41 +51,38 @@ G_BEGIN_DECLS
 typedef struct _RemminaConnectionWindowPriv RemminaConnectionWindowPriv;
 
 typedef struct _RemminaConnectionWindow {
-	GtkWindow window;
-	RemminaConnectionWindowPriv* priv;
+	GtkWindow			window;
+	RemminaConnectionWindowPriv *	priv;
 } RemminaConnectionWindow;
 
 typedef struct _RemminaConnectionWindowClass {
 	GtkWindowClass parent_class;
-	void (*toolbar_place)(RemminaConnectionWindow * gp);
+	void (*toolbar_place)(RemminaConnectionWindow *gp);
 } RemminaConnectionWindowClass;
 
 typedef struct _RemminaConnectionObject RemminaConnectionObject;
 
 typedef enum {
-	RCW_ONDELETE_CONFIRM_IF_2_OR_MORE = 0,
-	RCW_ONDELETE_NOCONFIRM		= 1
-
+	RCW_ONDELETE_CONFIRM_IF_2_OR_MORE	= 0,
+	RCW_ONDELETE_NOCONFIRM			= 1
 } RemminaConnectionWindowOnDeleteConfirmMode;
 
 GType rcw_get_type(void)
 G_GNUC_CONST;
 
 /* Open a new connection window for a .remmina file */
-gboolean rcw_open_from_filename(const gchar* filename);
+gboolean rcw_open_from_filename(const gchar *filename);
 /* Open a new connection window for a given RemminaFile struct. The struct will be freed after the call */
-void rcw_open_from_file(RemminaFile* remminafile);
-gboolean rcw_delete(RemminaConnectionWindow* cnnwin);
-void rcw_set_delete_confirm_mode(RemminaConnectionWindow* cnnwin, RemminaConnectionWindowOnDeleteConfirmMode mode);
-GtkWidget* rcw_open_from_file_full(RemminaFile* remminafile, GCallback disconnect_cb, gpointer data, guint* handler);
+void rcw_open_from_file(RemminaFile *remminafile);
+gboolean rcw_delete(RemminaConnectionWindow *cnnwin);
+void rcw_set_delete_confirm_mode(RemminaConnectionWindow *cnnwin, RemminaConnectionWindowOnDeleteConfirmMode mode);
+GtkWidget *rcw_open_from_file_full(RemminaFile *remminafile, GCallback disconnect_cb, gpointer data, guint *handler);
 
 void rco_destroy_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp);
 void rco_show_message_panel(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp);
-void rco_get_monitor_geometry(RemminaConnectionObject* cnnobj, GdkRectangle *sz);
+void rco_get_monitor_geometry(RemminaConnectionObject *cnnobj, GdkRectangle *sz);
 
 #define MESSAGE_PANEL_SPINNER 0x00000001
 #define MESSAGE_PANEL_OKBUTTON 0x00000002
 
 G_END_DECLS
-
-
diff --git a/src/remmina_about.h b/src/remmina_about.h
index 64eebc184..c6b78cb89 100644
--- a/src/remmina_about.h
+++ b/src/remmina_about.h
@@ -41,5 +41,3 @@ G_BEGIN_DECLS
 void remmina_about_open(GtkWindow *parent);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_applet_menu.h b/src/remmina_applet_menu.h
index f1797b7f6..c5bad91d9 100644
--- a/src/remmina_applet_menu.h
+++ b/src/remmina_applet_menu.h
@@ -53,27 +53,25 @@ typedef enum {
 typedef struct _RemminaAppletMenuPriv RemminaAppletMenuPriv;
 
 typedef struct _RemminaAppletMenu {
-	GtkMenu menu;
+	GtkMenu			menu;
 
-	RemminaAppletMenuPriv* priv;
+	RemminaAppletMenuPriv * priv;
 } RemminaAppletMenu;
 
 typedef struct _RemminaAppletMenuClass {
 	GtkMenuClass parent_class;
 
-	void (*launch_item)(RemminaAppletMenu* menu);
-	void (*edit_item)(RemminaAppletMenu* menu);
+	void (*launch_item)(RemminaAppletMenu *menu);
+	void (*edit_item)(RemminaAppletMenu *menu);
 } RemminaAppletMenuClass;
 
 GType remmina_applet_menu_get_type(void)
 G_GNUC_CONST;
 
-void remmina_applet_menu_register_item(RemminaAppletMenu* menu, RemminaAppletMenuItem* menuitem);
-void remmina_applet_menu_add_item(RemminaAppletMenu* menu, RemminaAppletMenuItem* menuitem);
-GtkWidget* remmina_applet_menu_new(void);
-void remmina_applet_menu_set_hide_count(RemminaAppletMenu* menu, gboolean hide_count);
-void remmina_applet_menu_populate(RemminaAppletMenu* menu);
+void remmina_applet_menu_register_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem);
+void remmina_applet_menu_add_item(RemminaAppletMenu *menu, RemminaAppletMenuItem *menuitem);
+GtkWidget *remmina_applet_menu_new(void);
+void remmina_applet_menu_set_hide_count(RemminaAppletMenu *menu, gboolean hide_count);
+void remmina_applet_menu_populate(RemminaAppletMenu *menu);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_applet_menu_item.h b/src/remmina_applet_menu_item.h
index 8cbe6499a..89cd1f6f9 100644
--- a/src/remmina_applet_menu_item.h
+++ b/src/remmina_applet_menu_item.h
@@ -49,15 +49,15 @@ typedef enum {
 } RemminaAppletMenuItemType;
 
 typedef struct _RemminaAppletMenuItem {
-	GtkImageMenuItem image_menu_item;
+	GtkImageMenuItem		image_menu_item;
 
-	RemminaAppletMenuItemType item_type;
-	gchar* filename;
-	gchar* name;
-	gchar* group;
-	gchar* protocol;
-	gchar* server;
-	gboolean ssh_enabled;
+	RemminaAppletMenuItemType	item_type;
+	gchar *				filename;
+	gchar *				name;
+	gchar *				group;
+	gchar *				protocol;
+	gchar *				server;
+	gboolean			ssh_enabled;
 } RemminaAppletMenuItem;
 
 typedef struct _RemminaAppletMenuItemClass {
@@ -67,9 +67,7 @@ typedef struct _RemminaAppletMenuItemClass {
 GType remmina_applet_menu_item_get_type(void)
 G_GNUC_CONST;
 
-GtkWidget* remmina_applet_menu_item_new(RemminaAppletMenuItemType item_type, ...);
+GtkWidget *remmina_applet_menu_item_new(RemminaAppletMenuItemType item_type, ...);
 gint remmina_applet_menu_item_compare(gconstpointer a, gconstpointer b, gpointer user_data);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_avahi.h b/src/remmina_avahi.h
index a4a7ce5ca..4efff4b3a 100644
--- a/src/remmina_avahi.h
+++ b/src/remmina_avahi.h
@@ -40,17 +40,15 @@ G_BEGIN_DECLS
 typedef struct _RemminaAvahiPriv RemminaAvahiPriv;
 
 typedef struct _RemminaAvahi {
-	GHashTable *discovered_services;
-	gboolean started;
+	GHashTable *		discovered_services;
+	gboolean		started;
 
-	RemminaAvahiPriv *priv;
+	RemminaAvahiPriv *	priv;
 } RemminaAvahi;
 
-RemminaAvahi* remmina_avahi_new(void);
-void remmina_avahi_start(RemminaAvahi* ga);
-void remmina_avahi_stop(RemminaAvahi* ga);
-void remmina_avahi_free(RemminaAvahi* ga);
+RemminaAvahi *remmina_avahi_new(void);
+void remmina_avahi_start(RemminaAvahi *ga);
+void remmina_avahi_stop(RemminaAvahi *ga);
+void remmina_avahi_free(RemminaAvahi *ga);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_chat_window.h b/src/remmina_chat_window.h
index d5df5117f..7867ca1d6 100644
--- a/src/remmina_chat_window.h
+++ b/src/remmina_chat_window.h
@@ -45,10 +45,10 @@ G_BEGIN_DECLS
 #define REMMINA_CHAT_WINDOW_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_CHAT_WINDOW, RemminaChatWindowClass))
 
 typedef struct _RemminaChatWindow {
-	GtkWindow window;
+	GtkWindow	window;
 
-	GtkWidget *history_text;
-	GtkWidget *send_text;
+	GtkWidget *	history_text;
+	GtkWidget *	send_text;
 } RemminaChatWindow;
 
 typedef struct _RemminaChatWindowClass {
@@ -60,9 +60,7 @@ typedef struct _RemminaChatWindowClass {
 GType remmina_chat_window_get_type(void)
 G_GNUC_CONST;
 
-GtkWidget* remmina_chat_window_new(GtkWindow *parent, const gchar *chat_with);
+GtkWidget *remmina_chat_window_new(GtkWindow *parent, const gchar *chat_with);
 void remmina_chat_window_receive(RemminaChatWindow *window, const gchar *name, const gchar *text);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_crypt.h b/src/remmina_crypt.h
index 1606e2586..5eb9d1b42 100644
--- a/src/remmina_crypt.h
+++ b/src/remmina_crypt.h
@@ -37,9 +37,7 @@
 
 G_BEGIN_DECLS
 
-gchar* remmina_crypt_encrypt(const gchar* str);
-gchar* remmina_crypt_decrypt(const gchar* str);
+gchar *remmina_crypt_encrypt(const gchar *str);
+gchar *remmina_crypt_decrypt(const gchar *str);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_exec.h b/src/remmina_exec.h
index 52e5f2e9d..f61910e9c 100644
--- a/src/remmina_exec.h
+++ b/src/remmina_exec.h
@@ -57,12 +57,10 @@ typedef enum {
 	REMMINA_CONDEXIT_ONMAINWINDELETE	= 2
 } RemminaCondExitType;
 
-void remmina_exec_command(RemminaCommandType command, const gchar* data);
+void remmina_exec_command(RemminaCommandType command, const gchar *data);
 void remmina_exec_exitremmina(void);
 void remmina_application_condexit(RemminaCondExitType why);
 
 int remmina_exec_set_setting(gchar *profilefilename, gchar **settings);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_ext_exec.h b/src/remmina_ext_exec.h
index 533460652..ac9347469 100644
--- a/src/remmina_ext_exec.h
+++ b/src/remmina_ext_exec.h
@@ -38,13 +38,12 @@
 G_BEGIN_DECLS
 
 typedef struct {
-	GtkDialog *dialog;
-	GtkLabel *label_pleasewait;
-	GtkButton *button_cancel;
-	GtkWidget *spinner;
+	GtkDialog *	dialog;
+	GtkLabel *	label_pleasewait;
+	GtkButton *	button_cancel;
+	GtkWidget *	spinner;
 } PCon_Spinner;
 
-GtkDialog* remmina_ext_exec_new(RemminaFile* remminafile, const char *remmina_ext_exec_type);
+GtkDialog *remmina_ext_exec_new(RemminaFile *remminafile, const char *remmina_ext_exec_type);
 
 G_END_DECLS
-
diff --git a/src/remmina_external_tools.h b/src/remmina_external_tools.h
index 7dc2eddbc..8b09eab82 100644
--- a/src/remmina_external_tools.h
+++ b/src/remmina_external_tools.h
@@ -42,8 +42,6 @@
 G_BEGIN_DECLS
 
 /* Open a new connection window for a .remmina file */
-gboolean remmina_external_tools_from_filename(RemminaMain *remminamain, gchar* filename);
+gboolean remmina_external_tools_from_filename(RemminaMain *remminamain, gchar *filename);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_ftp_client.h b/src/remmina_ftp_client.h
index 929294807..975b7d6a3 100644
--- a/src/remmina_ftp_client.h
+++ b/src/remmina_ftp_client.h
@@ -48,9 +48,9 @@ G_BEGIN_DECLS
 typedef struct _RemminaFTPClientPriv RemminaFTPClientPriv;
 
 typedef struct _RemminaFTPClient {
-	GtkVBox vbox;
+	GtkVBox			vbox;
 
-	RemminaFTPClientPriv *priv;
+	RemminaFTPClientPriv *	priv;
 } RemminaFTPClient;
 
 typedef struct _RemminaFTPClientClass {
@@ -108,21 +108,21 @@ enum {
 
 typedef struct _RemminaFTPTask {
 	/* Read-only */
-	gint type;
-	gchar *name;
-	gint taskid;
-	gint tasktype;
-	gchar *remotedir;
-	gchar *localdir;
-	GtkTreeRowReference *rowref;
+	gint			type;
+	gchar *			name;
+	gint			taskid;
+	gint			tasktype;
+	gchar *			remotedir;
+	gchar *			localdir;
+	GtkTreeRowReference *	rowref;
 	/* Updatable */
-	gfloat size;
-	gint status;
-	gfloat donesize;
-	gchar *tooltip;
+	gfloat			size;
+	gint			status;
+	gfloat			donesize;
+	gchar *			tooltip;
 } RemminaFTPTask;
 
-GtkWidget* remmina_ftp_client_new(void);
+GtkWidget *remmina_ftp_client_new(void);
 
 void remmina_ftp_client_save_state(RemminaFTPClient *client, RemminaFile *remminafile);
 void remmina_ftp_client_load_state(RemminaFTPClient *client, RemminaFile *remminafile);
@@ -134,11 +134,11 @@ void remmina_ftp_client_add_file(RemminaFTPClient *client, ...);
 /* Set the current directory. Should be called by opendir signal handler */
 void remmina_ftp_client_set_dir(RemminaFTPClient *client, const gchar *dir);
 /* Get the current directory as newly allocated string */
-gchar* remmina_ftp_client_get_dir(RemminaFTPClient *client);
+gchar *remmina_ftp_client_get_dir(RemminaFTPClient *client);
 /* Get the next waiting task */
-RemminaFTPTask* remmina_ftp_client_get_waiting_task(RemminaFTPClient *client);
+RemminaFTPTask *remmina_ftp_client_get_waiting_task(RemminaFTPClient *client);
 /* Update the task */
-void remmina_ftp_client_update_task(RemminaFTPClient *client, RemminaFTPTask* task);
+void remmina_ftp_client_update_task(RemminaFTPClient *client, RemminaFTPTask *task);
 /* Free the RemminaFTPTask object */
 void remmina_ftp_task_free(RemminaFTPTask *task);
 /* Get/Set Set overwrite_all status */
@@ -146,5 +146,3 @@ void remmina_ftp_client_set_overwrite_status(RemminaFTPClient *client, gboolean
 gboolean remmina_ftp_client_get_overwrite_status(RemminaFTPClient *client);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_icon.h b/src/remmina_icon.h
index 7bd36f7bc..6fd855ddf 100644
--- a/src/remmina_icon.h
+++ b/src/remmina_icon.h
@@ -45,5 +45,3 @@ void remmina_icon_destroy(void);
 gboolean remmina_icon_is_available(void);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_key_chooser.h b/src/remmina_key_chooser.h
index 9c7f77f8d..cf86c64ce 100644
--- a/src/remmina_key_chooser.h
+++ b/src/remmina_key_chooser.h
@@ -44,21 +44,19 @@
 #define KEY_CHOOSER_NONE _("<None>")
 
 typedef struct _RemminaKeyChooserArguments {
-	guint keyval;
-	guint state;
-	gboolean use_modifiers;
-	gint response;
+	guint		keyval;
+	guint		state;
+	gboolean	use_modifiers;
+	gint		response;
 } RemminaKeyChooserArguments;
 
 G_BEGIN_DECLS
 
 /* Show a key chooser dialog and return the keyval for the selected key */
-RemminaKeyChooserArguments* remmina_key_chooser_new(GtkWindow *parent_window, gboolean use_modifiers);
+RemminaKeyChooserArguments *remmina_key_chooser_new(GtkWindow *parent_window, gboolean use_modifiers);
 /* Get the uppercase character value of a keyval */
-gchar* remmina_key_chooser_get_value(guint keyval, guint state);
+gchar *remmina_key_chooser_get_value(guint keyval, guint state);
 /* Get the keyval of a (lowercase) character value */
 guint remmina_key_chooser_get_keyval(const gchar *value);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_log.h b/src/remmina_log.h
index 66e67317a..06a227269 100644
--- a/src/remmina_log.h
+++ b/src/remmina_log.h
@@ -43,5 +43,3 @@ void remmina_log_print(const gchar *text);
 void remmina_log_printf(const gchar *fmt, ...);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_main.h b/src/remmina_main.h
index 364428937..317e5673c 100644
--- a/src/remmina_main.h
+++ b/src/remmina_main.h
@@ -43,67 +43,67 @@
 typedef struct _RemminaMainPriv RemminaMainPriv;
 
 typedef struct _RemminaMain {
-	GtkBuilder *builder;
-	GtkWindow *window;
+	GtkBuilder *		builder;
+	GtkWindow *		window;
 	/* Menu widgets */
-	GtkMenu *menu_popup;
-	GtkMenuButton *menu_header_button;
-	GtkMenu *menu_popup_full;
-	GtkRadioMenuItem *menuitem_view_mode_list;
-	GtkRadioMenuItem *menuitem_view_mode_tree;
-	GtkMenuItem *menuitem_connection_quit;
+	GtkMenu *		menu_popup;
+	GtkMenuButton *		menu_header_button;
+	GtkMenu *		menu_popup_full;
+	GtkRadioMenuItem *	menuitem_view_mode_list;
+	GtkRadioMenuItem *	menuitem_view_mode_tree;
+	GtkMenuItem *		menuitem_connection_quit;
 	/* Button new */
-	GtkButton *button_new;
-	GtkButton *button_make_default;
+	GtkButton *		button_new;
+	GtkButton *		button_make_default;
 	/* Search bar objects */
-	GtkToggleButton *search_toggle;
-	GtkToggleButton *view_toggle_button;
-	GtkToggleButton *ustats_toggle;
-	GtkSearchBar *search_bar;
+	GtkToggleButton *	search_toggle;
+	GtkToggleButton *	view_toggle_button;
+	GtkToggleButton *	ustats_toggle;
+	GtkSearchBar *		search_bar;
 	/* Quick connect objects */
-	GtkBox *box_quick_connect;
-	GtkComboBoxText *combo_quick_connect_protocol;
-	GtkEntry *entry_quick_connect_server;
-	GtkButton *button_quick_connect;
+	GtkBox *		box_quick_connect;
+	GtkComboBoxText *	combo_quick_connect_protocol;
+	GtkEntry *		entry_quick_connect_server;
+	GtkButton *		button_quick_connect;
 	/* Other widgets */
-	GtkTreeView *tree_files_list;
-	GtkTreeViewColumn *column_files_list_group;
-	GtkStatusbar *statusbar_main;
+	GtkTreeView *		tree_files_list;
+	GtkTreeViewColumn *	column_files_list_group;
+	GtkStatusbar *		statusbar_main;
 	/* Non widget objects */
-	GtkAccelGroup *accelgroup_shortcuts;
+	GtkAccelGroup *		accelgroup_shortcuts;
 	/* Actions from the view ActionGroup */
-	GtkToggleAction *action_view_quick_connect;
-	GtkToggleAction *action_view_mode_list;
-	GtkToggleAction *action_view_mode_tree;
-	RemminaMainPriv *priv;
+	GtkToggleAction *	action_view_quick_connect;
+	GtkToggleAction *	action_view_mode_list;
+	GtkToggleAction *	action_view_mode_tree;
+	RemminaMainPriv *	priv;
 } RemminaMain;
 
 struct _RemminaMainPriv {
-	GtkTreeModel *file_model;
-	GtkTreeModel *file_model_filter;
-	GtkTreeModel *file_model_sort;
+	GtkTreeModel *		file_model;
+	GtkTreeModel *		file_model_filter;
+	GtkTreeModel *		file_model_sort;
 
-	gboolean initialized;
+	gboolean		initialized;
 
-	gchar *selected_filename;
-	gchar *selected_name;
-	gboolean override_view_file_mode_to_list;
-	RemminaStringArray *expanded_group;
+	gchar *			selected_filename;
+	gchar *			selected_name;
+	gboolean		override_view_file_mode_to_list;
+	RemminaStringArray *	expanded_group;
 };
 
 G_BEGIN_DECLS
 
 /* Create the main Remmina window */
-GtkWidget* remmina_main_new(void);
+GtkWidget *remmina_main_new(void);
 /* Get the current main window or NULL if not initialized */
-GtkWindow* remmina_main_get_window(void);
+GtkWindow *remmina_main_get_window(void);
 
 void remmina_main_update_file_datetime(RemminaFile *file);
 
 void remmina_main_destroy(void);
 void remmina_main_save_before_destroy(void);
 
-void remmina_main_show_warning_dialog(const gchar* message);
+void remmina_main_show_warning_dialog(const gchar *message);
 void remmina_main_on_action_application_about(GSimpleAction *action, GVariant *param, gpointer data);
 void remmina_main_on_action_application_default(GSimpleAction *action, GVariant *param, gpointer data);
 void remmina_main_on_action_application_mpchange(GSimpleAction *action, GVariant *param, gpointer data);
@@ -125,4 +125,3 @@ void remmina_main_on_action_tools_export(GSimpleAction *action, GVariant *param,
 void remmina_main_on_action_tools_import(GSimpleAction *action, GVariant *param, gpointer data);
 
 G_END_DECLS
-
diff --git a/src/remmina_marshals.h b/src/remmina_marshals.h
index ed64aba56..005e14fdc 100644
--- a/src/remmina_marshals.h
+++ b/src/remmina_marshals.h
@@ -6,14 +6,11 @@
 G_BEGIN_DECLS
 
 /* BOOLEAN:INT (remminamarshals.list:4) */
-extern void remmina_marshal_BOOLEAN__INT(GClosure *closure, GValue *return_value, guint n_param_values,
-					 const GValue *param_values, gpointer invocation_hint, gpointer marshal_data);
+extern void remmina_marshal_BOOLEAN__INT(GClosure *closure, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer invocation_hint, gpointer marshal_data);
 
 /* BOOLEAN:INT,STRING (remminamarshals.list:5) */
-extern void remmina_marshal_BOOLEAN__INT_STRING(GClosure *closure, GValue *return_value, guint n_param_values,
-						const GValue *param_values, gpointer invocation_hint, gpointer marshal_data);
+extern void remmina_marshal_BOOLEAN__INT_STRING(GClosure *closure, GValue *return_value, guint n_param_values, const GValue *param_values, gpointer invocation_hint, gpointer marshal_data);
 
 G_END_DECLS
 
 #endif /* __remmina_marshal_MARSHAL_H__ */
-
diff --git a/src/remmina_masterthread_exec.h b/src/remmina_masterthread_exec.h
index 88b673582..78da5f08d 100644
--- a/src/remmina_masterthread_exec.h
+++ b/src/remmina_masterthread_exec.h
@@ -41,7 +41,6 @@
 #include "remmina_ssh_plugin.h"
 
 typedef struct remmina_masterthread_exec_data {
-
 	enum { FUNC_GTK_LABEL_SET_TEXT,
 	       FUNC_INIT_SAVE_CRED, FUNC_CHAT_RECEIVE, FUNC_FILE_GET_STRING,
 	       FUNC_FTP_CLIENT_UPDATE_TASK, FUNC_FTP_CLIENT_GET_WAITING_TASK,
@@ -51,86 +50,81 @@ typedef struct remmina_masterthread_exec_data {
 	       FUNC_PROTOCOLWIDGET_MPDESTROY,
 	       FUNC_PROTOCOLWIDGET_MPSHOWRETRY,
 	       FUNC_PROTOCOLWIDGET_PANELSHOWLISTEN,
-	       FUNC_VTE_TERMINAL_SET_ENCODING_AND_PTY
-	      } func;
+	       FUNC_VTE_TERMINAL_SET_ENCODING_AND_PTY } func;
 
 	union {
 		struct {
-			GtkLabel *label;
-			const gchar *str;
+			GtkLabel *	label;
+			const gchar *	str;
 		} gtk_label_set_text;
 		struct {
-			RemminaProtocolWidget* gp;
+			RemminaProtocolWidget *gp;
 		} init_save_creds;
 		struct {
-			RemminaProtocolWidget* gp;
-			const gchar *text;
+			RemminaProtocolWidget * gp;
+			const gchar *		text;
 		} chat_receive;
 		struct {
-			RemminaFile *remminafile;
-			const gchar *setting;
-			const gchar* retval;
+			RemminaFile *	remminafile;
+			const gchar *	setting;
+			const gchar *	retval;
 		} file_get_string;
 		struct {
-			RemminaFTPClient *client;
-			RemminaFTPTask* task;
+			RemminaFTPClient *	client;
+			RemminaFTPTask *	task;
 		} ftp_client_update_task;
 		struct {
-			RemminaFTPClient *client;
-			RemminaFTPTask* retval;
+			RemminaFTPClient *	client;
+			RemminaFTPTask *	retval;
 		} ftp_client_get_waiting_task;
 		struct {
-			RemminaProtocolWidget* gp;
-			const gchar* signal_name;
+			RemminaProtocolWidget * gp;
+			const gchar *		signal_name;
 		} protocolwidget_emit_signal;
 		struct {
-			RemminaConnectionObject *cnnobj;
-			const gchar *message;
-			RemminaMessagePanelCallback response_callback;
-			gpointer response_callback_data;
-			RemminaMessagePanel *ret_mp;
+			RemminaConnectionObject *	cnnobj;
+			const gchar *			message;
+			RemminaMessagePanelCallback	response_callback;
+			gpointer			response_callback_data;
+			RemminaMessagePanel *		ret_mp;
 		} protocolwidget_mpprogress;
 		struct {
-			RemminaConnectionObject *cnnobj;
-			RemminaMessagePanel *mp;
+			RemminaConnectionObject *	cnnobj;
+			RemminaMessagePanel *		mp;
 		} protocolwidget_mpdestroy;
 		struct {
 			RemminaProtocolWidget *gp;
 		} protocolwidget_mpshowretry;
 		struct {
-			RemminaProtocolWidget *gp;
-			int port;
+			RemminaProtocolWidget * gp;
+			int			port;
 		} protocolwidget_panelshowlisten;
 #ifdef HAVE_LIBSSH
 		struct {
-			RemminaSFTPClient *client;
-			const gchar *path;
-			gint retval;
+			RemminaSFTPClient *	client;
+			const gchar *		path;
+			gint			retval;
 		} sftp_client_confirm_resume;
 #endif
 #ifdef HAVE_LIBVTE
 		struct {
-			VteTerminal *terminal;
-			const char *codeset;
-			int master;
-			int slave;
+			VteTerminal *	terminal;
+			const char *	codeset;
+			int		master;
+			int		slave;
 		} vte_terminal_set_encoding_and_pty;
 #endif
 	} p;
 
 	/* Mutex for thread synchronization */
 	pthread_mutex_t pt_mutex;
-	pthread_cond_t pt_cond;
+	pthread_cond_t	pt_cond;
 	/* Flag to catch cancellations */
-	gboolean cancelled;
-	gboolean complete;
-
+	gboolean	cancelled;
+	gboolean	complete;
 } RemminaMTExecData;
 
 void remmina_masterthread_exec_and_wait(RemminaMTExecData *d);
 
 void remmina_masterthread_exec_save_main_thread_id(void);
 gboolean remmina_masterthread_exec_is_main_thread(void);
-
-
-
diff --git a/src/remmina_message_panel.h b/src/remmina_message_panel.h
index 6c4e73385..691c9fbff 100644
--- a/src/remmina_message_panel.h
+++ b/src/remmina_message_panel.h
@@ -42,8 +42,8 @@ G_BEGIN_DECLS
 G_DECLARE_DERIVABLE_TYPE(RemminaMessagePanel, remmina_message_panel, REMMINA, MESSAGE_PANEL, GtkBox)
 
 struct _RemminaMessagePanelClass {
-	GtkBoxClass parent_class;
-	void (* response) (RemminaMessagePanel *mp, gint response_id);
+	GtkBoxClass	parent_class;
+	void		(*response) (RemminaMessagePanel *mp, gint response_id);
 };
 
 
@@ -72,11 +72,11 @@ void remmina_message_panel_setup_auth(RemminaMessagePanel *mp, RemminaMessagePan
 void remmina_message_panel_setup_auth_x509(RemminaMessagePanel *mp, RemminaMessagePanelCallback response_callback, gpointer response_callback_data);
 void remmina_message_panel_focus_auth_entry(RemminaMessagePanel *mp);
 void remmina_message_panel_field_set_string(RemminaMessagePanel *mp, int entryid, const gchar *text);
-gchar* remmina_message_panel_field_get_string(RemminaMessagePanel *mp, int entryid);
+gchar *remmina_message_panel_field_get_string(RemminaMessagePanel *mp, int entryid);
 void remmina_message_panel_field_set_switch(RemminaMessagePanel *mp, int entryid, gboolean state);
 gboolean remmina_message_panel_field_get_switch_state(RemminaMessagePanel *mp, int entryid);
 void remmina_message_panel_field_set_filename(RemminaMessagePanel *mp, int entryid, const gchar *filename);
-gchar* remmina_message_panel_field_get_filename(RemminaMessagePanel *mp, int entryid);
+gchar *remmina_message_panel_field_get_filename(RemminaMessagePanel *mp, int entryid);
 void remmina_message_panel_response(RemminaMessagePanel *mp, gint response_id);
 
 
diff --git a/src/remmina_mpchange.h b/src/remmina_mpchange.h
index a3e54a27b..c1cb79eb7 100644
--- a/src/remmina_mpchange.h
+++ b/src/remmina_mpchange.h
@@ -43,4 +43,3 @@ G_BEGIN_DECLS
 
 /* Schedule the multipassword change confirmation dialog to be executed ASAP */
 void remmina_mpchange_schedule(gboolean has_domain, const gchar *group, const gchar *domain, const gchar *username, const gchar *password);
-
diff --git a/src/remmina_plugin_manager.h b/src/remmina_plugin_manager.h
index 7700fd52b..81b549f33 100644
--- a/src/remmina_plugin_manager.h
+++ b/src/remmina_plugin_manager.h
@@ -43,21 +43,19 @@ G_BEGIN_DECLS
 typedef gboolean (*RemminaPluginFunc)(gchar *name, RemminaPlugin *plugin, gpointer data);
 
 void remmina_plugin_manager_init(void);
-RemminaPlugin* remmina_plugin_manager_get_plugin(RemminaPluginType type, const gchar *name);
-gboolean remmina_plugin_manager_query_feature_by_type(RemminaPluginType ptype, const gchar* name, RemminaProtocolFeatureType ftype);
+RemminaPlugin *remmina_plugin_manager_get_plugin(RemminaPluginType type, const gchar *name);
+gboolean remmina_plugin_manager_query_feature_by_type(RemminaPluginType ptype, const gchar *name, RemminaProtocolFeatureType ftype);
 void remmina_plugin_manager_for_each_plugin(RemminaPluginType type, RemminaPluginFunc func, gpointer data);
 void remmina_plugin_manager_show(GtkWindow *parent);
 void remmina_plugin_manager_for_each_plugin_stdout(RemminaPluginType type, RemminaPluginFunc func, gpointer data);
 void remmina_plugin_manager_show_stdout();
-RemminaFilePlugin* remmina_plugin_manager_get_import_file_handler(const gchar *file);
-RemminaFilePlugin* remmina_plugin_manager_get_export_file_handler(RemminaFile *remminafile);
-RemminaSecretPlugin* remmina_plugin_manager_get_secret_plugin(void);
-const gchar *remmina_plugin_manager_get_canonical_setting_name(const RemminaProtocolSetting* setting);
+RemminaFilePlugin *remmina_plugin_manager_get_import_file_handler(const gchar *file);
+RemminaFilePlugin *remmina_plugin_manager_get_export_file_handler(RemminaFile *remminafile);
+RemminaSecretPlugin *remmina_plugin_manager_get_secret_plugin(void);
+const gchar *remmina_plugin_manager_get_canonical_setting_name(const RemminaProtocolSetting *setting);
 gboolean remmina_plugin_manager_is_encrypted_setting(RemminaProtocolPlugin *pp, const char *setting);
 gboolean remmina_gtksocket_available();
 
 extern RemminaPluginService remmina_plugin_manager_service;
 
 G_END_DECLS
-
-
diff --git a/src/remmina_pref.h b/src/remmina_pref.h
index de30ed8f4..0b7c93248 100644
--- a/src/remmina_pref.h
+++ b/src/remmina_pref.h
@@ -87,126 +87,125 @@ enum {
 
 typedef struct _RemminaColorPref {
 	/* Color palette for VTE terminal */
-	gchar *background;
-	gchar *cursor;
-	gchar *foreground;
-	gchar *color0;
-	gchar *color1;
-	gchar *color2;
-	gchar *color3;
-	gchar *color4;
-	gchar *color5;
-	gchar *color6;
-	gchar *color7;
-	gchar *color8;
-	gchar *color9;
-	gchar *color10;
-	gchar *color11;
-	gchar *color12;
-	gchar *color13;
-	gchar *color14;
-	gchar *color15;
+	gchar * background;
+	gchar * cursor;
+	gchar * foreground;
+	gchar * color0;
+	gchar * color1;
+	gchar * color2;
+	gchar * color3;
+	gchar * color4;
+	gchar * color5;
+	gchar * color6;
+	gchar * color7;
+	gchar * color8;
+	gchar * color9;
+	gchar * color10;
+	gchar * color11;
+	gchar * color12;
+	gchar * color13;
+	gchar * color14;
+	gchar * color15;
 } RemminaColorPref;
 
 typedef struct _RemminaPref {
 	/* In RemminaPrefDialog options tab */
-	const gchar *datadir_path;
-	const gchar *remmina_file_name;
-	const gchar *screenshot_path;
-	gboolean deny_screenshot_clipboard;
-	const gchar *screenshot_name;
-	gboolean save_view_mode;
-	gboolean use_master_password;
-	const gchar *unlock_password;
-	const gchar *unlock_repassword;
-	gint unlock_timeout;
-	gint default_action;
-	gint scale_quality;
-	gint auto_scroll_step;
-	gint recent_maximum;
-	gchar *resolutions;
-	gchar *keystrokes;
+	const gchar *		datadir_path;
+	const gchar *		remmina_file_name;
+	const gchar *		screenshot_path;
+	gboolean		deny_screenshot_clipboard;
+	const gchar *		screenshot_name;
+	gboolean		save_view_mode;
+	gboolean		use_master_password;
+	const gchar *		unlock_password;
+	const gchar *		unlock_repassword;
+	gint			unlock_timeout;
+	gint			default_action;
+	gint			scale_quality;
+	gint			auto_scroll_step;
+	gint			recent_maximum;
+	gchar *			resolutions;
+	gchar *			keystrokes;
 	/* In RemminaPrefDialog appearance tab */
-	gboolean fullscreen_on_auto;
-	gboolean always_show_tab;
-	gboolean hide_connection_toolbar;
-	gboolean hide_searchbar;
-	gint default_mode;
-	gint tab_mode;
-	gint fullscreen_toolbar_visibility;
+	gboolean		fullscreen_on_auto;
+	gboolean		always_show_tab;
+	gboolean		hide_connection_toolbar;
+	gboolean		hide_searchbar;
+	gint			default_mode;
+	gint			tab_mode;
+	gint			fullscreen_toolbar_visibility;
 	/* In RemminaPrefDialog applet tab */
-	gboolean applet_new_ontop;
-	gboolean applet_hide_count;
-	gboolean disable_tray_icon;
-	gboolean dark_tray_icon;
+	gboolean		applet_new_ontop;
+	gboolean		applet_hide_count;
+	gboolean		disable_tray_icon;
+	gboolean		dark_tray_icon;
 	/* In RemminaPrefDialog SSH Option tab */
-	gint ssh_loglevel;
-	gboolean ssh_parseconfig;
-	gint sshtunnel_port;
-	gint ssh_tcp_keepidle;
-	gint ssh_tcp_keepintvl;
-	gint ssh_tcp_keepcnt;
-	gint ssh_tcp_usrtimeout;
+	gint			ssh_loglevel;
+	gboolean		ssh_parseconfig;
+	gint			sshtunnel_port;
+	gint			ssh_tcp_keepidle;
+	gint			ssh_tcp_keepintvl;
+	gint			ssh_tcp_keepcnt;
+	gint			ssh_tcp_usrtimeout;
 	/* In RemminaPrefDialog keyboard tab */
-	guint hostkey;
-	guint shortcutkey_fullscreen;
-	guint shortcutkey_autofit;
-	guint shortcutkey_prevtab;
-	guint shortcutkey_nexttab;
-	guint shortcutkey_dynres;
-	guint shortcutkey_scale;
-	guint shortcutkey_grab;
-	guint shortcutkey_viewonly;
-	guint shortcutkey_screenshot;
-	guint shortcutkey_minimize;
-	guint shortcutkey_disconnect;
-	guint shortcutkey_toolbar;
+	guint			hostkey;
+	guint			shortcutkey_fullscreen;
+	guint			shortcutkey_autofit;
+	guint			shortcutkey_prevtab;
+	guint			shortcutkey_nexttab;
+	guint			shortcutkey_dynres;
+	guint			shortcutkey_scale;
+	guint			shortcutkey_grab;
+	guint			shortcutkey_viewonly;
+	guint			shortcutkey_screenshot;
+	guint			shortcutkey_minimize;
+	guint			shortcutkey_disconnect;
+	guint			shortcutkey_toolbar;
 	/* In RemminaPrefDialog terminal tab */
-	gchar *vte_font;
-	gboolean vte_allow_bold_text;
-	gboolean vte_system_colors;
-	gint vte_lines;
-	guint vte_shortcutkey_copy;
-	guint vte_shortcutkey_paste;
-	guint vte_shortcutkey_select_all;
+	gchar *			vte_font;
+	gboolean		vte_allow_bold_text;
+	gboolean		vte_system_colors;
+	gint			vte_lines;
+	guint			vte_shortcutkey_copy;
+	guint			vte_shortcutkey_paste;
+	guint			vte_shortcutkey_select_all;
 	/* In View menu */
-	gboolean hide_toolbar;
-	gboolean small_toolbutton;
-	gint view_file_mode;
+	gboolean		hide_toolbar;
+	gboolean		small_toolbutton;
+	gint			view_file_mode;
 	/* In tray icon */
-	gboolean applet_enable_avahi;
+	gboolean		applet_enable_avahi;
 	/* Auto */
-	gint main_width;
-	gint main_height;
-	gboolean main_maximize;
-	gint main_sort_column_id;
-	gint main_sort_order;
-	gchar *expanded_group;
-	gboolean toolbar_pin_down;
-	gint floating_toolbar_placement;
-	gint toolbar_placement;
-	gboolean prevent_snap_welcome_message;
-	gchar *last_quickconnect_protocol;
+	gint			main_width;
+	gint			main_height;
+	gboolean		main_maximize;
+	gint			main_sort_column_id;
+	gint			main_sort_order;
+	gchar *			expanded_group;
+	gboolean		toolbar_pin_down;
+	gint			floating_toolbar_placement;
+	gint			toolbar_placement;
+	gboolean		prevent_snap_welcome_message;
+	gchar *			last_quickconnect_protocol;
 
 	/* Crypto */
-	gchar *secret;
+	gchar *			secret;
 
 	/* UID */
-	gchar *uid;
+	gchar *			uid;
 
-	RemminaColorPref color_pref;
+	RemminaColorPref	color_pref;
 
 	/* Usage stats */
-	gboolean periodic_usage_stats_permitted;
-	glong periodic_usage_stats_last_sent;
-	gchar *periodic_usage_stats_uuid_prefix;
-	gchar *last_success;
+	gboolean		periodic_usage_stats_permitted;
+	glong			periodic_usage_stats_last_sent;
+	gchar *			periodic_usage_stats_uuid_prefix;
+	gchar *			last_success;
 
 	/* Remmina news */
-	glong periodic_rmnews_last_get;
-	glong periodic_rmnews_get_count;
-	gchar *periodic_rmnews_uuid_prefix;
-
+	glong			periodic_rmnews_last_get;
+	glong			periodic_rmnews_get_count;
+	gchar *			periodic_rmnews_uuid_prefix;
 } RemminaPref;
 
 #define DEFAULT_SSH_PARSECONFIG TRUE
@@ -228,11 +227,11 @@ gboolean remmina_pref_is_rw(void);
 gboolean remmina_pref_save(void);
 
 void remmina_pref_add_recent(const gchar *protocol, const gchar *server);
-gchar* remmina_pref_get_recent(const gchar *protocol);
+gchar *remmina_pref_get_recent(const gchar *protocol);
 void remmina_pref_clear_recent(void);
 
 guint remmina_pref_keymap_get_keyval(const gchar *keymap, guint keyval);
-gchar** remmina_pref_keymap_groups(void);
+gchar **remmina_pref_keymap_groups(void);
 
 gint remmina_pref_get_scale_quality(void);
 gint remmina_pref_get_ssh_loglevel(void);
@@ -245,8 +244,7 @@ gint remmina_pref_get_ssh_tcp_keepcnt(void);
 gint remmina_pref_get_ssh_tcp_usrtimeout(void);
 
 void remmina_pref_set_value(const gchar *key, const gchar *value);
-gchar* remmina_pref_get_value(const gchar *key);
+gchar *remmina_pref_get_value(const gchar *key);
 gboolean remmina_pref_get_boolean(const gchar *key);
 
 G_END_DECLS
-
diff --git a/src/remmina_pref_dialog.h b/src/remmina_pref_dialog.h
index b49f9be89..82962db3e 100644
--- a/src/remmina_pref_dialog.h
+++ b/src/remmina_pref_dialog.h
@@ -44,96 +44,96 @@ typedef struct _RemminaPrefDialogPriv {
 } RemminaPrefDialogPriv;
 
 typedef struct _RemminaPrefDialog {
-	GtkBuilder *builder;
-	GtkDialog *dialog;
-	GtkNotebook *notebook_preferences;
+	GtkBuilder *		builder;
+	GtkDialog *		dialog;
+	GtkNotebook *		notebook_preferences;
 
-	GtkFileChooser *filechooserbutton_options_datadir_path;
-	GtkEntry *entry_options_file_name;
-	GtkFileChooser *filechooserbutton_options_screenshots_path;
-	GtkEntry *entry_options_screenshot_name;
-	GtkSwitch *switch_options_deny_screenshot_clipboard;
-	GtkSwitch *switch_options_remember_last_view_mode;
-	GtkSwitch *switch_security_use_master_password;
-	GtkEntry *unlock_timeout;
-	GtkEntry *unlock_password;
-	GtkEntry *unlock_repassword;
-	GtkCheckButton *checkbutton_options_save_settings;
-	GtkCheckButton *checkbutton_appearance_fullscreen_on_auto;
-	GtkCheckButton *checkbutton_appearance_show_tabs;
-	GtkCheckButton *checkbutton_appearance_hide_toolbar;
-	GtkCheckButton *checkbutton_appearance_hide_searchbar;
-	GtkSwitch *switch_permit_send_stats;
-	GtkComboBox *comboboxtext_options_double_click;
-	GtkComboBox *comboboxtext_appearance_view_mode;
-	GtkComboBox *comboboxtext_appearance_tab_interface;
-	GtkComboBox *comboboxtext_options_scale_quality;
-	GtkComboBox *comboboxtext_options_ssh_loglevel;
-	GtkComboBox *comboboxtext_appearance_fullscreen_toolbar_visibility;
-	GtkCheckButton *checkbutton_options_ssh_parseconfig;
-	GtkEntry *entry_options_ssh_port;
-	GtkEntry *entry_options_ssh_tcp_keepidle;
-	GtkEntry *entry_options_ssh_tcp_keepintvl;
-	GtkEntry *entry_options_ssh_tcp_keepcnt;
-	GtkEntry *entry_options_ssh_tcp_usrtimeout;
-	GtkEntry *entry_options_scroll;
-	GtkEntry *entry_options_recent_items;
-	GtkButton *button_options_recent_items_clear;
-	GtkButton *button_options_resolutions;
+	GtkFileChooser *	filechooserbutton_options_datadir_path;
+	GtkEntry *		entry_options_file_name;
+	GtkFileChooser *	filechooserbutton_options_screenshots_path;
+	GtkEntry *		entry_options_screenshot_name;
+	GtkSwitch *		switch_options_deny_screenshot_clipboard;
+	GtkSwitch *		switch_options_remember_last_view_mode;
+	GtkSwitch *		switch_security_use_master_password;
+	GtkEntry *		unlock_timeout;
+	GtkEntry *		unlock_password;
+	GtkEntry *		unlock_repassword;
+	GtkCheckButton *	checkbutton_options_save_settings;
+	GtkCheckButton *	checkbutton_appearance_fullscreen_on_auto;
+	GtkCheckButton *	checkbutton_appearance_show_tabs;
+	GtkCheckButton *	checkbutton_appearance_hide_toolbar;
+	GtkCheckButton *	checkbutton_appearance_hide_searchbar;
+	GtkSwitch *		switch_permit_send_stats;
+	GtkComboBox *		comboboxtext_options_double_click;
+	GtkComboBox *		comboboxtext_appearance_view_mode;
+	GtkComboBox *		comboboxtext_appearance_tab_interface;
+	GtkComboBox *		comboboxtext_options_scale_quality;
+	GtkComboBox *		comboboxtext_options_ssh_loglevel;
+	GtkComboBox *		comboboxtext_appearance_fullscreen_toolbar_visibility;
+	GtkCheckButton *	checkbutton_options_ssh_parseconfig;
+	GtkEntry *		entry_options_ssh_port;
+	GtkEntry *		entry_options_ssh_tcp_keepidle;
+	GtkEntry *		entry_options_ssh_tcp_keepintvl;
+	GtkEntry *		entry_options_ssh_tcp_keepcnt;
+	GtkEntry *		entry_options_ssh_tcp_usrtimeout;
+	GtkEntry *		entry_options_scroll;
+	GtkEntry *		entry_options_recent_items;
+	GtkButton *		button_options_recent_items_clear;
+	GtkButton *		button_options_resolutions;
 
-	GtkCheckButton *checkbutton_applet_new_connection_on_top;
-	GtkCheckButton *checkbutton_applet_hide_totals;
-	GtkCheckButton *checkbutton_applet_disable_tray;
-	GtkCheckButton *checkbutton_applet_light_tray;
-	GtkCheckButton *checkbutton_applet_start_in_tray;
+	GtkCheckButton *	checkbutton_applet_new_connection_on_top;
+	GtkCheckButton *	checkbutton_applet_hide_totals;
+	GtkCheckButton *	checkbutton_applet_disable_tray;
+	GtkCheckButton *	checkbutton_applet_light_tray;
+	GtkCheckButton *	checkbutton_applet_start_in_tray;
 
-	GtkButton *button_keyboard_host_key;
-	GtkButton *button_keyboard_fullscreen;
-	GtkButton *button_keyboard_auto_fit;
-	GtkButton *button_keyboard_switch_tab_left;
-	GtkButton *button_keyboard_switch_tab_right;
-	GtkButton *button_keyboard_scaled;
-	GtkButton *button_keyboard_grab_keyboard;
-	GtkButton *button_keyboard_screenshot;
-	GtkButton *button_keyboard_viewonly;
-	GtkButton *button_keyboard_minimize;
-	GtkButton *button_keyboard_disconnect;
-	GtkButton *button_keyboard_toolbar;
+	GtkButton *		button_keyboard_host_key;
+	GtkButton *		button_keyboard_fullscreen;
+	GtkButton *		button_keyboard_auto_fit;
+	GtkButton *		button_keyboard_switch_tab_left;
+	GtkButton *		button_keyboard_switch_tab_right;
+	GtkButton *		button_keyboard_scaled;
+	GtkButton *		button_keyboard_grab_keyboard;
+	GtkButton *		button_keyboard_screenshot;
+	GtkButton *		button_keyboard_viewonly;
+	GtkButton *		button_keyboard_minimize;
+	GtkButton *		button_keyboard_disconnect;
+	GtkButton *		button_keyboard_toolbar;
 
-	GtkSwitch *switch_terminal_font_system;
-	GtkFontButton *fontbutton_terminal_font;
-	GtkSwitch *switch_terminal_bold;
-	GtkLabel *label_terminal_foreground;
-	GtkColorButton *colorbutton_foreground;
-	GtkLabel *label_terminal_background;
-	GtkColorButton *colorbutton_background;
-	GtkEntry *entry_scrollback_lines;
-	GtkButton *button_keyboard_copy;
-	GtkButton *button_keyboard_paste;
-	GtkButton *button_keyboard_select_all;
-	GtkLabel *label_terminal_cursor_color;
-	GtkLabel *label_terminal_normal_colors;
-	GtkLabel *label_terminal_bright_colors;
-	GtkColorButton *colorbutton_cursor;
-	GtkColorButton *colorbutton_color0;
-	GtkColorButton *colorbutton_color1;
-	GtkColorButton *colorbutton_color2;
-	GtkColorButton *colorbutton_color3;
-	GtkColorButton *colorbutton_color4;
-	GtkColorButton *colorbutton_color5;
-	GtkColorButton *colorbutton_color6;
-	GtkColorButton *colorbutton_color7;
-	GtkColorButton *colorbutton_color8;
-	GtkColorButton *colorbutton_color9;
-	GtkColorButton *colorbutton_color10;
-	GtkColorButton *colorbutton_color11;
-	GtkColorButton *colorbutton_color12;
-	GtkColorButton *colorbutton_color13;
-	GtkColorButton *colorbutton_color14;
-	GtkColorButton *colorbutton_color15;
-	GtkFileChooser *button_term_cs;
+	GtkSwitch *		switch_terminal_font_system;
+	GtkFontButton *		fontbutton_terminal_font;
+	GtkSwitch *		switch_terminal_bold;
+	GtkLabel *		label_terminal_foreground;
+	GtkColorButton *	colorbutton_foreground;
+	GtkLabel *		label_terminal_background;
+	GtkColorButton *	colorbutton_background;
+	GtkEntry *		entry_scrollback_lines;
+	GtkButton *		button_keyboard_copy;
+	GtkButton *		button_keyboard_paste;
+	GtkButton *		button_keyboard_select_all;
+	GtkLabel *		label_terminal_cursor_color;
+	GtkLabel *		label_terminal_normal_colors;
+	GtkLabel *		label_terminal_bright_colors;
+	GtkColorButton *	colorbutton_cursor;
+	GtkColorButton *	colorbutton_color0;
+	GtkColorButton *	colorbutton_color1;
+	GtkColorButton *	colorbutton_color2;
+	GtkColorButton *	colorbutton_color3;
+	GtkColorButton *	colorbutton_color4;
+	GtkColorButton *	colorbutton_color5;
+	GtkColorButton *	colorbutton_color6;
+	GtkColorButton *	colorbutton_color7;
+	GtkColorButton *	colorbutton_color8;
+	GtkColorButton *	colorbutton_color9;
+	GtkColorButton *	colorbutton_color10;
+	GtkColorButton *	colorbutton_color11;
+	GtkColorButton *	colorbutton_color12;
+	GtkColorButton *	colorbutton_color13;
+	GtkColorButton *	colorbutton_color14;
+	GtkColorButton *	colorbutton_color15;
+	GtkFileChooser *	button_term_cs;
 
-	RemminaPrefDialogPriv *priv;
+	RemminaPrefDialogPriv * priv;
 } RemminaPrefDialog;
 
 enum {
@@ -145,10 +145,9 @@ enum {
 G_BEGIN_DECLS
 
 /* RemminaPrefDialog instance */
-GtkDialog* remmina_pref_dialog_new(gint default_tab, GtkWindow *parent);
+GtkDialog *remmina_pref_dialog_new(gint default_tab, GtkWindow *parent);
 /* Get the current PrefDialog or NULL if not initialized */
-GtkDialog* remmina_pref_dialog_get_dialog(void);
-void remmina_prefdiag_unlock_repwd_on_changed(GtkEditable* editable, RemminaPrefDialog *dialog);
+GtkDialog *remmina_pref_dialog_get_dialog(void);
+void remmina_prefdiag_unlock_repwd_on_changed(GtkEditable *editable, RemminaPrefDialog *dialog);
 
 G_END_DECLS
-
diff --git a/src/remmina_protocol_widget.c b/src/remmina_protocol_widget.c
index 7431472ee..d2c6fad55 100644
--- a/src/remmina_protocol_widget.c
+++ b/src/remmina_protocol_widget.c
@@ -55,51 +55,47 @@
 #include "remmina/remmina_trace_calls.h"
 
 #ifdef GDK_WINDOWING_WAYLAND
-	#include <gdk/gdkwayland.h>
+#include <gdk/gdkwayland.h>
 #endif
 
 struct _RemminaProtocolWidgetPriv {
+	RemminaFile *		remmina_file;
+	RemminaProtocolPlugin * plugin;
+	RemminaProtocolFeature *features;
 
-	RemminaFile* remmina_file;
-	RemminaProtocolPlugin* plugin;
-	RemminaProtocolFeature* features;
+	gint			width;
+	gint			height;
+	RemminaScaleMode	scalemode;
+	gboolean		scaler_expand;
 
-	gint width;
-	gint height;
-	RemminaScaleMode scalemode;
-	gboolean scaler_expand;
-
-	gboolean has_error;
-	gchar* error_message;
-	RemminaSSHTunnel* ssh_tunnel;
-	RemminaTunnelInitFunc init_func;
+	gboolean		has_error;
+	gchar *			error_message;
+	RemminaSSHTunnel *	ssh_tunnel;
+	RemminaTunnelInitFunc	init_func;
 
-	GtkWidget* chat_window;
+	GtkWidget *		chat_window;
 
-	gboolean closed;
+	gboolean		closed;
 
-	RemminaHostkeyFunc hostkey_func;
+	RemminaHostkeyFunc	hostkey_func;
 
-	gint profile_remote_width;
-	gint profile_remote_height;
+	gint			profile_remote_width;
+	gint			profile_remote_height;
 
-	RemminaMessagePanel *connect_message_panel;
-	RemminaMessagePanel *listen_message_panel;
-	RemminaMessagePanel *auth_message_panel;
+	RemminaMessagePanel *	connect_message_panel;
+	RemminaMessagePanel *	listen_message_panel;
+	RemminaMessagePanel *	auth_message_panel;
 
 	/* Data saved from the last message_panel when the user confirm */
-	gchar *username;
-	gchar *password;
-	gchar *domain;
-	gboolean save_password;
-
-	gchar *cacert;
-	gchar *cacrl;
-	gchar *clientcert;
-	gchar *clientkey;
-
-
-
+	gchar *			username;
+	gchar *			password;
+	gchar *			domain;
+	gboolean		save_password;
+
+	gchar *			cacert;
+	gchar *			cacrl;
+	gchar *			clientcert;
+	gchar *			clientkey;
 };
 
 enum panel_type {
@@ -120,8 +116,8 @@ enum {
 };
 
 typedef struct _RemminaProtocolWidgetSignalData {
-	RemminaProtocolWidget* gp;
-	const gchar* signal_name;
+	RemminaProtocolWidget * gp;
+	const gchar *		signal_name;
 } RemminaProtocolWidgetSignalData;
 
 static guint remmina_protocol_widget_signals[LAST_SIGNAL] =
@@ -131,23 +127,23 @@ static void remmina_protocol_widget_class_init(RemminaProtocolWidgetClass *klass
 {
 	TRACE_CALL(__func__);
 	remmina_protocol_widget_signals[CONNECT_SIGNAL] = g_signal_new("connect", G_TYPE_FROM_CLASS(klass),
-		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, connect), NULL, NULL,
-		g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+								       G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, connect), NULL, NULL,
+								       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 	remmina_protocol_widget_signals[DISCONNECT_SIGNAL] = g_signal_new("disconnect", G_TYPE_FROM_CLASS(klass),
-		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, disconnect), NULL, NULL,
-		g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+									  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, disconnect), NULL, NULL,
+									  g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 	remmina_protocol_widget_signals[DESKTOP_RESIZE_SIGNAL] = g_signal_new("desktop-resize", G_TYPE_FROM_CLASS(klass),
-		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, desktop_resize), NULL, NULL,
-		g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+									      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, desktop_resize), NULL, NULL,
+									      g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 	remmina_protocol_widget_signals[UPDATE_ALIGN_SIGNAL] = g_signal_new("update-align", G_TYPE_FROM_CLASS(klass),
-		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, update_align), NULL, NULL,
-		g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+									    G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, update_align), NULL, NULL,
+									    g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 	remmina_protocol_widget_signals[UNLOCK_DYNRES_SIGNAL] = g_signal_new("unlock-dynres", G_TYPE_FROM_CLASS(klass),
-		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, unlock_dynres), NULL, NULL,
-		g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+									     G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET(RemminaProtocolWidgetClass, unlock_dynres), NULL, NULL,
+									     g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 }
 
-static void remmina_protocol_widget_destroy(RemminaProtocolWidget* gp, gpointer data)
+static void remmina_protocol_widget_destroy(RemminaProtocolWidget *gp, gpointer data)
 {
 	TRACE_CALL(__func__);
 
@@ -187,10 +183,10 @@ static void remmina_protocol_widget_destroy(RemminaProtocolWidget* gp, gpointer
 
 
 
-void remmina_protocol_widget_grab_focus(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_grab_focus(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
-	GtkWidget* child;
+	GtkWidget *child;
 
 	child = gtk_bin_get_child(GTK_BIN(gp));
 
@@ -200,7 +196,7 @@ void remmina_protocol_widget_grab_focus(RemminaProtocolWidget* gp)
 	}
 }
 
-static void remmina_protocol_widget_init(RemminaProtocolWidget* gp)
+static void remmina_protocol_widget_init(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	RemminaProtocolWidgetPriv *priv;
@@ -215,10 +211,10 @@ static void remmina_protocol_widget_init(RemminaProtocolWidget* gp)
 void remmina_protocol_widget_open_connection_real(gpointer data)
 {
 	TRACE_CALL(__func__);
-	RemminaProtocolWidget* gp = REMMINA_PROTOCOL_WIDGET(data);
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(data);
 
 	RemminaProtocolPlugin *plugin;
-	RemminaProtocolFeature* feature;
+	RemminaProtocolFeature *feature;
 	gint num_plugin;
 	gint num_ssh;
 
@@ -227,18 +223,18 @@ void remmina_protocol_widget_open_connection_real(gpointer data)
 	plugin = gp->priv->plugin;
 	plugin->init(gp);
 
-	for (num_plugin = 0, feature = (RemminaProtocolFeature*)plugin->features; feature && feature->type; num_plugin++, feature++) {
+	for (num_plugin = 0, feature = (RemminaProtocolFeature *)plugin->features; feature && feature->type; num_plugin++, feature++) {
 	}
 
 	num_ssh = 0;
 #ifdef HAVE_LIBSSH
-	if (remmina_file_get_int(gp->priv->remmina_file, "ssh_enabled", FALSE)) {
+	if (remmina_file_get_int(gp->priv->remmina_file, "ssh_enabled", FALSE))
 		num_ssh += 2;
-	}
+
 #endif
 	if (num_plugin + num_ssh == 0) {
 		gp->priv->features = NULL;
-	}else  {
+	} else {
 		gp->priv->features = g_new0(RemminaProtocolFeature, num_plugin + num_ssh + 1);
 		feature = gp->priv->features;
 		if (plugin->features) {
@@ -263,18 +259,18 @@ void remmina_protocol_widget_open_connection_real(gpointer data)
 #endif
 	}
 
-	if (!plugin->open_connection(gp)) {
+	if (!plugin->open_connection(gp))
 		remmina_protocol_widget_close_connection(gp);
-	}
 }
 
 static void cancel_open_connection_cb(void *cbdata, int btn)
 {
-	RemminaProtocolWidget *gp = (RemminaProtocolWidget*)cbdata;
+	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)cbdata;
+
 	remmina_protocol_widget_close_connection(gp);
 }
 
-void remmina_protocol_widget_open_connection(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_open_connection(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	gchar *s;
@@ -307,12 +303,12 @@ static gboolean conn_closed(gpointer data)
 	TRACE_CALL(__func__);
 	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
 
-	#ifdef HAVE_LIBSSH
-		if (gp->priv->ssh_tunnel) {
-			remmina_ssh_tunnel_free(gp->priv->ssh_tunnel);
-			gp->priv->ssh_tunnel = NULL;
-		}
-	#endif
+#ifdef HAVE_LIBSSH
+	if (gp->priv->ssh_tunnel) {
+		remmina_ssh_tunnel_free(gp->priv->ssh_tunnel);
+		gp->priv->ssh_tunnel = NULL;
+	}
+#endif
 	/* Exec postcommand */
 	remmina_ext_exec_new(gp->priv->remmina_file, "postcommand");
 	/* Notify listeners (usually rcw) that the connection is closed */
@@ -320,10 +316,10 @@ static gboolean conn_closed(gpointer data)
 	return G_SOURCE_REMOVE;
 }
 
-void remmina_protocol_widget_signal_connection_closed(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_signal_connection_closed(RemminaProtocolWidget *gp)
 {
 	/* Plugin told us that it closed the connection,
-	   add async event to main thread to complete our close tasks */
+	 * add async event to main thread to complete our close tasks */
 	TRACE_CALL(__func__);
 	gp->priv->closed = TRUE;
 	g_idle_add(conn_closed, (gpointer)gp);
@@ -331,13 +327,13 @@ void remmina_protocol_widget_signal_connection_closed(RemminaProtocolWidget* gp)
 
 static gboolean conn_opened(gpointer data)
 {
-    TRACE_CALL(__func__);
+	TRACE_CALL(__func__);
 	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
 
 #ifdef HAVE_LIBSSH
-	if (gp->priv->ssh_tunnel) {
+	if (gp->priv->ssh_tunnel)
 		remmina_ssh_tunnel_cancel_accept(gp->priv->ssh_tunnel);
-	}
+
 #endif
 	if (gp->priv->listen_message_panel) {
 		rco_destroy_message_panel(gp->cnnobj, gp->priv->listen_message_panel);
@@ -347,14 +343,14 @@ static gboolean conn_opened(gpointer data)
 		rco_destroy_message_panel(gp->cnnobj, gp->priv->connect_message_panel);
 		gp->priv->connect_message_panel = NULL;
 	}
-    g_signal_emit_by_name(G_OBJECT(gp), "connect");
-    return G_SOURCE_REMOVE;
+	g_signal_emit_by_name(G_OBJECT(gp), "connect");
+	return G_SOURCE_REMOVE;
 }
 
-void remmina_protocol_widget_signal_connection_opened(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_signal_connection_opened(RemminaProtocolWidget *gp)
 {
 	/* Plugin told us that it closed the connection,
-	   add async event to main thread to complete our close tasks */
+	 * add async event to main thread to complete our close tasks */
 	TRACE_CALL(__func__);
 	g_idle_add(conn_opened, (gpointer)gp);
 }
@@ -364,57 +360,57 @@ static gboolean update_align(gpointer data)
 	TRACE_CALL(__func__);
 	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
 
-    g_signal_emit_by_name(G_OBJECT(gp), "update-align");
-    return G_SOURCE_REMOVE;
+	g_signal_emit_by_name(G_OBJECT(gp), "update-align");
+	return G_SOURCE_REMOVE;
 }
 
-void remmina_protocol_widget_update_align(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_update_align(RemminaProtocolWidget *gp)
 {
-    /* Called by the plugin to do updates on rcw */
-    TRACE_CALL(__func__);
-    g_idle_add(update_align, (gpointer)gp);
+	/* Called by the plugin to do updates on rcw */
+	TRACE_CALL(__func__);
+	g_idle_add(update_align, (gpointer)gp);
 }
 
 static gboolean unlock_dynres(gpointer data)
 {
 	TRACE_CALL(__func__);
 	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
-    g_signal_emit_by_name(G_OBJECT(gp), "unlock-dynres");
-    return G_SOURCE_REMOVE;
+	g_signal_emit_by_name(G_OBJECT(gp), "unlock-dynres");
+	return G_SOURCE_REMOVE;
 }
 
-void remmina_protocol_widget_unlock_dynres(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_unlock_dynres(RemminaProtocolWidget *gp)
 {
-    /* Called by the plugin to do updates on rcw */
-    TRACE_CALL(__func__);
-    g_idle_add(unlock_dynres, (gpointer)gp);
+	/* Called by the plugin to do updates on rcw */
+	TRACE_CALL(__func__);
+	g_idle_add(unlock_dynres, (gpointer)gp);
 }
 
 static gboolean desktop_resize(gpointer data)
 {
 	TRACE_CALL(__func__);
 	RemminaProtocolWidget *gp = (RemminaProtocolWidget *)data;
-    g_signal_emit_by_name(G_OBJECT(gp), "desktop-resize");
-    return G_SOURCE_REMOVE;
+	g_signal_emit_by_name(G_OBJECT(gp), "desktop-resize");
+	return G_SOURCE_REMOVE;
 }
 
-void remmina_protocol_widget_desktop_resize(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_desktop_resize(RemminaProtocolWidget *gp)
 {
-    /* Called by the plugin to do updates on rcw */
-    TRACE_CALL(__func__);
-    g_idle_add(desktop_resize, (gpointer)gp);
+	/* Called by the plugin to do updates on rcw */
+	TRACE_CALL(__func__);
+	g_idle_add(desktop_resize, (gpointer)gp);
 }
 
 
-void remmina_protocol_widget_close_connection(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_close_connection(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 
 	/* kindly ask the protocol plugin to close the connection.
-		Nothing else is done here. */
+	 *      Nothing else is done here. */
 
 	if (!GTK_IS_WIDGET(gp))
-			return;
+		return;
 
 	if (gp->priv->chat_window) {
 		gtk_widget_destroy(gp->priv->chat_window);
@@ -424,14 +420,14 @@ void remmina_protocol_widget_close_connection(RemminaProtocolWidget* gp)
 	if (gp->priv->closed) {
 		/* Connection is already closed by the plugin, but
 		 * rcw is asking to close again (usually after an error panel)
-		*/
+		 */
 		g_signal_emit_by_name(G_OBJECT(gp), "disconnect");
 		return;
 	}
 
 	/* Ask the plugin to close, async.
-	 	The plugin will emit a "disconnect" signal on gp to call our
-		remmina_protocol_widget_on_disconnected() when done */
+	 *      The plugin will emit a "disconnect" signal on gp to call our
+	 *      remmina_protocol_widget_on_disconnected() when done */
 	gp->priv->plugin->close_connection(gp);
 
 	return;
@@ -440,7 +436,7 @@ void remmina_protocol_widget_close_connection(RemminaProtocolWidget* gp)
 
 /** Check if the plugin accepts keystrokes.
  */
-gboolean remmina_protocol_widget_plugin_receives_keystrokes(RemminaProtocolWidget* gp)
+gboolean remmina_protocol_widget_plugin_receives_keystrokes(RemminaProtocolWidget *gp)
 {
 	return gp->priv->plugin->send_keystrokes ? TRUE : FALSE;
 }
@@ -448,7 +444,7 @@ gboolean remmina_protocol_widget_plugin_receives_keystrokes(RemminaProtocolWidge
 /**
  * Send to the plugin some keystrokes.
  */
-void remmina_protocol_widget_send_keystrokes(RemminaProtocolWidget* gp, GtkMenuItem *widget)
+void remmina_protocol_widget_send_keystrokes(RemminaProtocolWidget *gp, GtkMenuItem *widget)
 {
 	TRACE_CALL(__func__);
 	gchar *keystrokes = g_object_get_data(G_OBJECT(widget), "keystrokes");
@@ -462,9 +458,9 @@ void remmina_protocol_widget_send_keystrokes(RemminaProtocolWidget* gp, GtkMenuI
 	gint n_keys;
 	/* Single keystroke replace */
 	typedef struct _KeystrokeReplace {
-		gchar *search;
-		gchar *replace;
-		guint keyval;
+		gchar * search;
+		gchar * replace;
+		guint	keyval;
 	} KeystrokeReplace;
 	/* Special characters to replace */
 	KeystrokeReplace keystrokes_replaces[] =
@@ -481,10 +477,10 @@ void remmina_protocol_widget_send_keystrokes(RemminaProtocolWidget* gp, GtkMenuI
 		/* Replace special characters */
 		for (i = 0; keystrokes_replaces[i].replace; i++) {
 			remmina_public_str_replace_in_place(keystrokes,
-				keystrokes_replaces[i].search,
-				keystrokes_replaces[i].replace);
+							    keystrokes_replaces[i].search,
+							    keystrokes_replaces[i].replace);
 		}
-		keyvals = (guint*)g_malloc(strlen(keystrokes));
+		keyvals = (guint *)g_malloc(strlen(keystrokes));
 		while (TRUE) {
 			/* Process each character in the keystrokes */
 			character = g_utf8_get_char_validated(iter, -1);
@@ -529,7 +525,7 @@ void remmina_protocol_widget_send_keystrokes(RemminaProtocolWidget* gp, GtkMenuI
 	return;
 }
 
-gboolean remmina_protocol_widget_plugin_screenshot(RemminaProtocolWidget* gp, RemminaPluginScreenshotData *rpsd)
+gboolean remmina_protocol_widget_plugin_screenshot(RemminaProtocolWidget *gp, RemminaPluginScreenshotData *rpsd)
 {
 	if (!gp->priv->plugin->get_plugin_screenshot) {
 		remmina_log_printf("plugin screenshot function is not implemented\n");
@@ -537,20 +533,19 @@ gboolean remmina_protocol_widget_plugin_screenshot(RemminaProtocolWidget* gp, Re
 	}
 
 	return gp->priv->plugin->get_plugin_screenshot(gp, rpsd);
-
 }
 
-void remmina_protocol_widget_emit_signal(RemminaProtocolWidget* gp, const gchar* signal_name)
+void remmina_protocol_widget_emit_signal(RemminaProtocolWidget *gp, const gchar *signal_name)
 {
 	TRACE_CALL(__func__);
 
 	g_print("Emitting signals should be used from the object itself, not from another object");
 	raise(SIGINT);
 
-	if ( !remmina_masterthread_exec_is_main_thread() ) {
+	if (!remmina_masterthread_exec_is_main_thread()) {
 		/* Allow the execution of this function from a non main thread */
 		RemminaMTExecData *d;
-		d = (RemminaMTExecData*)g_malloc( sizeof(RemminaMTExecData) );
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
 		d->func = FUNC_PROTOCOLWIDGET_EMIT_SIGNAL;
 		d->p.protocolwidget_emit_signal.signal_name = signal_name;
 		d->p.protocolwidget_emit_signal.gp = gp;
@@ -559,40 +554,38 @@ void remmina_protocol_widget_emit_signal(RemminaProtocolWidget* gp, const gchar*
 		return;
 	}
 	g_signal_emit_by_name(G_OBJECT(gp), signal_name);
-
 }
 
-const RemminaProtocolFeature* remmina_protocol_widget_get_features(RemminaProtocolWidget* gp)
+const RemminaProtocolFeature *remmina_protocol_widget_get_features(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return gp->priv->features;
 }
 
-gboolean remmina_protocol_widget_query_feature_by_type(RemminaProtocolWidget* gp, RemminaProtocolFeatureType type)
+gboolean remmina_protocol_widget_query_feature_by_type(RemminaProtocolWidget *gp, RemminaProtocolFeatureType type)
 {
 	TRACE_CALL(__func__);
 	const RemminaProtocolFeature *feature;
 
 #ifdef HAVE_LIBSSH
 	if (type == REMMINA_PROTOCOL_FEATURE_TYPE_TOOL &&
-	    remmina_file_get_int(gp->priv->remmina_file, "ssh_enabled", FALSE)) {
+	    remmina_file_get_int(gp->priv->remmina_file, "ssh_enabled", FALSE))
 		return TRUE;
-	}
+
 #endif
-	for (feature = gp->priv->plugin->features; feature && feature->type; feature++) {
+	for (feature = gp->priv->plugin->features; feature && feature->type; feature++)
 		if (feature->type == type)
 			return TRUE;
-	}
 	return FALSE;
 }
 
-gboolean remmina_protocol_widget_query_feature_by_ref(RemminaProtocolWidget* gp, const RemminaProtocolFeature *feature)
+gboolean remmina_protocol_widget_query_feature_by_ref(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
 {
 	TRACE_CALL(__func__);
 	return gp->priv->plugin->query_feature(gp, feature);
 }
 
-void remmina_protocol_widget_call_feature_by_type(RemminaProtocolWidget* gp, RemminaProtocolFeatureType type, gint id)
+void remmina_protocol_widget_call_feature_by_type(RemminaProtocolWidget *gp, RemminaProtocolFeatureType type, gint id)
 {
 	TRACE_CALL(__func__);
 	const RemminaProtocolFeature *feature;
@@ -605,7 +598,7 @@ void remmina_protocol_widget_call_feature_by_type(RemminaProtocolWidget* gp, Rem
 	}
 }
 
-void remmina_protocol_widget_call_feature_by_ref(RemminaProtocolWidget* gp, const RemminaProtocolFeature *feature)
+void remmina_protocol_widget_call_feature_by_ref(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature)
 {
 	TRACE_CALL(__func__);
 	switch (feature->id) {
@@ -632,46 +625,44 @@ void remmina_protocol_widget_call_feature_by_ref(RemminaProtocolWidget* gp, cons
 	gp->priv->plugin->call_feature(gp, feature);
 }
 
-static gboolean remmina_protocol_widget_on_key_press(GtkWidget *widget, GdkEventKey *event, RemminaProtocolWidget* gp)
+static gboolean remmina_protocol_widget_on_key_press(GtkWidget *widget, GdkEventKey *event, RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
-	if (gp->priv->hostkey_func) {
+	if (gp->priv->hostkey_func)
 		return gp->priv->hostkey_func(gp, event->keyval, FALSE);
-	}
 	return FALSE;
 }
 
-static gboolean remmina_protocol_widget_on_key_release(GtkWidget *widget, GdkEventKey *event, RemminaProtocolWidget* gp)
+static gboolean remmina_protocol_widget_on_key_release(GtkWidget *widget, GdkEventKey *event, RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
-	if (gp->priv->hostkey_func) {
+	if (gp->priv->hostkey_func)
 		return gp->priv->hostkey_func(gp, event->keyval, TRUE);
-	}
 
 	return FALSE;
 }
 
-void remmina_protocol_widget_register_hostkey(RemminaProtocolWidget* gp, GtkWidget *widget)
+void remmina_protocol_widget_register_hostkey(RemminaProtocolWidget *gp, GtkWidget *widget)
 {
 	TRACE_CALL(__func__);
 	g_signal_connect(G_OBJECT(widget), "key-press-event", G_CALLBACK(remmina_protocol_widget_on_key_press), gp);
 	g_signal_connect(G_OBJECT(widget), "key-release-event", G_CALLBACK(remmina_protocol_widget_on_key_release), gp);
 }
 
-void remmina_protocol_widget_set_hostkey_func(RemminaProtocolWidget* gp, RemminaHostkeyFunc func)
+void remmina_protocol_widget_set_hostkey_func(RemminaProtocolWidget *gp, RemminaHostkeyFunc func)
 {
 	TRACE_CALL(__func__);
 	gp->priv->hostkey_func = func;
 }
 
-RemminaMessagePanel* remmina_protocol_widget_mpprogress(RemminaConnectionObject* cnnobj, const gchar *msg, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
+RemminaMessagePanel *remmina_protocol_widget_mpprogress(RemminaConnectionObject *cnnobj, const gchar *msg, RemminaMessagePanelCallback response_callback, gpointer response_callback_data)
 {
 	RemminaMessagePanel *mp;
 
-	if ( !remmina_masterthread_exec_is_main_thread() ) {
+	if (!remmina_masterthread_exec_is_main_thread()) {
 		/* Allow the execution of this function from a non main thread */
 		RemminaMTExecData *d;
-		d = (RemminaMTExecData*)g_malloc( sizeof(RemminaMTExecData) );
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
 		d->func = FUNC_PROTOCOLWIDGET_MPPROGRESS;
 		d->p.protocolwidget_mpprogress.cnnobj = cnnobj;
 		d->p.protocolwidget_mpprogress.message = msg;
@@ -691,10 +682,10 @@ RemminaMessagePanel* remmina_protocol_widget_mpprogress(RemminaConnectionObject*
 
 void remmina_protocol_widget_mpdestroy(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp)
 {
-	if ( !remmina_masterthread_exec_is_main_thread() ) {
+	if (!remmina_masterthread_exec_is_main_thread()) {
 		/* Allow the execution of this function from a non main thread */
 		RemminaMTExecData *d;
-		d = (RemminaMTExecData*)g_malloc( sizeof(RemminaMTExecData) );
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
 		d->func = FUNC_PROTOCOLWIDGET_MPDESTROY;
 		d->p.protocolwidget_mpdestroy.cnnobj = cnnobj;
 		d->p.protocolwidget_mpdestroy.mp = mp;
@@ -710,13 +701,13 @@ static void cancel_init_tunnel_cb(void *cbdata, int btn)
 {
 	printf("REMMINA: cancelling an opening tunnel is not implemented\n");
 }
-static gboolean remmina_protocol_widget_init_tunnel(RemminaProtocolWidget* gp)
+static gboolean remmina_protocol_widget_init_tunnel(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	RemminaSSHTunnel *tunnel;
 	gint ret;
-	gchar* msg;
-	RemminaMessagePanel* mp;
+	gchar *msg;
+	RemminaMessagePanel *mp;
 
 	/* Reuse existing SSH connection if it’s reconnecting to destination */
 	if (gp->priv->ssh_tunnel == NULL) {
@@ -735,9 +726,8 @@ static gboolean remmina_protocol_widget_init_tunnel(RemminaProtocolWidget* gp)
 
 		ret = remmina_ssh_auth_gui(REMMINA_SSH(tunnel), gp, gp->priv->remmina_file);
 		if (ret <= 0) {
-			if (ret == 0) {
+			if (ret == 0)
 				remmina_protocol_widget_set_error(gp, REMMINA_SSH(tunnel)->error);
-			}
 			remmina_ssh_tunnel_free(tunnel);
 			return FALSE;
 		}
@@ -764,7 +754,7 @@ static void cancel_start_direct_tunnel_cb(void *cbdata, int btn)
  * Start an SSH tunnel if possible and return the host:port string.
  *
  */
-gchar* remmina_protocol_widget_start_direct_tunnel(RemminaProtocolWidget* gp, gint default_port, gboolean port_plus)
+gchar *remmina_protocol_widget_start_direct_tunnel(RemminaProtocolWidget *gp, gint default_port, gboolean port_plus)
 {
 	TRACE_CALL(__func__);
 	const gchar *server;
@@ -774,16 +764,14 @@ gchar* remmina_protocol_widget_start_direct_tunnel(RemminaProtocolWidget* gp, gi
 
 	server = remmina_file_get_string(gp->priv->remmina_file, "server");
 
-	if (!server) {
+	if (!server)
 		return g_strdup("");
-	}
 
 	remmina_public_get_server_port(server, default_port, &host, &port);
 
-	if (port_plus && port < 100) {
+	if (port_plus && port < 100)
 		/* Protocols like VNC supports using instance number :0, :1, etc as port number. */
 		port += default_port;
-	}
 
 #ifdef HAVE_LIBSSH
 	RemminaMessagePanel *mp;
@@ -842,20 +830,18 @@ static void cancel_start_reverse_tunnel_cb(void *cbdata, int btn)
 #endif
 
 
-gboolean remmina_protocol_widget_start_reverse_tunnel(RemminaProtocolWidget* gp, gint local_port)
+gboolean remmina_protocol_widget_start_reverse_tunnel(RemminaProtocolWidget *gp, gint local_port)
 {
 	TRACE_CALL(__func__);
 #ifdef HAVE_LIBSSH
 	gchar *msg;
 	RemminaMessagePanel *mp;
 
-	if (!remmina_file_get_int(gp->priv->remmina_file, "ssh_enabled", FALSE)) {
+	if (!remmina_file_get_int(gp->priv->remmina_file, "ssh_enabled", FALSE))
 		return TRUE;
-	}
 
-	if (!remmina_protocol_widget_init_tunnel(gp)) {
+	if (!remmina_protocol_widget_init_tunnel(gp))
 		return FALSE;
-	}
 
 	msg = g_strdup_printf(_("Waiting for an incoming SSH tunnel at port %i…"), remmina_file_get_int(gp->priv->remmina_file, "listenport", 0));
 	mp = remmina_protocol_widget_mpprogress(gp->cnnobj, msg, cancel_start_reverse_tunnel_cb, NULL);
@@ -871,7 +857,7 @@ gboolean remmina_protocol_widget_start_reverse_tunnel(RemminaProtocolWidget* gp,
 	return TRUE;
 }
 
-gboolean remmina_protocol_widget_ssh_exec(RemminaProtocolWidget* gp, gboolean wait, const gchar *fmt, ...)
+gboolean remmina_protocol_widget_ssh_exec(RemminaProtocolWidget *gp, gboolean wait, const gchar *fmt, ...)
 {
 	TRACE_CALL(__func__);
 #ifdef HAVE_LIBSSH
@@ -882,9 +868,8 @@ gboolean remmina_protocol_widget_ssh_exec(RemminaProtocolWidget* gp, gboolean wa
 	gchar *cmd, *ptr;
 	va_list args;
 
-	if ((channel = ssh_channel_new(REMMINA_SSH(tunnel)->session)) == NULL) {
+	if ((channel = ssh_channel_new(REMMINA_SSH(tunnel)->session)) == NULL)
 		return FALSE;
-	}
 
 	va_start(args, fmt);
 	cmd = g_strdup_vprintf(fmt, args);
@@ -903,17 +888,17 @@ gboolean remmina_protocol_widget_ssh_exec(RemminaProtocolWidget* gp, gboolean wa
 				break;
 			case 127:
 				remmina_ssh_set_application_error(REMMINA_SSH(tunnel),
-					_("Command %s not found on SSH server"), cmd);
+								  _("Command %s not found on SSH server"), cmd);
 				break;
 			default:
 				remmina_ssh_set_application_error(REMMINA_SSH(tunnel),
-					_("Command %s failed on SSH server (status = %i)."), cmd, status);
+								  _("Command %s failed on SSH server (status = %i)."), cmd, status);
 				break;
 			}
-		}else  {
+		} else {
 			ret = TRUE;
 		}
-	}else  {
+	} else {
 		remmina_ssh_set_error(REMMINA_SSH(tunnel), _("Failed to execute command: %s"));
 	}
 	g_free(cmd);
@@ -933,33 +918,32 @@ gboolean remmina_protocol_widget_ssh_exec(RemminaProtocolWidget* gp, gboolean wa
 static gboolean remmina_protocol_widget_tunnel_init_callback(RemminaSSHTunnel *tunnel, gpointer data)
 {
 	TRACE_CALL(__func__);
-	RemminaProtocolWidget* gp = REMMINA_PROTOCOL_WIDGET(data);
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(data);
 	gchar *server;
 	gint port;
 	gboolean ret;
 
 	remmina_public_get_server_port(remmina_file_get_string(gp->priv->remmina_file, "server"), 177, &server, &port);
 	ret = ((RemminaXPortTunnelInitFunc)gp->priv->init_func)(gp,
-		tunnel->remotedisplay, (tunnel->bindlocalhost ? "localhost" : server), port);
+								tunnel->remotedisplay, (tunnel->bindlocalhost ? "localhost" : server), port);
 	g_free(server);
 
 	return ret;
 }
 
-static gboolean remmina_protocol_widget_tunnel_connect_callback(RemminaSSHTunnel* tunnel, gpointer data)
+static gboolean remmina_protocol_widget_tunnel_connect_callback(RemminaSSHTunnel *tunnel, gpointer data)
 {
 	TRACE_CALL(__func__);
 	return TRUE;
 }
 
-static gboolean remmina_protocol_widget_tunnel_disconnect_callback(RemminaSSHTunnel* tunnel, gpointer data)
+static gboolean remmina_protocol_widget_tunnel_disconnect_callback(RemminaSSHTunnel *tunnel, gpointer data)
 {
 	TRACE_CALL(__func__);
-	RemminaProtocolWidget* gp = REMMINA_PROTOCOL_WIDGET(data);
+	RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET(data);
 
-	if (REMMINA_SSH(tunnel)->error) {
+	if (REMMINA_SSH(tunnel)->error)
 		remmina_protocol_widget_set_error(gp, "%s", REMMINA_SSH(tunnel)->error);
-	}
 
 	IDLE_ADD((GSourceFunc)remmina_protocol_widget_close_connection, gp);
 	return TRUE;
@@ -971,7 +955,7 @@ static void cancel_connect_xport_cb(void *cbdata, int btn)
 	printf("REMMINA: cancelling a xport connect is not implemented\n");
 }
 #endif
-gboolean remmina_protocol_widget_start_xport_tunnel(RemminaProtocolWidget* gp, RemminaXPortTunnelInitFunc init_func)
+gboolean remmina_protocol_widget_start_xport_tunnel(RemminaProtocolWidget *gp, RemminaXPortTunnelInitFunc init_func)
 {
 	TRACE_CALL(__func__);
 #ifdef HAVE_LIBSSH
@@ -998,7 +982,7 @@ gboolean remmina_protocol_widget_start_xport_tunnel(RemminaProtocolWidget* gp, R
 
 	if (!remmina_ssh_tunnel_xport(gp->priv->ssh_tunnel, bindlocalhost)) {
 		remmina_protocol_widget_set_error(gp, "Failed to open channel: %s",
-			ssh_get_error(REMMINA_SSH(gp->priv->ssh_tunnel)->session));
+						  ssh_get_error(REMMINA_SSH(gp->priv->ssh_tunnel)->session));
 		return FALSE;
 	}
 
@@ -1011,7 +995,7 @@ gboolean remmina_protocol_widget_start_xport_tunnel(RemminaProtocolWidget* gp, R
 #endif
 }
 
-void remmina_protocol_widget_set_display(RemminaProtocolWidget* gp, gint display)
+void remmina_protocol_widget_set_display(RemminaProtocolWidget *gp, gint display)
 {
 	TRACE_CALL(__func__);
 #ifdef HAVE_LIBSSH
@@ -1020,14 +1004,14 @@ void remmina_protocol_widget_set_display(RemminaProtocolWidget* gp, gint display
 #endif
 }
 
-gint remmina_protocol_widget_get_profile_remote_width(RemminaProtocolWidget* gp)
+gint remmina_protocol_widget_get_profile_remote_width(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	/* Returns the width of remote desktop as choosen by the user profile */
 	return gp->priv->profile_remote_width;
 }
 
-gint remmina_protocol_widget_get_profile_remote_height(RemminaProtocolWidget* gp)
+gint remmina_protocol_widget_get_profile_remote_height(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	/* Returns the height of remote desktop as choosen by the user profile */
@@ -1035,25 +1019,25 @@ gint remmina_protocol_widget_get_profile_remote_height(RemminaProtocolWidget* gp
 }
 
 
-gint remmina_protocol_widget_get_width(RemminaProtocolWidget* gp)
+gint remmina_protocol_widget_get_width(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return gp->priv->width;
 }
 
-void remmina_protocol_widget_set_width(RemminaProtocolWidget* gp, gint width)
+void remmina_protocol_widget_set_width(RemminaProtocolWidget *gp, gint width)
 {
 	TRACE_CALL(__func__);
 	gp->priv->width = width;
 }
 
-gint remmina_protocol_widget_get_height(RemminaProtocolWidget* gp)
+gint remmina_protocol_widget_get_height(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return gp->priv->height;
 }
 
-void remmina_protocol_widget_set_height(RemminaProtocolWidget* gp, gint height)
+void remmina_protocol_widget_set_height(RemminaProtocolWidget *gp, gint height)
 {
 	TRACE_CALL(__func__);
 	gp->priv->height = height;
@@ -1071,32 +1055,32 @@ void remmina_protocol_widget_set_current_scale_mode(RemminaProtocolWidget *gp, R
 	gp->priv->scalemode = scalemode;
 }
 
-gboolean remmina_protocol_widget_get_expand(RemminaProtocolWidget* gp)
+gboolean remmina_protocol_widget_get_expand(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return gp->priv->scaler_expand;
 }
 
-void remmina_protocol_widget_set_expand(RemminaProtocolWidget* gp, gboolean expand)
+void remmina_protocol_widget_set_expand(RemminaProtocolWidget *gp, gboolean expand)
 {
 	TRACE_CALL(__func__);
 	gp->priv->scaler_expand = expand;
 	return;
 }
 
-gboolean remmina_protocol_widget_has_error(RemminaProtocolWidget* gp)
+gboolean remmina_protocol_widget_has_error(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return gp->priv->has_error;
 }
 
-const gchar* remmina_protocol_widget_get_error_message(RemminaProtocolWidget* gp)
+const gchar *remmina_protocol_widget_get_error_message(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return gp->priv->error_message;
 }
 
-void remmina_protocol_widget_set_error(RemminaProtocolWidget* gp, const gchar *fmt, ...)
+void remmina_protocol_widget_set_error(RemminaProtocolWidget *gp, const gchar *fmt, ...)
 {
 	TRACE_CALL(__func__);
 	va_list args;
@@ -1116,13 +1100,13 @@ void remmina_protocol_widget_set_error(RemminaProtocolWidget* gp, const gchar *f
 	gp->priv->has_error = TRUE;
 }
 
-gboolean remmina_protocol_widget_is_closed(RemminaProtocolWidget* gp)
+gboolean remmina_protocol_widget_is_closed(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return gp->priv->closed;
 }
 
-RemminaFile* remmina_protocol_widget_get_file(RemminaProtocolWidget* gp)
+RemminaFile *remmina_protocol_widget_get_file(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return gp->priv->remmina_file;
@@ -1130,25 +1114,26 @@ RemminaFile* remmina_protocol_widget_get_file(RemminaProtocolWidget* gp)
 
 struct remmina_protocol_widget_dialog_mt_data_t {
 	/* Input data */
-	RemminaProtocolWidget *gp;
-	gchar *title;
-	gchar *default_username;
-	gchar *default_password;
-	gchar *default_domain;
-	gchar *strpasswordlabel;
-	enum panel_type dtype;
-	RemminaMessagePanelFlags pflags;
-	gboolean called_from_subthread;
+	RemminaProtocolWidget *		gp;
+	gchar *				title;
+	gchar *				default_username;
+	gchar *				default_password;
+	gchar *				default_domain;
+	gchar *				strpasswordlabel;
+	enum panel_type			dtype;
+	RemminaMessagePanelFlags	pflags;
+	gboolean			called_from_subthread;
 	/* Running status */
-	pthread_mutex_t pt_mutex;
-	pthread_cond_t pt_cond;
+	pthread_mutex_t			pt_mutex;
+	pthread_cond_t			pt_cond;
 	/* Output/retval */
-	int rcbutton;
+	int				rcbutton;
 };
 
 static void authpanel_mt_cb(void *user_data, int button)
 {
 	struct remmina_protocol_widget_dialog_mt_data_t *d = (struct remmina_protocol_widget_dialog_mt_data_t *)user_data;
+
 	d->rcbutton = button;
 	if (button == GTK_RESPONSE_OK) {
 		if (d->dtype == RPWDT_AUTH) {
@@ -1176,14 +1161,13 @@ static void authpanel_mt_cb(void *user_data, int button)
 		/* Signal completion, when called from main thread. Message panel will be destroyed by the caller */
 		remmina_message_panel_response(d->gp->priv->auth_message_panel, button);
 	}
-
 }
 
 static gboolean remmina_protocol_widget_dialog_mt_setup(gpointer user_data)
 {
 	struct remmina_protocol_widget_dialog_mt_data_t *d = (struct remmina_protocol_widget_dialog_mt_data_t *)user_data;
 
-	RemminaFile* remminafile = d->gp->priv->remmina_file;
+	RemminaFile *remminafile = d->gp->priv->remmina_file;
 	RemminaMessagePanel *mp;
 	const gchar *s;
 
@@ -1195,9 +1179,8 @@ static gboolean remmina_protocol_widget_dialog_mt_setup(gpointer user_data)
 		if (d->pflags & REMMINA_MESSAGE_PANEL_FLAG_DOMAIN)
 			remmina_message_panel_field_set_string(mp, REMMINA_MESSAGE_PANEL_DOMAIN, d->default_domain);
 		remmina_message_panel_field_set_string(mp, REMMINA_MESSAGE_PANEL_PASSWORD, d->default_password);
-		if (d->pflags & REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD) {
-			remmina_message_panel_field_set_switch(mp, REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD, (d->pflags & REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD) ? TRUE: FALSE);
-		}
+		if (d->pflags & REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD)
+			remmina_message_panel_field_set_switch(mp, REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD, (d->pflags & REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD) ? TRUE : FALSE);
 	} else if (d->dtype == RPWDT_QUESTIONYESNO) {
 		remmina_message_panel_setup_question(mp, d->title, authpanel_mt_cb, d);
 	} else if (d->dtype == RPWDT_AUTHX509) {
@@ -1218,23 +1201,23 @@ static gboolean remmina_protocol_widget_dialog_mt_setup(gpointer user_data)
 	return FALSE;
 }
 
-typedef struct
-{
-	RemminaMessagePanel *mp;
-	GMainLoop *loop;
-	gint response;
-	gboolean destroyed;
+typedef struct {
+	RemminaMessagePanel *	mp;
+	GMainLoop *		loop;
+	gint			response;
+	gboolean		destroyed;
 } MpRunInfo;
 
-static void shutdown_loop (MpRunInfo *mpri)
+static void shutdown_loop(MpRunInfo *mpri)
 {
-  if (g_main_loop_is_running (mpri->loop))
-    g_main_loop_quit (mpri->loop);
+	if (g_main_loop_is_running(mpri->loop))
+		g_main_loop_quit(mpri->loop);
 }
 
 static void run_response_handler(RemminaMessagePanel *mp, gint response_id, gpointer data)
 {
 	MpRunInfo *mpri = (MpRunInfo *)data;
+
 	mpri->response = response_id;
 	shutdown_loop(mpri);
 }
@@ -1242,25 +1225,27 @@ static void run_response_handler(RemminaMessagePanel *mp, gint response_id, gpoi
 static void run_unmap_handler(RemminaMessagePanel *mp, gpointer data)
 {
 	MpRunInfo *mpri = (MpRunInfo *)data;
+
 	mpri->response = GTK_RESPONSE_CANCEL;
 	shutdown_loop(mpri);
 }
 
-static void run_destroy_handler (RemminaMessagePanel *mp, gpointer data)
+static void run_destroy_handler(RemminaMessagePanel *mp, gpointer data)
 {
 	MpRunInfo *mpri = (MpRunInfo *)data;
+
 	mpri->destroyed = TRUE;
 	mpri->response = GTK_RESPONSE_CANCEL;
 	shutdown_loop(mpri);
 }
 
-static int remmina_protocol_widget_dialog(enum panel_type dtype, RemminaProtocolWidget* gp, RemminaMessagePanelFlags pflags,
-		const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain,
-		const gchar *strpasswordlabel)
+static int remmina_protocol_widget_dialog(enum panel_type dtype, RemminaProtocolWidget *gp, RemminaMessagePanelFlags pflags,
+					  const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain,
+					  const gchar *strpasswordlabel)
 {
 	TRACE_CALL(__func__);
 
-	struct remmina_protocol_widget_dialog_mt_data_t *d = (struct remmina_protocol_widget_dialog_mt_data_t*)g_malloc( sizeof(struct remmina_protocol_widget_dialog_mt_data_t) );
+	struct remmina_protocol_widget_dialog_mt_data_t *d = (struct remmina_protocol_widget_dialog_mt_data_t *)g_malloc(sizeof(struct remmina_protocol_widget_dialog_mt_data_t));
 	int rcbutton;
 
 	d->gp = gp;
@@ -1287,27 +1272,26 @@ static int remmina_protocol_widget_dialog(enum panel_type dtype, RemminaProtocol
 
 		if (!gtk_widget_get_visible(GTK_WIDGET(mpri.mp)))
 			gtk_widget_show(GTK_WIDGET(mpri.mp));
-		response_handler = g_signal_connect (mpri.mp, "response", G_CALLBACK (run_response_handler), &mpri);
-		unmap_handler = g_signal_connect (mpri.mp, "unmap", G_CALLBACK (run_unmap_handler), &mpri);
-		destroy_handler = g_signal_connect (mpri.mp, "destroy", G_CALLBACK (run_destroy_handler),&mpri);
+		response_handler = g_signal_connect(mpri.mp, "response", G_CALLBACK(run_response_handler), &mpri);
+		unmap_handler = g_signal_connect(mpri.mp, "unmap", G_CALLBACK(run_unmap_handler), &mpri);
+		destroy_handler = g_signal_connect(mpri.mp, "destroy", G_CALLBACK(run_destroy_handler), &mpri);
 
 		g_object_ref(mpri.mp);
 
-		mpri.loop = g_main_loop_new (NULL, FALSE);
-		g_main_loop_run (mpri.loop);
-		g_main_loop_unref (mpri.loop);
+		mpri.loop = g_main_loop_new(NULL, FALSE);
+		g_main_loop_run(mpri.loop);
+		g_main_loop_unref(mpri.loop);
 
 		if (!mpri.destroyed) {
-			g_signal_handler_disconnect (mpri.mp, response_handler);
-			g_signal_handler_disconnect (mpri.mp, destroy_handler);
-			g_signal_handler_disconnect (mpri.mp, unmap_handler);
+			g_signal_handler_disconnect(mpri.mp, response_handler);
+			g_signal_handler_disconnect(mpri.mp, destroy_handler);
+			g_signal_handler_disconnect(mpri.mp, unmap_handler);
 		}
 		g_object_unref(mpri.mp);
 
 		rco_destroy_message_panel(d->gp->cnnobj, d->gp->priv->auth_message_panel);
 
 		rcbutton = mpri.response;
-
 	} else {
 		d->called_from_subthread = TRUE;
 		// pthread_cleanup_push(ptcleanup, (void*)d);
@@ -1330,78 +1314,76 @@ static int remmina_protocol_widget_dialog(enum panel_type dtype, RemminaProtocol
 	g_free(d->default_domain);
 	g_free(d);
 	return rcbutton;
-
 }
 
-gint remmina_protocol_widget_panel_question_yesno(RemminaProtocolWidget* gp, const char *msg)
+gint remmina_protocol_widget_panel_question_yesno(RemminaProtocolWidget *gp, const char *msg)
 {
 	return remmina_protocol_widget_dialog(RPWDT_QUESTIONYESNO, gp, 0, msg, NULL, NULL, NULL, NULL);
 }
 
-gint remmina_protocol_widget_panel_auth(RemminaProtocolWidget* gp, RemminaMessagePanelFlags pflags,
-	const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain, const gchar *password_prompt)
+gint remmina_protocol_widget_panel_auth(RemminaProtocolWidget *gp, RemminaMessagePanelFlags pflags,
+					const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain, const gchar *password_prompt)
 {
 	TRACE_CALL(__func__);
 	return remmina_protocol_widget_dialog(RPWDT_AUTH, gp, pflags, title, default_username,
-			default_password, default_domain, password_prompt == NULL ? _("Password") : password_prompt);
+					      default_password, default_domain, password_prompt == NULL ? _("Password") : password_prompt);
 }
 
-gint remmina_protocol_widget_panel_authuserpwd_ssh_tunnel(RemminaProtocolWidget* gp, gboolean want_domain, gboolean allow_password_saving)
+gint remmina_protocol_widget_panel_authuserpwd_ssh_tunnel(RemminaProtocolWidget *gp, gboolean want_domain, gboolean allow_password_saving)
 {
 	TRACE_CALL(__func__);
 	unsigned pflags;
-	RemminaFile* remminafile = gp->priv->remmina_file;
+	RemminaFile *remminafile = gp->priv->remmina_file;
 	const gchar *username, *password;
 
 	pflags = REMMINA_MESSAGE_PANEL_FLAG_USERNAME;
 	if (remmina_file_get_filename(remminafile) != NULL &&
-		 !remminafile->prevent_saving && allow_password_saving)
+	    !remminafile->prevent_saving && allow_password_saving)
 		pflags |= REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD;
 
 	username = remmina_file_get_string(remminafile, "ssh_username");
 	password = remmina_file_get_string(remminafile, "ssh_password");
 
 	return remmina_protocol_widget_dialog(RPWDT_AUTH, gp, pflags, _("Enter SSH tunnel authentication credentials"), username,
-			password, NULL, _("Password"));
+					      password, NULL, _("Password"));
 }
 
 /*
-gint remmina_protocol_widget_panel_authpwd(RemminaProtocolWidget* gp, RemminaAuthpwdType authpwd_type, gboolean allow_password_saving)
-{
-	TRACE_CALL(__func__);
-	unsigned pflags;
-	RemminaFile* remminafile = gp->priv->remmina_file;
-	char *password_prompt;
-	int rc;
-
-	pflags = 0;
-	if (remmina_file_get_filename(remminafile) != NULL &&
-		 !remminafile->prevent_saving && allow_password_saving)
-		pflags |= REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD;
-
-	switch (authpwd_type) {
-		case REMMINA_AUTHPWD_TYPE_PROTOCOL:
-			password_prompt = g_strdup_printf(_("%s password"), remmina_file_get_string(remminafile, "protocol"));
-			break;
-		case REMMINA_AUTHPWD_TYPE_SSH_PWD:
-			password_prompt = g_strdup(_("SSH password"));
-			break;
-		case REMMINA_AUTHPWD_TYPE_SSH_PRIVKEY:
-			password_prompt = g_strdup(_("SSH private key passphrase"));
-			break;
-		default:
-			password_prompt = g_strdup(_("Password"));
-			break;
-	}
-
-	rc = remmina_protocol_widget_dialog(RPWDT_AUTH, gp, pflags, password_prompt);
-	g_free(password_prompt);
-	return rc;
-
-}
-*/
-
-gint remmina_protocol_widget_panel_authx509(RemminaProtocolWidget* gp)
+ * gint remmina_protocol_widget_panel_authpwd(RemminaProtocolWidget* gp, RemminaAuthpwdType authpwd_type, gboolean allow_password_saving)
+ * {
+ *      TRACE_CALL(__func__);
+ *      unsigned pflags;
+ *      RemminaFile* remminafile = gp->priv->remmina_file;
+ *      char *password_prompt;
+ *      int rc;
+ *
+ *      pflags = 0;
+ *      if (remmina_file_get_filename(remminafile) != NULL &&
+ *               !remminafile->prevent_saving && allow_password_saving)
+ *              pflags |= REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD;
+ *
+ *      switch (authpwd_type) {
+ *              case REMMINA_AUTHPWD_TYPE_PROTOCOL:
+ *                      password_prompt = g_strdup_printf(_("%s password"), remmina_file_get_string(remminafile, "protocol"));
+ *                      break;
+ *              case REMMINA_AUTHPWD_TYPE_SSH_PWD:
+ *                      password_prompt = g_strdup(_("SSH password"));
+ *                      break;
+ *              case REMMINA_AUTHPWD_TYPE_SSH_PRIVKEY:
+ *                      password_prompt = g_strdup(_("SSH private key passphrase"));
+ *                      break;
+ *              default:
+ *                      password_prompt = g_strdup(_("Password"));
+ *                      break;
+ *      }
+ *
+ *      rc = remmina_protocol_widget_dialog(RPWDT_AUTH, gp, pflags, password_prompt);
+ *      g_free(password_prompt);
+ *      return rc;
+ *
+ * }
+ */
+gint remmina_protocol_widget_panel_authx509(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 
@@ -1409,7 +1391,7 @@ gint remmina_protocol_widget_panel_authx509(RemminaProtocolWidget* gp)
 }
 
 
-gint remmina_protocol_widget_panel_new_certificate(RemminaProtocolWidget* gp, const gchar* subject, const gchar* issuer, const gchar* fingerprint)
+gint remmina_protocol_widget_panel_new_certificate(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *fingerprint)
 {
 	TRACE_CALL(__func__);
 	gchar *s;
@@ -1418,20 +1400,19 @@ gint remmina_protocol_widget_panel_new_certificate(RemminaProtocolWidget* gp, co
 	// For markup see https://developer.gnome.org/pygtk/stable/pango-markup-language.html
 	s = g_strdup_printf(
 		"<big>%s</big>\n\n%s %s\n%s %s\n%s %s\n\n<big>%s</big>",
-		 _("Certificate Details:"),
-		 _("Subject:"), subject,
-		 _("Issuer:"), issuer,
-		 _("Fingerprint:"), fingerprint,
-		  _("Accept Certificate?"));
+		_("Certificate Details:"),
+		_("Subject:"), subject,
+		_("Issuer:"), issuer,
+		_("Fingerprint:"), fingerprint,
+		_("Accept Certificate?"));
 	rc = remmina_protocol_widget_dialog(RPWDT_QUESTIONYESNO, gp, 0, s, NULL, NULL, NULL, NULL);
 	g_free(s);
 
 	/* For compatibility with plugin API: the plugin expects GTK_RESPONSE_OK when user confirms new cert */
 	return rc == GTK_RESPONSE_YES ? GTK_RESPONSE_OK : rc;
-
 }
 
-gint remmina_protocol_widget_panel_changed_certificate(RemminaProtocolWidget *gp, const gchar* subject, const gchar* issuer, const gchar* new_fingerprint, const gchar* old_fingerprint)
+gint remmina_protocol_widget_panel_changed_certificate(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *new_fingerprint, const gchar *old_fingerprint)
 {
 	TRACE_CALL(__func__);
 	gchar *s;
@@ -1440,12 +1421,12 @@ gint remmina_protocol_widget_panel_changed_certificate(RemminaProtocolWidget *gp
 	// For markup see https://developer.gnome.org/pygtk/stable/pango-markup-language.html
 	s = g_strdup_printf(
 		"<big>%s</big>\n\n%s %s\n%s %s\n%s %s\n%s %s\n\n<big>%s</big>",
-		 _("The certificate changed! Details:"),
-		 _("Subject:"), subject,
-		 _("Issuer:"), issuer,
-		 _("Old Fingerprint:"), old_fingerprint,
-		 _("New Fingerprint:"), new_fingerprint,
-		 _("Accept Changed Certificate?"));
+		_("The certificate changed! Details:"),
+		_("Subject:"), subject,
+		_("Issuer:"), issuer,
+		_("Old Fingerprint:"), old_fingerprint,
+		_("New Fingerprint:"), new_fingerprint,
+		_("Accept Changed Certificate?"));
 	rc = remmina_protocol_widget_dialog(RPWDT_QUESTIONYESNO, gp, 0, s, NULL, NULL, NULL, NULL);
 	g_free(s);
 
@@ -1453,19 +1434,19 @@ gint remmina_protocol_widget_panel_changed_certificate(RemminaProtocolWidget *gp
 	return rc == GTK_RESPONSE_YES ? GTK_RESPONSE_OK : rc;
 }
 
-gchar* remmina_protocol_widget_get_username(RemminaProtocolWidget* gp)
+gchar *remmina_protocol_widget_get_username(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return g_strdup(gp->priv->username);
 }
 
-gchar* remmina_protocol_widget_get_password(RemminaProtocolWidget* gp)
+gchar *remmina_protocol_widget_get_password(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return g_strdup(gp->priv->password);
 }
 
-gchar* remmina_protocol_widget_get_domain(RemminaProtocolWidget* gp)
+gchar *remmina_protocol_widget_get_domain(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	return g_strdup(gp->priv->domain);
@@ -1477,54 +1458,54 @@ gboolean remmina_protocol_widget_get_savepassword(RemminaProtocolWidget *gp)
 	return gp->priv->save_password;
 }
 
-gchar* remmina_protocol_widget_get_cacert(RemminaProtocolWidget* gp)
+gchar *remmina_protocol_widget_get_cacert(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
-	gchar* s;
+	gchar *s;
 
 	s = gp->priv->cacert;
-	return (s && s[0] ? g_strdup(s) : NULL);
+	return s && s[0] ? g_strdup(s) : NULL;
 }
 
-gchar* remmina_protocol_widget_get_cacrl(RemminaProtocolWidget* gp)
+gchar *remmina_protocol_widget_get_cacrl(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
-	gchar* s;
+	gchar *s;
 
 	s = gp->priv->cacrl;
-	return (s && s[0] ? g_strdup(s) : NULL);
+	return s && s[0] ? g_strdup(s) : NULL;
 }
 
-gchar* remmina_protocol_widget_get_clientcert(RemminaProtocolWidget* gp)
+gchar *remmina_protocol_widget_get_clientcert(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
-	gchar* s;
+	gchar *s;
 
 	s = gp->priv->clientcert;
-	return (s && s[0] ? g_strdup(s) : NULL);
+	return s && s[0] ? g_strdup(s) : NULL;
 }
 
-gchar* remmina_protocol_widget_get_clientkey(RemminaProtocolWidget* gp)
+gchar *remmina_protocol_widget_get_clientkey(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
-	gchar* s;
+	gchar *s;
 
 	s = gp->priv->clientkey;
-	return (s && s[0] ? g_strdup(s) : NULL);
+	return s && s[0] ? g_strdup(s) : NULL;
 }
 
-void remmina_protocol_widget_save_cred(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_save_cred(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 
-	RemminaFile* remminafile = gp->priv->remmina_file;
-	gchar* s;
+	RemminaFile *remminafile = gp->priv->remmina_file;
+	gchar *s;
 	gboolean save = FALSE;
 
-	if ( !remmina_masterthread_exec_is_main_thread() ) {
+	if (!remmina_masterthread_exec_is_main_thread()) {
 		/* Allow the execution of this function from a non main thread */
 		RemminaMTExecData *d;
-		d = (RemminaMTExecData*)g_malloc( sizeof(RemminaMTExecData) );
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
 		d->func = FUNC_INIT_SAVE_CRED;
 		d->p.init_save_creds.gp = gp;
 		remmina_masterthread_exec_and_wait(d);
@@ -1562,22 +1543,21 @@ void remmina_protocol_widget_save_cred(RemminaProtocolWidget* gp)
 		remmina_file_set_string(remminafile, "password", gp->priv->password);
 		save = TRUE;
 	}
-	if (save) {
+	if (save)
 		remmina_file_save(remminafile);
-	}
 }
 
 
-void remmina_protocol_widget_panel_show_listen(RemminaProtocolWidget* gp, gint port)
+void remmina_protocol_widget_panel_show_listen(RemminaProtocolWidget *gp, gint port)
 {
 	TRACE_CALL(__func__);
 	RemminaMessagePanel *mp;
-	gchar* s;
+	gchar *s;
 
-	if ( !remmina_masterthread_exec_is_main_thread() ) {
+	if (!remmina_masterthread_exec_is_main_thread()) {
 		/* Allow the execution of this function from a non main thread */
 		RemminaMTExecData *d;
-		d = (RemminaMTExecData*)g_malloc( sizeof(RemminaMTExecData) );
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
 		d->func = FUNC_PROTOCOLWIDGET_PANELSHOWLISTEN;
 		d->p.protocolwidget_panelshowlisten.gp = gp;
 		d->p.protocolwidget_panelshowlisten.port = port;
@@ -1596,15 +1576,15 @@ void remmina_protocol_widget_panel_show_listen(RemminaProtocolWidget* gp, gint p
 	rco_show_message_panel(gp->cnnobj, mp);
 }
 
-void remmina_protocol_widget_panel_show_retry(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_panel_show_retry(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	RemminaMessagePanel *mp;
 
-	if ( !remmina_masterthread_exec_is_main_thread() ) {
+	if (!remmina_masterthread_exec_is_main_thread()) {
 		/* Allow the execution of this function from a non main thread */
 		RemminaMTExecData *d;
-		d = (RemminaMTExecData*)g_malloc( sizeof(RemminaMTExecData) );
+		d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
 		d->func = FUNC_PROTOCOLWIDGET_MPSHOWRETRY;
 		d->p.protocolwidget_mpshowretry.gp = gp;
 		remmina_masterthread_exec_and_wait(d);
@@ -1615,61 +1595,59 @@ void remmina_protocol_widget_panel_show_retry(RemminaProtocolWidget* gp)
 	mp = remmina_message_panel_new();
 	remmina_message_panel_setup_progress(mp, _("Authentication failed. Trying to reconnect…"), NULL, NULL);
 	rco_show_message_panel(gp->cnnobj, mp);
-
 }
 
-void remmina_protocol_widget_panel_show(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_panel_show(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	printf("REMMINA: error, function %s is not implemented. Is left here only for plugin API compatibility.\n", __func__);
 }
 
-void remmina_protocol_widget_panel_hide(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_panel_hide(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	printf("REMMINA: error, function %s is not implemented. Is left here only for plugin API compatibility.\n", __func__);
 }
 
-static void remmina_protocol_widget_chat_on_destroy(RemminaProtocolWidget* gp)
+static void remmina_protocol_widget_chat_on_destroy(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	gp->priv->chat_window = NULL;
 }
 
-void remmina_protocol_widget_chat_open(RemminaProtocolWidget* gp, const gchar *name,
-				       void (*on_send)(RemminaProtocolWidget* gp, const gchar *text), void (*on_destroy)(RemminaProtocolWidget* gp))
+void remmina_protocol_widget_chat_open(RemminaProtocolWidget *gp, const gchar *name,
+				       void (*on_send)(RemminaProtocolWidget *gp, const gchar *text), void (*on_destroy)(RemminaProtocolWidget *gp))
 {
 	TRACE_CALL(__func__);
 	if (gp->priv->chat_window) {
 		gtk_window_present(GTK_WINDOW(gp->priv->chat_window));
-	}else  {
+	} else {
 		gp->priv->chat_window = remmina_chat_window_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(gp))), name);
 		g_signal_connect_swapped(G_OBJECT(gp->priv->chat_window), "send", G_CALLBACK(on_send), gp);
 		g_signal_connect_swapped(G_OBJECT(gp->priv->chat_window), "destroy",
-			G_CALLBACK(remmina_protocol_widget_chat_on_destroy), gp);
+					 G_CALLBACK(remmina_protocol_widget_chat_on_destroy), gp);
 		g_signal_connect_swapped(G_OBJECT(gp->priv->chat_window), "destroy", G_CALLBACK(on_destroy), gp);
 		gtk_widget_show(gp->priv->chat_window);
 	}
 }
 
-void remmina_protocol_widget_chat_close(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_chat_close(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
-	if (gp->priv->chat_window) {
+	if (gp->priv->chat_window)
 		gtk_widget_destroy(gp->priv->chat_window);
-	}
 }
 
-void remmina_protocol_widget_chat_receive(RemminaProtocolWidget* gp, const gchar* text)
+void remmina_protocol_widget_chat_receive(RemminaProtocolWidget *gp, const gchar *text)
 {
 	TRACE_CALL(__func__);
 	/* This function can be called from a non main thread */
 
 	if (gp->priv->chat_window) {
-		if ( !remmina_masterthread_exec_is_main_thread() ) {
+		if (!remmina_masterthread_exec_is_main_thread()) {
 			/* Allow the execution of this function from a non main thread */
 			RemminaMTExecData *d;
-			d = (RemminaMTExecData*)g_malloc( sizeof(RemminaMTExecData) );
+			d = (RemminaMTExecData *)g_malloc(sizeof(RemminaMTExecData));
 			d->func = FUNC_CHAT_RECEIVE;
 			d->p.chat_receive.gp = gp;
 			d->p.chat_receive.text = text;
@@ -1682,7 +1660,7 @@ void remmina_protocol_widget_chat_receive(RemminaProtocolWidget* gp, const gchar
 	}
 }
 
-void remmina_protocol_widget_setup(RemminaProtocolWidget *gp, RemminaFile* remminafile, RemminaConnectionObject* cnnobj)
+void remmina_protocol_widget_setup(RemminaProtocolWidget *gp, RemminaFile *remminafile, RemminaConnectionObject *cnnobj)
 {
 	RemminaProtocolPlugin *plugin;
 
@@ -1690,12 +1668,12 @@ void remmina_protocol_widget_setup(RemminaProtocolWidget *gp, RemminaFile* remmi
 	gp->cnnobj = cnnobj;
 
 	/* Locate the protocol plugin */
-	plugin = (RemminaProtocolPlugin*)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL,
-		remmina_file_get_string(remminafile, "protocol"));
+	plugin = (RemminaProtocolPlugin *)remmina_plugin_manager_get_plugin(REMMINA_PLUGIN_TYPE_PROTOCOL,
+									    remmina_file_get_string(remminafile, "protocol"));
 
 	if (!plugin || !plugin->init || !plugin->open_connection) {
 		remmina_protocol_widget_set_error(gp, _("Protocol plugin %s is not installed."),
-			remmina_file_get_string(remminafile, "protocol"));
+						  remmina_file_get_string(remminafile, "protocol"));
 		gp->priv->plugin = NULL;
 		return;
 	}
@@ -1703,10 +1681,9 @@ void remmina_protocol_widget_setup(RemminaProtocolWidget *gp, RemminaFile* remmi
 
 	gp->priv->scalemode = remmina_file_get_int(gp->priv->remmina_file, "scale", FALSE);
 	gp->priv->scaler_expand = remmina_file_get_int(gp->priv->remmina_file, "scaler_expand", FALSE);
-
 }
 
-GtkWidget* remmina_protocol_widget_new(void)
+GtkWidget *remmina_protocol_widget_new(void)
 {
 	return GTK_WIDGET(g_object_new(REMMINA_TYPE_PROTOCOL_WIDGET, NULL));
 }
@@ -1754,7 +1731,7 @@ void remmina_protocol_widget_send_keys_signals(GtkWidget *widget, const guint *k
 	}
 }
 
-void remmina_protocol_widget_update_remote_resolution(RemminaProtocolWidget* gp)
+void remmina_protocol_widget_update_remote_resolution(RemminaProtocolWidget *gp)
 {
 	TRACE_CALL(__func__);
 	GdkRectangle rect;
@@ -1798,7 +1775,6 @@ void remmina_protocol_widget_update_remote_resolution(RemminaProtocolWidget* gp)
 			w = rect.width;
 		if (h > rect.height)
 			h = rect.height;
-
 	} else if (res_mode == RES_USE_CLIENT) {
 		w = rect.width;
 		h = rect.height;
diff --git a/src/remmina_protocol_widget.h b/src/remmina_protocol_widget.h
index 2108464f6..778b9398a 100644
--- a/src/remmina_protocol_widget.h
+++ b/src/remmina_protocol_widget.h
@@ -55,43 +55,43 @@ G_BEGIN_DECLS
 typedef struct _RemminaProtocolWidgetPriv RemminaProtocolWidgetPriv;
 
 struct _RemminaProtocolWidget {
-	GtkEventBox event_box;
-	RemminaConnectionObject *cnnobj;
-	RemminaProtocolWidgetPriv *priv;
+	GtkEventBox			event_box;
+	RemminaConnectionObject *	cnnobj;
+	RemminaProtocolWidgetPriv *	priv;
 };
 
 struct _RemminaProtocolWidgetClass {
-	GtkEventBoxClass parent_class;
+	GtkEventBoxClass	parent_class;
 
-	void (*connect)(RemminaProtocolWidget *gp);
-	void (*disconnect)(RemminaProtocolWidget *gp);
-	void (*desktop_resize)(RemminaProtocolWidget *gp);
-	void (*update_align)(RemminaProtocolWidget *gp);
-	void (*unlock_dynres)(RemminaProtocolWidget *gp);
+	void			(*connect)(RemminaProtocolWidget *gp);
+	void			(*disconnect)(RemminaProtocolWidget *gp);
+	void			(*desktop_resize)(RemminaProtocolWidget *gp);
+	void			(*update_align)(RemminaProtocolWidget *gp);
+	void			(*unlock_dynres)(RemminaProtocolWidget *gp);
 };
 
 GType remmina_protocol_widget_get_type(void)
 G_GNUC_CONST;
 
-GtkWidget* remmina_protocol_widget_new(void);
-void remmina_protocol_widget_setup(RemminaProtocolWidget *gp, RemminaFile* remminafile, RemminaConnectionObject* cnnobj);
+GtkWidget *remmina_protocol_widget_new(void);
+void remmina_protocol_widget_setup(RemminaProtocolWidget *gp, RemminaFile *remminafile, RemminaConnectionObject *cnnobj);
 
 gint remmina_protocol_widget_get_width(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_set_width(RemminaProtocolWidget *gp, gint width);
 gint remmina_protocol_widget_get_height(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_set_height(RemminaProtocolWidget *gp, gint height);
-gint remmina_protocol_widget_get_profile_remote_width(RemminaProtocolWidget* gp);
-gint remmina_protocol_widget_get_profile_remote_height(RemminaProtocolWidget* gp);
+gint remmina_protocol_widget_get_profile_remote_width(RemminaProtocolWidget *gp);
+gint remmina_protocol_widget_get_profile_remote_height(RemminaProtocolWidget *gp);
 
 RemminaScaleMode remmina_protocol_widget_get_current_scale_mode(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_set_current_scale_mode(RemminaProtocolWidget *gp, RemminaScaleMode scalemode);
 gboolean remmina_protocol_widget_get_expand(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_set_expand(RemminaProtocolWidget *gp, gboolean expand);
 gboolean remmina_protocol_widget_has_error(RemminaProtocolWidget *gp);
-const gchar* remmina_protocol_widget_get_error_message(RemminaProtocolWidget *gp);
+const gchar *remmina_protocol_widget_get_error_message(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_set_error(RemminaProtocolWidget *gp, const gchar *fmt, ...);
 gboolean remmina_protocol_widget_is_closed(RemminaProtocolWidget *gp);
-RemminaFile* remmina_protocol_widget_get_file(RemminaProtocolWidget *gp);
+RemminaFile *remmina_protocol_widget_get_file(RemminaProtocolWidget *gp);
 
 void remmina_protocol_widget_open_connection(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_close_connection(RemminaProtocolWidget *gp);
@@ -101,7 +101,7 @@ void remmina_protocol_widget_update_align(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_unlock_dynres(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_desktop_resize(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_grab_focus(RemminaProtocolWidget *gp);
-const RemminaProtocolFeature* remmina_protocol_widget_get_features(RemminaProtocolWidget *gp);
+const RemminaProtocolFeature *remmina_protocol_widget_get_features(RemminaProtocolWidget *gp);
 gboolean remmina_protocol_widget_query_feature_by_type(RemminaProtocolWidget *gp, RemminaProtocolFeatureType type);
 gboolean remmina_protocol_widget_query_feature_by_ref(RemminaProtocolWidget *gp, const RemminaProtocolFeature *feature);
 void remmina_protocol_widget_call_feature_by_type(RemminaProtocolWidget *gp, RemminaProtocolFeatureType type, gint id);
@@ -119,21 +119,21 @@ gboolean remmina_protocol_widget_ssh_exec(RemminaProtocolWidget *gp, gboolean wa
  * 1. The actual destination (host:port) if SSH tunnel is disable
  * 2. The tunnel local destination (127.0.0.1:port) if SSH tunnel is enabled
  */
-gchar* remmina_protocol_widget_start_direct_tunnel(RemminaProtocolWidget *gp, gint default_port, gboolean port_plus);
+gchar *remmina_protocol_widget_start_direct_tunnel(RemminaProtocolWidget *gp, gint default_port, gboolean port_plus);
 
 gboolean remmina_protocol_widget_start_reverse_tunnel(RemminaProtocolWidget *gp, gint local_port);
 gboolean remmina_protocol_widget_start_xport_tunnel(RemminaProtocolWidget *gp, RemminaXPortTunnelInitFunc init_func);
 void remmina_protocol_widget_set_display(RemminaProtocolWidget *gp, gint display);
 
 /* Extension for remmina_protocol_widget_panel_authuserpwd() not currently exported to plugins */
-gint remmina_protocol_widget_panel_authuserpwd_ssh_tunnel(RemminaProtocolWidget* gp, gboolean want_domain, gboolean allow_password_saving);
+gint remmina_protocol_widget_panel_authuserpwd_ssh_tunnel(RemminaProtocolWidget *gp, gboolean want_domain, gboolean allow_password_saving);
 
 /* Dialog panel API used by the plugins */
 
-gint remmina_protocol_widget_panel_auth(RemminaProtocolWidget* gp, RemminaMessagePanelFlags pflags, const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain, const gchar *password_prompt);
-gint remmina_protocol_widget_panel_new_certificate(RemminaProtocolWidget* gp, const gchar* subject, const gchar* issuer, const gchar* fingerprint);
-gint remmina_protocol_widget_panel_changed_certificate(RemminaProtocolWidget *gp, const gchar* subject, const gchar* issuer, const gchar* new_fingerprint, const gchar* old_fingerprint);
-gint remmina_protocol_widget_panel_question_yesno(RemminaProtocolWidget* gp, const char *msg);
+gint remmina_protocol_widget_panel_auth(RemminaProtocolWidget *gp, RemminaMessagePanelFlags pflags, const gchar *title, const gchar *default_username, const gchar *default_password, const gchar *default_domain, const gchar *password_prompt);
+gint remmina_protocol_widget_panel_new_certificate(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *fingerprint);
+gint remmina_protocol_widget_panel_changed_certificate(RemminaProtocolWidget *gp, const gchar *subject, const gchar *issuer, const gchar *new_fingerprint, const gchar *old_fingerprint);
+gint remmina_protocol_widget_panel_question_yesno(RemminaProtocolWidget *gp, const char *msg);
 
 void remmina_protocol_widget_panel_show(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_panel_hide(RemminaProtocolWidget *gp);
@@ -144,31 +144,30 @@ void remmina_protocol_widget_panel_show_retry(RemminaProtocolWidget *gp);
 
 void remmina_protocol_widget_save_cred(RemminaProtocolWidget *gp);
 
-gchar* remmina_protocol_widget_get_username(RemminaProtocolWidget *gp);
-gchar* remmina_protocol_widget_get_password(RemminaProtocolWidget *gp);
-gchar* remmina_protocol_widget_get_domain(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_username(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_password(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_domain(RemminaProtocolWidget *gp);
 gboolean remmina_protocol_widget_get_savepassword(RemminaProtocolWidget *gp);
-gchar* remmina_protocol_widget_get_cacert(RemminaProtocolWidget *gp);
-gchar* remmina_protocol_widget_get_cacrl(RemminaProtocolWidget *gp);
-gchar* remmina_protocol_widget_get_clientcert(RemminaProtocolWidget *gp);
-gchar* remmina_protocol_widget_get_clientkey(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_cacert(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_cacrl(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_clientcert(RemminaProtocolWidget *gp);
+gchar *remmina_protocol_widget_get_clientkey(RemminaProtocolWidget *gp);
 
-void remmina_protocol_widget_chat_open(RemminaProtocolWidget *gp, const gchar *name,
-				       void (*on_send)(RemminaProtocolWidget *gp, const gchar *text), void (*on_destroy)(RemminaProtocolWidget *gp));
+void remmina_protocol_widget_chat_open(RemminaProtocolWidget *gp, const gchar *name, void (*on_send)(RemminaProtocolWidget *gp, const gchar *text), void (*on_destroy)(RemminaProtocolWidget *gp));
 void remmina_protocol_widget_chat_close(RemminaProtocolWidget *gp);
 void remmina_protocol_widget_chat_receive(RemminaProtocolWidget *gp, const gchar *text);
 void remmina_protocol_widget_send_keys_signals(GtkWidget *widget, const guint *keyvals, int length, GdkEventType action);
 /* Check if the plugin accepts keystrokes */
-gboolean remmina_protocol_widget_plugin_receives_keystrokes(RemminaProtocolWidget* gp);
+gboolean remmina_protocol_widget_plugin_receives_keystrokes(RemminaProtocolWidget *gp);
 /* Send to the plugin some keystrokes */
-void remmina_protocol_widget_send_keystrokes(RemminaProtocolWidget* gp, GtkMenuItem *widget);
+void remmina_protocol_widget_send_keystrokes(RemminaProtocolWidget *gp, GtkMenuItem *widget);
 /* Take screenshot of plugin */
-gboolean remmina_protocol_widget_plugin_screenshot(RemminaProtocolWidget* gp, RemminaPluginScreenshotData *rpsd);
+gboolean remmina_protocol_widget_plugin_screenshot(RemminaProtocolWidget *gp, RemminaPluginScreenshotData *rpsd);
 
-void remmina_protocol_widget_update_remote_resolution(RemminaProtocolWidget* gp);
+void remmina_protocol_widget_update_remote_resolution(RemminaProtocolWidget *gp);
 
 /* Functions to support execution of GTK code on master thread */
-RemminaMessagePanel* remmina_protocol_widget_mpprogress(RemminaConnectionObject* cnnobj, const gchar *msg, RemminaMessagePanelCallback response_callback, gpointer response_callback_data);
+RemminaMessagePanel *remmina_protocol_widget_mpprogress(RemminaConnectionObject *cnnobj, const gchar *msg, RemminaMessagePanelCallback response_callback, gpointer response_callback_data);
 void remmina_protocol_widget_mpdestroy(RemminaConnectionObject *cnnobj, RemminaMessagePanel *mp);
 
 
diff --git a/src/remmina_public.h b/src/remmina_public.h
index 4bec97672..73f369d24 100644
--- a/src/remmina_public.h
+++ b/src/remmina_public.h
@@ -68,17 +68,16 @@
 G_BEGIN_DECLS
 
 /* items is separated by STRING_DELIMTOR */
-GtkWidget* remmina_public_create_combo_entry(const gchar *text, const gchar *def, gboolean descending);
-GtkWidget* remmina_public_create_combo_text_d(const gchar *text, const gchar *def, const gchar *empty_choice);
+GtkWidget *remmina_public_create_combo_entry(const gchar *text, const gchar *def, gboolean descending);
+GtkWidget *remmina_public_create_combo_text_d(const gchar *text, const gchar *def, const gchar *empty_choice);
 void remmina_public_load_combo_text_d(GtkWidget *combo, const gchar *text, const gchar *def, const gchar *empty_choice);
-GtkWidget* remmina_public_create_combo(gboolean use_icon);
-GtkWidget* remmina_public_create_combo_map(const gpointer *key_value_list, const gchar *def, gboolean use_icon,
-					   const gchar *domain);
-GtkWidget* remmina_public_create_combo_mapint(const gpointer *key_value_list, gint def, gboolean use_icon, const gchar *domain);
+GtkWidget *remmina_public_create_combo(gboolean use_icon);
+GtkWidget *remmina_public_create_combo_map(const gpointer *key_value_list, const gchar *def, gboolean use_icon, const gchar *domain);
+GtkWidget *remmina_public_create_combo_mapint(const gpointer *key_value_list, gint def, gboolean use_icon, const gchar *domain);
 
 void remmina_public_create_group(GtkGrid *table, const gchar *group, gint row, gint rows, gint cols);
 
-gchar* remmina_public_combo_get_active_text(GtkComboBox *combo);
+gchar *remmina_public_combo_get_active_text(GtkComboBox *combo);
 
 #if !GTK_CHECK_VERSION(3, 22, 0)
 /* A function for gtk_menu_popup to get the position right below the widget specified by user_data */
@@ -86,7 +85,7 @@ void remmina_public_popup_position(GtkMenu *menu, gint *x, gint *y, gboolean *pu
 #endif
 
 /* Combine two paths into one by correctly handling trailing slash. Return newly allocated string */
-gchar* remmina_public_combine_path(const gchar *path1, const gchar *path2);
+gchar *remmina_public_combine_path(const gchar *path1, const gchar *path2);
 
 /* Parse a server entry with server name and port */
 void remmina_public_get_server_port(const gchar *server, gint defaultport, gchar **host, gint *port);
@@ -102,18 +101,17 @@ guint16 remmina_public_get_keycode_for_keyval(GdkKeymap *keymap, guint keyval);
 /* Check if the requested keycode is a key modifier */
 gboolean remmina_public_get_modifier_for_keycode(GdkKeymap *keymap, guint16 keycode);
 /* Load a GtkBuilder object from a filename */
-GtkBuilder* remmina_public_gtk_builder_new_from_file(gchar *filename);
+GtkBuilder *remmina_public_gtk_builder_new_from_file(gchar *filename);
 /* Change parent container for a widget */
 void remmina_public_gtk_widget_reparent(GtkWidget *widget, GtkContainer *container);
 /* Used to send desktop notifications */
-void remmina_public_send_notification(const gchar *notification_id,
-				      const gchar *notification_title, const gchar *notification_message);
+void remmina_public_send_notification(const gchar *notification_id, const gchar *notification_title, const gchar *notification_message);
 /* Validate the inserted value for a new resolution */
 gboolean remmina_public_resolution_validation_func(const gchar *new_str, gchar **error);
 /* Replaces all occurences of search in a new copy of string by replacement. */
-gchar* remmina_public_str_replace(const gchar *string, const gchar *search, const gchar *replacement);
+gchar *remmina_public_str_replace(const gchar *string, const gchar *search, const gchar *replacement);
 /* Replaces all occurences of search in a new copy of string by replacement
  * and overwrites the original string */
-gchar* remmina_public_str_replace_in_place(gchar *string, const gchar *search, const gchar *replacement);
+gchar *remmina_public_str_replace_in_place(gchar *string, const gchar *search, const gchar *replacement);
 int remmina_public_split_resolution_string(const char *resolution_string, int *w, int *h);
 gboolean remmina_gtk_check_version(guint major, guint minor, guint micro);
diff --git a/src/remmina_scrolled_viewport.h b/src/remmina_scrolled_viewport.h
index fd84cd404..29d8f5724 100644
--- a/src/remmina_scrolled_viewport.h
+++ b/src/remmina_scrolled_viewport.h
@@ -51,12 +51,11 @@ G_BEGIN_DECLS
 	(G_TYPE_INSTANCE_GET_CLASS((obj), REMMINA_TYPE_SCROLLED_VIEWPORT, RemminaScrolledViewportClass))
 
 typedef struct _RemminaScrolledViewport {
-	GtkEventBox event_box;
+	GtkEventBox	event_box;
 
 	/* Motion activates in Viewport Fullscreen mode */
-	gboolean viewport_motion;
-	guint viewport_motion_handler;
-
+	gboolean	viewport_motion;
+	guint		viewport_motion_handler;
 } RemminaScrolledViewport;
 
 typedef struct _RemminaScrolledViewportClass {
@@ -66,11 +65,9 @@ typedef struct _RemminaScrolledViewportClass {
 GType remmina_scrolled_viewport_get_type(void)
 G_GNUC_CONST;
 
-GtkWidget* remmina_scrolled_viewport_new(void);
+GtkWidget *remmina_scrolled_viewport_new(void);
 void remmina_scrolled_viewport_remove_motion(RemminaScrolledViewport *gsv);
 
 #define SCROLL_BORDER_SIZE 1
 
 G_END_DECLS
-
-
diff --git a/src/remmina_ssh.c b/src/remmina_ssh.c
index 74d83f1ca..229fd6031 100644
--- a/src/remmina_ssh.c
+++ b/src/remmina_ssh.c
@@ -271,10 +271,10 @@ remmina_ssh_auth_auto_pubkey(RemminaSSH *ssh, RemminaProtocolWidget *gp, Remmina
 		disablepasswordstoring = remmina_file_get_int(remminafile, "disablepasswordstoring", FALSE);
 
 		ret = remmina_protocol_widget_panel_auth(gp, (disablepasswordstoring ? 0 : REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD),
-			_("SSH credentials"), NULL,
-			remmina_file_get_string(remminafile, "ssh_passphrase"),
-			NULL,
-			_("SSH private key passphrase"));
+							 _("SSH credentials"), NULL,
+							 remmina_file_get_string(remminafile, "ssh_passphrase"),
+							 NULL,
+							 _("SSH private key passphrase"));
 		if (ret == GTK_RESPONSE_OK) {
 			pwd = remmina_protocol_widget_get_password(gp);
 			save_password = remmina_protocol_widget_get_savepassword(gp);
@@ -282,8 +282,9 @@ remmina_ssh_auth_auto_pubkey(RemminaSSH *ssh, RemminaProtocolWidget *gp, Remmina
 				remmina_file_set_string(remminafile, "ssh_passphrase", pwd);
 			else
 				remmina_file_set_string(remminafile, "ssh_passphrase", NULL);
-		} else
+		} else {
 			return -1;
+		}
 		ssh->passphrase = pwd;
 	}
 	ret = ssh_userauth_publickey_auto(ssh->session, NULL, ssh->passphrase);
@@ -502,10 +503,10 @@ remmina_ssh_auth_gui(RemminaSSH *ssh, RemminaProtocolWidget *gp, RemminaFile *re
 
 		if (g_strcmp0(pwdtype, "ssh_passphrase") == 0) {
 			ret = remmina_protocol_widget_panel_auth(gp, (disablepasswordstoring ? 0 : REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD),
-				_("SSH credentials"), NULL,
-				remmina_file_get_string(remminafile, "ssh_passphrase"),
-				NULL,
-				_("SSH private key passphrase"));
+								 _("SSH credentials"), NULL,
+								 remmina_file_get_string(remminafile, "ssh_passphrase"),
+								 NULL,
+								 _("SSH private key passphrase"));
 			if (ret == GTK_RESPONSE_OK) {
 				pwd = remmina_protocol_widget_get_password(gp);
 				save_password = remmina_protocol_widget_get_savepassword(gp);
@@ -514,14 +515,16 @@ remmina_ssh_auth_gui(RemminaSSH *ssh, RemminaProtocolWidget *gp, RemminaFile *re
 				else
 					remmina_file_set_string(remminafile, "ssh_passphrase", NULL);
 				g_free(pwd);
-			} else return -1;
+			} else {
+				return -1;
+			}
 		} else if (g_strcmp0(pwdtype, "ssh_password") == 0) {
-		   ret = remmina_protocol_widget_panel_auth(gp, (disablepasswordstoring ? 0 : REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD) | REMMINA_MESSAGE_PANEL_FLAG_USERNAME,
-				_("SSH credentials"),
-				remmina_file_get_string(remminafile, "ssh_username"),
-				remmina_file_get_string(remminafile, "ssh_password"),
-				NULL,
-				NULL);
+			ret = remmina_protocol_widget_panel_auth(gp, (disablepasswordstoring ? 0 : REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD) | REMMINA_MESSAGE_PANEL_FLAG_USERNAME,
+								 _("SSH credentials"),
+								 remmina_file_get_string(remminafile, "ssh_username"),
+								 remmina_file_get_string(remminafile, "ssh_password"),
+								 NULL,
+								 NULL);
 			if (ret == GTK_RESPONSE_OK) {
 				pwd = remmina_protocol_widget_get_username(gp);
 				remmina_file_set_string(remminafile, "ssh_username", pwd);
@@ -533,16 +536,17 @@ remmina_ssh_auth_gui(RemminaSSH *ssh, RemminaProtocolWidget *gp, RemminaFile *re
 				else
 					remmina_file_set_string(remminafile, "ssh_password", NULL);
 				g_free(pwd);
-			} else
+			} else {
 				return -1;
+			}
 		} else {
 			/* ??? */
 			ret = remmina_protocol_widget_panel_auth(gp, (disablepasswordstoring ? 0 : REMMINA_MESSAGE_PANEL_FLAG_SAVEPASSWORD) | REMMINA_MESSAGE_PANEL_FLAG_USERNAME,
-				_("SSH authentication"),
-				remmina_file_get_string(remminafile, "Username"),
-				remmina_file_get_string(remminafile, "Password"),
-				NULL,
-				NULL);
+								 _("SSH authentication"),
+								 remmina_file_get_string(remminafile, "Username"),
+								 remmina_file_get_string(remminafile, "Password"),
+								 NULL,
+								 NULL);
 			if (ret == GTK_RESPONSE_OK) {
 				pwd = remmina_protocol_widget_get_username(gp);
 				remmina_file_set_string(remminafile, "Username", pwd);
@@ -554,8 +558,9 @@ remmina_ssh_auth_gui(RemminaSSH *ssh, RemminaProtocolWidget *gp, RemminaFile *re
 				else
 					remmina_file_set_string(remminafile, "Password", NULL);
 				g_free(pwd);
-			} else
+			} else {
 				return -1;
+			}
 		}
 
 		pwd = remmina_protocol_widget_get_password(gp);
diff --git a/src/remmina_stats.h b/src/remmina_stats.h
index f7a87e9fb..04ccf079f 100644
--- a/src/remmina_stats.h
+++ b/src/remmina_stats.h
@@ -41,5 +41,3 @@ G_BEGIN_DECLS
 JsonNode *remmina_stats_get_all(void);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_stats_sender.h b/src/remmina_stats_sender.h
index 2a62ae8f4..6a4f6d72a 100644
--- a/src/remmina_stats_sender.h
+++ b/src/remmina_stats_sender.h
@@ -43,5 +43,3 @@ gboolean remmina_stat_sender_can_send(void);
 void remmina_stats_sender_send(gboolean show_only);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_string_array.h b/src/remmina_string_array.h
index d2efeee76..4441efa08 100644
--- a/src/remmina_string_array.h
+++ b/src/remmina_string_array.h
@@ -39,19 +39,17 @@ G_BEGIN_DECLS
 
 typedef GPtrArray RemminaStringArray;
 
-RemminaStringArray* remmina_string_array_new(void);
-#define remmina_string_array_index(array, i) (gchar*)g_ptr_array_index(array, i)
-RemminaStringArray* remmina_string_array_new_from_string(const gchar *strs);
-RemminaStringArray* remmina_string_array_new_from_allocated_string(gchar *strs);
+RemminaStringArray *remmina_string_array_new(void);
+#define remmina_string_array_index(array, i) (gchar *)g_ptr_array_index(array, i)
+RemminaStringArray *remmina_string_array_new_from_string(const gchar *strs);
+RemminaStringArray *remmina_string_array_new_from_allocated_string(gchar *strs);
 void remmina_string_array_add(RemminaStringArray *array, const gchar *str);
 gint remmina_string_array_find(RemminaStringArray *array, const gchar *str);
 void remmina_string_array_remove_index(RemminaStringArray *array, gint i);
 void remmina_string_array_remove(RemminaStringArray *array, const gchar *str);
 void remmina_string_array_intersect(RemminaStringArray *array, const gchar *dest_strs);
 void remmina_string_array_sort(RemminaStringArray *array);
-gchar* remmina_string_array_to_string(RemminaStringArray *array);
+gchar *remmina_string_array_to_string(RemminaStringArray *array);
 void remmina_string_array_free(RemminaStringArray *array);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_string_list.h b/src/remmina_string_list.h
index 026dbcec3..6205e79f1 100644
--- a/src/remmina_string_list.h
+++ b/src/remmina_string_list.h
@@ -40,44 +40,43 @@ typedef gboolean (*RemminaStringListValidationFunc)(const gchar *new_str, gchar
 
 typedef struct _RemminaStringListPriv {
 	RemminaStringListValidationFunc validation_func;
-	const gchar *fields_separator;
-	gboolean two_columns;
+	const gchar *			fields_separator;
+	gboolean			two_columns;
 } RemminaStringListPriv;
 
 typedef struct _RemminaStringList {
-	GtkBuilder *builder;
-	GtkDialog *dialog;
+	GtkBuilder *		builder;
+	GtkDialog *		dialog;
 
-	GtkListStore *liststore_items;
-	GtkTreeView *treeview_items;
-	GtkTreeViewColumn *treeviewcolumn_item;
-	GtkTreeSelection *treeview_selection;
-	GtkCellRendererText *cellrenderertext_item1;
-	GtkCellRendererText *cellrenderertext_item2;
+	GtkListStore *		liststore_items;
+	GtkTreeView *		treeview_items;
+	GtkTreeViewColumn *	treeviewcolumn_item;
+	GtkTreeSelection *	treeview_selection;
+	GtkCellRendererText *	cellrenderertext_item1;
+	GtkCellRendererText *	cellrenderertext_item2;
 
-	GtkButton *button_add;
-	GtkButton *button_remove;
-	GtkButton *button_up;
-	GtkButton *button_down;
+	GtkButton *		button_add;
+	GtkButton *		button_remove;
+	GtkButton *		button_up;
+	GtkButton *		button_down;
 
-	GtkLabel *label_title;
-	GtkLabel *label_status;
+	GtkLabel *		label_title;
+	GtkLabel *		label_status;
 
-	RemminaStringListPriv *priv;
+	RemminaStringListPriv * priv;
 } RemminaStringList;
 
 G_BEGIN_DECLS
 
 /* RemminaStringList instance */
-GtkDialog* remmina_string_list_new(gboolean two_columns, const gchar *fields_separator);
+GtkDialog *remmina_string_list_new(gboolean two_columns, const gchar *fields_separator);
 /* Load a string list by splitting a string value */
 void remmina_string_list_set_text(const gchar *text, const gboolean clear_data);
 /* Get a string value representing the string list */
-gchar* remmina_string_list_get_text(void);
+gchar *remmina_string_list_get_text(void);
 /* Set the dialog titles */
 void remmina_string_list_set_titles(gchar *title1, gchar *title2);
 /* Set a function that will be used to validate the new rows */
 void remmina_string_list_set_validation_func(RemminaStringListValidationFunc func);
 
 G_END_DECLS
-
diff --git a/src/remmina_sysinfo.h b/src/remmina_sysinfo.h
index d0349f1d1..e687f0e69 100644
--- a/src/remmina_sysinfo.h
+++ b/src/remmina_sysinfo.h
@@ -43,5 +43,3 @@ gchar *remmina_sysinfo_get_gnome_shell_version(void);
 gchar *remmina_sysinfo_get_wm_name(void);
 
 G_END_DECLS
-
-
diff --git a/src/remmina_unlock.h b/src/remmina_unlock.h
index 0641caad3..a2834d8df 100644
--- a/src/remmina_unlock.h
+++ b/src/remmina_unlock.h
@@ -38,16 +38,16 @@
 
 #if SODIUM_VERSION_INT >= 90200
 typedef struct _RemminaUnlockDialog {
-	GtkBuilder *builder;
-	GtkDialog *dialog;
+	GtkBuilder *	builder;
+	GtkDialog *	dialog;
 
-	GtkEntry *entry_unlock;
-	GtkButton *button_unlock;
-	GtkButton *button_unlock_cancel;
+	GtkEntry *	entry_unlock;
+	GtkButton *	button_unlock;
+	GtkButton *	button_unlock_cancel;
 
-	gboolean unlock_init;
+	gboolean	unlock_init;
 
-	gint retval;
+	gint		retval;
 } RemminaUnlockDialog;
 
 extern GTimer *timer;
diff --git a/src/remmina_utils.h b/src/remmina_utils.h
index e4e581070..b7e58c8d3 100644
--- a/src/remmina_utils.h
+++ b/src/remmina_utils.h
@@ -45,7 +45,7 @@ gint remmina_utils_string_replace(GString *str, gint pos, gint len, const gchar
 guint remmina_utils_string_replace_all(GString *haystack, const gchar *needle, const gchar *replace);
 gchar *remmina_utils_string_strip(const gchar *s);
 
-gchar* remmina_utils_get_lang();
+gchar *remmina_utils_get_lang();
 const gchar *remmina_utils_get_kernel_name();
 const gchar *remmina_utils_get_kernel_release();
 const gchar *remmina_utils_get_kernel_arch();
@@ -56,5 +56,5 @@ gchar *remmina_utils_get_lsb_codename();
 GHashTable *remmina_utils_get_etc_release();
 const gchar *remmina_utils_get_os_info();
 gchar *remmina_sha1_file(const gchar *filename);
-gchar* remmina_gen_random_uuid();
+gchar *remmina_gen_random_uuid();
 G_END_DECLS
diff --git a/src/remmina_widget_pool.h b/src/remmina_widget_pool.h
index 342b270ca..558ff79fc 100644
--- a/src/remmina_widget_pool.h
+++ b/src/remmina_widget_pool.h
@@ -41,11 +41,9 @@ typedef gboolean (*RemminaWidgetPoolForEachFunc)(GtkWidget *widget, gpointer dat
 
 void remmina_widget_pool_init(void);
 void remmina_widget_pool_register(GtkWidget *widget);
-GtkWidget* remmina_widget_pool_find(GType type, const gchar *tag);
-GtkWidget* remmina_widget_pool_find_by_window(GType type, GdkWindow *window);
+GtkWidget *remmina_widget_pool_find(GType type, const gchar *tag);
+GtkWidget *remmina_widget_pool_find_by_window(GType type, GdkWindow *window);
 gint remmina_widget_pool_foreach(RemminaWidgetPoolForEachFunc callback, gpointer data);
 gint remmina_widget_pool_count(void);
 
 G_END_DECLS
-
-