kmag/kmagzoomview.cpp

   1 /***************************************************************************
   2                           kmagview.cpp  -  description
   3                              -------------------
   4     begin                : Mon Feb 12 23:45:41 EST 2001
   5     copyright            : (C) 2001-2003 by Sarang Lakare
   6     email                : sarang#users.sourceforge.net
   7     copyright            : (C) 2003-2004 by Olaf Schmidt
   8     email                : ojschmidt@kde.org
   9     copyright            : (C) 2008 by Matthew Woehlke
  10     email                : mw_triad@users.sourceforge.net
  11  ***************************************************************************/
  12
  13 /***************************************************************************
  14  *                                                                         *
  15  *   This program is free software; you can redistribute it and/or modify  *
  16  *   it under the terms of the GNU General Public License as published by  *
  17  *   the Free Software Foundation; either version 2 of the License, or     *
  18  *   (at your option) any later version.                                   *
  19  *                                                                         *
  20  ***************************************************************************/
  21
  22
  23 // application specific includes
  24 #include "kmagzoomview.h"
  25 #include "kmagzoomview.moc"
  26 #include "colorsim.h"
  27
  28 // include files for Qt
  29 #include <QtGui/QBitmap>
  30 #include <QtGui/QCursor>
  31 #include <QtCore/qglobal.h>
  32 #include <QtGui/QPainter>
  33 #include <QtGui/QWidget>
  34 #include <QtGui/QPixmap>
  35 #include <QtGui/QFocusEvent>
  36 #include <QtGui/QHideEvent>
  37 #include <QtGui/QKeyEvent>
  38 #include <QtGui/QShowEvent>
  39 #include <QtGui/QResizeEvent>
  40 #include <QtGui/QMouseEvent>
  41 #include <QtGui/QDesktopWidget>
  42
  43 // include files for KDE
  44 #include <kapplication.h>
  45 #include <kcursor.h>
  46 #include <kdebug.h>
  47 #include <klocale.h>
  48
  49 // include bitmaps for cursors
  50 static uchar left_ptr_bits[] = {
  51    0x00, 0x00, 0x08, 0x00, 0x18, 0x00, 0x38, 0x00, 0x78, 0x00, 0xf8, 0x00,
  52    0xf8, 0x01, 0xf8, 0x03, 0xf8, 0x07, 0xf8, 0x00, 0xd8, 0x00, 0x88, 0x01,
  53    0x80, 0x01, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00};
  54
  55 static uchar left_ptrmsk_bits[] = {
  56    0x0c, 0x00, 0x1c, 0x00, 0x3c, 0x00, 0x7c, 0x00, 0xfc, 0x00, 0xfc, 0x01,
  57    0xfc, 0x03, 0xfc, 0x07, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x01, 0xdc, 0x03,
  58    0xcc, 0x03, 0x80, 0x07, 0x80, 0x07, 0x00, 0x03};
  59
  60 static uchar phand_bits[] = {
  61   0x00, 0x00, 0x00, 0x00,  0xfe, 0x01, 0x00, 0x00,  0x01, 0x02, 0x00, 0x00,
  62   0x7e, 0x04, 0x00, 0x00,  0x08, 0x08, 0x00, 0x00,  0x70, 0x08, 0x00, 0x00,
  63   0x08, 0x08, 0x00, 0x00,  0x70, 0x14, 0x00, 0x00,  0x08, 0x22, 0x00, 0x00,
  64   0x30, 0x41, 0x00, 0x00,  0xc0, 0x20, 0x00, 0x00,  0x40, 0x12, 0x00, 0x00,
  65   0x80, 0x08, 0x00, 0x00,  0x00, 0x05, 0x00, 0x00,  0x00, 0x02, 0x00, 0x00,
  66   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  67   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  68   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  69   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  70   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  71   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00 };
  72     static uchar phandm_bits[] = {
  73   0xfe, 0x01, 0x00, 0x00,  0xff, 0x03, 0x00, 0x00,  0xff, 0x07, 0x00, 0x00,
  74   0xff, 0x0f, 0x00, 0x00,  0xfe, 0x1f, 0x00, 0x00,  0xf8, 0x1f, 0x00, 0x00,
  75   0xfc, 0x1f, 0x00, 0x00,  0xf8, 0x3f, 0x00, 0x00,  0xfc, 0x7f, 0x00, 0x00,
  76   0xf8, 0xff, 0x00, 0x00,  0xf0, 0x7f, 0x00, 0x00,  0xe0, 0x3f, 0x00, 0x00,
  77   0xc0, 0x1f, 0x00, 0x00,  0x80, 0x0f, 0x00, 0x00,  0x00, 0x07, 0x00, 0x00,
  78   0x00, 0x02, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  79   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  80   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  81   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  82   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
  83   0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00 };
  84
  85
  86 KMagZoomView::KMagZoomView(QWidget *parent, const char *name)
  87   : Q3ScrollView(parent, name),
  88     m_selRect(0, 0, 128, 128, this),
  89     m_grabTimer(parent),
  90     m_mouseViewTimer(parent),
  91     m_latestCursorPos(0,0),
  92     m_followMouse(false),
  93     m_showMouse(1),
  94     m_zoom(1.0),
  95     m_rotation(0),
  96     m_fitToWindow(true)
  97 {
  98   KApplication::setGlobalMouseTracking(true);
  99   viewport()->setMouseTracking(true);
 100   viewport()->setBackgroundMode (Qt::NoBackground);
 101   viewport()->setFocusPolicy(Qt::StrongFocus);
 102
 103   // init the zoom matrix
 104   m_zoomMatrix.reset();
 105   m_zoomMatrix.scale(m_zoom, m_zoom);
 106   m_zoomMatrix.rotate(m_rotation);
 107
 108   m_ctrlKeyPressed = false;
 109   m_shiftKeyPressed = false;
 110   m_refreshSwitch = true;
 111   m_refreshSwitchStateOnHide = m_refreshSwitch;
 112
 113   // set the refresh rate
 114   setRefreshRate(10);
 115
 116   // connect it to grabFrame()
 117   connect(&m_grabTimer, SIGNAL(timeout()), SLOT(grabFrame()));
 118   // start the grabTimer
 119   m_grabTimer.start(static_cast<int>(1000.0/m_fps));
 120
 121   // connect it to updateMouseView()
 122   connect(&m_mouseViewTimer, SIGNAL(timeout()), SLOT(updateMouseView()));
 123   // start the grabTimer @ 25 frames per second!
 124   m_mouseViewTimer.start(25);
 125
 126   this->setWhatsThis( i18n("This is the main window which shows the contents of the\
 127  selected region. The contents will be magnified according to the zoom level that is set."));
 128
 129   // different ways to show the cursor.
 130   m_showMouseTypes << "Hidden" << "Box" << "Arrow" << "Actual";
 131
 132   if(m_fitToWindow)
 133     fitToWindow();
 134 }
 135
 136 KMagZoomView::~KMagZoomView()
 137 {
 138   KApplication::setGlobalMouseTracking(true);
 139 }
 140
 141 /**
 142  * This function will set/reset mouse following of grab window.
 143  */
 144 void KMagZoomView::followMouse(bool follow)
 145 {
 146   if(follow) {
 147     m_followMouse = true;
 148     m_mouseMode = Normal;
 149     setVScrollBarMode (Q3ScrollView::AlwaysOff);
 150     setHScrollBarMode (Q3ScrollView::AlwaysOff);
 151   } else {
 152     m_followMouse = false;
 153     m_mouseMode = Normal;
 154     setVScrollBarMode (Q3ScrollView::AlwaysOn);
 155     setHScrollBarMode (Q3ScrollView::AlwaysOn);
 156   }
 157 }
 158
 159 /**
 160  * Called when the widget is hidden. Stop refresh when this happens.
 161  */
 162 void KMagZoomView::hideEvent( QHideEvent* )
 163 {
 164   // Save the state of the refresh switch.. the state will be restored
 165   // when showEvent is called
 166   m_refreshSwitchStateOnHide = m_refreshSwitch;
 167
 168   // Check if refresh is ON
 169   if(m_refreshSwitch) {
 170     toggleRefresh();
 171   }
 172 }
 173
 174
 175 /**
 176  * Called when the widget is shown. Start refresh when this happens.
 177  */
 178 void KMagZoomView::showEvent( QShowEvent* )
 179 {
 180   // Check if refresh switch was ON when hide was called and if currently it is OFF
 181   if(m_refreshSwitchStateOnHide && !m_refreshSwitch) {
 182     // start the refresh in that case
 183     toggleRefresh();
 184   }
 185 }
 186
 187 /**
 188  * Called when the widget is resized. Check if fitToWindow is active when this happens.
 189  */
 190 void KMagZoomView::resizeEvent( QResizeEvent * e )
 191 {
 192   Q3ScrollView::resizeEvent (e);
 193   if(m_fitToWindow)
 194     fitToWindow();
 195 }
 196
 197 /**
 198  * Called when the widget is to be repainted.
 199  *
 200  * @param p
 201  */
 202 void KMagZoomView::drawContents ( QPainter * p, int clipx, int clipy, int clipw, int cliph )
 203 {
 204   if(m_zoomedPixmap.isNull())
 205     return;
 206
 207   // Paint empty areas Qt::black
 208   if (contentsX()+contentsWidth() < visibleWidth())
 209     p->fillRect (
 210         QRect (contentsX()+contentsWidth(), clipy, visibleWidth()-contentsX()-contentsWidth(), cliph)
 211         & QRect (clipx, clipy, clipw, cliph),
 212         Qt::black);
 213   if (contentsY()+contentsHeight() < visibleHeight())
 214     p->fillRect (
 215         QRect (clipx, contentsY()+contentsHeight(), clipw, visibleHeight()-contentsY()-contentsHeight())
 216         & QRect (clipx, clipy, clipw, cliph),
 217         Qt::black);
 218
 219   // A pixmap which will be eventually displayed
 220   QPixmap *zoomView;
 221
 222   // Get mouse position relative to the image
 223   QPoint mousePos = calcMousePos (m_refreshSwitch);
 224
 225   // show the pixel under mouse cursor
 226   if(m_showMouse) {
 227
 228     // Pixmap which will have the zoomed pixmap + mouse
 229     zoomView = new QPixmap(m_zoomedPixmap);
 230
 231     // paint the mouse cursor
 232     paintMouseCursor(zoomView, mousePos);
 233   } else { // do not show mouse
 234     zoomView = &m_zoomedPixmap;
 235   }
 236
 237   // bitBlt this part on to the widget.
 238   bitBlt(viewport(), QPoint (clipx-contentsX(), clipy-contentsY()), zoomView, QRect(clipx, clipy, clipw, cliph));
 239
 240   if(zoomView != &m_zoomedPixmap)
 241     delete zoomView;
 242 }
 243
 244 /**
 245  * Draws the mouse cursor according to the current selection of the type of
 246  * mouse cursor to draw.
 247  */
 248 void KMagZoomView::paintMouseCursor(QPaintDevice *dev, const QPoint &mousePos)
 249 {
 250   if(!dev)
 251     return;
 252
 253   // painter for the zoom view
 254   QPainter pz(dev);
 255
 256   if(m_latestCursorPos.x() >= 0 && m_latestCursorPos.x() < m_selRect.width() &&
 257      m_latestCursorPos.y() >= 0 && m_latestCursorPos.y() < m_selRect.height() ) { // || updateMousePos) {
 258     // mouse position is indeed inside the selRect
 259
 260     // How to show the mouse :
 261
 262     switch(m_showMouse) {
 263     case 1:
 264       // 1. Square around the pixel
 265       pz.setPen(Qt::white);
 266 #ifdef __GNUC__
 267 #warning "Port Qt4 pz.setRasterOp(Qt::XorROP);";
 268 #endif
 269       //pz.setRasterOp(Qt::XorROP);
 270       pz.drawRect(mousePos.x()-1, mousePos.y()-1, (int)m_zoom+2, (int)m_zoom+2);
 271       break;
 272
 273     case 2:
 274     {
 275       // 2. Arrow cursor
 276       pz.setPen(Qt::black);
 277       pz.setBackgroundColor(Qt::white);
 278
 279       QBitmap sCursor = QBitmap::fromData( QSize(16,  16),  left_ptr_bits);
 280       QBitmap mask = QBitmap::fromData( QSize(16,  16),  left_ptrmsk_bits);
 281       sCursor.setMask(mask);
 282       sCursor = sCursor.transformed(m_zoomMatrix);
 283
 284       // since hot spot is at 3,1
 285       if (m_rotation == 0)
 286         pz.drawPixmap(mousePos.x()-(int)(3.0*m_zoom), mousePos.y()-(int)m_zoom, sCursor);
 287       else if (m_rotation == 90)
 288         pz.drawPixmap(mousePos.x()-(int)(16.0*m_zoom), mousePos.y()-(int)(3.0*m_zoom), sCursor);
 289       else if (m_rotation == 180)
 290         pz.drawPixmap(mousePos.x()-(int)(13.0*m_zoom), mousePos.y()-(int)(16.0*m_zoom), sCursor);
 291       else if (m_rotation == 270)
 292         pz.drawPixmap(mousePos.x()-(int)m_zoom, mousePos.y()-(int)(13.0*m_zoom), sCursor);
 293     }
 294     break;
 295
 296     case 3:
 297     {
 298       // 3. Actual cursor
 299       // Get the current cursor type
 300       QWidget *dummy  = KApplication::topLevelAt(QCursor::pos());
 301       if(!dummy)
 302         break;
 303       kDebug() << ">" << dummy->name() << ":" << dummy->cursor().shape() << "-";
 304       switch(this->cursor().shape())  {
 305                           case Qt::ArrowCursor :
 306          {
 307           // 2. Arrow cursor
 308           pz.setPen(Qt::black);
 309           pz.setBackgroundColor(Qt::white);
 310
 311           QBitmap sCursor = QBitmap::fromData( QSize(16,  16),  left_ptr_bits);
 312           QBitmap mask = QBitmap::fromData( QSize(16,  16),  left_ptrmsk_bits);
 313           sCursor.setMask(mask);
 314           sCursor = sCursor.transformed(m_zoomMatrix);
 315
 316           // since hot spot is at 3,1
 317           pz.drawPixmap(mousePos.x()-(int)(3.0*m_zoom), mousePos.y()-(int)m_zoom, sCursor);
 318         }
 319         break;
 320         default:
 321           QBitmap sCursor = QBitmap::fromData( QSize(32,  32),  phand_bits);
 322           QBitmap mask = QBitmap::fromData( QSize(32,  32),  phandm_bits);
 323           sCursor.setMask(mask);
 324
 325           pz.drawPixmap(mousePos.x(), mousePos.y(), sCursor);
 326         break;
 327       } // switch(cursor)
 328
 329
 330     }
 331     break;
 332
 333     default:
 334       // do not show anything
 335       break;
 336     } // switch(m_showMouse)
 337   }
 338 }
 339
 340
 341 QPoint KMagZoomView::calcMousePos(bool updateMousePos)
 342 {
 343   // get position of mouse wrt selRect
 344   if(updateMousePos) { // get a new position only if asked
 345     m_latestCursorPos = QCursor::pos();
 346     m_latestCursorPos -= QPoint(m_selRect.x(), m_selRect.y());
 347   }
 348
 349   // get coordinates of the pixel w.r.t. the zoomed pixmap
 350   if (m_rotation == 90)
 351     return QPoint ((int)((float)(m_selRect.height()-m_latestCursorPos.y())*m_zoom),
 352                    (int)((float)m_latestCursorPos.x()*m_zoom));
 353   else if (m_rotation == 180)
 354     return QPoint ((int)((float)(m_selRect.width()-m_latestCursorPos.x())*m_zoom),
 355                    (int)((float)(m_selRect.height()-m_latestCursorPos.y())*m_zoom));
 356   else if (m_rotation == 270)
 357     return QPoint ((int)((float)m_latestCursorPos.y()*m_zoom),
 358                    (int)((float)(m_selRect.width()-m_latestCursorPos.x())*m_zoom));
 359   else
 360     return QPoint ((int)((float)m_latestCursorPos.x()*m_zoom),
 361                    (int)((float)m_latestCursorPos.y()*m_zoom));
 362 }
 363
 364
 365 // MOUSE ACTIONS
 366
 367 /**
 368  * Called when mouse is clicked inside the window.
 369  *
 370  * @param e
 371  */
 372 void KMagZoomView::mousePressEvent(QMouseEvent *e)
 373 {
 374   switch(e->button()) {
 375   case Qt::LeftButton :
 376     if(m_ctrlKeyPressed) {
 377       // check if currently in resize mode
 378       // don't do anything if fitToWindow is enabled
 379       if ((m_mouseMode != ResizeSelection) && !m_fitToWindow) {
 380         // set the mode to ResizeSelection
 381         m_mouseMode = ResizeSelection;
 382
 383         // set mouse cursor to "resize all direction"
 384         setCursor(Qt::SizeAllCursor);
 385
 386         // backup the old position
 387         m_oldMousePos.setX(e->globalX());
 388         m_oldMousePos.setY(e->globalY());
 389
 390         // set the cursor position to the bottom-right of the selected region
 391         QCursor::setPos(m_selRect.bottomRight());
 392
 393         // show the selection rectangle
 394         m_selRect.show();
 395       }
 396       else {
 397         // ignore this button press.. so it goes to the parent
 398         e->ignore();
 399       }
 400     } else if(m_shiftKeyPressed) {
 401       // check if currently in move mode
 402       // don't do anything if follow mouse is enabled
 403       if ((m_mouseMode != MoveSelection) && !m_followMouse) {
 404         m_mouseMode = MoveSelection;
 405
 406         // set mouse cursor to cross hair
 407         setCursor(Qt::CrossCursor);
 408
 409         // backup the old position
 410         m_oldMousePos.setX(e->globalX());
 411         m_oldMousePos.setY(e->globalY());
 412
 413         // set the cursor position to the center of the selected region
 414         QCursor::setPos(m_selRect.center());
 415
 416         // show the selected rectangle
 417         m_selRect.show();
 418       }
 419       else {
 420         // ignore this button press.. so it goes to the parent
 421         e->ignore();
 422       }
 423     } else {
 424       // check if currently in move mode
 425       // don't do anything if follow mouse is enabled
 426       if ((m_mouseMode != GrabSelection) && !m_followMouse) {
 427         m_mouseMode = GrabSelection;
 428
 429         // set mouse cursor to hand
 430         setCursor(Qt::PointingHandCursor);
 431
 432         // store the old position
 433         m_oldMousePos.setX(e->globalX());
 434         m_oldMousePos.setY(e->globalY());
 435
 436         m_oldCenter = m_selRect.center();
 437
 438         // show the selected rectangle
 439         m_selRect.show();
 440       }
 441       else {
 442         // ignore this button press.. so it goes to the parent
 443         e->ignore();
 444       }
 445     }
 446     break;
 447
 448   case Qt::MidButton :
 449     // check if currently in move mode
 450     // don't do anything if follow mouse is enabled
 451     if ((m_mouseMode != MoveSelection) && !m_followMouse) {
 452       m_mouseMode = MoveSelection;
 453
 454       // set mouse cursor to cross hair
 455       setCursor(Qt::CrossCursor);
 456
 457       // backup the old position
 458       m_oldMousePos.setX(e->globalX());
 459       m_oldMousePos.setY(e->globalY());
 460
 461       // set the cursor position to the center of the selected region
 462       QCursor::setPos(m_selRect.center());
 463
 464       // show the selected rectangle
 465       m_selRect.show();
 466     }
 467     else {
 468       // ignore this button press.. so it goes to the parent
 469       e->ignore();
 470     }
 471     break;
 472   // do nothing
 473   default:
 474     // ignore this button press.. so it goes to the parent
 475     e->ignore();
 476     break;
 477   }
 478 }
 479
 480
 481 /**
 482  * Called when a mouse button is released
 483  *
 484  * @param e
 485  */
 486 void KMagZoomView::mouseReleaseEvent(QMouseEvent *e)
 487 {
 488   switch(e->button()) {
 489   case Qt::LeftButton :
 490   case Qt::MidButton :
 491     // check if currently in move mode
 492     if(m_mouseMode == MoveSelection) {
 493       // hide the selection window
 494       m_selRect.hide();
 495       // set the mouse mode to normal
 496       m_mouseMode = Normal;
 497
 498       // restore the cursor shape
 499       setCursor(Qt::ArrowCursor);
 500
 501       // restore the cursor position
 502       QCursor::setPos(m_oldMousePos);
 503     } else if(m_mouseMode == ResizeSelection) {
 504       // hide the selection window
 505       m_selRect.hide();
 506       // set the mouse mode to normal
 507       m_mouseMode = Normal;
 508
 509       // restore the cursor shape
 510       setCursor(Qt::ArrowCursor);
 511
 512       // restore the cursor position
 513       QCursor::setPos(m_oldMousePos);
 514     } else if(m_mouseMode == GrabSelection) {
 515       // hide the selection window
 516       m_selRect.hide();
 517
 518       // set the mouse mode to normal
 519       m_mouseMode = Normal;
 520
 521       // restore the cursor shape
 522       setCursor(Qt::ArrowCursor);
 523     }
 524     break;
 525
 526   case Qt::RightButton :
 527     break;
 528   case Qt::NoButton :
 529     break;
 530
 531   // do nothing
 532   default:
 533     ;
 534   }
 535 }
 536
 537
 538 /**
 539  * Called when mouse is moved inside the window
 540  *
 541  * @param e
 542  */
 543 void KMagZoomView::mouseMoveEvent(QMouseEvent *e)
 544 {
 545   if(m_mouseMode == ResizeSelection) {
 546     // In resize selection mode
 547     // set the current mouse position as the bottom, right corner
 548     m_selRect.setRight(e->globalX());
 549     m_selRect.setBottom(e->globalY());
 550     m_selRect.update();
 551     grabFrame();
 552   } else if(m_mouseMode == MoveSelection) {
 553      QPoint newCenter;
 554
 555     // set new center to be the current mouse position
 556     newCenter = e->globalPos();
 557
 558     // make sure the mouse position is not taking the grab window outside
 559     // the display
 560     if(newCenter.x() < m_selRect.width()/2) {
 561       // set X to the minimum possible X
 562       newCenter.setX(m_selRect.width()/2);
 563     } else if(newCenter.x() >=  QApplication::desktop()->width()-m_selRect.width()/2) {
 564       // set X to the maximum possible X
 565       newCenter.setX(QApplication::desktop()->width()-m_selRect.width()/2-1);
 566     }
 567
 568     if(newCenter.y() < m_selRect.height()/2) {
 569       // set Y to the minimum possible Y
 570       newCenter.setY(m_selRect.height()/2);
 571     } else if(newCenter.y() >=  QApplication::desktop()->height()-m_selRect.height()/2) {
 572       // set Y to the maximum possible Y
 573       newCenter.setY(QApplication::desktop()->height()-m_selRect.height()/2-1);
 574     }
 575     // move to the new center
 576     m_selRect.moveCenter(newCenter);
 577     // update the grab rectangle display
 578     m_selRect.update();
 579     grabFrame();
 580   } else if(m_mouseMode == GrabSelection) {
 581      QPoint newPos;
 582
 583     // get new position
 584     newPos = e->globalPos();
 585
 586     QPoint delta = (newPos - m_oldMousePos)/m_zoom;
 587     QPoint newCenter = m_oldCenter-delta;
 588
 589     // make sure the mouse position is not taking the grab window outside
 590     // the display
 591     if(newCenter.x() < m_selRect.width()/2) {
 592       // set X to the minimum possible X
 593       newCenter.setX(m_selRect.width()/2);
 594     } else if(newCenter.x() >=  QApplication::desktop()->width()-m_selRect.width()/2) {
 595       // set X to the maximum possible X
 596       newCenter.setX(QApplication::desktop()->width()-m_selRect.width()/2-1);
 597     }
 598
 599     if(newCenter.y() < m_selRect.height()/2) {
 600       // set Y to the minimum possible Y
 601       newCenter.setY(m_selRect.height()/2);
 602     } else if(newCenter.y() >=  QApplication::desktop()->height()-m_selRect.height()/2) {
 603       // set Y to the maximum possible Y
 604       newCenter.setY(QApplication::desktop()->height()-m_selRect.height()/2-1);
 605     }
 606
 607     // move to the new center
 608     m_selRect.moveCenter(newCenter);
 609     // update the grab rectangle display
 610     m_selRect.update();
 611     grabFrame();
 612   }
 613 }
 614
 615 void KMagZoomView::keyPressEvent(QKeyEvent *e)
 616 {
 617   int offset = 16;
 618   if (e->state() & Qt::ShiftModifier)
 619     offset = 1;
 620
 621   if (e->key() == Qt::Key_Control)
 622     m_ctrlKeyPressed = true;
 623   else if (e->key() == Qt::Key_Shift)
 624     m_shiftKeyPressed = true;
 625   else if (e->key() == Qt::Key_Left)
 626   {
 627     if (e->state() & Qt::ControlModifier)
 628     {
 629       if (offset >= m_selRect.width())
 630         m_selRect.setWidth (1);
 631       else
 632         m_selRect.setWidth (m_selRect.width()-offset);
 633   }
 634     else if (contentsX() > 0)
 635     {
 636       offset = (int)(offset*m_zoom);
 637       if (contentsX() > offset)
 638         setContentsPos (contentsX()-offset, contentsY());
 639       else
 640         setContentsPos (0, contentsY());
 641     }
 642     else if (m_followMouse == false)
 643     {
 644       if (offset > m_selRect.x())
 645         m_selRect.setX (0);
 646       else
 647         m_selRect.translate (-offset,0);
 648     }
 649     m_selRect.update();
 650   }
 651   else if (e->key() == Qt::Key_Right)
 652   {
 653     if (e->state() & Qt::ControlModifier)
 654     {
 655       if (m_selRect.right()+offset >= QApplication::desktop()->width())
 656         m_selRect.setRight (QApplication::desktop()->width()-1);
 657       else
 658         m_selRect.setRight (m_selRect.right()+offset);
 659     }
 660     else if (contentsX() < contentsWidth()-visibleWidth())
 661     {
 662       offset = (int)(offset*m_zoom);
 663       if (contentsX()+offset < contentsWidth()-visibleWidth())
 664         setContentsPos (contentsX()+offset, contentsY());
 665       else
 666         setContentsPos (contentsWidth()-visibleWidth(), contentsY());
 667     }
 668     else if (m_followMouse == false)
 669     {
 670       if (m_selRect.right()+offset >= QApplication::desktop()->width())
 671         m_selRect.moveTopRight (QPoint (QApplication::desktop()->width()-1, m_selRect.top()));
 672       else
 673         m_selRect.translate (offset,0);
 674     }
 675     m_selRect.update();
 676   }
 677   else if (e->key() == Qt::Key_Up)
 678   {
 679     if (e->state() & Qt::ControlModifier)
 680     {
 681       if (offset >= m_selRect.height())
 682         m_selRect.setHeight (1);
 683       else
 684         m_selRect.setHeight (m_selRect.height()-offset);
 685     }
 686     else if (contentsY() > 0)
 687     {
 688       offset = (int)(offset*m_zoom);
 689       if (contentsY() > offset)
 690         setContentsPos (contentsX(), contentsY()-offset);
 691       else
 692         setContentsPos (contentsX(), 0);
 693     }
 694     else if (m_followMouse == false)
 695     {
 696       if (offset > m_selRect.y())
 697         m_selRect.setY (0);
 698       else
 699         m_selRect.translate (0, -offset);
 700     }
 701     m_selRect.update();
 702   }
 703   else if (e->key() == Qt::Key_Down)
 704   {
 705     if (e->state() & Qt::ControlModifier)
 706     {
 707       if (m_selRect.bottom()+offset >= QApplication::desktop()->height())
 708         m_selRect.setBottom (QApplication::desktop()->height()-1);
 709       else
 710         m_selRect.setBottom (m_selRect.bottom()+offset);
 711     }
 712     else if (contentsY() < contentsHeight()-visibleHeight())
 713     {
 714       offset = (int)(offset*m_zoom);
 715       if (contentsY()+offset < contentsHeight()-visibleHeight())
 716         setContentsPos (contentsX(), contentsY()+offset);
 717       else
 718         setContentsPos (contentsX(), contentsHeight()-visibleHeight());
 719     }
 720     else if (m_followMouse == false)
 721     {
 722       if (m_selRect.bottom()+offset >= QApplication::desktop()->height())
 723         m_selRect.moveBottomLeft (QPoint (m_selRect.left(), QApplication::desktop()->height()-1));
 724       else
 725         m_selRect.translate (0, offset);
 726     }
 727     m_selRect.update();
 728   }
 729   else
 730     e->ignore();
 731 }
 732
 733 void KMagZoomView::keyReleaseEvent(QKeyEvent *e)
 734 {
 735   if (e->key() == Qt::Key_Control)
 736     m_ctrlKeyPressed = false;
 737   else if (e->key() == Qt::Key_Shift)
 738     m_shiftKeyPressed = false;
 739   else
 740     e->ignore();
 741 }
 742
 743 void KMagZoomView::focusOutEvent(QFocusEvent *e)
 744 {
 745   if(e->lostFocus() == true) {
 746     m_ctrlKeyPressed = false;
 747     m_shiftKeyPressed = false;
 748   }
 749 }
 750
 751 // SLOTS
 752
 753 /**
 754  * This will fit the zoom view to the view window, thus using the maximum
 755  * possible space in the window.
 756  */
 757 void KMagZoomView::fitToWindow()
 758 {
 759   unsigned int newWidth, newHeight;
 760
 761   // this is a temporary solution, cast, maybe newWidth and newHeight should be float
 762   if ((m_rotation == 90) || (m_rotation == 270))
 763   {
 764     newWidth = static_cast<unsigned int>(visibleHeight()/m_zoom);
 765     newHeight = static_cast<unsigned int>(visibleWidth()/m_zoom);
 766   } else {
 767     newWidth = static_cast<unsigned int>(visibleWidth()/m_zoom);
 768     newHeight = static_cast<unsigned int>(visibleHeight()/m_zoom);
 769   }
 770
 771   QPoint currCenter = m_selRect.center();
 772
 773   m_selRect.setWidth(newWidth);
 774   m_selRect.setHeight(newHeight);
 775
 776    // make sure the selection window does not go outside of the display
 777    if(currCenter.x() < m_selRect.width()/2) {
 778      // set X to the minimum possible X
 779      currCenter.setX(m_selRect.width()/2);
 780    } else if(currCenter.x() >=  QApplication::desktop()->width()-m_selRect.width()/2) {
 781      // set X to the maximum possible X
 782      currCenter.setX(QApplication::desktop()->width()-m_selRect.width()/2-1);
 783    }
 784
 785    if(currCenter.y() < m_selRect.height()/2) {
 786      // set Y to the minimum possible Y
 787      currCenter.setY(m_selRect.height()/2);
 788    } else if(currCenter.y() >=  QApplication::desktop()->height()-m_selRect.height()/2) {
 789      // set Y to the maximum possible Y
 790      currCenter.setY(QApplication::desktop()->height()-m_selRect.height()/2-1);
 791    }
 792
 793   m_selRect.moveCenter(currCenter);
 794   // update the grab rectangle display
 795   m_selRect.update();
 796 //  m_fitToWindow = true;
 797   viewport()->repaint(false);
 798 }
 799
 800 void KMagZoomView::setFitToWindow(bool fit)
 801 {
 802   m_fitToWindow = fit;
 803   if (fit)
 804     fitToWindow();
 805 }
 806
 807
 808 /**
 809  * Grabs frame from X
 810  */
 811 void KMagZoomView::grabFrame()
 812 {
 813   // check refresh status
 814   if (!m_refreshSwitch)
 815      return;
 816
 817   // check if follow-mouse is enabled
 818   if(m_followMouse && (m_mouseMode != ResizeSelection)) {
 819     // in this case grab w.r.t the current mouse position
 820      QPoint newCenter;
 821
 822     // set new center to be the current mouse position
 823     newCenter = QCursor::pos();
 824
 825     // make sure the mouse position is not taking the grab window outside
 826     // the display
 827     if(newCenter.x() < m_selRect.width()/2) {
 828       // set X to the minimum possible X
 829       newCenter.setX(m_selRect.width()/2);
 830     } else if(newCenter.x() >=  QApplication::desktop()->width()-m_selRect.width()/2) {
 831       // set X to the maximum possible X
 832       newCenter.setX(QApplication::desktop()->width()-m_selRect.width()/2-1);
 833     }
 834
 835     if(newCenter.y() < m_selRect.height()/2) {
 836       // set Y to the minimum possible Y
 837       newCenter.setY(m_selRect.height()/2);
 838     } else if(newCenter.y() >=  QApplication::desktop()->height()-m_selRect.height()/2) {
 839       // set Y to the maximum possible Y
 840       newCenter.setY(QApplication::desktop()->height()-m_selRect.height()/2-1);
 841     }
 842     // move to the new center
 843     m_selRect.moveCenter(newCenter);
 844
 845     // update the grab rectangle display
 846     m_selRect.update();
 847   }
 848
 849   //QRect r = pixmapRect();
 850
 851   // define a normalized rectangle
 852   QRect selRect = m_selRect.normalized();
 853
 854   // grab screenshot from the screen and put it in the pixmap
 855   m_grabbedPixmap = QPixmap::grabWindow(QApplication::desktop()->winId(), selRect.x(), selRect.y(),
 856                                         selRect.width(), selRect.height());
 857
 858   // colorize the grabbed pixmap, if applicable - TODO
 859   if (m_colormode == 0)
 860     m_coloredPixmap = m_grabbedPixmap;
 861   else
 862     m_coloredPixmap = ColorSim::recolor(m_grabbedPixmap, m_colormode);
 863
 864   // zoom the image
 865   m_zoomedPixmap = m_coloredPixmap.transformed(m_zoomMatrix);
 866
 867   // call repaint to display the newly grabbed image
 868   resizeContents (m_zoomedPixmap.width(), m_zoomedPixmap.height());
 869   viewport()->repaint(false);
 870 }
 871
 872
 873 /**
 874  * Updates the mouse cursor in the zoom view.
 875  */
 876 void KMagZoomView::updateMouseView()
 877 {
 878   QPoint pos(QCursor::pos());
 879   if(m_selRect.left() <= pos.x() && pos.x() <= m_selRect.right() &&
 880      m_selRect.top() <= pos.y() && pos.y() <= m_selRect.bottom() &&
 881      m_refreshSwitch)
 882     viewport()->repaint(false);
 883 }
 884
 885 /**
 886  * Toggles the state of refreshing.
 887  */
 888 void KMagZoomView::toggleRefresh()
 889 {
 890   if(m_refreshSwitch) {
 891     m_refreshSwitch = false;
 892     m_grabTimer.stop();
 893     m_mouseViewTimer.stop();
 894   } else {
 895     m_refreshSwitch = true;
 896     m_grabTimer.start(1000/m_fps);
 897     m_mouseViewTimer.start(40);
 898   }
 899 }
 900
 901 /**
 902  * This function sets the zoom value to be used.
 903  */
 904 void KMagZoomView::setZoom(float zoom)
 905 {
 906   // use this zoom
 907   m_zoom = zoom;
 908
 909   // update selection window size when zooming in if necessary
 910   if (m_fitToWindow)
 911     fitToWindow();
 912
 913   // recompute the zoom matrix
 914   m_zoomMatrix.reset();
 915   m_zoomMatrix.scale(m_zoom, m_zoom);
 916   m_zoomMatrix.rotate(m_rotation);
 917
 918   m_zoomedPixmap = m_coloredPixmap.transformed(m_zoomMatrix);
 919
 920   viewport()->repaint();
 921 }
 922
 923 /**
 924  * This function sets the rotation value to be used.
 925  */
 926 void KMagZoomView::setRotation(int rotation)
 927 {
 928   // use this rotation
 929   m_rotation = rotation;
 930
 931   // update selection window size if necessary
 932   if (m_fitToWindow)
 933     fitToWindow();
 934
 935   // recompute the zoom matrix
 936   m_zoomMatrix.reset();
 937   m_zoomMatrix.scale(m_zoom, m_zoom);
 938   m_zoomMatrix.rotate(m_rotation);
 939
 940   m_zoomedPixmap = m_coloredPixmap.transformed(m_zoomMatrix);
 941
 942   viewport()->repaint();
 943 }
 944
 945 /**
 946  * Set a new color simulation mode.
 947  */
 948 void KMagZoomView::setColorMode(int mode)
 949 {
 950   if (m_colormode != mode) {
 951     m_colormode = mode;
 952     viewport()->repaint();
 953   }
 954 }
 955
 956 /**
 957  * Set a new refresh rate.
 958  */
 959 void KMagZoomView::setRefreshRate(float fps)
 960 {
 961   if(fps < 0.1)
 962     return;
 963   m_fps = static_cast<unsigned int>(fps);
 964
 965   if(m_grabTimer.isActive())
 966     m_grabTimer.start(static_cast<int>(1000.0/m_fps));
 967 }
 968
 969 void KMagZoomView::showSelRect(bool show)
 970 {
 971   m_selRect.alwaysVisible(show);
 972   if(show) {
 973     m_selRect.show();
 974   } else if(m_mouseMode == Normal) {
 975     m_selRect.hide();
 976   }
 977 }
 978
 979 /**
 980  * Sets the selection rectangle to the given position.
 981  */
 982 void KMagZoomView::setSelRectPos(const QRect & rect)
 983 {
 984   m_selRect.setRect(rect.x(), rect.y(), rect.width(), rect.height());
 985   m_selRect.update();
 986   grabFrame();
 987 }
 988
 989 bool KMagZoomView::showMouse(unsigned int type)
 990 {
 991   if(type > m_showMouseTypes.count()-1)
 992     return (false);
 993   else
 994     m_showMouse = type;
 995
 996   return(true);
 997 }
 998
 999 unsigned int KMagZoomView::getShowMouseType() const
1000 {
1001   return (m_showMouse);
1002 }
1003
1004 QStringList KMagZoomView::getShowMouseStringList() const
1005 {
1006   return (m_showMouseTypes);
1007 }
1008
1009
1010 /**
1011  * Returns the image which is being displayed. It's again drawn by adding
1012  * the mouse cursor if needed.
1013  */
1014 QPixmap KMagZoomView::getPixmap()
1015 {
1016   // show the pixel under mouse cursor
1017   if(m_showMouse && !m_zoomedPixmap.isNull()) {
1018     // Pixmap which will have the zoomed pixmap + mouse
1019     QPixmap zoomView(m_zoomedPixmap);
1020
1021     // paint the mouse cursor w/o updating to a newer position
1022     paintMouseCursor(&zoomView, calcMousePos(false));
1023
1024     return(zoomView);
1025   } else { // no mouse cursor
1026      return(m_zoomedPixmap);
1027   }
1028 }