blob: 8350a42fd82704704301687946704e7416513e32 [file] [log] [blame]
Pierre Ossman5156d5e2011-03-09 09:42:34 +00001/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
2 * Copyright 2011 Pierre Ossman <ossman@cendio.se> for Cendio AB
3 *
4 * This is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this software; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17 * USA.
18 */
19
20#include <assert.h>
21#include <stdio.h>
22#include <string.h>
23
Pierre Ossman4ae229f2011-04-15 12:58:31 +000024#include <FL/Fl_Scroll.H>
Pierre Ossman407a5c32011-05-26 14:48:29 +000025#include <FL/x.H>
Pierre Ossman4ae229f2011-04-15 12:58:31 +000026
Pierre Ossman5156d5e2011-03-09 09:42:34 +000027#include <rfb/LogWriter.h>
28
29#include "DesktopWindow.h"
Pierre Ossman407a5c32011-05-26 14:48:29 +000030#include "OptionsDialog.h"
Pierre Ossman5156d5e2011-03-09 09:42:34 +000031#include "i18n.h"
Pierre Ossman407a5c32011-05-26 14:48:29 +000032#include "parameters.h"
33
34#ifdef WIN32
35#include "win32.h"
36#endif
37
38#ifdef __APPLE__
39#include "cocoa.h"
40#endif
Pierre Ossman89f868a2011-04-11 11:59:31 +000041
Pierre Ossman5156d5e2011-03-09 09:42:34 +000042using namespace rfb;
43
44extern void exit_vncviewer();
45
46static rfb::LogWriter vlog("DesktopWindow");
47
48DesktopWindow::DesktopWindow(int w, int h, const char *name,
49 const rfb::PixelFormat& serverPF,
50 CConn* cc_)
Pierre Ossmand50b3d12011-04-15 07:46:56 +000051 : Fl_Window(w, h)
Pierre Ossman5156d5e2011-03-09 09:42:34 +000052{
Pierre Ossman4ae229f2011-04-15 12:58:31 +000053 // Allow resize
Pierre Ossman343e2e02011-04-15 13:00:12 +000054 size_range(100, 100, w, h);
Pierre Ossman4ae229f2011-04-15 12:58:31 +000055
56 Fl_Scroll *scroll = new Fl_Scroll(0, 0, w, h);
57 scroll->color(FL_BLACK);
58
59 // Automatically adjust the scroll box to the window
60 resizable(scroll);
61
Pierre Ossmand50b3d12011-04-15 07:46:56 +000062 viewport = new Viewport(w, h, serverPF, cc_);
63
Pierre Ossman4ae229f2011-04-15 12:58:31 +000064 scroll->end();
65
Pierre Ossman5156d5e2011-03-09 09:42:34 +000066 callback(handleClose, this);
67
68 setName(name);
69
Pierre Ossman407a5c32011-05-26 14:48:29 +000070 OptionsDialog::addCallback(handleOptions, this);
71
Pierre Ossman63ca58e2011-05-26 14:59:32 +000072#ifdef HAVE_FLTK_FULLSCREEN
73 if (fullScreen)
74 fullscreen();
75#endif
76
Pierre Ossman5156d5e2011-03-09 09:42:34 +000077 show();
Pierre Ossman3f6c4d02011-04-15 14:09:09 +000078
79 // The window manager might give us an initial window size that is different
80 // than the one we requested, and in those cases we need to manually adjust
81 // the scroll widget for things to behave sanely.
82 if ((w != this->w()) || (h != this->h()))
83 scroll->size(this->w(), this->h());
Pierre Ossman5156d5e2011-03-09 09:42:34 +000084}
85
86
87DesktopWindow::~DesktopWindow()
88{
Pierre Ossman407a5c32011-05-26 14:48:29 +000089 // Unregister all timeouts in case they get a change tro trigger
90 // again later when this object is already gone.
91 Fl::remove_timeout(handleGrab, this);
92
93 OptionsDialog::removeCallback(handleOptions);
94
Pierre Ossmand50b3d12011-04-15 07:46:56 +000095 // FLTK automatically deletes all child widgets, so we shouldn't touch
96 // them ourselves here
Pierre Ossman5156d5e2011-03-09 09:42:34 +000097}
98
99
100void DesktopWindow::setServerPF(const rfb::PixelFormat& pf)
101{
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000102 viewport->setServerPF(pf);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000103}
104
105
106const rfb::PixelFormat &DesktopWindow::getPreferredPF()
107{
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000108 return viewport->getPreferredPF();
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000109}
110
111
112// Cursor stuff
113
114void DesktopWindow::setCursor(int width, int height, const Point& hotspot,
115 void* data, void* mask)
116{
117}
118
119
120void DesktopWindow::setName(const char *name)
121{
122 CharArray windowNameStr;
123 windowNameStr.replaceBuf(new char[256]);
124
125 snprintf(windowNameStr.buf, 256, _("TigerVNC: %.240s"), name);
126
127 copy_label(windowNameStr.buf);
128}
129
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000130
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000131void DesktopWindow::setColourMapEntries(int firstColour, int nColours,
132 rdr::U16* rgbs)
133{
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000134 viewport->setColourMapEntries(firstColour, nColours, rgbs);
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000135}
136
137
138// Copy the areas of the framebuffer that have been changed (damaged)
139// to the displayed window.
140
141void DesktopWindow::updateWindow()
142{
Pierre Ossmand50b3d12011-04-15 07:46:56 +0000143 viewport->updateWindow();
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000144}
145
146
Pierre Ossman6455d852011-06-01 09:33:00 +0000147void DesktopWindow::resizeFramebuffer(int new_w, int new_h)
148{
149 if ((new_w == viewport->w()) && (new_h == viewport->h()))
150 return;
151
152 // Turn off size limitations for a bit while we juggle things around
153 size_range(100, 100, 0, 0);
154
155 // If we're letting the viewport match the window perfectly, then
156 // keep things that way for the new size, otherwise just keep things
157 // like they are.
158 if ((w() == viewport->w()) && (h() == viewport->h()))
159 size(new_w, new_h);
160 else {
161#ifdef HAVE_FLTK_FULLSCREEN
162 if (!fullscreen_active()) {
163#endif
164 // Make sure the window isn't too big
165 if ((w() > new_w) || (h() > new_h))
166 size(__rfbmin(w(), new_w), __rfbmin(h(), new_h));
167#ifdef HAVE_FLTK_FULLSCREEN
168 }
169#endif
170 }
171
172 viewport->size(new_w, new_h);
173
174 // We might not resize the main window, so we need to manually call this
175 // to make sure the viewport is centered.
176 repositionViewport();
177
178 // Update allowed resize range
179 size_range(100, 100, new_w, new_h);
180
181 // repositionViewport() makes sure the scroll widget notices any changes
182 // in position, but it might be just the size that changes so we also
183 // need a poke here as well.
184 redraw();
185}
186
187
Pierre Ossman4ae229f2011-04-15 12:58:31 +0000188void DesktopWindow::resize(int x, int y, int w, int h)
189{
Pierre Ossman4ae229f2011-04-15 12:58:31 +0000190 Fl_Window::resize(x, y, w, h);
Pierre Ossman6455d852011-06-01 09:33:00 +0000191
192 // Deal with some scrolling corner cases
193 repositionViewport();
Pierre Ossman4ae229f2011-04-15 12:58:31 +0000194}
195
196
Pierre Ossman407a5c32011-05-26 14:48:29 +0000197int DesktopWindow::handle(int event)
198{
199 switch (event) {
200#ifdef HAVE_FLTK_FULLSCREEN
201 case FL_FOCUS:
202 // FIXME: We reassert the keyboard grabbing on focus/unfocus as FLTK
203 // releases the grab when someone calls Fl::grab(0)
204 case FL_FULLSCREEN:
Pierre Ossman105738c2011-05-26 14:57:25 +0000205 if (event == FL_FULLSCREEN)
206 fullScreen.setParam(fullscreen_active());
Pierre Ossman1870ab12011-05-26 14:53:49 +0000207
Pierre Ossman407a5c32011-05-26 14:48:29 +0000208 if (!fullscreenSystemKeys)
209 break;
210
211 if (fullscreen_active())
212 grabKeyboard();
213 else
214 ungrabKeyboard();
215
216 break;
217 case FL_UNFOCUS:
218 // FIXME: We need to relinquish control when the entire window loses
219 // focus as it seems to interfere with the WM:s ability to handle
220 // interactions with popups' window decorations.
221 ungrabKeyboard();
222 break;
223#endif
224 case FL_SHORTCUT:
225 // Sometimes the focus gets out of whack and we fall through to the
226 // shortcut dispatching. Try to make things sane again...
227 if (Fl::focus() == NULL) {
228 take_focus();
229 Fl::handle(FL_KEYDOWN, this);
230 }
231 return 1;
232 }
233
234 return Fl_Window::handle(event);
235}
236
237
238void DesktopWindow::grabKeyboard()
239{
240 // Grabbing the keyboard is fairly safe as FLTK reroutes events to the
241 // correct widget regardless of which low level window got the system
242 // event.
243
244 // FIXME: Push this stuff into FLTK.
245
246#if defined(WIN32)
247 int ret;
248
249 ret = win32_enable_lowlevel_keyboard(fl_xid(this));
250 if (ret != 0)
251 vlog.error(_("Failure grabbing keyboard"));
252#elif defined(__APPLE__)
253 int ret;
254
255 ret = cocoa_capture_display(this);
256 if (ret != 0)
257 vlog.error(_("Failure grabbing keyboard"));
258#else
259 int ret;
260
261 ret = XGrabKeyboard(fl_display, fl_xid(this), True,
262 GrabModeAsync, GrabModeAsync, fl_event_time);
263 if (ret) {
264 if (ret == AlreadyGrabbed) {
265 // It seems like we can race with the WM in some cases.
266 // Try again in a bit.
267 if (!Fl::has_timeout(handleGrab, this))
268 Fl::add_timeout(0.500, handleGrab, this);
269 } else {
270 vlog.error(_("Failure grabbing keyboard"));
271 }
272 }
273#endif
274}
275
276
277void DesktopWindow::ungrabKeyboard()
278{
279 Fl::remove_timeout(handleGrab, this);
280
281#if defined(WIN32)
282 win32_disable_lowlevel_keyboard(fl_xid(this));
283#elif defined(__APPLE__)
284 cocoa_release_display(this);
285#else
286 // FLTK has a grab so lets not mess with it
287 if (Fl::grab())
288 return;
289
290 XUngrabKeyboard(fl_display, fl_event_time);
291#endif
292}
293
294
295void DesktopWindow::handleGrab(void *data)
296{
297 DesktopWindow *self = (DesktopWindow*)data;
298
299 assert(self);
300
301#ifdef HAVE_FLTK_FULLSCREEN
302 if (!fullscreenSystemKeys)
303 return;
304 if (!self->fullscreen_active())
305 return;
306
307 self->grabKeyboard();
308#endif
309}
310
311
Pierre Ossman6455d852011-06-01 09:33:00 +0000312void DesktopWindow::repositionViewport()
313{
314 int new_x, new_y;
315
316 // Deal with some scrolling corner cases:
317 //
318 // a) If the window is larger then the viewport, center the viewport.
319 // b) If the window is smaller than the viewport, make sure there is
320 // no wasted space on the sides.
321 //
322 // FIXME: Doesn't compensate for scroll widget size properly.
323
324 new_x = viewport->x();
325 new_y = viewport->y();
326
327 if (w() > viewport->w())
328 new_x = (w() - viewport->w()) / 2;
329 else {
330 if (viewport->x() > 0)
331 new_x = 0;
332 else if (w() > (viewport->x() + viewport->w()))
333 new_x = w() - viewport->w();
334 }
335
336 // Same thing for y axis
337 if (h() > viewport->h())
338 new_y = (h() - viewport->h()) / 2;
339 else {
340 if (viewport->y() > 0)
341 new_y = 0;
342 else if (h() > (viewport->y() + viewport->h()))
343 new_y = h() - viewport->h();
344 }
345
346 if ((new_x != viewport->x()) || (new_y != viewport->y())) {
347 viewport->position(new_x, new_y);
348
349 // The scroll widget does not notice when you move around child widgets,
350 // so redraw everything to make sure things update.
351 redraw();
352 }
353}
354
Pierre Ossman5156d5e2011-03-09 09:42:34 +0000355void DesktopWindow::handleClose(Fl_Widget *wnd, void *data)
356{
357 exit_vncviewer();
358}
Pierre Ossman407a5c32011-05-26 14:48:29 +0000359
360
361void DesktopWindow::handleOptions(void *data)
362{
363 DesktopWindow *self = (DesktopWindow*)data;
364
365#ifdef HAVE_FLTK_FULLSCREEN
366 if (self->fullscreen_active() && fullscreenSystemKeys)
367 self->grabKeyboard();
368 else
369 self->ungrabKeyboard();
Pierre Ossman91911642011-05-26 14:57:51 +0000370
371 if (fullScreen && !self->fullscreen_active())
372 self->fullscreen();
373 else if (!fullScreen && self->fullscreen_active())
374 self->fullscreen_off();
Pierre Ossman407a5c32011-05-26 14:48:29 +0000375#endif
376}