--- a/src/video/qtopia/SDL_QWin.cc	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/video/qtopia/SDL_QWin.cc	Mon Jul 10 21:04:37 2006 +0000
@@ -27,501 +27,667 @@
 
 screenRotationT screenRotation = SDL_QT_NO_ROTATION;
 
-SDL_QWin::SDL_QWin(const QSize& size)
-  : QWidget(0, "SDL_main"), my_painter(0), my_image(0),
-    my_inhibit_resize(false), my_mouse_pos(-1,-1), my_flags(0),
-    my_has_fullscreen(false), my_locked(0)
+SDL_QWin::SDL_QWin(const QSize & size):
+QWidget(0, "SDL_main"),
+my_painter(0),
+my_image(0),
+my_inhibit_resize(false),
+my_mouse_pos(-1, -1),
+my_flags(0),
+my_has_fullscreen(false),
+my_locked(0)
 {
-  setBackgroundMode(NoBackground);
+    setBackgroundMode(NoBackground);
 }
 
-SDL_QWin::~SDL_QWin() {
-  // Nothing to do yet.
-  if(my_image) {
-    delete my_image;
-  }
-}
-
-void SDL_QWin::setImage(QImage *image) {
-  if ( my_image ) {
-    delete my_image;
-  }
-  my_image = image;
-  //  setFixedSize(image->size());
+SDL_QWin::~SDL_QWin()
+{
+    // Nothing to do yet.
+    if (my_image) {
+        delete my_image;
+    }
 }
 
-void SDL_QWin::resizeEvent(QResizeEvent *e) {
-  if(size() != qApp->desktop()->size()) {
-    // Widget is not the correct size, so do the fullscreen magic
-    my_has_fullscreen = false;
-    enableFullscreen();
-  }
-  if(my_inhibit_resize) {
-    my_inhibit_resize = false;
-  } else {
-    SDL_PrivateResize(e->size().width(), e->size().height());
-  }
+void
+SDL_QWin::setImage(QImage * image)
+{
+    if (my_image) {
+        delete my_image;
+    }
+    my_image = image;
+    //  setFixedSize(image->size());
 }
 
-void SDL_QWin::focusInEvent(QFocusEvent *) {
-  // Always do it here, no matter the size.
-  enableFullscreen();
-  SDL_PrivateAppActive(true, SDL_APPINPUTFOCUS);
+void
+SDL_QWin::resizeEvent(QResizeEvent * e)
+{
+    if (size() != qApp->desktop()->size()) {
+        // Widget is not the correct size, so do the fullscreen magic
+        my_has_fullscreen = false;
+        enableFullscreen();
+    }
+    if (my_inhibit_resize) {
+        my_inhibit_resize = false;
+    } else {
+        SDL_PrivateResize(e->size().width(), e->size().height());
+    }
 }
 
-void SDL_QWin::focusOutEvent(QFocusEvent *) {
-  my_has_fullscreen = false;
-  SDL_PrivateAppActive(false, SDL_APPINPUTFOCUS);
+void
+SDL_QWin::focusInEvent(QFocusEvent *)
+{
+    // Always do it here, no matter the size.
+    enableFullscreen();
+    SDL_PrivateAppActive(true, SDL_APPINPUTFOCUS);
 }
 
-void SDL_QWin::closeEvent(QCloseEvent *e) {
-  SDL_PrivateQuit();
-  e->ignore();
+void
+SDL_QWin::focusOutEvent(QFocusEvent *)
+{
+    my_has_fullscreen = false;
+    SDL_PrivateAppActive(false, SDL_APPINPUTFOCUS);
 }
 
-void SDL_QWin::setMousePos(const QPoint &pos) {
-  if(my_image->width() == height()) {
-    if (screenRotation == SDL_QT_ROTATION_90)
-      my_mouse_pos = QPoint(height()-pos.y(), pos.x());
-    else if (screenRotation == SDL_QT_ROTATION_270)
-      my_mouse_pos = QPoint(pos.y(), width()-pos.x());
-  } else {
-    my_mouse_pos = pos;
-  }
+void
+SDL_QWin::closeEvent(QCloseEvent * e)
+{
+    SDL_PrivateQuit();
+    e->ignore();
+}
+
+void
+SDL_QWin::setMousePos(const QPoint & pos)
+{
+    if (my_image->width() == height()) {
+        if (screenRotation == SDL_QT_ROTATION_90)
+            my_mouse_pos = QPoint(height() - pos.y(), pos.x());
+        else if (screenRotation == SDL_QT_ROTATION_270)
+            my_mouse_pos = QPoint(pos.y(), width() - pos.x());
+    } else {
+        my_mouse_pos = pos;
+    }
 }
 
-void SDL_QWin::mouseMoveEvent(QMouseEvent *e) {
-  Qt::ButtonState button = e->button();
-  int sdlstate = 0;
-  if( (button & Qt::LeftButton)) {
-    sdlstate |= SDL_BUTTON_LMASK;
-  }
-  if( (button & Qt::RightButton)) {
-    sdlstate |= SDL_BUTTON_RMASK;
-  }
-  if( (button & Qt::MidButton)) {
-    sdlstate |= SDL_BUTTON_MMASK;
-  }
-  setMousePos(e->pos());
-  SDL_PrivateMouseMotion(sdlstate, 0, my_mouse_pos.x(), my_mouse_pos.y());
+void
+SDL_QWin::mouseMoveEvent(QMouseEvent * e)
+{
+    Qt::ButtonState button = e->button();
+    int sdlstate = 0;
+    if ((button & Qt::LeftButton)) {
+        sdlstate |= SDL_BUTTON_LMASK;
+    }
+    if ((button & Qt::RightButton)) {
+        sdlstate |= SDL_BUTTON_RMASK;
+    }
+    if ((button & Qt::MidButton)) {
+        sdlstate |= SDL_BUTTON_MMASK;
+    }
+    setMousePos(e->pos());
+    SDL_PrivateMouseMotion(sdlstate, 0, my_mouse_pos.x(), my_mouse_pos.y());
 }
 
-void SDL_QWin::mousePressEvent(QMouseEvent *e) {
-  mouseMoveEvent(e);
-  Qt::ButtonState button = e->button();
-  SDL_PrivateMouseButton(SDL_PRESSED,
-			 (button & Qt::LeftButton) ? 1 :
-			 ((button & Qt::RightButton) ? 2 : 3),
-			 my_mouse_pos.x(), my_mouse_pos.y());
+void
+SDL_QWin::mousePressEvent(QMouseEvent * e)
+{
+    mouseMoveEvent(e);
+    Qt::ButtonState button = e->button();
+    SDL_PrivateMouseButton(SDL_PRESSED,
+                           (button & Qt::LeftButton) ? 1 :
+                           ((button & Qt::RightButton) ? 2 : 3),
+                           my_mouse_pos.x(), my_mouse_pos.y());
 }
 
-void SDL_QWin::mouseReleaseEvent(QMouseEvent *e) {
-  setMousePos(e->pos());
-  Qt::ButtonState button = e->button();
-  SDL_PrivateMouseButton(SDL_RELEASED,
-			 (button & Qt::LeftButton) ? 1 :
-			 ((button & Qt::RightButton) ? 2 : 3),
-			 my_mouse_pos.x(), my_mouse_pos.y());
-  my_mouse_pos = QPoint(-1, -1);
+void
+SDL_QWin::mouseReleaseEvent(QMouseEvent * e)
+{
+    setMousePos(e->pos());
+    Qt::ButtonState button = e->button();
+    SDL_PrivateMouseButton(SDL_RELEASED,
+                           (button & Qt::LeftButton) ? 1 :
+                           ((button & Qt::RightButton) ? 2 : 3),
+                           my_mouse_pos.x(), my_mouse_pos.y());
+    my_mouse_pos = QPoint(-1, -1);
 }
 
 static inline void
-gs_fastRotateBlit_3 ( unsigned short *fb,
-		      unsigned short *bits,
-		      const QRect& rect )
+gs_fastRotateBlit_3(unsigned short *fb,
+                    unsigned short *bits, const QRect & rect)
 {
-  // FIXME: this only works correctly for 240x320 displays
-  int startx, starty;
-  int width, height;
-  
-  startx = rect.left() >> 1;
-  starty = rect.top() >> 1;
-  width  = ((rect.right() - rect.left()) >> 1) + 2;
-  height = ((rect.bottom() - rect.top()) >> 1) + 2;
+    // FIXME: this only works correctly for 240x320 displays
+    int startx, starty;
+    int width, height;
+
+    startx = rect.left() >> 1;
+    starty = rect.top() >> 1;
+    width = ((rect.right() - rect.left()) >> 1) + 2;
+    height = ((rect.bottom() - rect.top()) >> 1) + 2;
 
-  if((startx+width) > 120) {
-    width = 120 - startx; // avoid horizontal overflow
-  }
-  if((starty+height) > 160) { 
-    height = 160 - starty; // avoid vertical overflow
-  }
+    if ((startx + width) > 120) {
+        width = 120 - startx;   // avoid horizontal overflow
+    }
+    if ((starty + height) > 160) {
+        height = 160 - starty;  // avoid vertical overflow
+    }
+
+    ulong *sp1, *sp2, *dp1, *dp2;
+    ulong stop, sbot, dtop, dbot;
 
-  ulong *sp1, *sp2, *dp1, *dp2;
-  ulong stop, sbot, dtop, dbot;    
-  
-  sp1 = (ulong*)bits + startx + starty*240;
-  sp2 = sp1 + 120;
-  dp1 = (ulong *)fb + (159 - starty) + startx*320;
-  dp2 = dp1 + 160;
-  int rowadd = (-320*width) - 1;
-  int rowadd2 = 240 - width;
-  // transfer in cells of 2x2 pixels in words
-  for (int y=0; y<height; y++) {
-    for (int x=0; x<width; x++) {
-      // read source pixels
-      stop = *sp1;
-      sbot = *sp2;
-      // rotate pixels
-      dtop = (sbot & 0xffff) + ((stop & 0xffff)<<16);
-      dbot = ((sbot & 0xffff0000)>>16) + (stop & 0xffff0000);
-      // write to framebuffer
-      *dp1 = dtop;
-      *dp2 = dbot;
-      // update source ptrs
-      sp1++; sp2++;
-      // update dest ptrs - 2 pix at a time
-      dp1 += 320;
-      dp2 += 320;
+    sp1 = (ulong *) bits + startx + starty * 240;
+    sp2 = sp1 + 120;
+    dp1 = (ulong *) fb + (159 - starty) + startx * 320;
+    dp2 = dp1 + 160;
+    int rowadd = (-320 * width) - 1;
+    int rowadd2 = 240 - width;
+    // transfer in cells of 2x2 pixels in words
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            // read source pixels
+            stop = *sp1;
+            sbot = *sp2;
+            // rotate pixels
+            dtop = (sbot & 0xffff) + ((stop & 0xffff) << 16);
+            dbot = ((sbot & 0xffff0000) >> 16) + (stop & 0xffff0000);
+            // write to framebuffer
+            *dp1 = dtop;
+            *dp2 = dbot;
+            // update source ptrs
+            sp1++;
+            sp2++;
+            // update dest ptrs - 2 pix at a time
+            dp1 += 320;
+            dp2 += 320;
+        }
+        // adjust src ptrs - skip a row as we work in pairs
+        sp1 += rowadd2;
+        sp2 += rowadd2;
+        // adjust dest ptrs for rotation
+        dp1 += rowadd;
+        dp2 += rowadd;
     }
-    // adjust src ptrs - skip a row as we work in pairs
-    sp1 += rowadd2;
-    sp2 += rowadd2;
-    // adjust dest ptrs for rotation
-    dp1 += rowadd;
-    dp2 += rowadd;
-  }
 }
 
 static inline void
-gs_fastRotateBlit_1 ( unsigned short *fb,
-		      unsigned short *bits,
-		      const QRect& rect ) {
-  // FIXME: this only works correctly for 240x320 displays
-  int startx, starty;
-  int width, height;
+gs_fastRotateBlit_1(unsigned short *fb,
+                    unsigned short *bits, const QRect & rect)
+{
+    // FIXME: this only works correctly for 240x320 displays
+    int startx, starty;
+    int width, height;
 
-  startx = rect.left() >> 1;
-  starty = rect.top() >> 1;
-  width  = ((rect.right() - rect.left()) >> 1) + 2;
-  height = ((rect.bottom() - rect.top()) >> 1) + 2;
+    startx = rect.left() >> 1;
+    starty = rect.top() >> 1;
+    width = ((rect.right() - rect.left()) >> 1) + 2;
+    height = ((rect.bottom() - rect.top()) >> 1) + 2;
 
-  if((startx+width) > 120) {
-    width = 120 - startx; // avoid horizontal overflow
-  }
-  if((starty+height) > 160) { 
-    height = 160 - starty; // avoid vertical overflow
-  }
+    if ((startx + width) > 120) {
+        width = 120 - startx;   // avoid horizontal overflow
+    }
+    if ((starty + height) > 160) {
+        height = 160 - starty;  // avoid vertical overflow
+    }
 
-  ulong *sp1, *sp2, *dp1, *dp2;
-  ulong stop, sbot, dtop, dbot;    
-  fb += 320*239; // Move "fb" to top left corner
-  sp1 = (ulong*)bits + startx + starty*240;
-  sp2 = sp1 + 120;
-  dp1 = (ulong*)fb - startx * 320 - starty;
-  dp2 = dp1 - 160;
-  int rowadd = (320*width) + 1;
-  int rowadd2 = 240 - width;
-  // transfer in cells of 2x2 pixels in words
-  for (int y=0; y<height; y++) {
-    for (int x=0; x<width; x++) {
-      // read
-      stop = *sp1;
-      sbot = *sp2;
-      // rotate
-      dtop = (stop & 0xffff) + ((sbot & 0xffff)<<16);
-      dbot = ((stop & 0xffff0000)>>16) + (sbot & 0xffff0000);
-      // write
-      *dp1 = dtop;
-      *dp2 = dbot;
-      // update source ptrs
-      sp1++; sp2++;
-      // update dest ptrs - 2 pix at a time
-      dp1 -= 320;
-      dp2 -= 320;
+    ulong *sp1, *sp2, *dp1, *dp2;
+    ulong stop, sbot, dtop, dbot;
+    fb += 320 * 239;            // Move "fb" to top left corner
+    sp1 = (ulong *) bits + startx + starty * 240;
+    sp2 = sp1 + 120;
+    dp1 = (ulong *) fb - startx * 320 - starty;
+    dp2 = dp1 - 160;
+    int rowadd = (320 * width) + 1;
+    int rowadd2 = 240 - width;
+    // transfer in cells of 2x2 pixels in words
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            // read
+            stop = *sp1;
+            sbot = *sp2;
+            // rotate
+            dtop = (stop & 0xffff) + ((sbot & 0xffff) << 16);
+            dbot = ((stop & 0xffff0000) >> 16) + (sbot & 0xffff0000);
+            // write
+            *dp1 = dtop;
+            *dp2 = dbot;
+            // update source ptrs
+            sp1++;
+            sp2++;
+            // update dest ptrs - 2 pix at a time
+            dp1 -= 320;
+            dp2 -= 320;
+        }
+        // adjust src ptrs - skip a row as we work in pairs
+        sp1 += rowadd2;
+        sp2 += rowadd2;
+        // adjust dest ptrs for rotation
+        dp1 += rowadd;
+        dp2 += rowadd;
     }
-    // adjust src ptrs - skip a row as we work in pairs
-    sp1 += rowadd2;
-    sp2 += rowadd2;
-    // adjust dest ptrs for rotation
-    dp1 += rowadd;
-    dp2 += rowadd;
-  }
 }
 
 // desktop, SL-A300 etc
-bool SDL_QWin::repaintRotation0(const QRect& rect) {
-  if(my_image->width() == width()) {
-    uchar *fb = (uchar*)my_painter->frameBuffer();
-    uchar *buf = (uchar*)my_image->bits();
-    if(rect == my_image->rect()) {
-      SDL_memcpy(fb, buf, width()*height()*2);
+/* *INDENT-OFF* */
+bool SDL_QWin::repaintRotation0 (const QRect & rect)
+{
+    if (my_image->width () == width ()) {
+        uchar * fb = (uchar *) my_painter->frameBuffer ();
+        uchar * buf = (uchar *) my_image->bits ();
+        if (rect == my_image->rect ()) {
+            SDL_memcpy (fb, buf, width () * height () * 2);
+        } else {
+            int h = rect.height ();
+            int wd = rect.width () << 1;
+            int fblineadd = my_painter->lineStep ();
+            int buflineadd = my_image->bytesPerLine ();
+            fb += (rect.left () << 1) + rect.top () * my_painter->lineStep ();
+            buf += (rect.left () << 1) + rect.top () * my_image->bytesPerLine ();
+            while (h--) {
+                SDL_memcpy (fb, buf, wd);
+                fb += fblineadd;
+                buf += buflineadd;
+            }
+        }
     } else {
-      int h = rect.height();
-      int wd = rect.width()<<1;
-      int fblineadd = my_painter->lineStep();
-      int buflineadd = my_image->bytesPerLine();
-      fb  += (rect.left()<<1) + rect.top() * my_painter->lineStep();
-      buf += (rect.left()<<1) + rect.top() * my_image->bytesPerLine();
-      while(h--) {
-	SDL_memcpy(fb, buf, wd);
-	fb += fblineadd;
-	buf += buflineadd;
-      }
+        return false;           // FIXME: Landscape
     }
-  } else {
-    return false; // FIXME: Landscape
-  }
 #ifdef __i386__
-  my_painter->fillRect( rect, QBrush( Qt::NoBrush ) );
+    my_painter->fillRect (rect, QBrush (Qt::NoBrush));
 #endif
-  return true;
+    return true;
 }
+/* *INDENT-ON* */
 
-  
+
 // Sharp Zaurus SL-5500 etc 
-bool SDL_QWin::repaintRotation3(const QRect& rect) {
-  if(my_image->width() == width()) {
-    ushort *fb = (ushort*)my_painter->frameBuffer();
-    ushort *buf = (ushort*)my_image->bits();
-    gs_fastRotateBlit_3(fb, buf, rect);
-  } else {
-    // landscape mode
-    if (screenRotation == SDL_QT_ROTATION_90) {
-      uchar *fb = (uchar*)my_painter->frameBuffer();
-      uchar *buf = (uchar*)my_image->bits();
-      if(rect == my_image->rect()) {
-	SDL_memcpy(fb, buf, width()*height()*2);
-      } else {
-	int h = rect.height();
-	int wd = rect.width()<<1;
-	int fblineadd = my_painter->lineStep();
-	int buflineadd = my_image->bytesPerLine();
-	fb  += (rect.left()<<1) + rect.top() * my_painter->lineStep();
-	buf += (rect.left()<<1) + rect.top() * my_image->bytesPerLine();
-	while(h--) {
-	  SDL_memcpy(fb, buf, wd);
-	  fb += fblineadd;
-	  buf += buflineadd;
-	}
-      }
-    } else if (screenRotation == SDL_QT_ROTATION_270) {
-      int h = rect.height();
-      int wd = rect.width();
-      int fblineadd = my_painter->lineStep() - (rect.width() << 1);
-      int buflineadd = my_image->bytesPerLine() - (rect.width() << 1);
-      int w;
+/* *INDENT-OFF* */
+bool SDL_QWin::repaintRotation3 (const QRect & rect)
+{
+    if (my_image->width () == width ()) {
+        ushort * fb = (ushort *) my_painter->frameBuffer ();
+        ushort * buf = (ushort *) my_image->bits ();
+        gs_fastRotateBlit_3 (fb, buf, rect);
+    } else {
+        // landscape mode
+        if (screenRotation == SDL_QT_ROTATION_90) {
+            uchar * fb = (uchar *) my_painter->frameBuffer ();
+            uchar * buf = (uchar *) my_image->bits ();
+            if (rect == my_image->rect ()) {
+                SDL_memcpy (fb, buf, width () * height () * 2);
+            } else {
+                int h = rect.height ();
+                int wd = rect.width () << 1;
+                int fblineadd = my_painter->lineStep ();
+                int buflineadd = my_image->bytesPerLine ();
+                fb +=
+                    (rect.left () << 1) +
+                    rect.top () * my_painter->lineStep ();
+                buf +=
+                    (rect.left () << 1) +
+                    rect.top () * my_image->bytesPerLine ();
+                while (h--) {
+                    SDL_memcpy (fb, buf, wd);
+                    fb += fblineadd;
+                    buf += buflineadd;
+                }
+            }
+        } else if (screenRotation == SDL_QT_ROTATION_270) {
+            int h = rect.height ();
+            int wd = rect.width ();
+            int fblineadd = my_painter->lineStep () - (rect.width () << 1);
+            int buflineadd = my_image->bytesPerLine () - (rect.width () << 1);
+            int w;
 
-      uchar *fb = (uchar*)my_painter->frameBuffer();
-      uchar *buf = (uchar*)my_image->bits();
-        
-      fb += ((my_painter->width() - (rect.top() + rect.height())) * 
-	     my_painter->lineStep()) + ((my_painter->height() - ((rect.left() + 
-								  rect.width()))) << 1);
+            uchar * fb = (uchar *) my_painter->frameBuffer ();
+            uchar * buf = (uchar *) my_image->bits ();
 
-      buf += my_image->bytesPerLine() * (rect.top() + rect.height()) -
-	(((my_image->width() - (rect.left() + rect.width())) << 1) + 2);
+            fb +=
+                ((my_painter->width () -
+                  (rect.top () +
+                   rect.height ())) * my_painter->lineStep ()) +
+                ((my_painter->height () -
+                  ((rect.left () + rect.width ()))) << 1);
 
-      while(h--) {
-	w = wd;
-	while(w--) *((unsigned short*)fb)++ = *((unsigned short*)buf)--;
-	fb += fblineadd;
-	buf -= buflineadd;
-      }
+            buf +=
+                my_image->bytesPerLine () * (rect.top () +
+                                             rect.height ()) -
+                (((my_image->width () -
+                   (rect.left () + rect.width ())) << 1) + 2);
+
+            while (h--) {
+                w = wd;
+                while (w--)
+                    *((unsigned short *) fb)++ = *((unsigned short *) buf)--;
+                fb += fblineadd;
+                buf -= buflineadd;
+            }
+        }
     }
-  }
-  return true;
+    return true;
 }
+/* *INDENT-ON* */
 
 // ipaq 3800...
-bool SDL_QWin::repaintRotation1(const QRect& rect) {
-  if(my_image->width() == width()) {
-    ushort *fb = (ushort*)my_painter->frameBuffer();
-    ushort *buf = (ushort*)my_image->bits();
-    gs_fastRotateBlit_1(fb, buf, rect);
-  } else {
-    return false; // FIXME: landscape mode
-  }
-  return true;
+/* *INDENT-OFF* */
+bool SDL_QWin::repaintRotation1 (const QRect & rect)
+{
+    if (my_image->width () == width ()) {
+        ushort *fb = (ushort *) my_painter->frameBuffer ();
+        ushort *buf = (ushort *) my_image->bits ();
+        gs_fastRotateBlit_1 (fb, buf, rect);
+    } else {
+        return false;           // FIXME: landscape mode
+    }
+    return true;
 }
+/* *INDENT-ON* */
+
+void
+SDL_QWin::repaintRect(const QRect & rect)
+{
+    if (!my_painter || !rect.width() || !rect.height()) {
+        return;
+    }
 
-void SDL_QWin::repaintRect(const QRect& rect) {
-  if(!my_painter || !rect.width() || !rect.height()) {
-    return;
-  }
-  
-  if(QPixmap::defaultDepth() == 16) {
-    switch(my_painter->transformOrientation()) {
-    case 3:
-      if(repaintRotation3(rect)) { return;  }
-      break;
-    case 1:
-      if(repaintRotation1(rect)) { return;  }
-      break;
-    case 0:
-      if(repaintRotation0(rect)) { return;  }
-      break;
+    if (QPixmap::defaultDepth() == 16) {
+        switch (my_painter->transformOrientation()) {
+        case 3:
+            if (repaintRotation3(rect)) {
+                return;
+            }
+            break;
+        case 1:
+            if (repaintRotation1(rect)) {
+                return;
+            }
+            break;
+        case 0:
+            if (repaintRotation0(rect)) {
+                return;
+            }
+            break;
+        }
     }
-  } 
-  my_painter->drawImage(rect.topLeft(), *my_image, rect);
+    my_painter->drawImage(rect.topLeft(), *my_image, rect);
 }
 
 // This paints the current buffer to the screen, when desired. 
-void SDL_QWin::paintEvent(QPaintEvent *ev) {  
-  if(my_image) {
-    lockScreen(true);
-    repaintRect(ev->rect());
-    unlockScreen();
-  }
-}  
+void
+SDL_QWin::paintEvent(QPaintEvent * ev)
+{
+    if (my_image) {
+        lockScreen(true);
+        repaintRect(ev->rect());
+        unlockScreen();
+    }
+}
 
 /* Function to translate a keyboard transition and queue the key event
  * This should probably be a table although this method isn't exactly
  * slow.
  */
-void SDL_QWin::QueueKey(QKeyEvent *e, int pressed)
-{  
-  SDL_keysym keysym;
-  int scancode = e->key();
-  /* Set the keysym information */
-  if(scancode >= 'A' && scancode <= 'Z') {
-    // Qt sends uppercase, SDL wants lowercase
-    keysym.sym = static_cast<SDLKey>(scancode + 32);
-  } else if(scancode  >= 0x1000) {
-    // Special keys
-    switch(scancode) {
-    case Qt::Key_Escape: scancode = SDLK_ESCAPE; break;
-    case Qt::Key_Tab: scancode = SDLK_TAB; break;
-    case Qt::Key_Backspace: scancode = SDLK_BACKSPACE; break;
-    case Qt::Key_Return: scancode = SDLK_RETURN; break;
-    case Qt::Key_Enter: scancode = SDLK_KP_ENTER; break;
-    case Qt::Key_Insert: scancode = SDLK_INSERT; break;
-    case Qt::Key_Delete: scancode = SDLK_DELETE; break;
-    case Qt::Key_Pause: scancode = SDLK_PAUSE; break;
-    case Qt::Key_Print: scancode = SDLK_PRINT; break;
-    case Qt::Key_SysReq: scancode = SDLK_SYSREQ; break;
-    case Qt::Key_Home: scancode = SDLK_HOME; break;
-    case Qt::Key_End: scancode = SDLK_END; break;
-    // We want the control keys to rotate with the screen
-    case Qt::Key_Left: 
-        if (screenRotation == SDL_QT_ROTATION_90) scancode = SDLK_UP;
-        else if (screenRotation == SDL_QT_ROTATION_270) scancode = SDLK_DOWN;
-        else scancode = SDLK_LEFT;
-        break;
-    case Qt::Key_Up: 
-        if (screenRotation == SDL_QT_ROTATION_90) scancode = SDLK_RIGHT;
-        else if (screenRotation == SDL_QT_ROTATION_270) scancode = SDLK_LEFT;
-        else scancode = SDLK_UP;
-        break;
-    case Qt::Key_Right: 
-        if (screenRotation == SDL_QT_ROTATION_90) scancode = SDLK_DOWN;
-        else if (screenRotation == SDL_QT_ROTATION_270) scancode = SDLK_UP;
-        else scancode = SDLK_RIGHT;
-        break;
-    case Qt::Key_Down:
-        if (screenRotation == SDL_QT_ROTATION_90) scancode = SDLK_LEFT;
-        else if (screenRotation == SDL_QT_ROTATION_270) scancode = SDLK_RIGHT;
-        else scancode = SDLK_DOWN;
-        break;
-    case Qt::Key_Prior: scancode = SDLK_PAGEUP; break;
-    case Qt::Key_Next: scancode = SDLK_PAGEDOWN; break;
-    case Qt::Key_Shift: scancode = SDLK_LSHIFT; break;
-    case Qt::Key_Control: scancode = SDLK_LCTRL; break;
-    case Qt::Key_Meta: scancode = SDLK_LMETA; break;
-    case Qt::Key_Alt: scancode = SDLK_LALT; break;
-    case Qt::Key_CapsLock: scancode = SDLK_CAPSLOCK; break;
-    case Qt::Key_NumLock: scancode = SDLK_NUMLOCK; break;
-    case Qt::Key_ScrollLock: scancode = SDLK_SCROLLOCK; break;
-    case Qt::Key_F1: scancode = SDLK_F1; break;
-    case Qt::Key_F2: scancode = SDLK_F2; break;
-    case Qt::Key_F3: scancode = SDLK_F3; break;
-    case Qt::Key_F4: scancode = SDLK_F4; break;
-    case Qt::Key_F5: scancode = SDLK_F5; break;
-    case Qt::Key_F6: scancode = SDLK_F6; break;
-    case Qt::Key_F7: scancode = SDLK_F7; break;
-    case Qt::Key_F8: scancode = SDLK_F8; break;
-    case Qt::Key_F9: scancode = SDLK_F9; break;
-    case Qt::Key_F10: scancode = SDLK_F10; break;
-    case Qt::Key_F11: scancode = SDLK_F11; break;
-    case Qt::Key_F12: scancode = SDLK_F12; break;
-    case Qt::Key_F13: scancode = SDLK_F13; break;
-    case Qt::Key_F14: scancode = SDLK_F14; break;
-    case Qt::Key_F15: scancode = SDLK_F15; break;
-    case Qt::Key_Super_L: scancode = SDLK_LSUPER; break;
-    case Qt::Key_Super_R: scancode = SDLK_RSUPER; break;
-    case Qt::Key_Menu: scancode = SDLK_MENU; break;
-    case Qt::Key_Help: scancode = SDLK_HELP; break;
+void
+SDL_QWin::QueueKey(QKeyEvent * e, int pressed)
+{
+    SDL_keysym keysym;
+    int scancode = e->key();
+    /* Set the keysym information */
+    if (scancode >= 'A' && scancode <= 'Z') {
+        // Qt sends uppercase, SDL wants lowercase
+        keysym.sym = static_cast < SDLKey > (scancode + 32);
+    } else if (scancode >= 0x1000) {
+        // Special keys
+        switch (scancode) {
+        case Qt::Key_Escape:
+            scancode = SDLK_ESCAPE;
+            break;
+        case Qt::Key_Tab:
+            scancode = SDLK_TAB;
+            break;
+        case Qt::Key_Backspace:
+            scancode = SDLK_BACKSPACE;
+            break;
+        case Qt::Key_Return:
+            scancode = SDLK_RETURN;
+            break;
+        case Qt::Key_Enter:
+            scancode = SDLK_KP_ENTER;
+            break;
+        case Qt::Key_Insert:
+            scancode = SDLK_INSERT;
+            break;
+        case Qt::Key_Delete:
+            scancode = SDLK_DELETE;
+            break;
+        case Qt::Key_Pause:
+            scancode = SDLK_PAUSE;
+            break;
+        case Qt::Key_Print:
+            scancode = SDLK_PRINT;
+            break;
+        case Qt::Key_SysReq:
+            scancode = SDLK_SYSREQ;
+            break;
+        case Qt::Key_Home:
+            scancode = SDLK_HOME;
+            break;
+        case Qt::Key_End:
+            scancode = SDLK_END;
+            break;
+            // We want the control keys to rotate with the screen
+        case Qt::Key_Left:
+            if (screenRotation == SDL_QT_ROTATION_90)
+                scancode = SDLK_UP;
+            else if (screenRotation == SDL_QT_ROTATION_270)
+                scancode = SDLK_DOWN;
+            else
+                scancode = SDLK_LEFT;
+            break;
+        case Qt::Key_Up:
+            if (screenRotation == SDL_QT_ROTATION_90)
+                scancode = SDLK_RIGHT;
+            else if (screenRotation == SDL_QT_ROTATION_270)
+                scancode = SDLK_LEFT;
+            else
+                scancode = SDLK_UP;
+            break;
+        case Qt::Key_Right:
+            if (screenRotation == SDL_QT_ROTATION_90)
+                scancode = SDLK_DOWN;
+            else if (screenRotation == SDL_QT_ROTATION_270)
+                scancode = SDLK_UP;
+            else
+                scancode = SDLK_RIGHT;
+            break;
+        case Qt::Key_Down:
+            if (screenRotation == SDL_QT_ROTATION_90)
+                scancode = SDLK_LEFT;
+            else if (screenRotation == SDL_QT_ROTATION_270)
+                scancode = SDLK_RIGHT;
+            else
+                scancode = SDLK_DOWN;
+            break;
+        case Qt::Key_Prior:
+            scancode = SDLK_PAGEUP;
+            break;
+        case Qt::Key_Next:
+            scancode = SDLK_PAGEDOWN;
+            break;
+        case Qt::Key_Shift:
+            scancode = SDLK_LSHIFT;
+            break;
+        case Qt::Key_Control:
+            scancode = SDLK_LCTRL;
+            break;
+        case Qt::Key_Meta:
+            scancode = SDLK_LMETA;
+            break;
+        case Qt::Key_Alt:
+            scancode = SDLK_LALT;
+            break;
+        case Qt::Key_CapsLock:
+            scancode = SDLK_CAPSLOCK;
+            break;
+        case Qt::Key_NumLock:
+            scancode = SDLK_NUMLOCK;
+            break;
+        case Qt::Key_ScrollLock:
+            scancode = SDLK_SCROLLOCK;
+            break;
+        case Qt::Key_F1:
+            scancode = SDLK_F1;
+            break;
+        case Qt::Key_F2:
+            scancode = SDLK_F2;
+            break;
+        case Qt::Key_F3:
+            scancode = SDLK_F3;
+            break;
+        case Qt::Key_F4:
+            scancode = SDLK_F4;
+            break;
+        case Qt::Key_F5:
+            scancode = SDLK_F5;
+            break;
+        case Qt::Key_F6:
+            scancode = SDLK_F6;
+            break;
+        case Qt::Key_F7:
+            scancode = SDLK_F7;
+            break;
+        case Qt::Key_F8:
+            scancode = SDLK_F8;
+            break;
+        case Qt::Key_F9:
+            scancode = SDLK_F9;
+            break;
+        case Qt::Key_F10:
+            scancode = SDLK_F10;
+            break;
+        case Qt::Key_F11:
+            scancode = SDLK_F11;
+            break;
+        case Qt::Key_F12:
+            scancode = SDLK_F12;
+            break;
+        case Qt::Key_F13:
+            scancode = SDLK_F13;
+            break;
+        case Qt::Key_F14:
+            scancode = SDLK_F14;
+            break;
+        case Qt::Key_F15:
+            scancode = SDLK_F15;
+            break;
+        case Qt::Key_Super_L:
+            scancode = SDLK_LSUPER;
+            break;
+        case Qt::Key_Super_R:
+            scancode = SDLK_RSUPER;
+            break;
+        case Qt::Key_Menu:
+            scancode = SDLK_MENU;
+            break;
+        case Qt::Key_Help:
+            scancode = SDLK_HELP;
+            break;
 
-    case Qt::Key_F33:
-      // FIXME: This is a hack to enable the OK key on
-      // Zaurii devices. SDLK_RETURN is a suitable key to use
-      // since it often is used as such.
-      //     david@hedbor.org
-      scancode = SDLK_RETURN;
-      break;
-    default:
-      scancode = SDLK_UNKNOWN;
-      break;
+        case Qt::Key_F33:
+            // FIXME: This is a hack to enable the OK key on
+            // Zaurii devices. SDLK_RETURN is a suitable key to use
+            // since it often is used as such.
+            //     david@hedbor.org
+            scancode = SDLK_RETURN;
+            break;
+        default:
+            scancode = SDLK_UNKNOWN;
+            break;
+        }
+        keysym.sym = static_cast < SDLKey > (scancode);
+    } else {
+        keysym.sym = static_cast < SDLKey > (scancode);
+    }
+    keysym.scancode = scancode;
+    keysym.mod = KMOD_NONE;
+    ButtonState st = e->state();
+    if ((st & ShiftButton)) {
+        keysym.mod = static_cast < SDLMod > (keysym.mod | KMOD_LSHIFT);
     }
-    keysym.sym = static_cast<SDLKey>(scancode);    
-  } else {
-    keysym.sym = static_cast<SDLKey>(scancode);    
-  }
-  keysym.scancode = scancode;
-  keysym.mod = KMOD_NONE;
-  ButtonState st = e->state();
-  if( (st & ShiftButton) )   { keysym.mod = static_cast<SDLMod>(keysym.mod | KMOD_LSHIFT);  }
-  if( (st & ControlButton) ) { keysym.mod = static_cast<SDLMod>(keysym.mod | KMOD_LCTRL);  }
-  if( (st & AltButton) )     { keysym.mod = static_cast<SDLMod>(keysym.mod | KMOD_LALT);  }
-  if ( SDL_TranslateUNICODE ) {
-    QChar qchar = e->text()[0];
-    keysym.unicode = qchar.unicode();
-  } else {
-    keysym.unicode = 0;
-  }
+    if ((st & ControlButton)) {
+        keysym.mod = static_cast < SDLMod > (keysym.mod | KMOD_LCTRL);
+    }
+    if ((st & AltButton)) {
+        keysym.mod = static_cast < SDLMod > (keysym.mod | KMOD_LALT);
+    }
+    if (SDL_TranslateUNICODE) {
+        QChar qchar = e->text()[0];
+        keysym.unicode = qchar.unicode();
+    } else {
+        keysym.unicode = 0;
+    }
 
-  /* NUMLOCK and CAPSLOCK are implemented as double-presses in reality */
-  //	if ( (keysym.sym == SDLK_NUMLOCK) || (keysym.sym == SDLK_CAPSLOCK) ) {
-  //		pressed = 1;
-  //	}
+    /* NUMLOCK and CAPSLOCK are implemented as double-presses in reality */
+    //    if ( (keysym.sym == SDLK_NUMLOCK) || (keysym.sym == SDLK_CAPSLOCK) ) {
+    //            pressed = 1;
+    //    }
 
-  /* Queue the key event */
-  if ( pressed ) {
-    SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
-  } else {
-    SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
-  }
+    /* Queue the key event */
+    if (pressed) {
+        SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
+    } else {
+        SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
+    }
 }
 
-void SDL_QWin::setFullscreen(bool fs_on) {
-  my_has_fullscreen = false;
-  enableFullscreen();
+void
+SDL_QWin::setFullscreen(bool fs_on)
+{
+    my_has_fullscreen = false;
+    enableFullscreen();
 }
 
-void SDL_QWin::enableFullscreen() {
-  // Make sure size is correct
-  if(!my_has_fullscreen) {
-    setFixedSize(qApp->desktop()->size());
-    // This call is needed because showFullScreen won't work
-    // correctly if the widget already considers itself to be fullscreen.
-    showNormal();
-    // This is needed because showNormal() forcefully changes the window
-    // style to WSTyle_TopLevel.
-    setWFlags(WStyle_Customize | WStyle_NoBorder);
-    // Enable fullscreen.
-    showFullScreen();
-    my_has_fullscreen = true;
-  }
+void
+SDL_QWin::enableFullscreen()
+{
+    // Make sure size is correct
+    if (!my_has_fullscreen) {
+        setFixedSize(qApp->desktop()->size());
+        // This call is needed because showFullScreen won't work
+        // correctly if the widget already considers itself to be fullscreen.
+        showNormal();
+        // This is needed because showNormal() forcefully changes the window
+        // style to WSTyle_TopLevel.
+        setWFlags(WStyle_Customize | WStyle_NoBorder);
+        // Enable fullscreen.
+        showFullScreen();
+        my_has_fullscreen = true;
+    }
 }
 
-bool SDL_QWin::lockScreen(bool force) {
-  if(!my_painter) {
-    if(force || (isVisible() && isActiveWindow())) {
-      my_painter = new QDirectPainter(this);
-    } else {
-      return false;
+/* *INDENT-OFF* */
+bool
+SDL_QWin::lockScreen (bool force)
+{
+    if (!my_painter) {
+        if (force || (isVisible () && isActiveWindow ())) {
+            my_painter = new QDirectPainter (this);
+        } else {
+            return false;
+        }
     }
-  }
-  my_locked++; // Increate lock refcount
-  return true;
+    my_locked++;                // Increate lock refcount
+    return true;
+}
+/* *INDENT-ON* */
+
+void
+SDL_QWin::unlockScreen()
+{
+    if (my_locked > 0) {
+        my_locked--;            // decrease lock refcount;
+    }
+    if (!my_locked && my_painter) {
+        my_painter->end();
+        delete my_painter;
+        my_painter = 0;
+    }
 }
 
-void SDL_QWin::unlockScreen() {
-  if(my_locked > 0) {
-    my_locked--; // decrease lock refcount;
-  }
-  if(!my_locked && my_painter) {
-    my_painter->end();
-    delete my_painter;
-    my_painter = 0;
-  }
-}
+/* vi: set ts=4 sw=4 expandtab: */