1/*
2    SDL - Simple DirectMedia Layer
3    Copyright (C) 1997-2012 Sam Lantinga
4
5    This library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    This library 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 GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with this library; if not, write to the Free Software
17    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
19    Sam Lantinga
20    slouken@libsdl.org
21*/
22#include "SDL_config.h"
23
24#include "SDL_QWin.h"
25#include <qapplication.h>
26#include <qdirectpainter_qws.h>
27
28screenRotationT screenRotation = SDL_QT_NO_ROTATION;
29
30SDL_QWin::SDL_QWin(const QSize& size)
31  : QWidget(0, "SDL_main"), my_painter(0), my_image(0),
32    my_inhibit_resize(false), my_mouse_pos(-1,-1), my_flags(0),
33    my_has_fullscreen(false), my_locked(0)
34{
35  setBackgroundMode(NoBackground);
36}
37
38SDL_QWin::~SDL_QWin() {
39  // Nothing to do yet.
40  if(my_image) {
41    delete my_image;
42  }
43}
44
45void SDL_QWin::setImage(QImage *image) {
46  if ( my_image ) {
47    delete my_image;
48  }
49  my_image = image;
50  //  setFixedSize(image->size());
51}
52
53void SDL_QWin::resizeEvent(QResizeEvent *e) {
54  if(size() != qApp->desktop()->size()) {
55    // Widget is not the correct size, so do the fullscreen magic
56    my_has_fullscreen = false;
57    enableFullscreen();
58  }
59  if(my_inhibit_resize) {
60    my_inhibit_resize = false;
61  } else {
62    SDL_PrivateResize(e->size().width(), e->size().height());
63  }
64}
65
66void SDL_QWin::focusInEvent(QFocusEvent *) {
67  // Always do it here, no matter the size.
68  enableFullscreen();
69  SDL_PrivateAppActive(true, SDL_APPINPUTFOCUS);
70}
71
72void SDL_QWin::focusOutEvent(QFocusEvent *) {
73  my_has_fullscreen = false;
74  SDL_PrivateAppActive(false, SDL_APPINPUTFOCUS);
75}
76
77void SDL_QWin::closeEvent(QCloseEvent *e) {
78  SDL_PrivateQuit();
79  e->ignore();
80}
81
82void SDL_QWin::setMousePos(const QPoint &pos) {
83  if(my_image->width() == height()) {
84    if (screenRotation == SDL_QT_ROTATION_90)
85      my_mouse_pos = QPoint(height()-pos.y(), pos.x());
86    else if (screenRotation == SDL_QT_ROTATION_270)
87      my_mouse_pos = QPoint(pos.y(), width()-pos.x());
88  } else {
89    my_mouse_pos = pos;
90  }
91}
92
93void SDL_QWin::mouseMoveEvent(QMouseEvent *e) {
94  Qt::ButtonState button = e->button();
95  int sdlstate = 0;
96  if( (button & Qt::LeftButton)) {
97    sdlstate |= SDL_BUTTON_LMASK;
98  }
99  if( (button & Qt::RightButton)) {
100    sdlstate |= SDL_BUTTON_RMASK;
101  }
102  if( (button & Qt::MidButton)) {
103    sdlstate |= SDL_BUTTON_MMASK;
104  }
105  setMousePos(e->pos());
106  SDL_PrivateMouseMotion(sdlstate, 0, my_mouse_pos.x(), my_mouse_pos.y());
107}
108
109void SDL_QWin::mousePressEvent(QMouseEvent *e) {
110  mouseMoveEvent(e);
111  Qt::ButtonState button = e->button();
112  SDL_PrivateMouseButton(SDL_PRESSED,
113			 (button & Qt::LeftButton) ? 1 :
114			 ((button & Qt::RightButton) ? 2 : 3),
115			 my_mouse_pos.x(), my_mouse_pos.y());
116}
117
118void SDL_QWin::mouseReleaseEvent(QMouseEvent *e) {
119  setMousePos(e->pos());
120  Qt::ButtonState button = e->button();
121  SDL_PrivateMouseButton(SDL_RELEASED,
122			 (button & Qt::LeftButton) ? 1 :
123			 ((button & Qt::RightButton) ? 2 : 3),
124			 my_mouse_pos.x(), my_mouse_pos.y());
125  my_mouse_pos = QPoint(-1, -1);
126}
127
128static inline void
129gs_fastRotateBlit_3 ( unsigned short *fb,
130		      unsigned short *bits,
131		      const QRect& rect )
132{
133  // FIXME: this only works correctly for 240x320 displays
134  int startx, starty;
135  int width, height;
136
137  startx = rect.left() >> 1;
138  starty = rect.top() >> 1;
139  width  = ((rect.right() - rect.left()) >> 1) + 2;
140  height = ((rect.bottom() - rect.top()) >> 1) + 2;
141
142  if((startx+width) > 120) {
143    width = 120 - startx; // avoid horizontal overflow
144  }
145  if((starty+height) > 160) {
146    height = 160 - starty; // avoid vertical overflow
147  }
148
149  ulong *sp1, *sp2, *dp1, *dp2;
150  ulong stop, sbot, dtop, dbot;
151
152  sp1 = (ulong*)bits + startx + starty*240;
153  sp2 = sp1 + 120;
154  dp1 = (ulong *)fb + (159 - starty) + startx*320;
155  dp2 = dp1 + 160;
156  int rowadd = (-320*width) - 1;
157  int rowadd2 = 240 - width;
158  // transfer in cells of 2x2 pixels in words
159  for (int y=0; y<height; y++) {
160    for (int x=0; x<width; x++) {
161      // read source pixels
162      stop = *sp1;
163      sbot = *sp2;
164      // rotate pixels
165      dtop = (sbot & 0xffff) + ((stop & 0xffff)<<16);
166      dbot = ((sbot & 0xffff0000)>>16) + (stop & 0xffff0000);
167      // write to framebuffer
168      *dp1 = dtop;
169      *dp2 = dbot;
170      // update source ptrs
171      sp1++; sp2++;
172      // update dest ptrs - 2 pix at a time
173      dp1 += 320;
174      dp2 += 320;
175    }
176    // adjust src ptrs - skip a row as we work in pairs
177    sp1 += rowadd2;
178    sp2 += rowadd2;
179    // adjust dest ptrs for rotation
180    dp1 += rowadd;
181    dp2 += rowadd;
182  }
183}
184
185static inline void
186gs_fastRotateBlit_1 ( unsigned short *fb,
187		      unsigned short *bits,
188		      const QRect& rect ) {
189  // FIXME: this only works correctly for 240x320 displays
190  int startx, starty;
191  int width, height;
192
193  startx = rect.left() >> 1;
194  starty = rect.top() >> 1;
195  width  = ((rect.right() - rect.left()) >> 1) + 2;
196  height = ((rect.bottom() - rect.top()) >> 1) + 2;
197
198  if((startx+width) > 120) {
199    width = 120 - startx; // avoid horizontal overflow
200  }
201  if((starty+height) > 160) {
202    height = 160 - starty; // avoid vertical overflow
203  }
204
205  ulong *sp1, *sp2, *dp1, *dp2;
206  ulong stop, sbot, dtop, dbot;
207  fb += 320*239; // Move "fb" to top left corner
208  sp1 = (ulong*)bits + startx + starty*240;
209  sp2 = sp1 + 120;
210  dp1 = (ulong*)fb - startx * 320 - starty;
211  dp2 = dp1 - 160;
212  int rowadd = (320*width) + 1;
213  int rowadd2 = 240 - width;
214  // transfer in cells of 2x2 pixels in words
215  for (int y=0; y<height; y++) {
216    for (int x=0; x<width; x++) {
217      // read
218      stop = *sp1;
219      sbot = *sp2;
220      // rotate
221      dtop = (stop & 0xffff) + ((sbot & 0xffff)<<16);
222      dbot = ((stop & 0xffff0000)>>16) + (sbot & 0xffff0000);
223      // write
224      *dp1 = dtop;
225      *dp2 = dbot;
226      // update source ptrs
227      sp1++; sp2++;
228      // update dest ptrs - 2 pix at a time
229      dp1 -= 320;
230      dp2 -= 320;
231    }
232    // adjust src ptrs - skip a row as we work in pairs
233    sp1 += rowadd2;
234    sp2 += rowadd2;
235    // adjust dest ptrs for rotation
236    dp1 += rowadd;
237    dp2 += rowadd;
238  }
239}
240
241// desktop, SL-A300 etc
242bool SDL_QWin::repaintRotation0(const QRect& rect) {
243  if(my_image->width() == width()) {
244    uchar *fb = (uchar*)my_painter->frameBuffer();
245    uchar *buf = (uchar*)my_image->bits();
246    if(rect == my_image->rect()) {
247      SDL_memcpy(fb, buf, width()*height()*2);
248    } else {
249      int h = rect.height();
250      int wd = rect.width()<<1;
251      int fblineadd = my_painter->lineStep();
252      int buflineadd = my_image->bytesPerLine();
253      fb  += (rect.left()<<1) + rect.top() * my_painter->lineStep();
254      buf += (rect.left()<<1) + rect.top() * my_image->bytesPerLine();
255      while(h--) {
256	SDL_memcpy(fb, buf, wd);
257	fb += fblineadd;
258	buf += buflineadd;
259      }
260    }
261  } else {
262    return false; // FIXME: Landscape
263  }
264#ifdef __i386__
265  my_painter->fillRect( rect, QBrush( Qt::NoBrush ) );
266#endif
267  return true;
268}
269
270
271// Sharp Zaurus SL-5500 etc
272bool SDL_QWin::repaintRotation3(const QRect& rect) {
273  if(my_image->width() == width()) {
274    ushort *fb = (ushort*)my_painter->frameBuffer();
275    ushort *buf = (ushort*)my_image->bits();
276    gs_fastRotateBlit_3(fb, buf, rect);
277  } else {
278    // landscape mode
279    if (screenRotation == SDL_QT_ROTATION_90) {
280      uchar *fb = (uchar*)my_painter->frameBuffer();
281      uchar *buf = (uchar*)my_image->bits();
282      if(rect == my_image->rect()) {
283	SDL_memcpy(fb, buf, width()*height()*2);
284      } else {
285	int h = rect.height();
286	int wd = rect.width()<<1;
287	int fblineadd = my_painter->lineStep();
288	int buflineadd = my_image->bytesPerLine();
289	fb  += (rect.left()<<1) + rect.top() * my_painter->lineStep();
290	buf += (rect.left()<<1) + rect.top() * my_image->bytesPerLine();
291	while(h--) {
292	  SDL_memcpy(fb, buf, wd);
293	  fb += fblineadd;
294	  buf += buflineadd;
295	}
296      }
297    } else if (screenRotation == SDL_QT_ROTATION_270) {
298      int h = rect.height();
299      int wd = rect.width();
300      int fblineadd = my_painter->lineStep() - (rect.width() << 1);
301      int buflineadd = my_image->bytesPerLine() - (rect.width() << 1);
302      int w;
303
304      uchar *fb = (uchar*)my_painter->frameBuffer();
305      uchar *buf = (uchar*)my_image->bits();
306
307      fb += ((my_painter->width() - (rect.top() + rect.height())) *
308	     my_painter->lineStep()) + ((my_painter->height() - ((rect.left() +
309								  rect.width()))) << 1);
310
311      buf += my_image->bytesPerLine() * (rect.top() + rect.height()) -
312	(((my_image->width() - (rect.left() + rect.width())) << 1) + 2);
313
314      while(h--) {
315	w = wd;
316	while(w--) *((unsigned short*)fb)++ = *((unsigned short*)buf)--;
317	fb += fblineadd;
318	buf -= buflineadd;
319      }
320    }
321  }
322  return true;
323}
324
325// ipaq 3800...
326bool SDL_QWin::repaintRotation1(const QRect& rect) {
327  if(my_image->width() == width()) {
328    ushort *fb = (ushort*)my_painter->frameBuffer();
329    ushort *buf = (ushort*)my_image->bits();
330    gs_fastRotateBlit_1(fb, buf, rect);
331  } else {
332    return false; // FIXME: landscape mode
333  }
334  return true;
335}
336
337void SDL_QWin::repaintRect(const QRect& rect) {
338  if(!my_painter || !rect.width() || !rect.height()) {
339    return;
340  }
341
342  if(QPixmap::defaultDepth() == 16) {
343    switch(my_painter->transformOrientation()) {
344    case 3:
345      if(repaintRotation3(rect)) { return;  }
346      break;
347    case 1:
348      if(repaintRotation1(rect)) { return;  }
349      break;
350    case 0:
351      if(repaintRotation0(rect)) { return;  }
352      break;
353    }
354  }
355  my_painter->drawImage(rect.topLeft(), *my_image, rect);
356}
357
358// This paints the current buffer to the screen, when desired.
359void SDL_QWin::paintEvent(QPaintEvent *ev) {
360  if(my_image) {
361    lockScreen(true);
362    repaintRect(ev->rect());
363    unlockScreen();
364  }
365}
366
367/* Function to translate a keyboard transition and queue the key event
368 * This should probably be a table although this method isn't exactly
369 * slow.
370 */
371void SDL_QWin::QueueKey(QKeyEvent *e, int pressed)
372{
373  SDL_keysym keysym;
374  int scancode = e->key();
375  /* Set the keysym information */
376  if(scancode >= 'A' && scancode <= 'Z') {
377    // Qt sends uppercase, SDL wants lowercase
378    keysym.sym = static_cast<SDLKey>(scancode + 32);
379  } else if(scancode  >= 0x1000) {
380    // Special keys
381    switch(scancode) {
382    case Qt::Key_Escape: scancode = SDLK_ESCAPE; break;
383    case Qt::Key_Tab: scancode = SDLK_TAB; break;
384    case Qt::Key_Backspace: scancode = SDLK_BACKSPACE; break;
385    case Qt::Key_Return: scancode = SDLK_RETURN; break;
386    case Qt::Key_Enter: scancode = SDLK_KP_ENTER; break;
387    case Qt::Key_Insert: scancode = SDLK_INSERT; break;
388    case Qt::Key_Delete: scancode = SDLK_DELETE; break;
389    case Qt::Key_Pause: scancode = SDLK_PAUSE; break;
390    case Qt::Key_Print: scancode = SDLK_PRINT; break;
391    case Qt::Key_SysReq: scancode = SDLK_SYSREQ; break;
392    case Qt::Key_Home: scancode = SDLK_HOME; break;
393    case Qt::Key_End: scancode = SDLK_END; break;
394    // We want the control keys to rotate with the screen
395    case Qt::Key_Left:
396        if (screenRotation == SDL_QT_ROTATION_90) scancode = SDLK_UP;
397        else if (screenRotation == SDL_QT_ROTATION_270) scancode = SDLK_DOWN;
398        else scancode = SDLK_LEFT;
399        break;
400    case Qt::Key_Up:
401        if (screenRotation == SDL_QT_ROTATION_90) scancode = SDLK_RIGHT;
402        else if (screenRotation == SDL_QT_ROTATION_270) scancode = SDLK_LEFT;
403        else scancode = SDLK_UP;
404        break;
405    case Qt::Key_Right:
406        if (screenRotation == SDL_QT_ROTATION_90) scancode = SDLK_DOWN;
407        else if (screenRotation == SDL_QT_ROTATION_270) scancode = SDLK_UP;
408        else scancode = SDLK_RIGHT;
409        break;
410    case Qt::Key_Down:
411        if (screenRotation == SDL_QT_ROTATION_90) scancode = SDLK_LEFT;
412        else if (screenRotation == SDL_QT_ROTATION_270) scancode = SDLK_RIGHT;
413        else scancode = SDLK_DOWN;
414        break;
415    case Qt::Key_Prior: scancode = SDLK_PAGEUP; break;
416    case Qt::Key_Next: scancode = SDLK_PAGEDOWN; break;
417    case Qt::Key_Shift: scancode = SDLK_LSHIFT; break;
418    case Qt::Key_Control: scancode = SDLK_LCTRL; break;
419    case Qt::Key_Meta: scancode = SDLK_LMETA; break;
420    case Qt::Key_Alt: scancode = SDLK_LALT; break;
421    case Qt::Key_CapsLock: scancode = SDLK_CAPSLOCK; break;
422    case Qt::Key_NumLock: scancode = SDLK_NUMLOCK; break;
423    case Qt::Key_ScrollLock: scancode = SDLK_SCROLLOCK; break;
424    case Qt::Key_F1: scancode = SDLK_F1; break;
425    case Qt::Key_F2: scancode = SDLK_F2; break;
426    case Qt::Key_F3: scancode = SDLK_F3; break;
427    case Qt::Key_F4: scancode = SDLK_F4; break;
428    case Qt::Key_F5: scancode = SDLK_F5; break;
429    case Qt::Key_F6: scancode = SDLK_F6; break;
430    case Qt::Key_F7: scancode = SDLK_F7; break;
431    case Qt::Key_F8: scancode = SDLK_F8; break;
432    case Qt::Key_F9: scancode = SDLK_F9; break;
433    case Qt::Key_F10: scancode = SDLK_F10; break;
434    case Qt::Key_F11: scancode = SDLK_F11; break;
435    case Qt::Key_F12: scancode = SDLK_F12; break;
436    case Qt::Key_F13: scancode = SDLK_F13; break;
437    case Qt::Key_F14: scancode = SDLK_F14; break;
438    case Qt::Key_F15: scancode = SDLK_F15; break;
439    case Qt::Key_Super_L: scancode = SDLK_LSUPER; break;
440    case Qt::Key_Super_R: scancode = SDLK_RSUPER; break;
441    case Qt::Key_Menu: scancode = SDLK_MENU; break;
442    case Qt::Key_Help: scancode = SDLK_HELP; break;
443
444    case Qt::Key_F33:
445      // FIXME: This is a hack to enable the OK key on
446      // Zaurii devices. SDLK_RETURN is a suitable key to use
447      // since it often is used as such.
448      //     david@hedbor.org
449      scancode = SDLK_RETURN;
450      break;
451    default:
452      scancode = SDLK_UNKNOWN;
453      break;
454    }
455    keysym.sym = static_cast<SDLKey>(scancode);
456  } else {
457    keysym.sym = static_cast<SDLKey>(scancode);
458  }
459  keysym.scancode = scancode;
460  keysym.mod = KMOD_NONE;
461  ButtonState st = e->state();
462  if( (st & ShiftButton) )   { keysym.mod = static_cast<SDLMod>(keysym.mod | KMOD_LSHIFT);  }
463  if( (st & ControlButton) ) { keysym.mod = static_cast<SDLMod>(keysym.mod | KMOD_LCTRL);  }
464  if( (st & AltButton) )     { keysym.mod = static_cast<SDLMod>(keysym.mod | KMOD_LALT);  }
465  if ( SDL_TranslateUNICODE ) {
466    QChar qchar = e->text()[0];
467    keysym.unicode = qchar.unicode();
468  } else {
469    keysym.unicode = 0;
470  }
471
472  /* NUMLOCK and CAPSLOCK are implemented as double-presses in reality */
473  //	if ( (keysym.sym == SDLK_NUMLOCK) || (keysym.sym == SDLK_CAPSLOCK) ) {
474  //		pressed = 1;
475  //	}
476
477  /* Queue the key event */
478  if ( pressed ) {
479    SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
480  } else {
481    SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
482  }
483}
484
485void SDL_QWin::setFullscreen(bool fs_on) {
486  my_has_fullscreen = false;
487  enableFullscreen();
488}
489
490void SDL_QWin::enableFullscreen() {
491  // Make sure size is correct
492  if(!my_has_fullscreen) {
493    setFixedSize(qApp->desktop()->size());
494    // This call is needed because showFullScreen won't work
495    // correctly if the widget already considers itself to be fullscreen.
496    showNormal();
497    // This is needed because showNormal() forcefully changes the window
498    // style to WSTyle_TopLevel.
499    setWFlags(WStyle_Customize | WStyle_NoBorder);
500    // Enable fullscreen.
501    showFullScreen();
502    my_has_fullscreen = true;
503  }
504}
505
506bool SDL_QWin::lockScreen(bool force) {
507  if(!my_painter) {
508    if(force || (isVisible() && isActiveWindow())) {
509      my_painter = new QDirectPainter(this);
510    } else {
511      return false;
512    }
513  }
514  my_locked++; // Increate lock refcount
515  return true;
516}
517
518void SDL_QWin::unlockScreen() {
519  if(my_locked > 0) {
520    my_locked--; // decrease lock refcount;
521  }
522  if(!my_locked && my_painter) {
523    my_painter->end();
524    delete my_painter;
525    my_painter = 0;
526  }
527}
528