2
* Remmina - The GTK+ Remote Desktop Client
3
* Copyright (C) 2009-2010 Vic Lee
5
* This program is free software; you can redistribute it and/or modify
6
* it under the terms of the GNU General Public License as published by
7
* the Free Software Foundation; either version 2 of the License, or
8
* (at your option) any later version.
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
* GNU General Public License for more details.
15
* You should have received a copy of the GNU General Public License
16
* along with this program; if not, write to the Free Software
17
* Foundation, Inc., 59 Temple Place, Suite 330,
18
* Boston, MA 02111-1307, USA.
22
#include <gdk/gdkkeysyms.h>
23
#include <glib/gi18n.h>
26
#include "remminapublic.h"
27
#include "remminafile.h"
28
#include "remminafilemanager.h"
29
#include "remminainitdialog.h"
30
#include "remminaprotocolwidget.h"
31
#include "remminapref.h"
32
#include "remminascrolledviewport.h"
33
#include "remminascaler.h"
34
#include "remminawidgetpool.h"
35
#include "remminaconnectionwindow.h"
37
G_DEFINE_TYPE (RemminaConnectionWindow, remmina_connection_window, GTK_TYPE_WINDOW)
39
#define MOTION_TIME 100
41
/* One process can only have one option popup at a time */
42
static GtkWidget *scale_option_window = NULL;
44
typedef struct _RemminaConnectionHolder RemminaConnectionHolder;
46
struct _RemminaConnectionWindowPriv
48
RemminaConnectionHolder *cnnhld;
52
guint switch_page_handler;
54
GtkWidget *floating_toolbar;
55
GtkWidget *floating_toolbar_label;
56
gdouble floating_toolbar_opacity;
57
/* To avoid strange event-loop */
58
guint floating_toolbar_motion_handler;
60
gboolean floating_toolbar_motion_show;
61
gboolean floating_toolbar_motion_visible;
65
/* Toolitems that need to be handled */
66
GtkToolItem *toolitem_autofit;
67
GtkToolItem *toolitem_fullscreen;
68
GtkToolItem *toolitem_switch_page;
69
GtkToolItem *toolitem_scale;
70
GtkToolItem *toolitem_grab;
71
GtkToolItem *toolitem_preferences;
72
GtkToolItem *toolitem_tools;
73
GtkWidget *scale_option_button;
74
GtkWidget *fullscreen_option_button;
76
GtkWidget *pin_button;
84
typedef struct _RemminaConnectionObject
86
RemminaConnectionHolder *cnnhld;
88
RemminaFile *remmina_file;
90
/* A dummy window which will be realized as a container during initialize, before reparent to the real window */
93
/* Containers for RemminaProtocolWidget: RemminaProtocolWidget->alignment->viewport...->window */
98
/* Scrolled containers */
99
GtkWidget *scrolled_container;
102
} RemminaConnectionObject;
104
struct _RemminaConnectionHolder
106
RemminaConnectionWindow *cnnwin;
107
gint fullscreen_view_mode;
109
gboolean hostkey_activated;
110
gboolean hostkey_used;
113
#define DECLARE_CNNOBJ \
114
if (!cnnhld || !cnnhld->cnnwin || gtk_notebook_get_current_page (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook)) < 0) return; \
115
RemminaConnectionObject *cnnobj = (RemminaConnectionObject*) g_object_get_data ( \
116
G_OBJECT (gtk_notebook_get_nth_page (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook), \
117
gtk_notebook_get_current_page (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook)))), "cnnobj");
119
#define DECLARE_CNNOBJ_WITH_RETURN(r) \
120
if (!cnnhld || !cnnhld->cnnwin || gtk_notebook_get_current_page (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook)) < 0) return r; \
121
RemminaConnectionObject *cnnobj = (RemminaConnectionObject*) g_object_get_data ( \
122
G_OBJECT (gtk_notebook_get_nth_page (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook), \
123
gtk_notebook_get_current_page (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook)))), "cnnobj");
125
static void remmina_connection_holder_create_scrolled (RemminaConnectionHolder *cnnhld, RemminaConnectionObject *cnnobj);
126
static void remmina_connection_holder_create_fullscreen (RemminaConnectionHolder *cnnhld, RemminaConnectionObject *cnnobj, gint view_mode);
129
remmina_connection_window_class_init (RemminaConnectionWindowClass *klass)
131
gtk_rc_parse_string (
132
"style \"remmina-small-button-style\"\n"
134
" GtkWidget::focus-padding = 0\n"
135
" GtkWidget::focus-line-width = 0\n"
139
"widget \"*.remmina-small-button\" style \"remmina-small-button-style\"");
143
remmina_connection_holder_disconnect (RemminaConnectionHolder *cnnhld)
147
/* Notify the RemminaProtocolWidget to disconnect, but not to close the window here.
148
The window will be destroyed in RemminaProtocolWidget "disconnect" signal */
149
remmina_protocol_widget_close_connection (REMMINA_PROTOCOL_WIDGET (cnnobj->proto));
153
remmina_connection_holder_keyboard_grab (RemminaConnectionHolder *cnnhld)
157
if (remmina_file_get_int (cnnobj->remmina_file, "keyboard_grab", FALSE))
159
gdk_keyboard_grab (gtk_widget_get_window (GTK_WIDGET (cnnhld->cnnwin)), TRUE, GDK_CURRENT_TIME);
163
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
168
remmina_connection_window_delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
170
RemminaConnectionHolder *cnnhld = (RemminaConnectionHolder*) data;
171
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
172
RemminaConnectionObject *cnnobj;
173
GtkNotebook *notebook = GTK_NOTEBOOK (priv->notebook);
178
n = gtk_notebook_get_n_pages (notebook);
181
dialog = gtk_message_dialog_new (GTK_WINDOW (cnnhld->cnnwin),
182
GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
183
_("There are %i active connections in the current window. Are you sure to close?"), n);
184
i = gtk_dialog_run (GTK_DIALOG (dialog));
185
gtk_widget_destroy (dialog);
186
if (i != GTK_RESPONSE_YES) return TRUE;
188
/* Just in case the connection already closed by the server before clicking yes */
189
if (GTK_IS_WIDGET (notebook))
191
n = gtk_notebook_get_n_pages (notebook);
192
for (i = n - 1; i >= 0; i--)
194
w = gtk_notebook_get_nth_page (notebook, i);
195
cnnobj = (RemminaConnectionObject*) g_object_get_data (G_OBJECT (w), "cnnobj");
196
remmina_protocol_widget_close_connection (REMMINA_PROTOCOL_WIDGET (cnnobj->proto));
203
remmina_connection_window_destroy (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
205
RemminaConnectionWindowPriv *priv = REMMINA_CONNECTION_WINDOW (widget)->priv;
207
if (priv->floating_toolbar_motion_handler)
209
g_source_remove (priv->floating_toolbar_motion_handler);
210
priv->floating_toolbar_motion_handler = 0;
212
if (priv->floating_toolbar != NULL)
214
gtk_widget_destroy (priv->floating_toolbar);
215
priv->floating_toolbar = NULL;
217
if (priv->switch_page_handler)
219
g_source_remove (priv->switch_page_handler);
220
priv->switch_page_handler = 0;
226
remmina_connection_holder_update_toolbar_opacity (RemminaConnectionHolder *cnnhld)
229
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
231
priv->floating_toolbar_opacity = (1.0 - TOOLBAR_OPACITY_MIN) / ((gdouble) TOOLBAR_OPACITY_LEVEL)
232
* ((gdouble) (TOOLBAR_OPACITY_LEVEL - remmina_file_get_int (cnnobj->remmina_file, "toolbar_opacity", 0)))
233
+ TOOLBAR_OPACITY_MIN;
235
if (priv->floating_toolbar)
237
gtk_window_set_opacity (GTK_WINDOW (priv->floating_toolbar), priv->floating_toolbar_opacity);
242
remmina_connection_holder_floating_toolbar_motion (RemminaConnectionHolder *cnnhld)
244
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
248
if (priv->floating_toolbar == NULL)
250
priv->floating_toolbar_motion_handler = 0;
254
gtk_widget_size_request (priv->floating_toolbar, &req);
255
gtk_window_get_position (GTK_WINDOW (priv->floating_toolbar), &x, &y);
257
if (priv->floating_toolbar_motion_show || priv->floating_toolbar_motion_visible)
259
if (priv->floating_toolbar_motion_show) y += 2; else y -= 2;
260
t = (priv->pin_down ? 18 : 2) - req.height;
264
gtk_window_move (GTK_WINDOW (priv->floating_toolbar), x, y);
265
if (remmina_pref.invisible_toolbar && !priv->pin_down)
267
gtk_window_set_opacity (GTK_WINDOW (priv->floating_toolbar), (gdouble)(y - t) / (gdouble)(-t)
268
* priv->floating_toolbar_opacity);
270
if ((priv->floating_toolbar_motion_show && y >= 0) ||
271
(!priv->floating_toolbar_motion_show && y <= t))
273
priv->floating_toolbar_motion_handler = 0;
279
gtk_window_move (GTK_WINDOW (priv->floating_toolbar), x, -20 - req.height);
280
priv->floating_toolbar_motion_handler = 0;
287
remmina_connection_holder_floating_toolbar_update (RemminaConnectionHolder *cnnhld)
289
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
291
if (priv->floating_toolbar_motion_show || priv->floating_toolbar_motion_visible)
293
if (priv->floating_toolbar_motion_handler) g_source_remove (priv->floating_toolbar_motion_handler);
294
priv->floating_toolbar_motion_handler = g_idle_add (
295
(GSourceFunc) remmina_connection_holder_floating_toolbar_motion, cnnhld);
299
if (priv->floating_toolbar_motion_handler == 0)
301
priv->floating_toolbar_motion_handler = g_timeout_add (MOTION_TIME,
302
(GSourceFunc) remmina_connection_holder_floating_toolbar_motion, cnnhld);
308
remmina_connection_holder_floating_toolbar_show (RemminaConnectionHolder *cnnhld, gboolean show)
310
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
312
if (priv->floating_toolbar == NULL) return;
314
priv->floating_toolbar_motion_show = show;
316
remmina_connection_holder_floating_toolbar_update (cnnhld);
320
remmina_connection_holder_floating_toolbar_visible (RemminaConnectionHolder *cnnhld, gboolean visible)
322
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
324
if (priv->floating_toolbar == NULL) return;
326
priv->floating_toolbar_motion_visible = visible;
328
remmina_connection_holder_floating_toolbar_update (cnnhld);
332
remmina_connection_holder_get_desktop_size (RemminaConnectionHolder* cnnhld, gint *width, gint *height, gboolean expand)
335
RemminaFile *remminafile = cnnobj->remmina_file;
336
RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET (cnnobj->proto);
339
scale = remmina_protocol_widget_get_scale (gp);
340
*width = remmina_protocol_widget_get_width (gp);
343
if (remmina_file_get_int (remminafile, "hscale", 0) > 0)
345
*width = (*width) * remmina_file_get_int (remminafile, "hscale", 0) / 100;
352
*height = remmina_protocol_widget_get_height (gp);
355
if (remmina_file_get_int (remminafile, "vscale", 0) > 0)
357
*height = (*height) * remmina_file_get_int (remminafile, "vscale", 0) / 100;
367
remmina_connection_object_set_scrolled_policy (RemminaConnectionObject *cnnobj, GtkScrolledWindow *scrolled_window)
371
expand = remmina_protocol_widget_get_expand (REMMINA_PROTOCOL_WIDGET (cnnobj->proto));
372
gtk_scrolled_window_set_policy (scrolled_window,
373
expand ? GTK_POLICY_NEVER : GTK_POLICY_AUTOMATIC,
374
expand ? GTK_POLICY_NEVER : GTK_POLICY_AUTOMATIC);
378
remmina_connection_holder_toolbar_autofit_restore (RemminaConnectionHolder* cnnhld)
380
DECLARE_CNNOBJ_WITH_RETURN (FALSE)
381
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
384
if (cnnobj->connected && GTK_IS_SCROLLED_WINDOW (cnnobj->scrolled_container))
386
remmina_connection_holder_get_desktop_size (cnnhld, &width, &height, TRUE);
387
gtk_window_resize (GTK_WINDOW (cnnhld->cnnwin),
389
priv->notebook->allocation.width - cnnobj->scrolled_container->allocation.width),
390
MAX (1, height + priv->toolbar->allocation.height +
391
priv->notebook->allocation.height - cnnobj->scrolled_container->allocation.height));
392
gtk_container_check_resize (GTK_CONTAINER (cnnhld->cnnwin));
394
if (GTK_IS_SCROLLED_WINDOW (cnnobj->scrolled_container))
396
remmina_connection_object_set_scrolled_policy (cnnobj, GTK_SCROLLED_WINDOW (cnnobj->scrolled_container));
402
remmina_connection_holder_toolbar_autofit (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
406
if (GTK_IS_SCROLLED_WINDOW (cnnobj->scrolled_container))
408
if ((gdk_window_get_state (gtk_widget_get_window (GTK_WIDGET (cnnhld->cnnwin))) & GDK_WINDOW_STATE_MAXIMIZED) != 0)
410
gtk_window_unmaximize (GTK_WINDOW (cnnhld->cnnwin));
413
/* It's tricky to make the toolbars disappear automatically, while keeping scrollable.
414
Please tell me if you know a better way to do this */
415
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (cnnobj->scrolled_container),
416
GTK_POLICY_NEVER, GTK_POLICY_NEVER);
418
g_timeout_add (200, (GSourceFunc) remmina_connection_holder_toolbar_autofit_restore, cnnhld);
424
remmina_connection_object_init_adjustment (RemminaConnectionObject *cnnobj)
428
gint screen_width, screen_height;
430
screen = gdk_screen_get_default ();
431
screen_width = gdk_screen_get_width (screen);
432
screen_height = gdk_screen_get_height (screen);
434
adj = gtk_viewport_get_hadjustment (GTK_VIEWPORT (cnnobj->viewport));
435
gtk_adjustment_set_page_size (adj, screen_width);
436
adj = gtk_viewport_get_vadjustment (GTK_VIEWPORT (cnnobj->viewport));
437
gtk_adjustment_set_page_size (adj, screen_height);
441
remmina_connection_holder_check_resize (RemminaConnectionHolder *cnnhld)
444
gboolean scroll_required = FALSE;
446
gint screen_width, screen_height;
447
gint server_width, server_height;
449
remmina_connection_holder_get_desktop_size (cnnhld, &server_width, &server_height, FALSE);
450
screen = gdk_screen_get_default ();
451
screen_width = gdk_screen_get_width (screen);
452
screen_height = gdk_screen_get_height (screen);
454
if (!remmina_protocol_widget_get_expand (REMMINA_PROTOCOL_WIDGET (cnnobj->proto)) &&
455
(server_width <= 0 || server_height <= 0 || screen_width < server_width || screen_height < server_height))
457
scroll_required = TRUE;
460
switch (cnnhld->cnnwin->priv->view_mode)
463
case SCROLLED_FULLSCREEN_MODE:
464
gtk_window_resize (GTK_WINDOW (cnnhld->cnnwin), screen_width, screen_height);
465
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (cnnobj->scrolled_container),
466
(scroll_required ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER),
467
(scroll_required ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER));
470
case VIEWPORT_FULLSCREEN_MODE:
471
gtk_window_resize (GTK_WINDOW (cnnhld->cnnwin), screen_width, screen_height);
472
gtk_container_set_border_width (GTK_CONTAINER (cnnhld->cnnwin), scroll_required ? 1 : 0);
475
case SCROLLED_WINDOW_MODE:
476
if (remmina_file_get_int (cnnobj->remmina_file, "viewmode", AUTO_MODE) == AUTO_MODE)
478
gtk_window_set_default_size (GTK_WINDOW (cnnhld->cnnwin),
479
MIN (server_width, screen_width), MIN (server_height, screen_height));
480
if (server_width >= screen_width ||
481
server_height >= screen_height)
483
gtk_window_maximize (GTK_WINDOW (cnnhld->cnnwin));
484
remmina_file_set_int (cnnobj->remmina_file, "window_maximize", TRUE);
488
remmina_connection_holder_toolbar_autofit (NULL, cnnhld);
489
remmina_file_set_int (cnnobj->remmina_file, "window_maximize", FALSE);
494
gtk_window_set_default_size (GTK_WINDOW (cnnhld->cnnwin),
495
remmina_file_get_int (cnnobj->remmina_file, "window_width", 640),
496
remmina_file_get_int (cnnobj->remmina_file, "window_height", 480));
497
if (remmina_file_get_int (cnnobj->remmina_file, "window_maximize", FALSE))
499
gtk_window_maximize (GTK_WINDOW (cnnhld->cnnwin));
510
remmina_connection_holder_toolbar_fullscreen (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
512
if (gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (widget)))
514
remmina_connection_holder_create_fullscreen (cnnhld, NULL, cnnhld->fullscreen_view_mode);
518
remmina_connection_holder_create_scrolled (cnnhld, NULL);
523
remmina_connection_holder_viewport_fullscreen_mode (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
525
if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget))) return;
526
cnnhld->fullscreen_view_mode = VIEWPORT_FULLSCREEN_MODE;
527
remmina_connection_holder_create_fullscreen (cnnhld, NULL, cnnhld->fullscreen_view_mode);
531
remmina_connection_holder_scrolled_fullscreen_mode (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
533
if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget))) return;
534
cnnhld->fullscreen_view_mode = SCROLLED_FULLSCREEN_MODE;
535
remmina_connection_holder_create_fullscreen (cnnhld, NULL, cnnhld->fullscreen_view_mode);
539
remmina_connection_holder_fullscreen_option_popdown (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
541
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
543
priv->sticky = FALSE;
545
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->fullscreen_option_button), FALSE);
546
remmina_connection_holder_floating_toolbar_show (cnnhld, FALSE);
550
remmina_connection_holder_toolbar_fullscreen_option (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
552
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
557
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) return;
561
menu = gtk_menu_new ();
563
menuitem = gtk_radio_menu_item_new_with_label (NULL, _("Viewport fullscreen mode"));
564
gtk_widget_show (menuitem);
565
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
566
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
567
if (priv->view_mode == VIEWPORT_FULLSCREEN_MODE)
569
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
571
g_signal_connect (G_OBJECT (menuitem), "toggled",
572
G_CALLBACK (remmina_connection_holder_viewport_fullscreen_mode), cnnhld);
574
menuitem = gtk_radio_menu_item_new_with_label (group, _("Scrolled fullscreen mode"));
575
gtk_widget_show (menuitem);
576
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
577
if (priv->view_mode == SCROLLED_FULLSCREEN_MODE)
579
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
581
g_signal_connect (G_OBJECT (menuitem), "toggled",
582
G_CALLBACK (remmina_connection_holder_scrolled_fullscreen_mode), cnnhld);
584
g_signal_connect (G_OBJECT (menu), "deactivate",
585
G_CALLBACK (remmina_connection_holder_fullscreen_option_popdown), cnnhld);
587
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
588
remmina_public_popup_position, priv->toolitem_fullscreen,
589
0, gtk_get_current_event_time());
593
remmina_connection_holder_update_alignment (RemminaConnectionHolder* cnnhld)
596
RemminaProtocolWidget *gp = REMMINA_PROTOCOL_WIDGET (cnnobj->proto);
597
RemminaFile *remminafile = cnnobj->remmina_file;
598
gboolean scale, expand;
599
gint gp_width, gp_height;
602
scale = remmina_protocol_widget_get_scale (gp);
603
expand = remmina_protocol_widget_get_expand (gp);
604
gp_width = remmina_protocol_widget_get_width (gp);
605
gp_height = remmina_protocol_widget_get_height (gp);
608
remmina_file_get_int (remminafile, "aspectscale", FALSE) &&
609
remmina_file_get_int (remminafile, "hscale", 0) == 0)
611
width = cnnobj->alignment->allocation.width;
612
height = cnnobj->alignment->allocation.height;
613
if (width > 1 && height > 1)
615
if (gp_width * height >= width * gp_height)
617
gtk_alignment_set (GTK_ALIGNMENT (cnnobj->alignment), 0.5, 0.5,
619
(gfloat) (gp_height * width) / (gfloat) gp_width / (gfloat) height);
623
gtk_alignment_set (GTK_ALIGNMENT (cnnobj->alignment), 0.5, 0.5,
624
(gfloat) (gp_width * height) / (gfloat) gp_height / (gfloat) width,
631
gtk_alignment_set (GTK_ALIGNMENT (cnnobj->alignment), 0.5, 0.5,
632
((scale && remmina_file_get_int (remminafile, "hscale", 0) == 0) || expand ? 1.0 : 0.0),
633
((scale && remmina_file_get_int (remminafile, "vscale", 0) == 0) || expand ? 1.0 : 0.0));
638
remmina_connection_holder_switch_page_activate (GtkMenuItem *menuitem, RemminaConnectionHolder *cnnhld)
640
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
643
page_num = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menuitem), "new-page-num"));
644
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), page_num);
648
remmina_connection_holder_toolbar_switch_page_popdown (GtkWidget *widget, RemminaConnectionHolder *cnnhld)
650
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
652
priv->sticky = FALSE;
654
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (priv->toolitem_switch_page), FALSE);
655
remmina_connection_holder_floating_toolbar_show (cnnhld, FALSE);
659
remmina_connection_holder_toolbar_switch_page (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
661
RemminaConnectionObject *cnnobj;
662
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
669
if (!gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (widget))) return;
673
menu = gtk_menu_new ();
675
n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (priv->notebook));
676
for (i = 0; i < n; i++)
678
page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (priv->notebook), i);
680
cnnobj = (RemminaConnectionObject*) g_object_get_data (G_OBJECT (page), "cnnobj");
682
menuitem = gtk_image_menu_item_new_with_label (remmina_file_get_string (cnnobj->remmina_file, "name"));
683
gtk_widget_show (menuitem);
684
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
686
image = gtk_image_new_from_icon_name (remmina_file_get_icon_name (cnnobj->remmina_file), GTK_ICON_SIZE_MENU);
687
gtk_widget_show (image);
688
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
690
g_object_set_data (G_OBJECT (menuitem), "new-page-num", GINT_TO_POINTER (i));
691
g_signal_connect (G_OBJECT (menuitem), "activate",
692
G_CALLBACK (remmina_connection_holder_switch_page_activate), cnnhld);
693
if (i == gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->notebook)))
695
gtk_widget_set_sensitive (menuitem, FALSE);
699
g_signal_connect (G_OBJECT (menu), "deactivate",
700
G_CALLBACK (remmina_connection_holder_toolbar_switch_page_popdown), cnnhld);
702
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
703
remmina_public_popup_position, widget,
704
0, gtk_get_current_event_time());
708
remmina_connection_holder_toolbar_scaled_mode (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
713
remmina_connection_holder_update_alignment (cnnhld);
715
scale = gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (widget));
716
gtk_widget_set_sensitive (GTK_WIDGET (cnnhld->cnnwin->priv->scale_option_button), scale);
717
remmina_protocol_widget_set_scale (REMMINA_PROTOCOL_WIDGET (cnnobj->proto), scale);
718
remmina_file_set_int (cnnobj->remmina_file, "scale", scale);
720
remmina_protocol_widget_call_feature_by_type (REMMINA_PROTOCOL_WIDGET (cnnobj->proto),
721
REMMINA_PROTOCOL_FEATURE_TYPE_SCALE, 0);
722
if (cnnhld->cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE)
724
remmina_connection_holder_check_resize (cnnhld);
729
remmina_connection_holder_scale_option_on_scaled (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
733
remmina_file_set_int (cnnobj->remmina_file, "hscale", REMMINA_SCALER (widget)->hscale);
734
remmina_file_set_int (cnnobj->remmina_file, "vscale", REMMINA_SCALER (widget)->vscale);
735
remmina_file_set_int (cnnobj->remmina_file, "aspectscale", REMMINA_SCALER (widget)->aspectscale);
736
remmina_connection_holder_update_alignment (cnnhld);
737
remmina_protocol_widget_call_feature_by_type (REMMINA_PROTOCOL_WIDGET (cnnobj->proto),
738
REMMINA_PROTOCOL_FEATURE_TYPE_SCALE, 0);
739
if (cnnhld->cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE)
741
remmina_connection_holder_check_resize (cnnhld);
746
remmina_connection_holder_scale_option_popdown (RemminaConnectionHolder* cnnhld)
748
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
750
priv->sticky = FALSE;
752
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->scale_option_button), FALSE);
754
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
755
gdk_pointer_ungrab (GDK_CURRENT_TIME);
756
if (scale_option_window)
758
gtk_grab_remove (scale_option_window);
759
gtk_widget_destroy (scale_option_window);
760
scale_option_window = NULL;
762
remmina_connection_holder_floating_toolbar_show (cnnhld, FALSE);
766
remmina_connection_holder_trap_on_button (GtkWidget *widget, GdkEventButton *event, gpointer data)
772
remmina_connection_holder_scale_option_on_key (GtkWidget *widget, GdkEventKey *event, RemminaConnectionHolder* cnnhld)
774
switch (event->keyval)
777
remmina_connection_holder_scale_option_popdown (cnnhld);
784
remmina_connection_holder_scale_option_on_button (GtkWidget *widget, GdkEventButton *event, RemminaConnectionHolder* cnnhld)
786
remmina_connection_holder_scale_option_popdown (cnnhld);
791
remmina_connection_holder_toolbar_scale_option (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
794
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
795
RemminaFile *remminafile = cnnobj->remmina_file;
803
if (scale_option_window)
805
remmina_connection_holder_scale_option_popdown (cnnhld);
807
else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
809
window = gtk_window_new (GTK_WINDOW_POPUP);
810
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
812
/* Use an event-box to trap all button clicks events before sending up to the window */
813
eventbox = gtk_event_box_new ();
814
gtk_widget_show (eventbox);
815
gtk_container_add (GTK_CONTAINER (window), eventbox);
816
gtk_widget_add_events (eventbox, GDK_BUTTON_PRESS_MASK);
817
g_signal_connect (G_OBJECT (eventbox), "button-press-event",
818
G_CALLBACK (remmina_connection_holder_trap_on_button), NULL);
820
frame = gtk_frame_new (NULL);
821
gtk_widget_show (frame);
822
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
823
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
824
gtk_container_add (GTK_CONTAINER (eventbox), frame);
826
scaler = remmina_scaler_new ();
827
gtk_widget_show (scaler);
828
gtk_widget_set_size_request (scaler, 250, -1);
829
gtk_container_set_border_width (GTK_CONTAINER (scaler), 4);
830
remmina_scaler_set (REMMINA_SCALER (scaler),
831
remmina_file_get_int (remminafile, "hscale", 0),
832
remmina_file_get_int (remminafile, "vscale", 0),
833
remmina_file_get_int (remminafile, "aspectscale", FALSE));
834
remmina_scaler_set_draw_value (REMMINA_SCALER (scaler), FALSE);
835
gtk_container_add (GTK_CONTAINER (frame), scaler);
836
g_signal_connect (G_OBJECT (scaler), "scaled",
837
G_CALLBACK (remmina_connection_holder_scale_option_on_scaled), cnnhld);
839
g_signal_connect (G_OBJECT (window), "key-press-event",
840
G_CALLBACK (remmina_connection_holder_scale_option_on_key), cnnhld);
841
g_signal_connect (G_OBJECT (window), "button-press-event",
842
G_CALLBACK (remmina_connection_holder_scale_option_on_button), cnnhld);
844
gtk_widget_realize (window);
845
remmina_public_popup_position (NULL, &x, &y, &pushin, priv->toolitem_scale);
846
gtk_window_move (GTK_WINDOW (window), x, y);
847
gtk_widget_show (window);
849
gtk_grab_add (window);
850
gdk_pointer_grab (window->window, TRUE,
851
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
852
NULL, NULL, GDK_CURRENT_TIME);
853
gdk_keyboard_grab (window->window, TRUE, GDK_CURRENT_TIME);
855
scale_option_window = window;
861
remmina_connection_holder_toolbar_preferences_popdown (GtkWidget *widget, RemminaConnectionHolder *cnnhld)
863
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
865
priv->sticky = FALSE;
867
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (priv->toolitem_preferences), FALSE);
868
remmina_connection_holder_floating_toolbar_show (cnnhld, FALSE);
872
remmina_connection_holder_toolbar_tools_popdown (GtkWidget *widget, RemminaConnectionHolder *cnnhld)
874
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
876
priv->sticky = FALSE;
878
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (priv->toolitem_tools), FALSE);
879
remmina_connection_holder_floating_toolbar_show (cnnhld, FALSE);
883
remmina_connection_holder_call_protocol_feature_radio (GtkMenuItem *menuitem, RemminaConnectionHolder *cnnhld)
886
RemminaProtocolFeature *feature;
889
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem)))
891
feature = (RemminaProtocolFeature*) g_object_get_data (G_OBJECT (menuitem), "feature-type");
892
value = g_object_get_data (G_OBJECT (menuitem), "feature-value");
894
remmina_file_set_string (cnnobj->remmina_file, (const gchar*) feature->opt2, (const gchar*) value);
895
remmina_protocol_widget_call_feature_by_ref (REMMINA_PROTOCOL_WIDGET (cnnobj->proto), feature);
900
remmina_connection_holder_call_protocol_feature_check (GtkMenuItem *menuitem, RemminaConnectionHolder *cnnhld)
903
RemminaProtocolFeature *feature;
906
feature = (RemminaProtocolFeature*) g_object_get_data (G_OBJECT (menuitem), "feature-type");
907
value = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
908
remmina_file_set_int (cnnobj->remmina_file, (const gchar*) feature->opt2, value);
909
remmina_protocol_widget_call_feature_by_ref (REMMINA_PROTOCOL_WIDGET (cnnobj->proto), feature);
913
remmina_connection_holder_call_protocol_feature_activate (GtkMenuItem *menuitem, RemminaConnectionHolder *cnnhld)
916
RemminaProtocolFeature *feature;
918
feature = (RemminaProtocolFeature*) g_object_get_data (G_OBJECT (menuitem), "feature-type");
919
remmina_protocol_widget_call_feature_by_ref (REMMINA_PROTOCOL_WIDGET (cnnobj->proto), feature);
923
remmina_connection_holder_toolbar_preferences_radio (RemminaConnectionHolder *cnnhld,
924
RemminaFile *remminafile, GtkWidget *menu, const RemminaProtocolFeature *feature, const gchar *domain, gboolean enabled)
933
value = remmina_file_get_string (remminafile, (const gchar*) feature->opt2);
934
list = (const gchar**) feature->opt3;
935
for (i = 0; list[i]; i += 2)
937
menuitem = gtk_radio_menu_item_new_with_label (group, g_dgettext (domain, list[i + 1]));
938
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem));
939
gtk_widget_show (menuitem);
940
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
944
g_object_set_data (G_OBJECT (menuitem), "feature-type", (gpointer) feature);
945
g_object_set_data (G_OBJECT (menuitem), "feature-value", (gpointer) list[i]);
947
if (value && g_strcmp0 (list[i], value) == 0)
949
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), TRUE);
952
g_signal_connect (G_OBJECT (menuitem), "toggled",
953
G_CALLBACK (remmina_connection_holder_call_protocol_feature_radio), cnnhld);
957
gtk_widget_set_sensitive (menuitem, FALSE);
963
remmina_connection_holder_toolbar_preferences_check (RemminaConnectionHolder *cnnhld,
964
RemminaFile *remminafile, GtkWidget *menu, const RemminaProtocolFeature *feature, const gchar *domain, gboolean enabled)
968
menuitem = gtk_check_menu_item_new_with_label (g_dgettext (domain, (const gchar*) feature->opt3));
969
gtk_widget_show (menuitem);
970
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
974
g_object_set_data (G_OBJECT (menuitem), "feature-type", (gpointer) feature);
976
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
977
remmina_file_get_int (remminafile, (const gchar*) feature->opt2, FALSE));
979
g_signal_connect (G_OBJECT (menuitem), "toggled",
980
G_CALLBACK (remmina_connection_holder_call_protocol_feature_check), cnnhld);
984
gtk_widget_set_sensitive (menuitem, FALSE);
989
remmina_connection_holder_toolbar_preferences (GtkWidget *widget, RemminaConnectionHolder *cnnhld)
992
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
993
const RemminaProtocolFeature *feature;
1000
if (!gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (widget))) return;
1002
priv->sticky = TRUE;
1006
domain = remmina_protocol_widget_get_domain (REMMINA_PROTOCOL_WIDGET (cnnobj->proto));
1007
menu = gtk_menu_new ();
1008
for (feature = remmina_protocol_widget_get_features (REMMINA_PROTOCOL_WIDGET (cnnobj->proto)); feature && feature->type; feature++)
1010
if (feature->type != REMMINA_PROTOCOL_FEATURE_TYPE_PREF) continue;
1014
menuitem = gtk_separator_menu_item_new ();
1015
gtk_widget_show (menuitem);
1016
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1019
enabled = remmina_protocol_widget_query_feature_by_ref (REMMINA_PROTOCOL_WIDGET (cnnobj->proto), feature);
1020
switch (GPOINTER_TO_INT (feature->opt1))
1022
case REMMINA_PROTOCOL_FEATURE_PREF_RADIO:
1023
remmina_connection_holder_toolbar_preferences_radio (cnnhld, cnnobj->remmina_file, menu, feature, domain, enabled);
1026
case REMMINA_PROTOCOL_FEATURE_PREF_CHECK:
1027
remmina_connection_holder_toolbar_preferences_check (cnnhld, cnnobj->remmina_file, menu, feature, domain, enabled);
1032
g_signal_connect (G_OBJECT (menu), "deactivate",
1033
G_CALLBACK (remmina_connection_holder_toolbar_preferences_popdown), cnnhld);
1035
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
1036
remmina_public_popup_position, widget,
1037
0, gtk_get_current_event_time ());
1041
remmina_connection_holder_toolbar_tools (GtkWidget *widget, RemminaConnectionHolder *cnnhld)
1044
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1045
const RemminaProtocolFeature *feature;
1047
GtkWidget *menuitem;
1049
const gchar *domain;
1052
if (!gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (widget))) return;
1054
priv->sticky = TRUE;
1056
domain = remmina_protocol_widget_get_domain (REMMINA_PROTOCOL_WIDGET (cnnobj->proto));
1057
menu = gtk_menu_new ();
1058
for (feature = remmina_protocol_widget_get_features (REMMINA_PROTOCOL_WIDGET (cnnobj->proto)); feature && feature->type; feature++)
1060
if (feature->type != REMMINA_PROTOCOL_FEATURE_TYPE_TOOL) continue;
1064
menuitem = gtk_image_menu_item_new_with_label (g_dgettext (domain, (const gchar*) feature->opt1));
1067
image = gtk_image_new_from_icon_name ((const gchar*) feature->opt2, GTK_ICON_SIZE_MENU);
1068
gtk_widget_show (image);
1069
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
1074
menuitem = gtk_image_menu_item_new_from_stock ((const gchar*) feature->opt2, NULL);
1076
gtk_widget_show (menuitem);
1077
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
1079
enabled = remmina_protocol_widget_query_feature_by_ref (REMMINA_PROTOCOL_WIDGET (cnnobj->proto), feature);
1082
g_object_set_data (G_OBJECT (menuitem), "feature-type", (gpointer) feature);
1084
g_signal_connect (G_OBJECT (menuitem), "activate",
1085
G_CALLBACK (remmina_connection_holder_call_protocol_feature_activate), cnnhld);
1089
gtk_widget_set_sensitive (menuitem, FALSE);
1093
g_signal_connect (G_OBJECT (menu), "deactivate",
1094
G_CALLBACK (remmina_connection_holder_toolbar_tools_popdown), cnnhld);
1096
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
1097
remmina_public_popup_position, widget,
1098
0, gtk_get_current_event_time());
1102
remmina_connection_holder_toolbar_minimize (GtkWidget *widget, RemminaConnectionHolder *cnnhld)
1104
remmina_connection_holder_floating_toolbar_show (cnnhld, FALSE);
1105
gtk_window_iconify (GTK_WINDOW (cnnhld->cnnwin));
1109
remmina_connection_holder_toolbar_disconnect (GtkWidget *widget, RemminaConnectionHolder* cnnhld)
1111
remmina_connection_holder_disconnect (cnnhld);
1115
remmina_connection_holder_toolbar_grab (GtkWidget *widget, RemminaConnectionHolder *cnnhld)
1119
remmina_file_set_int (cnnobj->remmina_file, "keyboard_grab",
1120
gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (widget)));
1121
remmina_connection_holder_keyboard_grab (cnnhld);
1125
remmina_connection_holder_set_tooltip (GtkToolItem *toolitem, const gchar *tip, guint key1, guint key2)
1129
if (remmina_pref.hostkey && key1)
1133
s1 = g_strdup_printf (" (%s + %s,%s)", gdk_keyval_name (remmina_pref.hostkey),
1134
gdk_keyval_name (gdk_keyval_to_upper (key1)), gdk_keyval_name (gdk_keyval_to_upper (key2)));
1136
else if (key1 == remmina_pref.hostkey)
1138
s1 = g_strdup_printf (" (%s)", gdk_keyval_name (remmina_pref.hostkey));
1142
s1 = g_strdup_printf (" (%s + %s)", gdk_keyval_name (remmina_pref.hostkey),
1143
gdk_keyval_name (gdk_keyval_to_upper (key1)));
1150
s2 = g_strdup_printf ("%s%s", tip, s1 ? s1 : "");
1151
gtk_tool_item_set_tooltip_text (toolitem, s2);
1157
remmina_connection_holder_create_toolbar (RemminaConnectionHolder *cnnhld, gint mode)
1159
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1161
GtkToolItem *toolitem;
1165
toolbar = gtk_toolbar_new ();
1166
gtk_widget_show (toolbar);
1167
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
1168
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE);
1169
if (remmina_pref.small_toolbutton)
1171
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_MENU);
1175
toolitem = gtk_tool_button_new (NULL, NULL);
1176
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (toolitem), "remmina-fit-window");
1177
remmina_connection_holder_set_tooltip (toolitem, _("Resize the window to fit in remote resolution"),
1178
remmina_pref.shortcutkey_autofit, 0);
1179
g_signal_connect (G_OBJECT (toolitem), "clicked",
1180
G_CALLBACK (remmina_connection_holder_toolbar_autofit), cnnhld);
1181
priv->toolitem_autofit = toolitem;
1182
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1183
gtk_widget_show (GTK_WIDGET (toolitem));
1185
/* Fullscreen toggle */
1186
toolitem = gtk_toggle_tool_button_new ();
1187
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (toolitem), "remmina-fullscreen");
1188
remmina_connection_holder_set_tooltip (toolitem, _("Toggle fullscreen mode"),
1189
remmina_pref.shortcutkey_fullscreen, 0);
1190
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1191
gtk_widget_show (GTK_WIDGET (toolitem));
1192
priv->toolitem_fullscreen = toolitem;
1193
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (toolitem),
1194
mode != SCROLLED_WINDOW_MODE);
1195
g_signal_connect (G_OBJECT (toolitem), "clicked",
1196
G_CALLBACK (remmina_connection_holder_toolbar_fullscreen), cnnhld);
1198
/* Fullscreen drop-down options */
1199
toolitem = gtk_tool_item_new ();
1200
gtk_widget_show (GTK_WIDGET (toolitem));
1201
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1203
widget = gtk_toggle_button_new ();
1204
gtk_widget_show (widget);
1205
gtk_container_set_border_width (GTK_CONTAINER (widget), 0);
1206
gtk_button_set_relief (GTK_BUTTON (widget), GTK_RELIEF_NONE);
1207
gtk_button_set_focus_on_click (GTK_BUTTON (widget), FALSE);
1208
if (remmina_pref.small_toolbutton)
1210
gtk_widget_set_name (widget, "remmina-small-button");
1212
gtk_container_add (GTK_CONTAINER (toolitem), widget);
1214
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
1215
gtk_widget_show (arrow);
1216
gtk_container_add (GTK_CONTAINER (widget), arrow);
1218
g_signal_connect (G_OBJECT (widget), "toggled",
1219
G_CALLBACK(remmina_connection_holder_toolbar_fullscreen_option), cnnhld);
1220
priv->fullscreen_option_button = widget;
1221
if (mode == SCROLLED_WINDOW_MODE)
1223
gtk_widget_set_sensitive (GTK_WIDGET (widget), FALSE);
1227
toolitem = gtk_toggle_tool_button_new ();
1228
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (toolitem), "remmina-switch-page");
1229
remmina_connection_holder_set_tooltip (toolitem, _("Switch tab pages"),
1230
remmina_pref.shortcutkey_prevtab, remmina_pref.shortcutkey_nexttab);
1231
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1232
gtk_widget_show (GTK_WIDGET (toolitem));
1233
g_signal_connect (G_OBJECT (toolitem), "toggled",
1234
G_CALLBACK (remmina_connection_holder_toolbar_switch_page), cnnhld);
1235
priv->toolitem_switch_page = toolitem;
1237
toolitem = gtk_separator_tool_item_new ();
1238
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1239
gtk_widget_show (GTK_WIDGET (toolitem));
1241
toolitem = gtk_toggle_tool_button_new ();
1242
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (toolitem), "remmina-scale");
1243
remmina_connection_holder_set_tooltip (toolitem, _("Toggle scaled mode"),
1244
remmina_pref.shortcutkey_scale, 0);
1245
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1246
gtk_widget_show (GTK_WIDGET (toolitem));
1247
g_signal_connect (G_OBJECT (toolitem), "toggled",
1248
G_CALLBACK (remmina_connection_holder_toolbar_scaled_mode), cnnhld);
1249
priv->toolitem_scale = toolitem;
1251
/* We need a toggle tool button with a popup arrow; and the popup is a window not a menu.
1252
GTK+ support neither of them. We need some tricks here... */
1253
toolitem = gtk_tool_item_new ();
1254
gtk_widget_show (GTK_WIDGET (toolitem));
1255
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1257
widget = gtk_toggle_button_new ();
1258
gtk_widget_show (widget);
1259
gtk_container_set_border_width (GTK_CONTAINER (widget), 0);
1260
gtk_button_set_relief (GTK_BUTTON (widget), GTK_RELIEF_NONE);
1261
gtk_button_set_focus_on_click (GTK_BUTTON (widget), FALSE);
1262
if (remmina_pref.small_toolbutton)
1264
gtk_widget_set_name (widget, "remmina-small-button");
1266
gtk_container_add (GTK_CONTAINER (toolitem), widget);
1268
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
1269
gtk_widget_show (arrow);
1270
gtk_container_add (GTK_CONTAINER (widget), arrow);
1272
g_signal_connect (G_OBJECT (widget), "toggled",
1273
G_CALLBACK(remmina_connection_holder_toolbar_scale_option), cnnhld);
1274
priv->scale_option_button = widget;
1276
toolitem = gtk_toggle_tool_button_new ();
1277
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (toolitem), "input-keyboard");
1278
remmina_connection_holder_set_tooltip (toolitem, _("Grab all keyboard events"),
1279
remmina_pref.shortcutkey_grab, 0);
1280
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1281
gtk_widget_show (GTK_WIDGET (toolitem));
1282
g_signal_connect (G_OBJECT (toolitem), "toggled",
1283
G_CALLBACK (remmina_connection_holder_toolbar_grab), cnnhld);
1284
priv->toolitem_grab = toolitem;
1286
toolitem = gtk_toggle_tool_button_new_from_stock (GTK_STOCK_PREFERENCES);
1287
gtk_tool_item_set_tooltip_text (toolitem, _("Preferences"));
1288
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1289
gtk_widget_show (GTK_WIDGET (toolitem));
1290
g_signal_connect (G_OBJECT (toolitem), "toggled",
1291
G_CALLBACK (remmina_connection_holder_toolbar_preferences), cnnhld);
1292
priv->toolitem_preferences = toolitem;
1294
toolitem = gtk_toggle_tool_button_new_from_stock (GTK_STOCK_EXECUTE);
1295
gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), _("Tools"));
1296
gtk_tool_item_set_tooltip_text (toolitem, _("Tools"));
1297
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1298
gtk_widget_show (GTK_WIDGET (toolitem));
1299
g_signal_connect (G_OBJECT (toolitem), "toggled",
1300
G_CALLBACK (remmina_connection_holder_toolbar_tools), cnnhld);
1301
priv->toolitem_tools = toolitem;
1303
toolitem = gtk_separator_tool_item_new ();
1304
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1305
gtk_widget_show (GTK_WIDGET (toolitem));
1307
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_GOTO_BOTTOM);
1308
remmina_connection_holder_set_tooltip (toolitem, _("Minimize window"),
1309
remmina_pref.shortcutkey_minimize, 0);
1310
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1311
gtk_widget_show (GTK_WIDGET (toolitem));
1312
g_signal_connect (G_OBJECT (toolitem), "clicked",
1313
G_CALLBACK (remmina_connection_holder_toolbar_minimize), cnnhld);
1315
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_DISCONNECT);
1316
remmina_connection_holder_set_tooltip (toolitem, _("Disconnect"),
1317
remmina_pref.shortcutkey_disconnect, 0);
1318
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
1319
gtk_widget_show (GTK_WIDGET (toolitem));
1320
g_signal_connect (G_OBJECT (toolitem), "clicked",
1321
G_CALLBACK (remmina_connection_holder_toolbar_disconnect), cnnhld);
1327
remmina_connection_holder_update_toolbar (RemminaConnectionHolder *cnnhld)
1330
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1331
GtkToolItem *toolitem;
1334
toolitem = priv->toolitem_autofit;
1337
if (priv->view_mode != SCROLLED_WINDOW_MODE)
1339
gtk_widget_set_sensitive (GTK_WIDGET (toolitem), FALSE);
1343
bval = remmina_protocol_widget_get_expand (REMMINA_PROTOCOL_WIDGET (cnnobj->proto));
1344
gtk_widget_set_sensitive (GTK_WIDGET (toolitem), !bval);
1348
toolitem = priv->toolitem_switch_page;
1349
bval = (gtk_notebook_get_n_pages (GTK_NOTEBOOK (priv->notebook)) > 1);
1350
gtk_widget_set_sensitive (GTK_WIDGET (toolitem), bval);
1352
toolitem = priv->toolitem_scale;
1353
bval = remmina_protocol_widget_get_scale (REMMINA_PROTOCOL_WIDGET (cnnobj->proto));
1354
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (toolitem), bval);
1355
gtk_widget_set_sensitive (GTK_WIDGET (priv->scale_option_button), bval);
1356
bval = remmina_protocol_widget_query_feature_by_type (REMMINA_PROTOCOL_WIDGET (cnnobj->proto),
1357
REMMINA_PROTOCOL_FEATURE_TYPE_SCALE);
1358
gtk_widget_set_sensitive (GTK_WIDGET (toolitem), bval);
1360
toolitem = priv->toolitem_grab;
1361
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (toolitem),
1362
remmina_file_get_int (cnnobj->remmina_file, "keyboard_grab", FALSE));
1364
toolitem = priv->toolitem_preferences;
1365
bval = remmina_protocol_widget_query_feature_by_type (REMMINA_PROTOCOL_WIDGET (cnnobj->proto),
1366
REMMINA_PROTOCOL_FEATURE_TYPE_PREF);
1367
gtk_widget_set_sensitive (GTK_WIDGET (toolitem), bval);
1369
toolitem = priv->toolitem_tools;
1370
bval = remmina_protocol_widget_query_feature_by_type (REMMINA_PROTOCOL_WIDGET (cnnobj->proto),
1371
REMMINA_PROTOCOL_FEATURE_TYPE_TOOL);
1372
gtk_widget_set_sensitive (GTK_WIDGET (toolitem), bval);
1374
gtk_window_set_title (GTK_WINDOW (cnnhld->cnnwin), remmina_file_get_string (cnnobj->remmina_file, "name"));
1376
if (priv->floating_toolbar)
1378
gtk_label_set_text (GTK_LABEL (priv->floating_toolbar_label),
1379
remmina_file_get_string (cnnobj->remmina_file, "name"));
1384
remmina_connection_holder_showhide_toolbar (RemminaConnectionHolder *cnnhld, gboolean resize)
1386
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1390
if (priv->view_mode == SCROLLED_WINDOW_MODE)
1393
(gdk_window_get_state (gtk_widget_get_window (GTK_WIDGET (cnnhld->cnnwin))) & GDK_WINDOW_STATE_MAXIMIZED) == 0)
1395
gtk_window_get_size (GTK_WINDOW (cnnhld->cnnwin), &width, &height);
1396
gtk_widget_size_request (priv->toolbar, &req);
1397
if (remmina_pref.hide_connection_toolbar)
1399
gtk_widget_hide (priv->toolbar);
1400
gtk_window_resize (GTK_WINDOW (cnnhld->cnnwin), width, height - req.height);
1404
gtk_window_resize (GTK_WINDOW (cnnhld->cnnwin), width, height + req.height);
1405
gtk_widget_show (priv->toolbar);
1410
if (remmina_pref.hide_connection_toolbar)
1412
gtk_widget_hide (priv->toolbar);
1416
gtk_widget_show (priv->toolbar);
1423
remmina_connection_holder_toolbar_enter (
1425
GdkEventCrossing *event,
1426
RemminaConnectionHolder *cnnhld)
1428
remmina_connection_holder_floating_toolbar_show (cnnhld, TRUE);
1433
remmina_connection_holder_toolbar_leave (
1435
GdkEventCrossing *event,
1436
RemminaConnectionHolder *cnnhld)
1438
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1440
if (!priv->sticky && event->mode == GDK_CROSSING_NORMAL)
1442
remmina_connection_holder_floating_toolbar_show (cnnhld, FALSE);
1449
remmina_connection_window_focus_in (GtkWidget *widget, GdkEventFocus *event, RemminaConnectionHolder *cnnhld)
1451
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1453
if (priv->floating_toolbar)
1455
remmina_connection_holder_floating_toolbar_visible (cnnhld, TRUE);
1461
remmina_connection_window_focus_out (GtkWidget *widget, GdkEventFocus *event, RemminaConnectionHolder *cnnhld)
1463
DECLARE_CNNOBJ_WITH_RETURN (FALSE)
1464
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1466
cnnhld->hostkey_activated = FALSE;
1467
if (!priv->sticky && priv->floating_toolbar)
1469
remmina_connection_holder_floating_toolbar_visible (cnnhld, FALSE);
1471
if (REMMINA_IS_SCROLLED_VIEWPORT (cnnobj->scrolled_container))
1473
remmina_scrolled_viewport_remove_motion (REMMINA_SCROLLED_VIEWPORT (cnnobj->scrolled_container));
1475
remmina_protocol_widget_call_feature_by_type (REMMINA_PROTOCOL_WIDGET (cnnobj->proto),
1476
REMMINA_PROTOCOL_FEATURE_TYPE_UNFOCUS, 0);
1481
remmina_connection_window_on_enter (
1483
GdkEventCrossing *event,
1484
RemminaConnectionHolder *cnnhld)
1486
if (event->detail == GDK_NOTIFY_VIRTUAL ||
1487
event->detail == GDK_NOTIFY_NONLINEAR ||
1488
event->detail == GDK_NOTIFY_NONLINEAR_VIRTUAL)
1490
remmina_connection_holder_keyboard_grab (cnnhld);
1496
remmina_connection_window_on_leave (
1498
GdkEventCrossing *event,
1499
RemminaConnectionHolder *cnnhld)
1501
if (event->detail == GDK_NOTIFY_VIRTUAL ||
1502
event->detail == GDK_NOTIFY_NONLINEAR ||
1503
event->detail == GDK_NOTIFY_NONLINEAR_VIRTUAL)
1505
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
1511
remmina_connection_holder_toolbar_scroll (GtkWidget *widget, GdkEventScroll *event, RemminaConnectionHolder *cnnhld)
1513
DECLARE_CNNOBJ_WITH_RETURN (FALSE)
1516
opacity = remmina_file_get_int (cnnobj->remmina_file, "toolbar_opacity", 0);
1517
switch (event->direction)
1522
remmina_file_set_int (cnnobj->remmina_file, "toolbar_opacity", opacity - 1);
1523
remmina_connection_holder_update_toolbar_opacity (cnnhld);
1527
case GDK_SCROLL_DOWN:
1528
if (opacity < TOOLBAR_OPACITY_LEVEL)
1530
remmina_file_set_int (cnnobj->remmina_file, "toolbar_opacity", opacity + 1);
1531
remmina_connection_holder_update_toolbar_opacity (cnnhld);
1542
remmina_connection_object_alignment_on_allocate (GtkWidget *widget, GtkAllocation *allocation, RemminaConnectionObject *cnnobj)
1544
remmina_connection_holder_update_alignment (cnnobj->cnnhld);
1548
remmina_connection_window_on_configure (GtkWidget *widget, GdkEventConfigure *event, RemminaConnectionHolder *cnnhld)
1550
DECLARE_CNNOBJ_WITH_RETURN (FALSE)
1551
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1556
if (cnnhld->cnnwin && gtk_widget_get_window (GTK_WIDGET (cnnhld->cnnwin)) &&
1557
cnnhld->cnnwin->priv->view_mode == SCROLLED_WINDOW_MODE)
1559
/* Here we store the window state in real-time */
1560
if ((gdk_window_get_state (gtk_widget_get_window (GTK_WIDGET (cnnhld->cnnwin))) & GDK_WINDOW_STATE_MAXIMIZED) == 0)
1562
gtk_window_get_size (GTK_WINDOW (cnnhld->cnnwin), &width, &height);
1563
remmina_file_set_int (cnnobj->remmina_file, "window_width", width);
1564
remmina_file_set_int (cnnobj->remmina_file, "window_height", height);
1565
remmina_file_set_int (cnnobj->remmina_file, "window_maximize", FALSE);
1569
remmina_file_set_int (cnnobj->remmina_file, "window_maximize", TRUE);
1573
if (priv->floating_toolbar)
1575
gtk_widget_size_request (priv->floating_toolbar, &req);
1576
gtk_window_get_position (GTK_WINDOW (priv->floating_toolbar), NULL, &y);
1577
gtk_window_move (GTK_WINDOW (priv->floating_toolbar),
1578
event->x + MAX (0, (event->width - req.width) / 2), y);
1580
remmina_connection_holder_floating_toolbar_update (cnnhld);
1583
if (cnnhld->cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE)
1585
/* Notify window of change so that scroll border can be hidden or shown if needed */
1586
remmina_connection_holder_check_resize (cnnobj->cnnhld);
1592
remmina_connection_holder_update_pin (RemminaConnectionHolder *cnnhld)
1594
if (cnnhld->cnnwin->priv->pin_down)
1596
gtk_button_set_image (GTK_BUTTON (cnnhld->cnnwin->priv->pin_button),
1597
gtk_image_new_from_icon_name ("remmina-pin-down", GTK_ICON_SIZE_MENU));
1601
gtk_button_set_image (GTK_BUTTON (cnnhld->cnnwin->priv->pin_button),
1602
gtk_image_new_from_icon_name ("remmina-pin-up", GTK_ICON_SIZE_MENU));
1607
remmina_connection_holder_toolbar_pin (GtkWidget *widget, RemminaConnectionHolder *cnnhld)
1609
cnnhld->cnnwin->priv->pin_down = !cnnhld->cnnwin->priv->pin_down;
1610
remmina_connection_holder_update_pin (cnnhld);
1614
remmina_connection_holder_create_floating_toolbar (RemminaConnectionHolder *cnnhld, gint mode)
1617
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1621
GtkWidget *eventbox;
1624
/* This has to be a popup window to become visible in fullscreen mode */
1625
window = gtk_window_new (GTK_WINDOW_POPUP);
1627
vbox = gtk_vbox_new (FALSE, 0);
1628
gtk_widget_show (vbox);
1629
gtk_container_add (GTK_CONTAINER (window), vbox);
1631
widget = remmina_connection_holder_create_toolbar (cnnhld, mode);
1632
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
1634
hbox = gtk_hbox_new (FALSE, 0);
1635
gtk_widget_show (hbox);
1636
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
1638
/* The pin button */
1639
widget = gtk_button_new ();
1640
gtk_widget_show (widget);
1641
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1642
gtk_button_set_relief (GTK_BUTTON (widget), GTK_RELIEF_NONE);
1643
gtk_button_set_focus_on_click (GTK_BUTTON (widget), FALSE);
1644
gtk_widget_set_name (widget, "remmina-small-button");
1645
g_signal_connect (G_OBJECT (widget), "clicked",
1646
G_CALLBACK (remmina_connection_holder_toolbar_pin), cnnhld);
1647
priv->pin_button = widget;
1648
priv->pin_down = remmina_pref.toolbar_pin_down;
1649
remmina_connection_holder_update_pin (cnnhld);
1651
/* An event box is required to wrap the label to avoid infinite "leave-enter" event loop */
1652
eventbox = gtk_event_box_new ();
1653
gtk_widget_show (eventbox);
1654
gtk_box_pack_start (GTK_BOX (hbox), eventbox, TRUE, TRUE, 0);
1655
widget = gtk_label_new (remmina_file_get_string (cnnobj->remmina_file, "name"));
1656
gtk_label_set_max_width_chars (GTK_LABEL (widget), 50);
1657
gtk_widget_show (widget);
1658
gtk_container_add (GTK_CONTAINER (eventbox), widget);
1659
priv->floating_toolbar_label = widget;
1661
/* The position will be moved in configure event instead during maximizing. Just make it invisible here */
1662
gtk_window_move (GTK_WINDOW (window), 0, -200);
1663
gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE);
1665
priv->floating_toolbar = window;
1667
remmina_connection_holder_update_toolbar_opacity (cnnhld);
1668
if (remmina_pref.invisible_toolbar && !priv->pin_down)
1670
gtk_window_set_opacity (GTK_WINDOW (window), 0.0);
1673
g_signal_connect (G_OBJECT (window), "enter-notify-event",
1674
G_CALLBACK (remmina_connection_holder_toolbar_enter), cnnhld);
1675
g_signal_connect (G_OBJECT (window), "leave-notify-event",
1676
G_CALLBACK (remmina_connection_holder_toolbar_leave), cnnhld);
1677
g_signal_connect (G_OBJECT (window), "scroll-event",
1678
G_CALLBACK (remmina_connection_holder_toolbar_scroll), cnnhld);
1680
if (cnnobj->connected) gtk_widget_show (window);
1684
remmina_connection_window_init (RemminaConnectionWindow *cnnwin)
1686
RemminaConnectionWindowPriv *priv;
1688
priv = g_new0 (RemminaConnectionWindowPriv, 1);
1689
cnnwin->priv = priv;
1691
priv->view_mode = AUTO_MODE;
1692
priv->floating_toolbar_opacity = 1.0;
1694
gtk_window_set_position (GTK_WINDOW (cnnwin), GTK_WIN_POS_CENTER);
1695
gtk_container_set_border_width (GTK_CONTAINER (cnnwin), 0);
1697
remmina_widget_pool_register (GTK_WIDGET (cnnwin));
1701
remmina_connection_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer user_data)
1705
screen = gdk_screen_get_default ();
1706
if (remmina_pref.minimize_to_tray &&
1707
(event->changed_mask & GDK_WINDOW_STATE_ICONIFIED) != 0 &&
1708
(event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) != 0 &&
1709
remmina_public_get_current_workspace (screen) ==
1710
remmina_public_get_window_workspace (GTK_WINDOW (widget)) &&
1711
gdk_screen_get_number (screen) ==
1712
gdk_screen_get_number (gtk_widget_get_screen (widget))
1715
gtk_widget_hide (widget);
1722
remmina_connection_window_new_from_holder (RemminaConnectionHolder *cnnhld)
1724
RemminaConnectionWindow *cnnwin;
1726
cnnwin = REMMINA_CONNECTION_WINDOW (g_object_new (REMMINA_TYPE_CONNECTION_WINDOW, NULL));
1727
cnnwin->priv->cnnhld = cnnhld;
1729
g_signal_connect (G_OBJECT (cnnwin), "delete-event",
1730
G_CALLBACK (remmina_connection_window_delete_event), cnnhld);
1731
g_signal_connect (G_OBJECT (cnnwin), "destroy",
1732
G_CALLBACK (remmina_connection_window_destroy), cnnhld);
1733
g_signal_connect (G_OBJECT (cnnwin), "window-state-event",
1734
G_CALLBACK (remmina_connection_window_state_event), cnnhld);
1736
g_signal_connect (G_OBJECT (cnnwin), "focus-in-event",
1737
G_CALLBACK (remmina_connection_window_focus_in), cnnhld);
1738
g_signal_connect (G_OBJECT (cnnwin), "focus-out-event",
1739
G_CALLBACK (remmina_connection_window_focus_out), cnnhld);
1741
g_signal_connect (G_OBJECT (cnnwin), "enter-notify-event",
1742
G_CALLBACK (remmina_connection_window_on_enter), cnnhld);
1743
g_signal_connect (G_OBJECT (cnnwin), "leave-notify-event",
1744
G_CALLBACK (remmina_connection_window_on_leave), cnnhld);
1746
g_signal_connect (G_OBJECT (cnnwin), "configure_event",
1747
G_CALLBACK (remmina_connection_window_on_configure), cnnhld);
1749
return GTK_WIDGET (cnnwin);
1752
/* This function will be called for the first connection. A tag is set to the window so that
1753
* other connections can determine if whether a new tab should be append to the same window
1756
remmina_connection_window_update_tag (RemminaConnectionWindow *cnnwin, RemminaConnectionObject *cnnobj)
1760
switch (remmina_pref.tab_mode)
1762
case REMMINA_TAB_BY_GROUP:
1763
tag = g_strdup (remmina_file_get_string (cnnobj->remmina_file, "group"));
1765
case REMMINA_TAB_BY_PROTOCOL:
1766
tag = g_strdup (remmina_file_get_string (cnnobj->remmina_file, "protocol"));
1772
g_object_set_data_full (G_OBJECT (cnnwin), "tag", tag, (GDestroyNotify) g_free);
1776
remmina_connection_object_create_scrolled_container (RemminaConnectionObject *cnnobj, gint view_mode)
1778
GtkWidget *container;
1780
if (view_mode == VIEWPORT_FULLSCREEN_MODE)
1782
container = remmina_scrolled_viewport_new ();
1786
container = gtk_scrolled_window_new (NULL, NULL);
1787
remmina_connection_object_set_scrolled_policy (cnnobj, GTK_SCROLLED_WINDOW (container));
1788
gtk_container_set_border_width (GTK_CONTAINER (container), 0);
1789
GTK_WIDGET_UNSET_FLAGS (container, GTK_CAN_FOCUS);
1791
g_object_set_data (G_OBJECT (container), "cnnobj", cnnobj);
1792
gtk_widget_show (container);
1793
cnnobj->scrolled_container = container;
1797
remmina_connection_holder_grab_focus (gpointer data)
1799
RemminaConnectionObject *cnnobj;
1800
GtkNotebook *notebook;
1803
if (GTK_IS_WIDGET (data))
1805
notebook = GTK_NOTEBOOK (data);
1806
child = gtk_notebook_get_nth_page (notebook, gtk_notebook_get_current_page (notebook));
1807
cnnobj = g_object_get_data (G_OBJECT (child), "cnnobj");
1808
if (GTK_IS_WIDGET (cnnobj->proto))
1810
remmina_protocol_widget_grab_focus (REMMINA_PROTOCOL_WIDGET (cnnobj->proto));
1817
remmina_connection_object_on_close_button_clicked (GtkButton *button, RemminaConnectionObject *cnnobj)
1819
if (REMMINA_IS_PROTOCOL_WIDGET (cnnobj->proto))
1821
remmina_protocol_widget_close_connection (REMMINA_PROTOCOL_WIDGET (cnnobj->proto));
1826
remmina_connection_object_create_tab (RemminaConnectionObject *cnnobj)
1832
hbox = gtk_hbox_new (FALSE, 4);
1833
gtk_widget_show (hbox);
1835
widget = gtk_image_new_from_icon_name (remmina_file_get_icon_name (cnnobj->remmina_file), GTK_ICON_SIZE_MENU);
1836
gtk_widget_show (widget);
1837
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
1839
widget = gtk_label_new (remmina_file_get_string (cnnobj->remmina_file, "name"));
1840
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
1841
gtk_widget_show (widget);
1842
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
1844
button = gtk_button_new ();
1845
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
1846
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
1847
gtk_widget_set_name (button, "remmina-small-button");
1848
gtk_widget_show (button);
1850
widget = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
1851
gtk_widget_show (widget);
1852
gtk_container_add (GTK_CONTAINER (button), widget);
1854
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
1856
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (remmina_connection_object_on_close_button_clicked), cnnobj);
1862
remmina_connection_object_append_page (RemminaConnectionObject *cnnobj, GtkNotebook *notebook, GtkWidget *tab, gint view_mode)
1866
remmina_connection_object_create_scrolled_container (cnnobj, view_mode);
1867
i = gtk_notebook_append_page (notebook, cnnobj->scrolled_container, tab);
1868
gtk_notebook_set_tab_reorderable (notebook, cnnobj->scrolled_container, TRUE);
1869
gtk_notebook_set_tab_detachable (notebook, cnnobj->scrolled_container, TRUE);
1870
/* This trick prevents the tab label from being focused */
1871
GTK_WIDGET_UNSET_FLAGS (gtk_widget_get_parent (tab), GTK_CAN_FOCUS);
1876
remmina_connection_window_initialize_notebook (GtkNotebook *to, GtkNotebook *from, RemminaConnectionObject *cnnobj, gint view_mode)
1884
/* Initial connection for a newly created window */
1885
tab = remmina_connection_object_create_tab (cnnobj);
1886
remmina_connection_object_append_page (cnnobj, to, tab, view_mode);
1888
gtk_widget_reparent (cnnobj->viewport, cnnobj->scrolled_container);
1892
gtk_widget_destroy (cnnobj->window);
1893
cnnobj->window = NULL;
1898
/* View mode changed. Migrate all existing connections to the new notebook */
1899
c = gtk_notebook_get_current_page (from);
1900
n = gtk_notebook_get_n_pages (from);
1901
for (i = 0; i < n; i++)
1903
widget = gtk_notebook_get_nth_page (from, i);
1904
cnnobj = (RemminaConnectionObject*) g_object_get_data (G_OBJECT (widget), "cnnobj");
1906
tab = remmina_connection_object_create_tab (cnnobj);
1907
remmina_connection_object_append_page (cnnobj, to, tab, view_mode);
1909
gtk_widget_reparent (cnnobj->viewport, cnnobj->scrolled_container);
1911
gtk_notebook_set_current_page (to, c);
1916
remmina_connection_holder_update_notebook (RemminaConnectionHolder *cnnhld)
1918
GtkNotebook *notebook;
1921
if (!cnnhld->cnnwin) return;
1923
notebook = GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook);
1925
switch (cnnhld->cnnwin->priv->view_mode)
1927
case SCROLLED_WINDOW_MODE:
1928
n = gtk_notebook_get_n_pages (notebook);
1929
gtk_notebook_set_show_tabs (notebook, remmina_pref.always_show_tab ? TRUE : n > 1);
1930
gtk_notebook_set_show_border (notebook, remmina_pref.always_show_tab ? TRUE : n > 1);
1933
gtk_notebook_set_show_tabs (notebook, FALSE);
1934
gtk_notebook_set_show_border (notebook, FALSE);
1940
remmina_connection_holder_on_switch_page_real (gpointer data)
1942
RemminaConnectionHolder *cnnhld = (RemminaConnectionHolder*) data;
1943
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1945
if (GTK_IS_WIDGET (cnnhld->cnnwin))
1947
remmina_connection_holder_update_toolbar (cnnhld);
1948
remmina_connection_holder_grab_focus (priv->notebook);
1949
if (cnnhld->cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE)
1951
remmina_connection_holder_check_resize (cnnhld);
1954
priv->switch_page_handler = 0;
1959
remmina_connection_holder_on_switch_page (GtkNotebook *notebook, GtkNotebookPage *page, guint page_num, RemminaConnectionHolder *cnnhld)
1961
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
1963
if (!priv->switch_page_handler)
1965
priv->switch_page_handler = g_idle_add (remmina_connection_holder_on_switch_page_real, cnnhld);
1970
remmina_connection_holder_on_page_added (GtkNotebook *notebook, GtkWidget *child, guint page_num, RemminaConnectionHolder *cnnhld)
1972
if (gtk_notebook_get_n_pages (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook)) <= 0)
1974
gtk_widget_destroy (GTK_WIDGET (cnnhld->cnnwin));
1979
remmina_connection_holder_update_notebook (cnnhld);
1984
remmina_connection_holder_create_notebook_func (GtkNotebook *source, GtkWidget *page, gint x, gint y, gpointer data)
1986
RemminaConnectionWindow *srccnnwin;
1987
RemminaConnectionWindow *dstcnnwin;
1988
RemminaConnectionObject *cnnobj;
1992
srccnnwin = REMMINA_CONNECTION_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (source)));
1993
window = gdk_display_get_window_at_pointer (gdk_display_get_default (), &x, &y);
1994
dstcnnwin = REMMINA_CONNECTION_WINDOW (remmina_widget_pool_find_by_window (REMMINA_TYPE_CONNECTION_WINDOW, window));
1996
if (srccnnwin == dstcnnwin) return NULL;
1998
if (gtk_notebook_get_n_pages (GTK_NOTEBOOK (srccnnwin->priv->notebook)) == 1 && !dstcnnwin) return NULL;
2000
cnnobj = (RemminaConnectionObject*) g_object_get_data (G_OBJECT (page), "cnnobj");
2001
srcpagenum = gtk_notebook_page_num (GTK_NOTEBOOK (srccnnwin->priv->notebook), cnnobj->scrolled_container);
2005
cnnobj->cnnhld = dstcnnwin->priv->cnnhld;
2009
cnnobj->cnnhld = g_new0 (RemminaConnectionHolder, 1);
2012
g_signal_emit_by_name (cnnobj->proto, "connect", cnnobj);
2013
gtk_notebook_remove_page (GTK_NOTEBOOK (srccnnwin->priv->notebook), srcpagenum);
2019
remmina_connection_holder_create_notebook (RemminaConnectionHolder *cnnhld)
2021
GtkWidget *notebook;
2023
gtk_notebook_set_window_creation_hook (remmina_connection_holder_create_notebook_func, NULL, NULL);
2025
notebook = gtk_notebook_new ();
2026
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
2027
gtk_widget_show (notebook);
2028
g_signal_connect (G_OBJECT (notebook), "switch-page",
2029
G_CALLBACK (remmina_connection_holder_on_switch_page), cnnhld);
2030
g_signal_connect (G_OBJECT (notebook), "page-added",
2031
G_CALLBACK (remmina_connection_holder_on_page_added), cnnhld);
2032
g_signal_connect (G_OBJECT (notebook), "page-removed",
2033
G_CALLBACK (remmina_connection_holder_on_page_added), cnnhld);
2034
GTK_WIDGET_UNSET_FLAGS (notebook, GTK_CAN_FOCUS);
2039
/* Create a scrolled window container */
2041
remmina_connection_holder_create_scrolled (RemminaConnectionHolder *cnnhld, RemminaConnectionObject *cnnobj)
2044
GtkWidget *oldwindow;
2047
GtkWidget *notebook;
2050
oldwindow = GTK_WIDGET (cnnhld->cnnwin);
2051
window = remmina_connection_window_new_from_holder (cnnhld);
2052
gtk_widget_realize (window);
2053
cnnhld->cnnwin = REMMINA_CONNECTION_WINDOW (window);
2055
/* Create the vbox container */
2056
vbox = gtk_vbox_new (FALSE, 0);
2057
gtk_widget_show (vbox);
2058
gtk_container_add (GTK_CONTAINER (window), vbox);
2060
/* Create the toolbar */
2061
toolbar = remmina_connection_holder_create_toolbar (cnnhld, SCROLLED_WINDOW_MODE);
2062
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
2064
/* Create the notebook */
2065
notebook = remmina_connection_holder_create_notebook (cnnhld);
2066
gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
2067
gtk_container_set_focus_chain (GTK_CONTAINER (vbox), g_list_append (NULL, notebook));
2069
cnnhld->cnnwin->priv->view_mode = SCROLLED_WINDOW_MODE;
2070
cnnhld->cnnwin->priv->toolbar = toolbar;
2071
cnnhld->cnnwin->priv->notebook = notebook;
2073
remmina_connection_window_initialize_notebook (GTK_NOTEBOOK (notebook),
2074
(oldwindow ? GTK_NOTEBOOK (REMMINA_CONNECTION_WINDOW (oldwindow)->priv->notebook) : NULL), cnnobj,
2075
SCROLLED_WINDOW_MODE);
2079
remmina_connection_window_update_tag (cnnhld->cnnwin, cnnobj);
2080
if (remmina_file_get_int (cnnobj->remmina_file, "window_maximize", FALSE))
2082
gtk_window_maximize (GTK_WINDOW (cnnhld->cnnwin));
2088
tag = g_strdup ((gchar*) g_object_get_data (G_OBJECT (oldwindow), "tag"));
2089
g_object_set_data_full (G_OBJECT (cnnhld->cnnwin), "tag", tag, (GDestroyNotify) g_free);
2090
gtk_widget_destroy (oldwindow);
2093
remmina_connection_holder_update_toolbar (cnnhld);
2094
remmina_connection_holder_showhide_toolbar (cnnhld, FALSE);
2095
remmina_connection_holder_check_resize (cnnhld);
2097
gtk_widget_show (GTK_WIDGET (cnnhld->cnnwin));
2101
remmina_connection_holder_create_fullscreen (RemminaConnectionHolder *cnnhld, RemminaConnectionObject *cnnobj, gint view_mode)
2104
GtkWidget *oldwindow;
2105
GtkWidget *notebook;
2109
oldwindow = GTK_WIDGET (cnnhld->cnnwin);
2110
window = remmina_connection_window_new_from_holder (cnnhld);
2111
gtk_widget_realize (window);
2112
cnnhld->cnnwin = REMMINA_CONNECTION_WINDOW (window);
2114
if (!view_mode) view_mode = VIEWPORT_FULLSCREEN_MODE;
2116
if (view_mode == VIEWPORT_FULLSCREEN_MODE)
2118
gdk_color_parse ("black", &color);
2119
gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &color);
2122
notebook = remmina_connection_holder_create_notebook (cnnhld);
2123
gtk_container_add (GTK_CONTAINER (window), notebook);
2125
cnnhld->cnnwin->priv->notebook = notebook;
2126
cnnhld->cnnwin->priv->view_mode = view_mode;
2127
cnnhld->fullscreen_view_mode = view_mode;
2129
remmina_connection_window_initialize_notebook (GTK_NOTEBOOK (notebook),
2130
(oldwindow ? GTK_NOTEBOOK (REMMINA_CONNECTION_WINDOW (oldwindow)->priv->notebook) : NULL), cnnobj,
2135
remmina_connection_window_update_tag (cnnhld->cnnwin, cnnobj);
2139
tag = g_strdup ((gchar*) g_object_get_data (G_OBJECT (oldwindow), "tag"));
2140
g_object_set_data_full (G_OBJECT (cnnhld->cnnwin), "tag", tag, (GDestroyNotify) g_free);
2141
gtk_widget_destroy (oldwindow);
2144
/* Create the floating toolbar */
2145
remmina_connection_holder_create_floating_toolbar (cnnhld, view_mode);
2146
remmina_connection_holder_update_toolbar (cnnhld);
2148
gtk_window_fullscreen (GTK_WINDOW (window));
2149
remmina_connection_holder_check_resize (cnnhld);
2151
gtk_widget_show (window);
2155
remmina_connection_window_hostkey_func (RemminaProtocolWidget *gp, guint keyval, gboolean release, RemminaConnectionHolder *cnnhld)
2157
RemminaConnectionWindowPriv *priv = cnnhld->cnnwin->priv;
2162
if (remmina_pref.hostkey && keyval == remmina_pref.hostkey)
2164
cnnhld->hostkey_activated = FALSE;
2165
if (cnnhld->hostkey_used)
2169
/* If hostkey is released without pressing other keys, we should execute the
2170
* shortcut key which is the same as hostkey. Be default, this is grab/ungrab
2173
else if (cnnhld->hostkey_activated)
2175
/* Trap all key releases when hostkey is pressed */
2183
else if (remmina_pref.hostkey && keyval == remmina_pref.hostkey)
2185
cnnhld->hostkey_activated = TRUE;
2186
cnnhld->hostkey_used = FALSE;
2189
else if (!cnnhld->hostkey_activated)
2194
cnnhld->hostkey_used = TRUE;
2195
keyval = gdk_keyval_to_lower (keyval);
2196
if (keyval == remmina_pref.shortcutkey_fullscreen)
2198
switch (priv->view_mode)
2200
case SCROLLED_WINDOW_MODE:
2201
remmina_connection_holder_create_fullscreen (cnnhld, NULL,
2202
cnnhld->fullscreen_view_mode ? cnnhld->fullscreen_view_mode : VIEWPORT_FULLSCREEN_MODE);
2204
case SCROLLED_FULLSCREEN_MODE:
2205
case VIEWPORT_FULLSCREEN_MODE:
2206
remmina_connection_holder_create_scrolled (cnnhld, NULL);
2212
else if (keyval == remmina_pref.shortcutkey_autofit)
2214
if (priv->toolitem_autofit && GTK_WIDGET_IS_SENSITIVE (priv->toolitem_autofit))
2216
remmina_connection_holder_toolbar_autofit (GTK_WIDGET (gp), cnnhld);
2219
else if (keyval == remmina_pref.shortcutkey_nexttab)
2221
i = gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->notebook)) + 1;
2222
if (i >= gtk_notebook_get_n_pages (GTK_NOTEBOOK (priv->notebook))) i = 0;
2223
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), i);
2225
else if (keyval == remmina_pref.shortcutkey_prevtab)
2227
i = gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->notebook)) - 1;
2228
if (i < 0) i = gtk_notebook_get_n_pages (GTK_NOTEBOOK (priv->notebook)) - 1;
2229
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), i);
2231
else if (keyval == remmina_pref.shortcutkey_scale)
2233
if (GTK_WIDGET_IS_SENSITIVE (priv->toolitem_scale))
2235
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (priv->toolitem_scale),
2236
!gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (priv->toolitem_scale)));
2239
else if (keyval == remmina_pref.shortcutkey_grab)
2241
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (priv->toolitem_grab),
2242
!gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (priv->toolitem_grab)));
2244
else if (keyval == remmina_pref.shortcutkey_minimize)
2246
remmina_connection_holder_toolbar_minimize (GTK_WIDGET (gp), cnnhld);
2248
else if (keyval == remmina_pref.shortcutkey_disconnect)
2250
remmina_connection_holder_disconnect (cnnhld);
2252
else if (keyval == remmina_pref.shortcutkey_toolbar)
2254
if (priv->view_mode == SCROLLED_WINDOW_MODE)
2256
remmina_pref.hide_connection_toolbar = !remmina_pref.hide_connection_toolbar;
2257
remmina_connection_holder_showhide_toolbar (cnnhld, TRUE);
2260
/* Trap all key presses when hostkey is pressed */
2264
static RemminaConnectionWindow*
2265
remmina_connection_window_find (RemminaFile *remminafile)
2269
switch (remmina_pref.tab_mode)
2271
case REMMINA_TAB_BY_GROUP:
2272
tag = remmina_file_get_string (remminafile, "group");
2274
case REMMINA_TAB_BY_PROTOCOL:
2275
tag = remmina_file_get_string (remminafile, "protocol");
2277
case REMMINA_TAB_ALL:
2280
case REMMINA_TAB_NONE:
2284
return REMMINA_CONNECTION_WINDOW (remmina_widget_pool_find (REMMINA_TYPE_CONNECTION_WINDOW, tag));
2288
remmina_connection_object_on_connect (RemminaProtocolWidget *gp, RemminaConnectionObject *cnnobj)
2290
RemminaConnectionWindow *cnnwin;
2291
RemminaConnectionHolder *cnnhld;
2295
cnnwin = remmina_connection_window_find (cnnobj->remmina_file);
2299
cnnhld = cnnwin->priv->cnnhld;
2303
cnnhld = g_new0 (RemminaConnectionHolder, 1);
2306
cnnobj->cnnhld = cnnhld;
2308
cnnobj->connected = TRUE;
2310
remmina_protocol_widget_set_hostkey_func (REMMINA_PROTOCOL_WIDGET (cnnobj->proto),
2311
(RemminaHostkeyFunc) remmina_connection_window_hostkey_func, cnnhld);
2313
/* Remember recent list for quick connect */
2314
if (remmina_file_get_filename (cnnobj->remmina_file) == NULL)
2316
remmina_pref_add_recent (remmina_file_get_string (cnnobj->remmina_file, "protocol"),
2317
remmina_file_get_string (cnnobj->remmina_file, "server"));
2320
if (!cnnhld->cnnwin)
2322
i = remmina_file_get_int (cnnobj->remmina_file, "viewmode", 0);
2325
case SCROLLED_FULLSCREEN_MODE:
2326
case VIEWPORT_FULLSCREEN_MODE:
2327
remmina_connection_holder_create_fullscreen (cnnhld, cnnobj, i);
2330
case SCROLLED_WINDOW_MODE:
2332
remmina_connection_holder_create_scrolled (cnnhld, cnnobj);
2338
tab = remmina_connection_object_create_tab (cnnobj);
2339
i = remmina_connection_object_append_page (cnnobj,
2340
GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook), tab, cnnhld->cnnwin->priv->view_mode);
2341
gtk_widget_reparent (cnnobj->viewport, cnnobj->scrolled_container);
2342
gtk_window_present (GTK_WINDOW (cnnhld->cnnwin));
2343
gtk_notebook_set_current_page (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook), i);
2345
remmina_connection_object_init_adjustment (cnnobj);
2347
if (cnnhld->cnnwin->priv->floating_toolbar)
2349
gtk_widget_show (cnnhld->cnnwin->priv->floating_toolbar);
2354
remmina_connection_object_on_disconnect (RemminaProtocolWidget *gp, RemminaConnectionObject *cnnobj)
2356
RemminaConnectionHolder *cnnhld = cnnobj->cnnhld;
2359
cnnobj->connected = FALSE;
2360
if (scale_option_window)
2362
gtk_widget_destroy (scale_option_window);
2363
scale_option_window = NULL;
2366
if (cnnhld && remmina_pref.save_view_mode)
2370
remmina_file_set_int (cnnobj->remmina_file, "viewmode", cnnhld->cnnwin->priv->view_mode);
2372
if (remmina_pref.save_when_connect)
2374
remmina_file_save_all (cnnobj->remmina_file);
2378
remmina_file_save_group (cnnobj->remmina_file, REMMINA_SETTING_GROUP_RUNTIME);
2380
if (cnnhld->cnnwin && remmina_pref.toolbar_pin_down != cnnhld->cnnwin->priv->pin_down)
2382
remmina_pref.toolbar_pin_down = cnnhld->cnnwin->priv->pin_down;
2383
remmina_pref_save ();
2386
remmina_file_free (cnnobj->remmina_file);
2388
if (remmina_protocol_widget_has_error (gp))
2390
dialog = gtk_message_dialog_new (NULL,
2391
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
2392
remmina_protocol_widget_get_error_message (gp), NULL);
2393
g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL);
2394
gtk_widget_show (dialog);
2395
remmina_widget_pool_register (dialog);
2400
gtk_widget_destroy (cnnobj->window);
2401
cnnobj->window = NULL;
2404
if (cnnhld && cnnhld->cnnwin && cnnobj->scrolled_container)
2406
gtk_notebook_remove_page (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook),
2407
gtk_notebook_page_num (GTK_NOTEBOOK (cnnhld->cnnwin->priv->notebook), cnnobj->scrolled_container));
2413
remmina_connection_object_on_desktop_resize (RemminaProtocolWidget *gp, RemminaConnectionObject *cnnobj)
2415
if (cnnobj->cnnhld &&
2416
cnnobj->cnnhld->cnnwin &&
2417
cnnobj->cnnhld->cnnwin->priv->view_mode != SCROLLED_WINDOW_MODE)
2419
remmina_connection_holder_check_resize (cnnobj->cnnhld);
2424
remmina_connection_window_open_from_filename (const gchar *filename)
2426
RemminaFile *remminafile;
2429
remminafile = remmina_file_manager_load_file (filename);
2432
remmina_connection_window_open_from_file (remminafile);
2437
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
2438
_("File %s not found."), filename);
2439
g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL);
2440
gtk_widget_show (dialog);
2441
remmina_widget_pool_register (dialog);
2447
remmina_connection_window_open_from_file (RemminaFile *remminafile)
2449
remmina_connection_window_open_from_file_full (remminafile, NULL, NULL, NULL);
2453
remmina_connection_window_open_from_file_full (RemminaFile *remminafile,
2454
GCallback disconnect_cb, gpointer data, guint *handler)
2456
RemminaConnectionObject *cnnobj;
2459
remmina_file_update_screen_resolution (remminafile);
2461
cnnobj = g_new0 (RemminaConnectionObject, 1);
2462
cnnobj->remmina_file = remminafile;
2464
/* Create the RemminaProtocolWidget */
2465
cnnobj->proto = remmina_protocol_widget_new ();
2469
g_object_set_data (G_OBJECT (cnnobj->proto), "user-data", data);
2472
gtk_widget_show (cnnobj->proto);
2473
g_signal_connect (G_OBJECT (cnnobj->proto), "connect",
2474
G_CALLBACK (remmina_connection_object_on_connect), cnnobj);
2477
*handler = g_signal_connect (G_OBJECT (cnnobj->proto), "disconnect",
2478
disconnect_cb, data);
2480
g_signal_connect (G_OBJECT (cnnobj->proto), "disconnect",
2481
G_CALLBACK (remmina_connection_object_on_disconnect), cnnobj);
2482
g_signal_connect (G_OBJECT (cnnobj->proto), "desktop-resize",
2483
G_CALLBACK (remmina_connection_object_on_desktop_resize), cnnobj);
2485
/* Create the alignment to make the RemminaProtocolWidget centered */
2486
cnnobj->alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
2487
gtk_widget_show (cnnobj->alignment);
2488
gtk_container_set_border_width (GTK_CONTAINER (cnnobj->alignment), 0);
2489
gtk_container_add (GTK_CONTAINER (cnnobj->alignment), cnnobj->proto);
2490
g_signal_connect (G_OBJECT (cnnobj->alignment), "size-allocate",
2491
G_CALLBACK (remmina_connection_object_alignment_on_allocate), cnnobj);
2493
/* Create the viewport to make the RemminaProtocolWidget scrollable */
2494
cnnobj->viewport = gtk_viewport_new (NULL, NULL);
2495
gtk_widget_show (cnnobj->viewport);
2496
gdk_color_parse ("black", &color);
2497
gtk_widget_modify_bg (cnnobj->viewport, GTK_STATE_NORMAL, &color);
2498
gtk_container_set_border_width (GTK_CONTAINER (cnnobj->viewport), 0);
2499
gtk_viewport_set_shadow_type (GTK_VIEWPORT (cnnobj->viewport), GTK_SHADOW_NONE);
2500
gtk_container_add (GTK_CONTAINER (cnnobj->viewport), cnnobj->alignment);
2502
cnnobj->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2503
gtk_widget_realize (cnnobj->window);
2504
gtk_container_add (GTK_CONTAINER (cnnobj->window), cnnobj->viewport);
2506
if (!remmina_pref.save_view_mode) remmina_file_set_int (cnnobj->remmina_file, "viewmode", remmina_pref.default_mode);
2508
remmina_protocol_widget_open_connection (REMMINA_PROTOCOL_WIDGET (cnnobj->proto), remminafile);
2510
return cnnobj->proto;
added
removed
src/remminaconnectionwindow.c
