diff options
author | Franklin Wei <git@fwei.tk> | 2017-01-21 15:18:31 -0500 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2017-12-23 21:01:26 -0500 |
commit | a855d6202536ff28e5aae4f22a0f31d8f5b325d0 (patch) | |
tree | 8c75f224dd64ed360505afa8843d016b0d75000b /apps/plugins/sdl/src/video/qtopia/SDL_QWin.cc | |
parent | 01c6dcf6c7b9bb1ad2fa0450f99bacc5f3d3e04b (diff) | |
download | rockbox-a855d6202536ff28e5aae4f22a0f31d8f5b325d0.tar.gz rockbox-a855d6202536ff28e5aae4f22a0f31d8f5b325d0.zip |
Port of Duke Nukem 3D
This ports Fabien Sanglard's Chocolate Duke to run on a version of SDL
for Rockbox.
Change-Id: I8f2c4c78af19de10c1633ed7bb7a997b43256dd9
Diffstat (limited to 'apps/plugins/sdl/src/video/qtopia/SDL_QWin.cc')
-rw-r--r-- | apps/plugins/sdl/src/video/qtopia/SDL_QWin.cc | 527 |
1 files changed, 527 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/qtopia/SDL_QWin.cc b/apps/plugins/sdl/src/video/qtopia/SDL_QWin.cc new file mode 100644 index 0000000000..04474ed9be --- /dev/null +++ b/apps/plugins/sdl/src/video/qtopia/SDL_QWin.cc | |||
@@ -0,0 +1,527 @@ | |||
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 | |||
28 | screenRotationT screenRotation = SDL_QT_NO_ROTATION; | ||
29 | |||
30 | SDL_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 | |||
38 | SDL_QWin::~SDL_QWin() { | ||
39 | // Nothing to do yet. | ||
40 | if(my_image) { | ||
41 | delete my_image; | ||
42 | } | ||
43 | } | ||
44 | |||
45 | void SDL_QWin::setImage(QImage *image) { | ||
46 | if ( my_image ) { | ||
47 | delete my_image; | ||
48 | } | ||
49 | my_image = image; | ||
50 | // setFixedSize(image->size()); | ||
51 | } | ||
52 | |||
53 | void 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 | |||
66 | void SDL_QWin::focusInEvent(QFocusEvent *) { | ||
67 | // Always do it here, no matter the size. | ||
68 | enableFullscreen(); | ||
69 | SDL_PrivateAppActive(true, SDL_APPINPUTFOCUS); | ||
70 | } | ||
71 | |||
72 | void SDL_QWin::focusOutEvent(QFocusEvent *) { | ||
73 | my_has_fullscreen = false; | ||
74 | SDL_PrivateAppActive(false, SDL_APPINPUTFOCUS); | ||
75 | } | ||
76 | |||
77 | void SDL_QWin::closeEvent(QCloseEvent *e) { | ||
78 | SDL_PrivateQuit(); | ||
79 | e->ignore(); | ||
80 | } | ||
81 | |||
82 | void 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 | |||
93 | void 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 | |||
109 | void 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 | |||
118 | void 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 | |||
128 | static inline void | ||
129 | gs_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 | |||
185 | static inline void | ||
186 | gs_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 | ||
242 | bool 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 | ||
272 | bool 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... | ||
326 | bool 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 | |||
337 | void 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. | ||
359 | void 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 | */ | ||
371 | void 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 | |||
485 | void SDL_QWin::setFullscreen(bool fs_on) { | ||
486 | my_has_fullscreen = false; | ||
487 | enableFullscreen(); | ||
488 | } | ||
489 | |||
490 | void 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 | |||
506 | bool 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 | |||
518 | void 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 | } | ||