| 1 | /* |
| 2 | SDL - Simple DirectMedia Layer |
| 3 | Copyright (C) 1997-2009 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 | } |