00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <stdlib.h>
00023 #include <math.h>
00024
00025 #include <qprogressdialog.h>
00026 #include <qfile.h>
00027 #include <qtextstream.h>
00028 #include <qpainter.h>
00029 #include <qpaintdevicemetrics.h>
00030 #include <qwmatrix.h>
00031 #include <qapplication.h>
00032 #include <kpopupmenu.h>
00033 #include <qimage.h>
00034 #include <qdatetime.h>
00035 #include <qdropsite.h>
00036 #include <qrect.h>
00037 #include <qsize.h>
00038 #include <qpoint.h>
00039 #include <qclipboard.h>
00040
00041 #include <kapplication.h>
00042 #include <kmimemagic.h>
00043 #include <klocale.h>
00044 #include <kiconloader.h>
00045 #include <kprinter.h>
00046 #include <kglobal.h>
00047 #include <kglobalsettings.h>
00048 #include <ktempfile.h>
00049 #include <kdebug.h>
00050 #include <kcursor.h>
00051 #include <kmessagebox.h>
00052 #include <kmultipledrag.h>
00053 #include <kconfig.h>
00054 #include <kurl.h>
00055 #include <kurldrag.h>
00056 #include <kio/netaccess.h>
00057
00058 #include <KoParagCounter.h>
00059 #include <KoPoint.h>
00060 #include <KoTextZoomHandler.h>
00061 #include <KoStore.h>
00062 #include <KoStoreDrag.h>
00063 #include "KoPointArray.h"
00064 #include <KoSpeaker.h>
00065
00066 #include "KPrView.h"
00067 #include "KPrBackground.h"
00068 #include "KPrPixmapObject.h"
00069 #include "KPrFreehandObject.h"
00070 #include "KPrBezierCurveObject.h"
00071 #include "KPrGotoPage.h"
00072 #include "KPrTextObject.h"
00073 #include "KPrSoundPlayer.h"
00074 #include "KPrNoteBar.h"
00075 #include "KPrPartObject.h"
00076 #include "KPrUtils.h"
00077 #include "KPrCommand.h"
00078 #include "KPrPolylineObject.h"
00079 #include "KPrClosedLineObject.h"
00080 #include "KPrPage.h"
00081 #include "KPrVariableCollection.h"
00082 #include "KPrGroupObject.h"
00083 #include "KPrDocument.h"
00084
00085 #include "KPrCanvas.h"
00086 #include "KPrCanvas.moc"
00087
00088 #include "KPrEffectHandler.h"
00089 #include "KPrPageEffects.h"
00090 #include <unistd.h>
00091
00092 const int KPrCanvas::MOUSE_SNAP_DISTANCE = 4;
00093 const int KPrCanvas::KEY_SNAP_DISTANCE = 2;
00094
00095 KPrCanvas::KPrCanvas( QWidget *parent, const char *name, KPrView *_view )
00096 : QWidget( parent, name, WStaticContents|WResizeNoErase|WRepaintNoErase )
00097 , buffer( size() )
00098 , m_gl( _view, _view->zoomHandler() )
00099 , m_paintGuides( false )
00100 , m_objectDisplayAbove( 0 )
00101 {
00102 m_presMenu = 0;
00103 m_currentTextObjectView=0L;
00104 m_activePage=0L;
00105 m_xOffset = 0;
00106 m_yOffset = 0;
00107 m_prevSpokenTO = 0;
00108
00109 m_keyPressEvent = false;
00110 m_drawSymetricObject = false;
00111 if ( parent ) {
00112 showingLastSlide = false;
00113 mousePressed = false;
00114 drawContour = false;
00115 modType = MT_NONE;
00116 m_resizeObject = 0;
00117 m_editObject = 0;
00118 m_rotateObject = 0;
00119 setBackgroundMode( Qt::NoBackground );
00120 m_view = _view;
00121 setupMenus();
00122 setMouseTracking( true );
00123 show();
00124 editMode = true;
00125 m_step.m_pageNumber = 0;
00126 m_step.m_step = 0;
00127 m_step.m_subStep = 0;
00128 goingBack = false;
00129 m_drawMode = false;
00130 fillBlack = true;
00131 drawRubber = false;
00132 m_zoomRubberDraw = false;
00133 toolEditMode = TEM_MOUSE;
00134 setAcceptDrops( true );
00135 m_ratio = 0.0;
00136 m_isMoving = false;
00137 m_isResizing = false;
00138 mouseSelectedObject = false;
00139 m_setPageTimer = true;
00140 m_drawLineInDrawMode = false;
00141 soundPlayer = 0;
00142 m_disableSnapping = false;
00143 m_drawPolyline = false;
00144 m_drawCubicBezierCurve = false;
00145 m_drawLineWithCubicBezierCurve = true;
00146 m_oldCubicBezierPointArray.putPoints( 0, 4, 0.0, 0.0, 0.0, 0.0,
00147 0.0, 0.0, 0.0, 0.0 );
00148 m_effectHandler = 0;
00149 m_pageEffect = 0;
00150 } else {
00151 m_view = 0;
00152 hide();
00153 }
00154
00155 setFocusPolicy( QWidget::StrongFocus );
00156 setFocus();
00157 setKeyCompression( true );
00158 setInputMethodEnabled( true );
00159 installEventFilter( this );
00160 KCursor::setAutoHideCursor( this, true, true );
00161 m_zoomBeforePresentation=100;
00162
00163 if( m_view)
00164 {
00165 m_activePage=m_view->kPresenterDoc()->pageList().getFirst();
00166 connect( m_view->kPresenterDoc(), SIGNAL( sig_terminateEditing( KPrTextObject * ) ),
00167 this, SLOT( terminateEditing( KPrTextObject * ) ) );
00168 connect( m_view, SIGNAL( autoScroll( const QPoint & )), this, SLOT( slotAutoScroll( const QPoint &)));
00169 }
00170
00171 if ( kospeaker )
00172 connect( kospeaker, SIGNAL( customSpeakWidget(QWidget*, const QPoint&, uint) ),
00173 this, SLOT( speakTextUnderMouse(QWidget*, const QPoint&, uint) ) );
00174 }
00175
00176 KPrCanvas::~KPrCanvas()
00177 {
00178
00179
00180 blockSignals(true);
00181
00182 exitEditMode( false );
00183
00184 delete m_presMenu;
00185
00186 stopSound();
00187 delete soundPlayer;
00188 blockSignals(false);
00189 }
00190
00191 void KPrCanvas::scrollX( int x )
00192 {
00193
00194 int dx = m_xOffset - x;
00195
00196 m_xOffset = x;
00197 bitBlt( &buffer, dx, 0, &buffer );
00198 scroll( dx, 0 );
00199 }
00200
00201 void KPrCanvas::scrollY( int y )
00202 {
00203
00204 int dy = m_yOffset - y;
00205
00206 m_yOffset = y;
00207 bitBlt( &buffer, 0, dy, &buffer );
00208 scroll( 0, dy );
00209 }
00210
00211 bool KPrCanvas::eventFilter( QObject *o, QEvent *e )
00212 {
00213 if ( !o || !e )
00214 return TRUE;
00215 if ( m_currentTextObjectView )
00216 KCursor::autoHideEventFilter( o, e );
00217 switch ( e->type() )
00218 {
00219 case QEvent::FocusIn:
00220 if ( m_currentTextObjectView )
00221 m_currentTextObjectView->focusInEvent();
00222 return TRUE;
00223 case QEvent::FocusOut:
00224 if ( m_currentTextObjectView )
00225 m_currentTextObjectView->focusOutEvent();
00226 return TRUE;
00227 case QEvent::KeyPress:
00228 {
00229 QKeyEvent * keyev = static_cast<QKeyEvent *>(e);
00230 if ( keyev->key() == KGlobalSettings::contextMenuKey() ) {
00231 popupContextMenu();
00232 return true;
00233 }
00234 if ( m_currentTextObjectView &&
00235 (keyev->key()==Qt::Key_Home ||keyev->key()==Key_End
00236 || keyev->key()==Qt::Key_Tab || keyev->key()==Key_Prior
00237 || keyev->key()==Qt::Key_Next || keyev->key() == Key_Backtab) )
00238 {
00239 m_currentTextObjectView->keyPressEvent( keyev );
00240 return true;
00241 }
00242 else if ( !m_currentTextObjectView && keyev->key()==Qt::Key_Tab )
00243 {
00244 keyPressEvent(keyev);
00245 return true;
00246 }
00247 break;
00248 }
00249 case QEvent::AccelOverride:
00250 {
00251 #ifndef NDEBUG
00252 QKeyEvent * keyev = static_cast<QKeyEvent *>(e);
00253
00254 if ( ( keyev->state() & ControlButton ) && ( keyev->state() & ShiftButton ) )
00255 {
00256 switch ( keyev->key() ) {
00257 case Qt::Key_P:
00258 printRTDebug( 0 );
00259 keyev->accept();
00260 break;
00261 case Qt::Key_V:
00262 printRTDebug( 1 );
00263 keyev->accept();
00264 break;
00265 default:
00266 break;
00267 }
00268 }
00269 #endif
00270 break;
00271 }
00272 default:
00273 break;
00274 }
00275 return QWidget::eventFilter(o,e);
00276 }
00277
00278 bool KPrCanvas::focusNextPrevChild( bool )
00279 {
00280 return TRUE;
00281 }
00282
00283 void KPrCanvas::paintEvent( QPaintEvent* paintEvent )
00284 {
00285 if ( isUpdatesEnabled() )
00286 {
00287
00288 KPrDocument *doc =m_view->kPresenterDoc();
00289
00290 if ( ! m_paintGuides )
00291 {
00292
00293 QPainter bufPainter;
00294 bufPainter.begin( &buffer, this );
00295 bufPainter.translate( -diffx(), -diffy() );
00296 bufPainter.setBrushOrigin( -diffx(), -diffy() );
00297
00298 QRect crect( paintEvent->rect() );
00299 bufPainter.setClipRect( crect );
00300
00301
00302
00303 crect.moveBy( diffx(), diffy() );
00304
00305
00306 if ( editMode || !fillBlack )
00307 bufPainter.fillRect( crect, white );
00308 else
00309 bufPainter.fillRect( crect, black );
00310
00311 KPrPage * page = editMode ? m_activePage : doc->pageList().at( m_step.m_pageNumber );
00312 drawBackground( &bufPainter, crect, page, editMode );
00313
00314 if ( editMode )
00315 {
00316 SelectionMode selectionMode;
00317
00318 if ( toolEditMode == TEM_MOUSE || toolEditMode == TEM_ZOOM )
00319 selectionMode = SM_MOVERESIZE;
00320 else if ( toolEditMode == TEM_ROTATE )
00321 selectionMode = SM_ROTATE;
00322 else
00323 selectionMode = SM_NONE;
00324
00325 if ( doc->showGrid() )
00326 drawGrid( &bufPainter, crect );
00327
00328 drawEditPage( &bufPainter, crect, page, selectionMode );
00329 }
00330 else
00331 {
00332
00333 #if 0 // this works but isn't enough - e.g. object effects need the same offsets
00334
00335
00336 QRect desk = KGlobalSettings::desktopGeometry(this);
00337 QRect pgRect = m_view->kPresenterDoc()->pageList().at(0)->getZoomPageRect();
00338 int offx = 0, offy = 0;
00339 if ( desk.width() > pgRect.width() )
00340 offx = ( desk.width() - pgRect.width() ) / 2;
00341 if ( desk.height() > pgRect.height() )
00342 offy = ( desk.height() - pgRect.height() ) / 2;
00343 bufPainter.translate( offx, offy );
00344 #endif
00345
00346 PresStep step( m_step.m_pageNumber, m_step.m_step, m_step.m_subStep, m_effectTimer.isActive(), !goingBack );
00347 drawPresPage( &bufPainter, crect, step );
00348 if ( m_drawMode && m_drawModeLines.count() )
00349 {
00350 bufPainter.save();
00351 bufPainter.setPen( m_view->kPresenterDoc()->presPen() );
00352 for ( unsigned int i = 0; i < m_drawModeLines.count(); ++i )
00353 {
00354 bufPainter.drawPolyline( m_drawModeLines[i] );
00355 }
00356 bufPainter.restore();
00357 }
00358 }
00359
00360 bufPainter.end();
00361 }
00362
00363
00364 QPixmap topBuffer( buffer );
00365 QPainter topPainter( &topBuffer, &buffer );
00366 topPainter.translate( -diffx(), -diffy() );
00367 topPainter.setBrushOrigin( -diffx(), -diffy() );
00368
00369 if ( editMode && doc->showGuideLines() )
00370 {
00371 m_gl.paintGuides( topPainter );
00372 }
00373
00374 topPainter.setPen( QPen( Qt::black, 1, Qt::SolidLine ) );
00375 topPainter.setRasterOp( NotROP );
00376 switch ( toolEditMode )
00377 {
00378 case MT_NONE:
00379 if ( drawRubber )
00380 {
00381 topPainter.setPen( QPen( black, 0, DotLine ) );
00382 topPainter.drawRect( m_view->zoomHandler()->zoomRect( m_rubber ) );
00383 }
00384 break;
00385 case INS_RECT:
00386 if ( !m_insertRect.isNull() )
00387 {
00388 topPainter.drawRoundRect( m_view->zoomHandler()->zoomRect( m_insertRect.normalize() ),
00389 m_view->getRndX(), m_view->getRndY() );
00390 }
00391 break;
00392 case INS_ELLIPSE:
00393 if ( !m_insertRect.isNull() )
00394 {
00395 topPainter.drawEllipse( m_view->zoomHandler()->zoomRect( m_insertRect.normalize() ) );
00396 }
00397 break;
00398 case INS_AUTOFORM:
00399 case INS_DIAGRAMM:
00400 case INS_FORMULA:
00401 case INS_CLIPART:
00402 case INS_PICTURE:
00403 case INS_OBJECT:
00404 case INS_TABLE:
00405 case INS_TEXT:
00406 if ( !m_insertRect.isNull() )
00407 {
00408 topPainter.drawRect( m_view->zoomHandler()->zoomRect( m_insertRect.normalize() ) );
00409 }
00410 break;
00411 case INS_PIE:
00412 if ( !m_insertRect.isNull() )
00413 {
00414 drawPieObject( &topPainter, m_insertRect );
00415 }
00416 break;
00417 case INS_LINE:
00418 topPainter.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
00419 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
00420 break;
00421 case INS_FREEHAND:
00422 case INS_CLOSED_FREEHAND:
00423 case INS_POLYLINE:
00424 case INS_CLOSED_POLYLINE:
00425 {
00426 QPointArray pointArray = m_pointArray.zoomPointArray( m_view->zoomHandler() );
00427 topPainter.drawPolyline( pointArray );
00428 topPainter.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
00429 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
00430 } break;
00431 case INS_QUADRICBEZIERCURVE:
00432 case INS_CUBICBEZIERCURVE:
00433 case INS_CLOSED_QUADRICBEZIERCURVE:
00434 case INS_CLOSED_CUBICBEZIERCURVE:
00435 if ( m_drawCubicBezierCurve )
00436 {
00437 if ( m_indexPointArray > 0 )
00438 {
00439 redrawCubicBezierCurve( topPainter );
00440 drawCubicBezierCurve( topPainter, m_oldCubicBezierPointArray );
00441 }
00442 }
00443 break;
00444 case INS_POLYGON:
00445 drawPolygon( topPainter, m_insertRect );
00446 break;
00447 default:
00448 break;
00449 }
00450 topPainter.end();
00451 bitBlt( this, paintEvent->rect().topLeft(), &topBuffer, paintEvent->rect() );
00452 }
00453
00454 }
00455
00456
00457 void KPrCanvas::drawBackground( QPainter *painter, const QRect& rect, KPrPage * page, bool edit ) const
00458 {
00459 if ( edit )
00460 {
00461 QRect pageRect = page->getZoomPageRect();
00462
00463 if ( rect.intersects( pageRect ) )
00464 {
00465 if ( page->displayBackground() )
00466 {
00467 if ( page->masterPage() && page->useMasterBackground() )
00468 page->masterPage()->background()->drawBackground( painter, m_view->zoomHandler(), rect, true );
00469 else
00470 page->background()->drawBackground( painter, m_view->zoomHandler(), rect, true );
00471 }
00472 }
00473
00474 pageRect.rLeft() -= 1;
00475 pageRect.rTop() -= 1;
00476 pageRect.rRight() += 1;
00477 pageRect.rBottom() += 1;
00478
00479 QRegion grayRegion( rect );
00480 grayRegion -= pageRect;
00481
00482
00483 if ( !grayRegion.isEmpty() )
00484 eraseEmptySpace( painter, grayRegion, QApplication::palette().active().brush( QColorGroup::Mid ) );
00485 }
00486 else
00487 {
00488
00489
00490
00491 QRect desk = KGlobalSettings::desktopGeometry(getView());
00492 QRect crect = desk.intersect( rect );
00493 if ( crect.isEmpty() || !page->displayBackground())
00494 return;
00495
00496 if ( page->masterPage() && page->useMasterBackground() )
00497 page->masterPage()->background()->drawBackground( painter, desk.size(), crect, false );
00498 else
00499 page->background()->drawBackground( painter, desk.size(), crect, false );
00500 }
00501 }
00502
00503
00504
00505 void KPrCanvas::eraseEmptySpace( QPainter * painter, const QRegion & emptySpaceRegion, const QBrush & brush ) const
00506 {
00507 painter->save();
00508 painter->setClipRegion( emptySpaceRegion, QPainter::CoordPainter );
00509 painter->setPen( Qt::NoPen );
00510
00511
00512 painter->fillRect( emptySpaceRegion.boundingRect(), brush );
00513 painter->restore();
00514 }
00515
00516
00517 void KPrCanvas::drawObjects( QPainter *painter, const QPtrList<KPrObject> &objects, SelectionMode selectionMode,
00518 bool contour, KPrTextView * textView, int pageNum ) const
00519 {
00520 QPtrListIterator<KPrObject> it( objects );
00521 for ( ; it.current(); ++it )
00522 {
00523 SelectionMode selMode = selectionMode;
00524 if ( selectionMode != SM_NONE
00525 && it.current()->isSelected()
00526 && ( m_view->kPresenterDoc()->isHeaderFooter(it.current())
00527 || it.current()->isProtect() ) )
00528 selMode = SM_PROTECT;
00529
00530 it.current()->draw( painter, m_view->zoomHandler(), pageNum, selMode, (it.current()->isSelected()) && contour );
00531
00532 it.current()->setSubPresStep( 0 );
00533 it.current()->doSpecificEffects( false );
00534 }
00535
00536 if ( textView )
00537 {
00538 textView->kpTextObject()->paintEdited( painter, m_view->zoomHandler(), false ,
00539 textView->cursor(), true );
00540 }
00541 }
00542
00543
00544 void KPrCanvas::drawObjectsPres( QPainter *painter, const QPtrList<KPrObject> &_objects, PresStep step ) const
00545 {
00546 QPtrList<KPrObject> objects;
00547
00548 QPtrListIterator<KPrObject> it( _objects );
00549 for ( ; it.current(); ++it )
00550 {
00551 if ( objectIsAHeaderFooterHidden(it.current()) )
00552 continue;
00553 if ( it.current()->getAppearStep() <= step.m_step
00554 && ( ! it.current()->getDisappear()
00555 || it.current()->getDisappear()
00556 && it.current()->getDisappearStep() > step.m_step ) )
00557 {
00558 if ( step.m_animate && it.current()->getAppearStep() == step.m_step && it.current()->getEffect() != EF_NONE )
00559 continue;
00560
00561 if ( step.m_animateSub && it.current()->getAppearStep() == step.m_step )
00562 {
00563 it.current()->setSubPresStep( step.m_subStep );
00564 it.current()->doSpecificEffects( true, false );
00565 }
00566
00567 objects.append( it.current() );
00568 }
00569 }
00570 drawObjects( painter, objects, SM_NONE, false, NULL, step.m_pageNumber );
00571 }
00572
00573
00574 void KPrCanvas::drawObjectsEdit( QPainter *painter, const KoRect &rect, const QPtrList<KPrObject> &_objects,
00575 SelectionMode selectionMode, int pageNum ) const
00576 {
00577 QPtrList<KPrObject> objects;
00578
00579 KPrTextView * textView = NULL;
00580 QPtrListIterator<KPrObject> it( _objects );
00581 for ( ; it.current(); ++it )
00582 {
00583 if ( objectIsAHeaderFooterHidden(it.current()) )
00584 continue;
00585
00586 if ( rect.intersects( it.current()->getRepaintRect() ) )
00587 {
00588 if ( m_currentTextObjectView && m_currentTextObjectView->kpTextObject() == it.current() )
00589 {
00590 textView = m_currentTextObjectView;
00591 }
00592
00593 objects.append( it.current() );
00594 }
00595 }
00596 drawObjects( painter, objects, selectionMode, drawContour, textView, pageNum );
00597 }
00598
00599
00600 void KPrCanvas::drawEditPage( QPainter *painter, const QRect &_rect,
00601 KPrPage *page, SelectionMode selectionMode ) const
00602 {
00603 KoRect rect = m_view->zoomHandler()->unzoomRect(_rect);
00604
00605 int pageNum = m_view->kPresenterDoc()->pageList().findRef( page );
00606
00607 if ( page->masterPage() && page->displayObjectFromMasterPage() )
00608 drawObjectsEdit( painter, rect, page->masterPage()->objectList(), selectionMode, pageNum );
00609
00610 drawObjectsEdit( painter, rect, displayObjectList(), selectionMode, pageNum );
00611 }
00612
00613
00614 void KPrCanvas::drawPresPage( QPainter *painter, const QRect &_rect, PresStep step ) const
00615 {
00616 KoRect rect = m_view->zoomHandler()->unzoomRect(_rect);
00617
00618 KPrPage * page = m_view->kPresenterDoc()->pageList().at(step.m_pageNumber);
00619
00620 if ( page->masterPage() && page->displayObjectFromMasterPage() )
00621 drawObjectsPres( painter, page->masterPage()->objectList(), step );
00622
00623 drawObjectsPres( painter, page->objectList(), step );
00624 }
00625
00626
00627 void KPrCanvas::drawGrid(QPainter *painter, const QRect &rect2) const
00628 {
00629 KPrDocument *doc=m_view->kPresenterDoc();
00630
00631 if(!doc->isReadWrite())
00632 return;
00633 QPen _pen = QPen( doc->gridColor(), 6, Qt::DotLine );
00634 painter->save();
00635 painter->setPen( _pen );
00636 QRect pageRect = m_activePage->getZoomPageRect();
00637
00638 int zoomedX, zoomedY;
00639 double offsetX = doc->getGridX();
00640 double offsetY = doc->getGridY();
00641
00642 for ( double i = offsetX; ( zoomedX = m_view->zoomHandler()->zoomItX( i )+pageRect.left() ) < pageRect.right(); i += offsetX )
00643 for ( double j = offsetY; ( zoomedY = m_view->zoomHandler()->zoomItY( j )+pageRect.top() ) < pageRect.bottom(); j += offsetY )
00644 if( rect2.contains( zoomedX, zoomedY ) )
00645 painter->drawPoint( zoomedX, zoomedY );
00646
00647 painter->restore();
00648 }
00649
00650
00651
00652
00653 void KPrCanvas::drawAllObjectsInPage( QPainter *painter, const QPtrList<KPrObject> & obj, int pageNum ) const
00654 {
00655 QPtrListIterator<KPrObject> it( obj );
00656 for ( ; it.current(); ++it ) {
00657 if ( objectIsAHeaderFooterHidden( it.current() ) )
00658 continue;
00659 it.current()->draw( painter, m_view->zoomHandler(), pageNum, SM_NONE, false );
00660 }
00661 }
00662
00663 void KPrCanvas::recalcAutoGuides( )
00664 {
00665 QValueList<double> horizontalPos;
00666 QValueList<double> verticalPos;
00667 QPtrListIterator<KPrObject> it( m_activePage->objectList() );
00668 for ( ; it.current(); ++it )
00669 {
00670 if( ! it.current()->isSelected() )
00671 it.current()->addSelfToGuides( horizontalPos, verticalPos);
00672 }
00673
00674 m_gl.setAutoGuideLines( horizontalPos, verticalPos );
00675 }
00676
00677 void KPrCanvas::mousePressEvent( QMouseEvent *e )
00678 {
00679 QPoint contentsPoint( e->pos().x()+diffx(), e->pos().y()+diffy() );
00680 KoPoint docPoint = m_view->zoomHandler()->unzoomPoint( contentsPoint );
00681 m_insertRect = KoRect();
00682
00683 if(!m_view->koDocument()->isReadWrite())
00684 return;
00685
00686 if ( editMode && m_view->kPresenterDoc()->showGuideLines() && toolEditMode == TEM_MOUSE && m_gl.mousePressEvent( e ) )
00687 return;
00688
00689 m_moveStartPosMouse = objectRect( false ).topLeft();
00690 if(m_currentTextObjectView)
00691 {
00692 KPrTextObject *txtObj=m_currentTextObjectView->kpTextObject();
00693 Q_ASSERT(txtObj);
00694 if(txtObj->contains( docPoint ))
00695 {
00696 KoPoint pos = docPoint - txtObj->innerRect().topLeft();
00697
00698 m_currentTextObjectView->mousePressEvent(e, m_view->zoomHandler()->ptToLayoutUnitPix( pos ) );
00699 mousePressed = true;
00700 m_view->enableAutoScroll();
00701 if(e->button() == RightButton)
00702 {
00703 m_currentTextObjectView->showPopup( m_view, QCursor::pos(), m_view->actionList() );
00704 m_view->disableAutoScroll();
00705 mousePressed=false;
00706 }
00707 else if( e->button() == MidButton )
00708 {
00709 QApplication::clipboard()->setSelectionMode( true );
00710 m_currentTextObjectView->paste();
00711 QApplication::clipboard()->setSelectionMode( false );
00712 }
00713 return;
00714 }
00715 }
00716
00717
00718 KPrObject *kpobject = 0;
00719
00720 m_disableSnapping = e->state() & ShiftButton;
00721
00722 exitEditMode();
00723
00724 if ( editMode ) {
00725 if ( e->button() == LeftButton ) {
00726 mousePressed = true;
00727 m_view->enableAutoScroll();
00728
00729 if ( m_drawPolyline && ( toolEditMode == INS_POLYLINE || toolEditMode == INS_CLOSED_POLYLINE ) )
00730 {
00731 m_startPoint = snapPoint( docPoint );
00732 m_pointArray.putPoints( m_indexPointArray, 1, m_startPoint.x(), m_startPoint.y() );
00733
00734 ++m_indexPointArray;
00735 return;
00736 }
00737
00738 if ( m_drawCubicBezierCurve && ( toolEditMode == INS_CUBICBEZIERCURVE
00739 || toolEditMode == INS_QUADRICBEZIERCURVE
00740 || toolEditMode == INS_CLOSED_CUBICBEZIERCURVE
00741 || toolEditMode == INS_CLOSED_QUADRICBEZIERCURVE ) ) {
00742 if ( m_drawLineWithCubicBezierCurve ) {
00743 QPainter p( this );
00744 p.setPen( QPen( Qt::black, 1, Qt::SolidLine ) );
00745 p.setBrush( Qt::NoBrush );
00746 p.setRasterOp( Qt::NotROP );
00747
00748 p.translate( -diffx(), -diffy() );
00749 KoPoint newStartPoint = snapPoint( docPoint );
00750
00751 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
00752 m_view->zoomHandler()->zoomPoint( newStartPoint ) );
00753
00754 m_startPoint = newStartPoint;
00755 p.end();
00756
00757 m_pointArray.putPoints( m_indexPointArray, 1, m_startPoint.x(), m_startPoint.y() );
00758
00759 ++m_indexPointArray;
00760 m_drawLineWithCubicBezierCurve = false;
00761 }
00762 else {
00763 QPainter p( this );
00764 QPen _pen = QPen( Qt::black, 1, Qt::DashLine );
00765 p.setPen( _pen );
00766 p.setBrush( Qt::NoBrush );
00767 p.setRasterOp( Qt::NotROP );
00768
00769 p.translate( -diffx(), -diffy() );
00770 p.save();
00771
00772 KoPoint endPoint = snapPoint( docPoint );
00773
00774 double angle = KoPoint::getAngle( endPoint, m_startPoint );
00775
00776 drawFigure( L_SQUARE, &p, endPoint, _pen.color(), _pen.width(), angle, m_view->zoomHandler() );
00777
00778 p.restore();
00779
00780 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
00781 m_view->zoomHandler()->zoomPoint( endPoint ) );
00782
00783 m_symmetricEndPoint = m_startPoint * 2 - endPoint;
00784
00785 p.save();
00786 angle = KoPoint::getAngle( m_symmetricEndPoint, m_startPoint );
00787
00788 drawFigure( L_SQUARE, &p, m_symmetricEndPoint, _pen.color(), _pen.width(), angle, m_view->zoomHandler() );
00789
00790 p.restore();
00791
00792 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
00793 m_view->zoomHandler()->zoomPoint( m_symmetricEndPoint ) );
00794
00795 m_pointArray.putPoints( m_indexPointArray, 3, m_CubicBezierSecondPoint.x(), m_CubicBezierSecondPoint.y(),
00796 m_CubicBezierThirdPoint.x(), m_CubicBezierThirdPoint.y(),
00797 m_startPoint.x(), m_startPoint.y() );
00798 m_indexPointArray += 3;
00799 m_drawLineWithCubicBezierCurve = true;
00800 m_oldCubicBezierPointArray = KoPointArray();
00801 m_oldCubicBezierPointArray.putPoints( 0, 4, (double)0,(double)0, (double)0,(double)0,
00802 (double)0,(double)0, (double)0,(double)0 );
00803 m_endPoint = m_startPoint;
00804 }
00805
00806 return;
00807 }
00808
00809 switch ( toolEditMode ) {
00810 case TEM_MOUSE: {
00811 KPrObject *kpobject = getObjectAt( docPoint, true );
00812
00813 if ( kpobject ) {
00814
00815 if ( e->state() & ControlButton && kpobject->isSelected() )
00816 deSelectObj( kpobject );
00817 else if ( e->state() & ControlButton )
00818 {
00819 selectObj( kpobject );
00820 raiseObject( kpobject );
00821 m_moveStartPosMouse = objectRect( false ).topLeft();
00822 }
00823 else
00824 {
00825 if ( modType != MT_MOVE || !kpobject->isSelected() )
00826 deSelectAllObj();
00827
00828 selectObj( kpobject );
00829 raiseObject( kpobject );
00830 m_moveStartPosMouse = objectRect( false ).topLeft();
00831 }
00832
00833
00834 if ( modType != MT_MOVE && modType != MT_NONE )
00835 {
00836 deSelectAllObj();
00837 selectObj( kpobject );
00838 raiseObject( kpobject );
00839
00840 m_resizeObject = kpobject;
00841
00842 m_ratio = static_cast<double>( kpobject->getSize().width() ) /
00843 static_cast<double>( kpobject->getSize().height() );
00844 m_rectBeforeResize = kpobject->getRect();
00845 }
00846 recalcAutoGuides();
00847 if ( m_view->kPresenterDoc()->showGuideLines() && !m_disableSnapping )
00848 {
00849 m_gl.repaintSnapping( objectRect( false ) );
00850 }
00851 }
00852 else
00853 {
00854 KPrPage *masterPage = m_activePage->masterPage();
00855 if ( masterPage && m_activePage->displayObjectFromMasterPage() )
00856 {
00857 kpobject = masterPage->getObjectAt( docPoint, true );
00858
00859 if ( kpobject && objectIsAHeaderFooterHidden( kpobject ) )
00860 {
00861 kpobject = 0;
00862 }
00863 }
00864
00865 if ( kpobject )
00866 {
00867 mousePressed = false;
00868 QString msg( i18n( "The object you are trying to select belongs to the master slide. "
00869 "Editing the object can only be done on the master slide.\n"
00870 "Go there now?" ) );
00871 m_view->disableAutoScroll();
00872 if ( KMessageBox::questionYesNo( this, msg ) == KMessageBox::Yes )
00873 {
00874 getView()->setEditMaster( true );
00875 selectObj( kpobject );
00876 raiseObject( kpobject );
00877 m_moveStartPosMouse = objectRect( false ).topLeft();
00878 }
00879 else
00880 {
00881 deSelectAllObj();
00882 modType = MT_NONE;
00883 }
00884 }
00885 else {
00886 modType = MT_NONE;
00887 if ( !( e->state() & ShiftButton ) && !( e->state() & ControlButton ) )
00888 deSelectAllObj();
00889
00890 drawRubber = true;
00891 m_rubber = KoRect( docPoint.x(), docPoint.y(), 0, 0 );
00892 }
00893 }
00894 m_origMousePos = docPoint;
00895 } break;
00896 case TEM_ZOOM: {
00897 modType = MT_NONE;
00898 drawRubber = true;
00899 m_zoomRubberDraw = false;
00900 m_rubber = KoRect( docPoint.x(), docPoint.y(), 0, 0 );
00901 }break;
00902 case TEM_ROTATE:
00903 {
00904 KPrObject *kpobject = getObjectAt( docPoint );
00905
00906
00907
00908 deSelectAllObj();
00909
00910 if ( kpobject && !kpobject->isProtect())
00911 {
00912 m_rotateObject = kpobject;
00913 m_rotateStart = docPoint;
00914 m_angleBeforeRotate = kpobject->getAngle();
00915 selectObj( kpobject );
00916 raiseObject( kpobject );
00917
00918
00919 m_rotateCenter = kpobject->getRealRect().center();
00920 }
00921 } break;
00922 case INS_LINE:
00923 deSelectAllObj();
00924 recalcAutoGuides();
00925 mousePressed = true;
00926
00927 m_startPoint = snapPoint( docPoint );
00928 m_endPoint = m_startPoint;
00929 break;
00930 case INS_FREEHAND: case INS_CLOSED_FREEHAND: {
00931 deSelectAllObj();
00932 recalcAutoGuides();
00933 mousePressed = true;
00934
00935 m_indexPointArray = 0;
00936 m_startPoint = snapPoint( docPoint );
00937 m_endPoint = m_startPoint;
00938 m_pointArray.putPoints( m_indexPointArray, 1, m_startPoint.x(), m_startPoint.y() );
00939 ++m_indexPointArray;
00940 } break;
00941 case INS_POLYLINE: case INS_CLOSED_POLYLINE: {
00942 deSelectAllObj();
00943 recalcAutoGuides();
00944 mousePressed = true;
00945
00946 m_drawPolyline = true;
00947 m_indexPointArray = 0;
00948 m_startPoint = snapPoint( docPoint );
00949 m_endPoint = m_startPoint;
00950 m_pointArray.putPoints( m_indexPointArray, 1, m_startPoint.x(), m_startPoint.y() );
00951 ++m_indexPointArray;
00952 } break;
00953 case INS_CUBICBEZIERCURVE: case INS_QUADRICBEZIERCURVE:
00954 case INS_CLOSED_CUBICBEZIERCURVE: case INS_CLOSED_QUADRICBEZIERCURVE: {
00955 deSelectAllObj();
00956 recalcAutoGuides();
00957 mousePressed = true;
00958
00959 m_drawCubicBezierCurve = true;
00960 m_drawLineWithCubicBezierCurve = true;
00961 m_indexPointArray = 0;
00962
00963 m_oldCubicBezierPointArray.putPoints( 0, 4, (double)0,(double)0, (double)0,(double)0,
00964 (double)0,(double)0, (double)0,(double)0 );
00965 m_startPoint = snapPoint( docPoint );
00966 m_endPoint = m_startPoint;
00967 m_pointArray.putPoints( m_indexPointArray, 1, m_startPoint.x(), m_startPoint.y() );
00968
00969 ++m_indexPointArray;
00970 } break;
00971 default: {
00972 deSelectAllObj();
00973 recalcAutoGuides();
00974 mousePressed = true;
00975 KoPoint sp( snapPoint( docPoint ) );
00976 m_insertRect = KoRect( sp.x(), sp.y(),0 ,0 );
00977 } break;
00978 }
00979 }
00980
00981 if ( e->button() == RightButton && ( toolEditMode == INS_POLYLINE || toolEditMode == INS_CLOSED_POLYLINE )
00982 && !m_pointArray.isNull() && m_drawPolyline ) {
00983 if( m_indexPointArray > 1)
00984 {
00985 QPainter p( this );
00986 p.setPen( QPen( black, 1, SolidLine ) );
00987 p.setBrush( NoBrush );
00988 p.translate( -diffx(), -diffy() );
00989 p.save();
00990 p.setRasterOp( NotROP );
00991
00992
00993 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
00994 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
00995
00996 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
00997 m_view->zoomHandler()->zoomPoint( m_pointArray.at( m_indexPointArray - 2 ) ) );
00998 p.restore();
00999
01000 m_indexPointArray = QMAX( 1, m_indexPointArray - 1 );
01001 m_pointArray.resize( m_indexPointArray );
01002 m_startPoint = m_pointArray.at( m_indexPointArray - 1 );
01003
01004 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
01005 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
01006
01007 p.end();
01008 }
01009 else if( m_indexPointArray == 1)
01010 {
01011 QPainter p( this );
01012 p.setPen( QPen( black, 1, SolidLine ) );
01013 p.setBrush( NoBrush );
01014 p.setRasterOp( NotROP );
01015 p.translate( -diffx(), -diffy() );
01016 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
01017 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
01018 p.end();
01019 m_pointArray = KoPointArray();
01020 m_indexPointArray = 0;
01021
01022 m_drawPolyline = false;
01023 m_view->disableAutoScroll();
01024 mousePressed = false;
01025 }
01026 return;
01027 }
01028
01029 if ( e->button() == RightButton && ( toolEditMode == INS_CUBICBEZIERCURVE || toolEditMode == INS_QUADRICBEZIERCURVE
01030 || toolEditMode == INS_CLOSED_CUBICBEZIERCURVE || toolEditMode == INS_CLOSED_QUADRICBEZIERCURVE )
01031 && !m_pointArray.isNull() && m_drawCubicBezierCurve ) {
01032 if ( m_drawLineWithCubicBezierCurve ) {
01033 KoPoint point = snapPoint( docPoint );
01034 m_pointArray.putPoints( m_indexPointArray, 1, point.x(), point.y() );
01035 ++m_indexPointArray;
01036 }
01037 else {
01038 m_pointArray.putPoints( m_indexPointArray, 2, m_CubicBezierSecondPoint.x(), m_CubicBezierSecondPoint.y(),
01039 m_CubicBezierThirdPoint.x(), m_CubicBezierThirdPoint.y() );
01040 m_indexPointArray += 2;
01041 }
01042
01043 endDrawCubicBezierCurve();
01044
01045 m_gl.repaintAfterSnapping();
01046
01047 return;
01048 }
01049
01050 if ( e->button() == RightButton && toolEditMode == TEM_MOUSE ) {
01051 KPrObject * obj = getObjectAt( docPoint );
01052 if ( obj )
01053 {
01054 kpobject = obj;
01055 QPoint pnt = QCursor::pos();
01056 mousePressed = false;
01057 m_view->disableAutoScroll();
01058 bool state=!( e->state() & ShiftButton ) && !( e->state() & ControlButton ) && !kpobject->isSelected();
01059
01060 if ( state )
01061 deSelectAllObj();
01062 selectObj( kpobject );
01063 objectPopup( kpobject, pnt );
01064 } else {
01065 QPoint pnt = QCursor::pos();
01066 m_view->openPopupMenuMenuPage( pnt );
01067 m_view->disableAutoScroll();
01068 mousePressed = false;
01069 }
01070 modType = MT_NONE;
01071
01072 }
01073 else if( e->button() == RightButton && toolEditMode == TEM_ZOOM ) {
01074 QPoint pnt = QCursor::pos();
01075 mousePressed = false;
01076 m_view->disableAutoScroll();
01077 m_view->openPopupMenuZoom( pnt );
01078 }
01079 else if( e->button() == RightButton && toolEditMode != TEM_MOUSE ) {
01080
01081 setToolEditMode( TEM_MOUSE );
01082 }
01083 } else {
01084 if ( e->button() == LeftButton ) {
01085 if ( m_drawMode ) {
01086 setCursor( KPrUtils::penCursor() );
01087 m_drawLineInDrawMode = true;
01088 m_drawModeLineIndex = 0;
01089 m_drawModeLines.append( QPointArray() );
01090 m_drawModeLines[m_drawModeLines.count() - 1].putPoints( m_drawModeLineIndex++, 1, e->x(), e->y() );
01091 }
01092 else
01093 m_view->screenNext();
01094 } else if ( e->button() == MidButton )
01095 m_view->screenPrev();
01096 else if ( e->button() == RightButton ) {
01097 if ( !m_drawMode && !spManualSwitch() )
01098 {
01099 finishObjectEffects();
01100 finishPageEffect();
01101 m_view->stopAutoPresTimer();
01102 }
01103
01104 setCursor( arrowCursor );
01105 QPoint pnt = QCursor::pos();
01106 int ret = m_presMenu->exec( pnt );
01107
01108 if ( ret == -1 && !m_presMenu->isItemChecked( PM_DM ) && !spManualSwitch() )
01109 m_view->continueAutoPresTimer();
01110 }
01111 }
01112
01113
01114 #if 0 // Where do you need this ? (toshitaka)
01115
01116 if ( toolEditMode == TEM_MOUSE )
01117 mouseMoveEvent( e );
01118 #endif
01119 }
01120
01121 KoRect KPrCanvas::getAlignBoundingRect() const
01122 {
01123 KoRect boundingRect;
01124
01125 QPtrListIterator<KPrObject> it( m_activePage->objectList() );
01126 for ( ; it.current() ; ++it )
01127 {
01128 if ( it.current() == m_view->kPresenterDoc()->header() ||
01129 it.current() == m_view->kPresenterDoc()->footer() )
01130 continue;
01131
01132 if( it.current()->isSelected() && !it.current()->isProtect() ) {
01133 boundingRect |= it.current()->getRealRect();
01134 }
01135 }
01136 return boundingRect;
01137 }
01138
01139 void KPrCanvas::mouseReleaseEvent( QMouseEvent *e )
01140 {
01141 if ( editMode && m_view->kPresenterDoc()->showGuideLines() && toolEditMode == TEM_MOUSE && m_gl.mouseReleaseEvent( e ) )
01142 return;
01143
01144 QPoint contentsPoint( e->pos().x()+diffx(), e->pos().y()+diffy() );
01145 if(m_currentTextObjectView)
01146 {
01147 m_currentTextObjectView->mouseReleaseEvent( e, contentsPoint );
01148 emit objectSelectedChanged();
01149 m_view->disableAutoScroll();
01150 mousePressed=false;
01151 return;
01152 }
01153
01154 if ( e->button() != LeftButton )
01155 return;
01156
01157 if ( m_drawMode ) {
01158 m_drawLineInDrawMode = false;
01159 m_drawModeLines[m_drawModeLines.count() - 1].putPoints( m_drawModeLineIndex++, 1, contentsPoint.x(), contentsPoint.y() );
01160 return;
01161 }
01162
01163 QPtrList<KPrObject> _objects;
01164 _objects.setAutoDelete( false );
01165
01166 if ( ( m_drawPolyline && ( toolEditMode == INS_POLYLINE || toolEditMode == INS_CLOSED_POLYLINE ) )
01167 || ( m_drawCubicBezierCurve && ( toolEditMode == INS_CUBICBEZIERCURVE || toolEditMode == INS_QUADRICBEZIERCURVE
01168 || toolEditMode == INS_CLOSED_CUBICBEZIERCURVE || toolEditMode == INS_CLOSED_QUADRICBEZIERCURVE ) ) ) {
01169 return;
01170 }
01171
01172 m_insertRect = m_insertRect.normalize();
01173
01174 switch ( toolEditMode ) {
01175 case TEM_MOUSE: {
01176 drawContour = FALSE;
01177 switch ( modType ) {
01178 case MT_NONE: {
01179 if ( drawRubber ) {
01180
01181 QPainter p;
01182 p.begin( this );
01183 p.setRasterOp( NotROP );
01184 p.setPen( QPen( black, 0, DotLine ) );
01185 p.translate( -diffx(), -diffy() );
01186 p.drawRect( m_view->zoomHandler()->zoomRect( m_rubber ) );
01187 p.end();
01188 drawRubber = false;
01189
01190 m_rubber = m_rubber.normalize();
01191
01192 QPtrListIterator<KPrObject> it( getObjectList() );
01193 for ( ; it.current() ; ++it )
01194 {
01195 if ( it.current()->intersects( m_rubber ) )
01196 {
01197 if( objectIsAHeaderFooterHidden(it.current()))
01198 continue;
01199 it.current()->setSelected( true );
01200 mouseSelectedObject = true;
01201 }
01202 }
01203
01204 if ( mouseSelectedObject )
01205 _repaint( false );
01206 emit objectSelectedChanged();
01207 }
01208 } break;
01209 case MT_MOVE: {
01210 KoPoint move( objectRect( false ).topLeft() - m_moveStartPosMouse );
01211 if ( move != KoPoint( 0, 0 ) )
01212 {
01213 KCommand *cmd=m_activePage->moveObject(m_view, move.x(), move.y());
01214 if(cmd)
01215 m_view->kPresenterDoc()->addCommand( cmd );
01216 } else
01217 {
01218 m_activePage->repaintObj();
01219 }
01220 m_isMoving = false;
01221 }
01222 break;
01223 case MT_RESIZE_UP:
01224 finishResizeObject( i18n( "Resize Object Up" ) );
01225 break;
01226 case MT_RESIZE_DN:
01227 finishResizeObject( i18n( "Resize Object Down" ), false );
01228 break;
01229 case MT_RESIZE_LF:
01230 finishResizeObject( i18n( "Resize Object Left" ) );
01231 break;
01232 case MT_RESIZE_RT:
01233 finishResizeObject( i18n( "Resize Object Right" ) );
01234 break;
01235 case MT_RESIZE_LU:
01236 finishResizeObject( i18n( "Resize Object Left && Up" ) );
01237 break;
01238 case MT_RESIZE_LD:
01239 finishResizeObject( i18n( "Resize Object Left && Down" ) );
01240 break;
01241 case MT_RESIZE_RU:
01242 finishResizeObject( i18n( "Resize Object Right && Up" ) );
01243 break;
01244 case MT_RESIZE_RD:
01245 finishResizeObject( i18n( "Resize Object Right && Down" ) );
01246 break;
01247 }
01248 } break;
01249 case INS_TEXT:
01250 if ( !m_insertRect.isNull() )
01251 {
01252 KPrTextObject* kptextobject = insertTextObject( m_insertRect );
01253 setToolEditMode( TEM_MOUSE );
01254
01255
01256 createEditing( kptextobject );
01257
01258
01259 }
01260 break;
01261 case TEM_ZOOM:{
01262 drawContour = FALSE;
01263 if( modType == MT_NONE && drawRubber )
01264 {
01265 QPainter p;
01266 p.begin( this );
01267 p.setRasterOp( NotROP );
01268 p.setPen( QPen( black, 0, DotLine ) );
01269 p.translate( -diffx(), -diffy() );
01270 p.drawRect( m_view->zoomHandler()->zoomRect( m_rubber ) );
01271 p.end();
01272 drawRubber = false;
01273 m_rubber = m_rubber.normalize();
01274 if ( m_zoomRubberDraw )
01275 {
01276 m_view->setZoomRect( m_rubber );
01277 }
01278 else
01279 {
01280 m_view->zoomPlus();
01281 }
01282 m_zoomRubberDraw = false;
01283 }
01284 }break;
01285 case TEM_ROTATE: {
01286 drawContour = FALSE;
01287 if ( !m_rotateObject )
01288 break;
01289 if ( m_angleBeforeRotate != m_rotateObject->getAngle() ) {
01290 QPtrList<KPrObject> objects;
01291 objects.append( m_rotateObject );
01292
01293
01294
01295
01296 float newAngle = m_rotateObject->getAngle();
01297 m_rotateObject->rotate( m_angleBeforeRotate );
01298
01299 KPrRotateCmd *rotateCmd = new KPrRotateCmd( i18n( "Change Rotation" ), newAngle,
01300 objects, m_view->kPresenterDoc() );
01301 m_view->kPresenterDoc()->addCommand( rotateCmd );
01302
01303 m_rotateObject->rotate( newAngle );
01304 m_rotateObject = NULL;
01305 }
01306 }break;
01307 case INS_LINE:
01308 if ( m_startPoint != m_endPoint )
01309 {
01310 insertLine( m_startPoint, m_endPoint );
01311 m_endPoint = m_startPoint;
01312 }
01313 break;
01314 case INS_RECT:
01315 if ( !m_insertRect.isNull() )
01316 {
01317 insertRect( m_insertRect );
01318 }
01319 break;
01320 case INS_ELLIPSE:
01321 if ( !m_insertRect.isNull() )
01322 {
01323 insertEllipse( m_insertRect );
01324 }
01325 break;
01326 case INS_PIE:
01327 if ( !m_insertRect.isNull() )
01328 {
01329 insertPie( m_insertRect );
01330 }
01331 break;
01332 case INS_OBJECT:
01333 case INS_DIAGRAMM:
01334 case INS_TABLE:
01335 case INS_FORMULA:
01336 if ( !m_insertRect.isNull() )
01337 {
01338 KPrPartObject *kpPartObject = insertObject( m_insertRect );
01339 setToolEditMode( TEM_MOUSE );
01340
01341 if ( kpPartObject )
01342 {
01343 kpPartObject->activate( m_view );
01344 m_editObject = kpPartObject;
01345 }
01346 }
01347 break;
01348 case INS_AUTOFORM:
01349 if ( !m_insertRect.isNull() )
01350 {
01351 insertAutoform( m_insertRect );
01352 }
01353 setToolEditMode( TEM_MOUSE );
01354 break;
01355 case INS_FREEHAND:
01356 if ( !m_pointArray.isNull() )
01357 {
01358 insertFreehand( m_pointArray );
01359 }
01360 break;
01361 case INS_POLYGON:
01362 if ( !m_pointArray.isNull() )
01363 insertPolygon( m_pointArray );
01364 break;
01365 case INS_PICTURE:
01366 case INS_CLIPART:
01367 insertPicture( m_insertRect );
01368 setToolEditMode( TEM_MOUSE );
01369 break;
01370 case INS_CLOSED_FREEHAND: {
01371 if ( !m_pointArray.isNull() )
01372 insertClosedLine( m_pointArray );
01373 }break;
01374 default: break;
01375 }
01376
01377 m_gl.repaintAfterSnapping();
01378
01379 emit objectSelectedChanged();
01380
01381 if ( toolEditMode != TEM_MOUSE && editMode )
01382 repaint( false );
01383
01384 m_view->disableAutoScroll();
01385 mousePressed = false;
01386 modType = MT_NONE;
01387 m_insertRect = KoRect();
01388 mouseMoveEvent( e );
01389 }
01390
01391 void KPrCanvas::mouseMoveEvent( QMouseEvent *e )
01392 {
01393 if ( editMode && m_view->kPresenterDoc()->showGuideLines() && toolEditMode == TEM_MOUSE && m_gl.mouseMoveEvent( e ) )
01394 return;
01395
01396 QPoint contentsPoint( e->pos().x()+diffx(), e->pos().y()+diffy() );
01397 KoPoint docPoint = m_view->zoomHandler()->unzoomPoint( contentsPoint );
01398 if(m_currentTextObjectView)
01399 {
01400 if (m_currentTextObjectView->isLinkVariable(e->pos()) )
01401 {
01402 setCursor(Qt::PointingHandCursor);
01403 return;
01404 }
01405 setCursor( arrowCursor );
01406
01407 KPrTextObject *txtObj=m_currentTextObjectView->kpTextObject();
01408 Q_ASSERT(txtObj);
01409 if(txtObj->contains( docPoint )&&mousePressed)
01410 {
01411 KoPoint pos = docPoint - txtObj->innerRect().topLeft();
01412 m_currentTextObjectView->mouseMoveEvent( e, m_view->zoomHandler()->ptToLayoutUnitPix( pos ) );
01413 }
01414 return;
01415 }
01416
01417 if (m_view->kPresenterDoc()->getVariableCollection()->variableSetting()->displayLink())
01418 {
01419 KPrObject *tmp_kpobject = getObjectAt( docPoint );
01420 if(tmp_kpobject && tmp_kpobject->getType() == OT_TEXT)
01421 {
01422 KPrTextObject *kptextobject = static_cast<KPrTextObject*>( tmp_kpobject );
01423 QPoint iPoint = kptextobject->viewToInternal( e->pos(), this );
01424 KoLinkVariable* linkVar = dynamic_cast<KoLinkVariable *>( kptextobject->textObject()->variableAtPoint( iPoint ) );
01425
01426 if ( linkVar )
01427 {
01428 setCursor(Qt::PointingHandCursor);
01429 return;
01430 }
01431 }
01432 }
01433
01434 m_disableSnapping = e->state() & ShiftButton;
01435
01436 if ( editMode ) {
01437 m_view->setRulerMousePos( e->x(), e->y() );
01438
01439 if ( toolEditMode == TEM_ROTATE )
01440 {
01441 setCursor( KPrUtils::rotateCursor() );
01442 if ( !mousePressed )
01443 return;
01444 }
01445 KPrObject *kpobject;
01446 if ( ( !mousePressed || ( !drawRubber && modType == MT_NONE ) ) &&
01447 toolEditMode == TEM_MOUSE )
01448 {
01449 bool cursorAlreadySet = false;
01450 if ( (int)objectList().count() > 0 )
01451 {
01452 kpobject = m_activePage->getCursor( docPoint );
01453 if( kpobject)
01454 {
01455 setCursor( kpobject->getCursor( docPoint, modType, m_view->kPresenterDoc() ) );
01456
01457 cursorAlreadySet = true;
01458 }
01459 }
01460
01461 if ( !cursorAlreadySet )
01462 setCursor( arrowCursor );
01463 else
01464 return;
01465 } else if ( mousePressed ) {
01466 switch ( toolEditMode ) {
01467 case TEM_MOUSE: {
01468 drawContour = TRUE;
01469 if ( modType == MT_NONE ) {
01470 if ( drawRubber )
01471 {
01472 QPainter p;
01473 p.begin( this );
01474 p.setRasterOp( NotROP );
01475 p.setPen( QPen( black, 0, DotLine ) );
01476 p.translate( -diffx(), -diffy() );
01477 p.drawRect( m_view->zoomHandler()->zoomRect( m_rubber ) );
01478 m_rubber.setRight( docPoint.x() );
01479 m_rubber.setBottom( docPoint.y() );
01480 p.drawRect( m_view->zoomHandler()->zoomRect( m_rubber ) );
01481 p.end();
01482 }
01483 } else if ( modType == MT_MOVE ) {
01484 if ( !m_isMoving )
01485 {
01486 m_moveSnapDiff= KoPoint(0,0);
01487 m_moveStartPoint = objectRect( false ).topLeft();
01488 m_isMoving = true;
01489 }
01490 moveObjectsByMouse( docPoint, e->state() & AltButton || e->state() & ControlButton );
01491 } else if ( modType != MT_NONE && m_resizeObject ) {
01492 if ( !m_isResizing )
01493 {
01494 m_isResizing = true;
01495 }
01496
01497 KoPoint sp( snapPoint( docPoint, false ) );
01498
01499 bool keepRatio = m_resizeObject->isKeepRatio();
01500 if ( e->state() & AltButton )
01501 {
01502 keepRatio = true;
01503 }
01504 bool scaleAroundCenter = false;
01505 if ( e->state() & ControlButton )
01506 {
01507 scaleAroundCenter = true;
01508 }
01509
01510 resizeObject( modType, sp, keepRatio, scaleAroundCenter );
01511 }
01512 } break;
01513 case TEM_ZOOM : {
01514 if ( drawRubber ) {
01515 QPainter p;
01516 p.begin( this );
01517 p.setRasterOp( NotROP );
01518 p.setPen( QPen( black, 0, DotLine ) );
01519 p.translate( -diffx(), -diffy() );
01520 p.drawRect( m_view->zoomHandler()->zoomRect( m_rubber ) );
01521 m_rubber.setRight( docPoint.x() );
01522 m_rubber.setBottom( docPoint.y() );
01523 p.drawRect( m_view->zoomHandler()->zoomRect( m_rubber ) );
01524 p.end();
01525 m_zoomRubberDraw = true;
01526 }
01527 }break;
01528 case TEM_ROTATE: {
01529 if ( m_rotateObject )
01530 {
01531 drawContour = TRUE;
01532
01533 double angle = KoPoint::getAngle( m_rotateCenter, docPoint );
01534
01535 double angle1 = KoPoint::getAngle( m_rotateCenter, m_rotateStart );
01536
01537 angle -= angle1;
01538 angle += m_angleBeforeRotate;
01539 if ( angle < 0 )
01540 angle += 360;
01541 else if ( angle > 360 )
01542 angle -= 360;
01543
01544 m_rotateObject->rotate( angle );
01545 _repaint( m_rotateObject );
01546 }
01547 }break;
01548 case INS_AUTOFORM:
01549 case INS_DIAGRAMM:
01550 case INS_FORMULA:
01551 case INS_CLIPART:
01552 case INS_PICTURE:
01553 case INS_OBJECT:
01554 case INS_TABLE:
01555 case INS_TEXT:
01556 {
01557 QPainter p( this );
01558 p.setPen( QPen( black, 1, SolidLine ) );
01559 p.setBrush( NoBrush );
01560 p.setRasterOp( NotROP );
01561 p.translate( -diffx(), -diffy() );
01562
01563 KoPoint sp( snapPoint( docPoint ) );
01564 p.drawRect( m_view->zoomHandler()->zoomRect( m_insertRect.normalize() ) );
01565 updateInsertRect( sp, e->state() );
01566 p.drawRect( m_view->zoomHandler()->zoomRect( m_insertRect.normalize() ) );
01567
01568 p.end();
01569
01570 mouseSelectedObject = true;
01571 } break;
01572 case INS_ELLIPSE: {
01573 QPainter p( this );
01574 p.setPen( QPen( black, 1, SolidLine ) );
01575 p.setBrush( NoBrush );
01576 p.setRasterOp( NotROP );
01577 p.translate( -diffx(), -diffy() );
01578
01579 KoPoint sp( snapPoint( docPoint ) );
01580 p.drawEllipse( m_view->zoomHandler()->zoomRect( m_insertRect.normalize() ) );
01581 updateInsertRect( sp, e->state() );
01582 p.drawEllipse( m_view->zoomHandler()->zoomRect( m_insertRect.normalize() ) );
01583
01584 p.end();
01585
01586 mouseSelectedObject = true;
01587 } break;
01588 case INS_RECT: {
01589 QPainter p( this );
01590 p.setPen( QPen( black, 1, SolidLine ) );
01591 p.setBrush( NoBrush );
01592 p.setRasterOp( NotROP );
01593 p.translate( -diffx(), -diffy() );
01594
01595 KoPoint sp( snapPoint( docPoint ) );
01596 p.drawRoundRect( m_view->zoomHandler()->zoomRect( m_insertRect.normalize() ), m_view->getRndX(), m_view->getRndY() );
01597 updateInsertRect( sp, e->state() );
01598 p.drawRoundRect( m_view->zoomHandler()->zoomRect( m_insertRect.normalize() ), m_view->getRndX(), m_view->getRndY() );
01599
01600 p.end();
01601
01602 mouseSelectedObject = true;
01603 } break;
01604 case INS_LINE: {
01605 QPainter p( this );
01606 p.setPen( QPen( black, 1, SolidLine ) );
01607 p.setBrush( NoBrush );
01608 p.setRasterOp( NotROP );
01609 p.translate( -diffx(), -diffy() );
01610
01611 KoPoint oldEndPoint( m_endPoint );
01612 m_endPoint = snapPoint( docPoint );
01613
01614 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
01615 m_view->zoomHandler()->zoomPoint( oldEndPoint ) );
01616
01617 if ( e->state() & AltButton )
01618 {
01619 m_startPoint += m_endPoint - oldEndPoint;
01620 }
01621
01622
01623 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
01624 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
01625 p.end();
01626
01627 mouseSelectedObject = true;
01628 } break;
01629 case INS_PIE: {
01630 QPainter p( this );
01631 p.setPen( QPen( black, 1, SolidLine ) );
01632 p.setBrush( NoBrush );
01633 p.setRasterOp( NotROP );
01634 p.translate( -diffx(), -diffy() );
01635
01636 KoPoint sp( snapPoint( docPoint ) );
01637 drawPieObject( &p, m_insertRect );
01638 updateInsertRect( sp, e->state() );
01639 drawPieObject( &p, m_insertRect );
01640
01641 p.end();
01642
01643 mouseSelectedObject = true;
01644 } break;
01645 case INS_FREEHAND:
01646 case INS_CLOSED_FREEHAND:
01647 {
01648 m_endPoint = snapPoint( docPoint );
01649 if ( m_endPoint != m_startPoint )
01650 {
01651 QPainter p( this );
01652 p.setPen( QPen( black, 1, SolidLine ) );
01653 p.setBrush( NoBrush );
01654 p.setRasterOp( NotROP );
01655 p.translate( -diffx(), -diffy() );
01656
01657 if ( e->state() & AltButton )
01658 {
01659 QPointArray pointArray = m_pointArray.zoomPointArray( m_view->zoomHandler() );
01660
01661 p.drawPolyline( pointArray );
01662 m_pointArray.translate( m_endPoint.x() - m_startPoint.x(),
01663 m_endPoint.y() - m_startPoint.y() );
01664 pointArray = m_pointArray.zoomPointArray( m_view->zoomHandler() );
01665
01666 p.drawPolyline( pointArray );
01667 }
01668 else
01669 {
01670 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
01671 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
01672 }
01673 p.end();
01674
01675 m_pointArray.putPoints( m_indexPointArray, 1, m_endPoint.x(), m_endPoint.y() );
01676 ++m_indexPointArray;
01677 m_startPoint = m_endPoint;
01678 }
01679
01680 mouseSelectedObject = true;
01681 } break;
01682 case INS_POLYLINE: case INS_CLOSED_POLYLINE: {
01683 QPainter p( this );
01684 p.setPen( QPen( black, 1, SolidLine ) );
01685 p.setBrush( NoBrush );
01686 p.setRasterOp( NotROP );
01687 p.translate( -diffx(), -diffy() );
01688
01689 KoPoint oldEndPoint( m_endPoint );
01690 m_endPoint = snapPoint( docPoint );
01691
01692 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
01693 m_view->zoomHandler()->zoomPoint( oldEndPoint ) );
01694
01695 if ( e->state() & AltButton )
01696 {
01697 QPointArray pointArray = m_pointArray.zoomPointArray( m_view->zoomHandler() );
01698
01699 p.drawPolyline( pointArray );
01700 m_pointArray.translate( m_endPoint.x() - oldEndPoint.x(),
01701 m_endPoint.y() - oldEndPoint.y() );
01702 pointArray = m_pointArray.zoomPointArray( m_view->zoomHandler() );
01703
01704 p.drawPolyline( pointArray );
01705 m_startPoint += m_endPoint - oldEndPoint;
01706 }
01707
01708
01709 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
01710 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
01711 p.end();
01712
01713 mouseSelectedObject = true;
01714 } break;
01715 case INS_CUBICBEZIERCURVE: case INS_QUADRICBEZIERCURVE:
01716 case INS_CLOSED_CUBICBEZIERCURVE: case INS_CLOSED_QUADRICBEZIERCURVE:{
01717 QPainter p( this );
01718 p.setPen( QPen( black, 1, SolidLine ) );
01719 p.setBrush( NoBrush );
01720 p.setRasterOp( NotROP );
01721 p.translate( -diffx(), -diffy() );
01722
01723 KoPoint newEndPoint( snapPoint( docPoint ) );
01724
01725 drawCubicBezierCurve( p, m_oldCubicBezierPointArray );
01726
01727 if ( e->state() & AltButton )
01728 {
01729
01730 redrawCubicBezierCurve( p );
01731
01732 KoPoint diff( newEndPoint - m_endPoint );
01733 m_pointArray.translate( diff.x(), diff.y() );
01734 m_endPoint = newEndPoint;
01735 m_startPoint += diff;
01736
01737
01738 redrawCubicBezierCurve( p );
01739 }
01740 else
01741 {
01742 m_endPoint = newEndPoint;
01743 }
01744
01745 KoPointArray points;
01746 if ( !m_drawLineWithCubicBezierCurve )
01747 {
01748 double _firstX = m_pointArray.at( m_indexPointArray - 2 ).x();
01749 double _firstY = m_pointArray.at( m_indexPointArray - 2 ).y();
01750
01751 double _fourthX = m_pointArray.at( m_indexPointArray - 1 ).x();
01752 double _fourthY = m_pointArray.at( m_indexPointArray - 1 ).y();
01753
01754 double _midpointX = (_firstX + _fourthX ) / 2;
01755 double _midpointY = (_firstY + _fourthY ) / 2;
01756 double _diffX = _fourthX - _midpointX;
01757 double _diffY = _fourthY - _midpointY;
01758
01759 double _secondX = m_endPoint.x() - _diffX;
01760 double _secondY = m_endPoint.y() - _diffY;
01761 m_CubicBezierSecondPoint = KoPoint( _secondX, _secondY );
01762
01763 m_symmetricEndPoint = m_startPoint * 2 - m_endPoint;
01764
01765 double _thirdX = m_symmetricEndPoint.x() - _diffX;
01766 double _thirdY = m_symmetricEndPoint.y() - _diffY;
01767 m_CubicBezierThirdPoint = KoPoint( _thirdX, _thirdY );
01768
01769 if ( toolEditMode == INS_QUADRICBEZIERCURVE || toolEditMode == INS_CLOSED_QUADRICBEZIERCURVE ) {
01770 _secondX = _thirdX;
01771 _secondY = _thirdY;
01772 m_CubicBezierSecondPoint = KoPoint( _secondX, _secondY );
01773 }
01774 points.putPoints( 0, 4, _firstX,_firstY, _secondX,_secondY, _thirdX,_thirdY, _fourthX,_fourthY );
01775 }
01776
01777 drawCubicBezierCurve( p, points );
01778 if ( points.size() > 0 )
01779 {
01780 m_oldCubicBezierPointArray = points;
01781 }
01782
01783 mouseSelectedObject = true;
01784 } break;
01785 case INS_POLYGON: {
01786 QPainter p( this );
01787 p.setPen( QPen( black, 1, SolidLine ) );
01788 p.setBrush( NoBrush );
01789 p.setRasterOp( NotROP );
01790 p.translate( -diffx(), -diffy() );
01791
01792 KoPoint sp( snapPoint( docPoint ) );
01793
01794 drawPolygon( p, m_insertRect );
01795 updateInsertRect( sp, e->state() );
01796
01797 drawPolygon( p, m_insertRect );
01798
01799 mouseSelectedObject = true;
01800 } break;
01801 default: break;
01802 }
01803 }
01804 } else if ( !editMode && m_drawMode && m_drawLineInDrawMode ) {
01805 QPainter p;
01806 p.begin( this );
01807 p.setPen( m_view->kPresenterDoc()->presPen() );
01808 p.drawLine( m_drawModeLines[m_drawModeLines.count() - 1].point( m_drawModeLineIndex - 1 ), e->pos() );
01809 p.end();
01810 m_drawModeLines[m_drawModeLines.count() - 1].putPoints( m_drawModeLineIndex++, 1, e->x(), e->y() );
01811 }
01812
01813 if ( !editMode && !m_drawMode && !m_presMenu->isVisible() && fillBlack )
01814 setCursor( blankCursor );
01815 }
01816
01817 void KPrCanvas::mouseDoubleClickEvent( QMouseEvent *e )
01818 {
01819 if(!m_view->koDocument()->isReadWrite())
01820 return;
01821 QPoint contentsPoint( e->pos().x()+diffx(), e->pos().y()+diffy() );
01822 KoPoint docPoint = m_view->zoomHandler()->unzoomPoint( contentsPoint );
01823 if(m_currentTextObjectView)
01824 {
01825 KPrTextObject *txtObj=m_currentTextObjectView->kpTextObject();
01826 Q_ASSERT(txtObj);
01827 if(txtObj->contains( docPoint ))
01828 {
01829 KoPoint pos = docPoint - txtObj->getOrig();
01830
01831 m_currentTextObjectView->mouseDoubleClickEvent( e, m_view->zoomHandler()->ptToLayoutUnitPix( pos ) );
01832 return;
01833 }
01834 }
01835
01836
01837 if ( !m_activePage->getPageRect().contains(docPoint))
01838 return;
01839
01840
01841 if ( ( toolEditMode == INS_POLYLINE || toolEditMode == INS_CLOSED_POLYLINE ) && !m_pointArray.isNull() && m_drawPolyline )
01842 {
01843 m_startPoint = snapPoint( docPoint );
01844
01845 m_pointArray.putPoints( m_indexPointArray, 1, m_startPoint.x(), m_startPoint.y() );
01846 ++m_indexPointArray;
01847 endDrawPolyline();
01848
01849 mouseMoveEvent( e );
01850 return;
01851 }
01852
01853
01854 if ( toolEditMode != TEM_MOUSE || !editMode ) return;
01855
01856 KPrObject *kpobject = getObjectAt( docPoint );
01857 if(kpobject)
01858 {
01859 if ( kpobject->getType() == OT_TEXT )
01860 {
01861 deSelectAllObj();
01862 KPrTextObject *kptextobject = dynamic_cast<KPrTextObject*>( kpobject );
01863 if(kptextobject && (!kptextobject->isProtectContent() || kptextobject->isProtectContent()
01864 && m_view->kPresenterDoc()->cursorInProtectedArea()))
01865 {
01866 if(m_currentTextObjectView)
01867 {
01868 m_currentTextObjectView->terminate();
01869 delete m_currentTextObjectView;
01870 }
01871 m_currentTextObjectView=kptextobject->createKPTextView(this);
01872
01873
01874 setCursor( arrowCursor );
01875 m_editObject = kpobject;
01876 }
01877 }
01878 else if ( kpobject->getType() == OT_PART )
01879 {
01880 deSelectAllObj();
01881 KPrPartObject * obj=dynamic_cast<KPrPartObject *>(kpobject);
01882 if(obj)
01883 {
01884 obj->activate( m_view );
01885 m_editObject = obj;
01886 }
01887 }
01888 else
01889 getView()->extraProperties();
01890 }
01891 }
01892
01893 void KPrCanvas::drawPieObject( QPainter *p, const KoRect & rect )
01894 {
01895 QRect pRect( m_view->zoomHandler()->zoomRect( rect ) );
01896 switch ( m_view->getPieType() ) {
01897 case PT_PIE:
01898 p->drawPie( pRect.x(), pRect.y(), pRect.width() - 2,
01899 pRect.height() - 2, m_view->getPieAngle(), m_view->getPieLength() );
01900 break;
01901 case PT_ARC:
01902 p->drawArc( pRect.x(), pRect.y(), pRect.width() - 2,
01903 pRect.height() - 2, m_view->getPieAngle(), m_view->getPieLength() );
01904 break;
01905 case PT_CHORD:
01906 p->drawChord( pRect.x(), pRect.y(), pRect.width() - 2,
01907 pRect.height() - 2, m_view->getPieAngle(), m_view->getPieLength() );
01908 break;
01909 default: break;
01910 }
01911
01912 }
01913
01914 void KPrCanvas::wheelEvent( QWheelEvent *e )
01915 {
01916 if ( !editMode && !m_drawMode ) {
01917 if ( e->delta() == -120 )
01918 m_view->screenNext();
01919 else if ( e->delta() == 120 )
01920 m_view->screenPrev();
01921 e->accept();
01922 }
01923 else if ( editMode )
01924 emit sigMouseWheelEvent( e );
01925 }
01926
01927 void KPrCanvas::keyPressEvent( QKeyEvent *e )
01928 {
01929 if ( editMode && m_view->kPresenterDoc()->showGuideLines() && m_gl.keyPressEvent( e ) )
01930 return;
01931 if ( !editMode ) {
01932 switch ( e->key() ) {
01933 case Qt::Key_Space: case Key_Right: case Key_Down:
01934 setSwitchingMode( false );
01935 m_view->screenNext();
01936 break;
01937 case Qt::Key_Next:
01938 setSwitchingMode( false );
01939 m_view->screenNext( true );
01940 break;
01941 case Qt::Key_Backspace: case Key_Left: case Key_Up:
01942 setSwitchingMode( false );
01943 finishObjectEffects();
01944 finishPageEffect( true );
01945 m_view->screenPrev();
01946 break;
01947 case Qt::Key_Prior:
01948 setSwitchingMode( false );
01949 finishObjectEffects();
01950 finishPageEffect( true );
01951 m_view->screenPrev( true );
01952 break;
01953 case Qt::Key_Escape: case Key_Q: case Key_X:
01954 setSwitchingMode( false );
01955 finishObjectEffects();
01956 finishPageEffect( true );
01957 m_view->screenStop();
01958 break;
01959 case Qt::Key_G:
01960
01961 if ( !spManualSwitch() )
01962 m_view->stopAutoPresTimer();
01963 slotGotoPage();
01964 break;
01965 case Qt::Key_Home:
01966 setSwitchingMode( false );
01967 presGotoFirstPage();
01968 if ( !spManualSwitch() ) {
01969 m_view->setAutoPresTimer( 1 );
01970 m_setPageTimer = true;
01971 }
01972 break;
01973 case Qt::Key_End:
01974 setSwitchingMode( false );
01975 if ( m_presentationSlidesIterator != m_presentationSlides.end() ) {
01976 gotoPage( *(--m_presentationSlides.end()) );
01977 if ( !spManualSwitch() ) {
01978 m_view->setAutoPresTimer( 1 );
01979 m_setPageTimer = true;
01980 }
01981 }
01982 break;
01983 default: break;
01984 }
01985 } else if ( m_editObject ) {
01986 if ( e->key() == Qt::Key_Escape ) {
01987 exitEditMode();
01988 }
01989 else if ( m_currentTextObjectView )
01990 {
01991 if ( !m_currentTextObjectView->kpTextObject()->isProtectContent() || (e->text().length() == 0))
01992 m_currentTextObjectView->keyPressEvent( e );
01993 else
01994 KMessageBox::information(this, i18n("Read-only content cannot be changed. No modifications will be accepted."));
01995 }
01996 }
01997 else
01998 {
01999 switch ( e->key() )
02000 {
02001 case Qt::Key_Next:
02002 m_view->nextPage();
02003 break;
02004 case Qt::Key_Prior:
02005 m_view->prevPage();
02006 break;
02007 case Qt::Key_Home:
02008 m_view->screenFirst();
02009 break;
02010 case Qt::Key_End:
02011 m_view->screenLast();
02012 break;
02013 default:
02014 break;
02015 }
02016
02017 if ( mouseSelectedObject )
02018 {
02019 m_disableSnapping = e->state() & ShiftButton;
02020
02021 int offsetx = 1;
02022 int offsety = 1;
02023
02024 if ( e->state() & ControlButton )
02025 {
02026 offsetx = QMAX(1,m_view->zoomHandler()->zoomItX(10));
02027 offsety = QMAX(1,m_view->zoomHandler()->zoomItY(10));
02028 }
02029
02030 if ( !m_keyPressEvent )
02031 {
02032 m_moveStartPosKey = objectRect( false ).topLeft();
02033 }
02034 switch ( e->key() )
02035 {
02036 case Qt::Key_Up:
02037 m_keyPressEvent = true;
02038 moveObjectsByKey( 0, -offsety );
02039 break;
02040 case Qt::Key_Down:
02041 m_keyPressEvent = true;
02042 moveObjectsByKey( 0, offsety );
02043 break;
02044 case Qt::Key_Right:
02045 m_keyPressEvent = true;
02046 moveObjectsByKey( offsetx, 0 );
02047 break;
02048 case Qt::Key_Left:
02049 m_keyPressEvent = true;
02050 moveObjectsByKey( -offsetx, 0 );
02051 break;
02052 case Qt::Key_Delete:
02053 case Key_Backspace:
02054 m_view->editDelete();
02055 break;
02056 case Qt::Key_Escape:
02057 {
02058 if ( mousePressed && toolEditMode == TEM_MOUSE )
02059 {
02060 switch (modType)
02061 {
02062 case MT_RESIZE_UP:
02063 case MT_RESIZE_DN:
02064 case MT_RESIZE_LF:
02065 case MT_RESIZE_RT:
02066 case MT_RESIZE_LU:
02067 case MT_RESIZE_LD:
02068 case MT_RESIZE_RU:
02069 case MT_RESIZE_RD:
02070 {
02071 QRect oldBoundingRect = m_view->zoomHandler()->zoomRect( m_resizeObject->getRepaintRect() );
02072 m_resizeObject->setOrig( m_rectBeforeResize.topLeft() );
02073 m_resizeObject->setSize( m_rectBeforeResize.size() );
02074 drawContour = false;
02075 m_view->kPresenterDoc()->repaint( oldBoundingRect );
02076 m_view->kPresenterDoc()->repaint( m_resizeObject );
02077 m_ratio = 0.0;
02078 m_resizeObject = 0;
02079 m_isResizing = false;
02080 m_view->disableAutoScroll();
02081 mousePressed = false;
02082 modType = MT_NONE;
02083 return;
02084 }
02085 case MT_MOVE:
02086 {
02087 if ( m_isMoving )
02088 {
02089 drawContour = false;
02090 KoPoint move( m_moveStartPoint - objectRect( false ).topLeft() );
02091 m_activePage->moveObject( m_view, move, false );
02092 m_view->disableAutoScroll();
02093 mousePressed = false;
02094 modType = MT_NONE;
02095 m_isMoving = false;
02096 return;
02097 }
02098 break;
02099 }
02100 default:
02101 break;
02102 }
02103 }
02104 setToolEditMode( TEM_MOUSE );
02105 break;
02106 }
02107 case Qt::Key_Shift:
02108 {
02109 bool oldChangeSnap = m_disableSnapping;
02110 m_disableSnapping = e->key() == Qt::Key_Shift;
02111 if ( !oldChangeSnap && m_disableSnapping )
02112 {
02113 m_gl.repaintAfterSnapping();
02114 }
02115
02116 if ( e->state() & Qt::LeftButton && m_isMoving )
02117 {
02118 moveObjectsByMouse( m_origMousePos, e->state() & AltButton || e->state() & ControlButton );
02119 }
02120 break;
02121 }
02122 default: break;
02123 }
02124 }
02125 else
02126 {
02127 switch ( e->key() ) {
02128 case Qt::Key_Down:
02129 m_view->getVScrollBar()->addLine();
02130 break;
02131 case Qt::Key_Up:
02132 m_view->getVScrollBar()->subtractLine();
02133 break;
02134 case Qt::Key_Right:
02135 m_view->getHScrollBar()->addLine();
02136 break;
02137 case Qt::Key_Left:
02138 m_view->getHScrollBar()->subtractLine();
02139 break;
02140 case Qt::Key_Tab:
02141 selectNext();
02142 break;
02143 case Qt::Key_Backtab:
02144 selectPrev();
02145 break;
02146 case Qt::Key_Escape:
02147 if ( toolEditMode == TEM_ZOOM )
02148 setToolEditMode( TEM_MOUSE );
02149 break;
02150 default: break;
02151 }
02152 }
02153 }
02154 }
02155
02156 void KPrCanvas::keyReleaseEvent( QKeyEvent *e )
02157 {
02158 if ( editMode && m_currentTextObjectView )
02159 m_currentTextObjectView->keyReleaseEvent( e );
02160 else
02161 {
02162 if ( mouseSelectedObject )
02163 {
02164 if(e->key()==Qt::Key_Up || e->key()==Key_Down || e->key()==Key_Right || e->key()==Key_Left)
02165 {
02166 if ( !e->isAutoRepeat() )
02167 {
02168 KoPoint move( objectRect( false ).topLeft() - m_moveStartPosKey);
02169 KCommand *cmd=m_activePage->moveObject(m_view, move.x(), move.y());
02170 if(cmd)
02171 m_view->kPresenterDoc()->addCommand( cmd );
02172 m_keyPressEvent = false;
02173 }
02174 emit objectSelectedChanged();
02175 }
02176 }
02177 }
02178 }
02179
02180 void KPrCanvas::imStartEvent( QIMEvent * e )
02181 {
02182 if ( m_editObject && m_currentTextObjectView )
02183 {
02184 if ( !m_currentTextObjectView->kpTextObject()->isProtectContent() )
02185 m_currentTextObjectView->imStartEvent( e );
02186 else
02187 KMessageBox::information(this, i18n("Read-only content cannot be changed. No modifications will be accepted."));
02188 }
02189 }
02190
02191 void KPrCanvas::imComposeEvent( QIMEvent * e )
02192 {
02193 if ( m_editObject && m_currentTextObjectView )
02194 {
02195 if ( !m_currentTextObjectView->kpTextObject()->isProtectContent() )
02196 m_currentTextObjectView->imComposeEvent( e );
02197 }
02198 }
02199
02200 void KPrCanvas::imEndEvent( QIMEvent * e )
02201 {
02202 if ( m_editObject && m_currentTextObjectView )
02203 {
02204 if ( !m_currentTextObjectView->kpTextObject()->isProtectContent() )
02205 m_currentTextObjectView->imEndEvent( e );
02206 }
02207 }
02208
02209 void KPrCanvas::resizeEvent( QResizeEvent *e )
02210 {
02211 if ( editMode )
02212 {
02213 QWidget::resizeEvent( e );
02214 }
02215 else
02216 QWidget::resizeEvent( new QResizeEvent( KGlobalSettings::desktopGeometry(this).size(),
02217 e->oldSize() ) );
02218 buffer.resize( size() );
02219 }
02220
02221 bool KPrCanvas::close( bool alsoDelete )
02222 {
02223 if ( editMode )
02224 {
02225 return QWidget::close(alsoDelete);
02226 }
02227 else
02228 {
02229 m_view->screenStop();
02230 return false;
02231 }
02232 }
02233
02234 KPrObject * KPrCanvas::getObjectAt( const KoPoint &pos, bool withoutProtected )
02235 {
02236 KPrObject *object = m_activePage->getObjectAt( pos, withoutProtected );
02237 if ( objectIsAHeaderFooterHidden( object ) )
02238 object = 0;
02239
02240 return object;
02241 }
02242
02243 void KPrCanvas::selectObj( KPrObject *kpobject )
02244 {
02245 kpobject->setSelected( true );
02246 _repaint( kpobject );
02247 emit objectSelectedChanged();
02248
02249 mouseSelectedObject = true;
02250 }
02251
02252 void KPrCanvas::deSelectObj( KPrObject *kpobject )
02253 {
02254 kpobject->setSelected( false );
02255 _repaint( kpobject );
02256
02257 if ( !m_activePage->isOneObjectSelected() )
02258 {
02259 mouseSelectedObject = false;
02260 }
02261 emit objectSelectedChanged();
02262 }
02263
02264 void KPrCanvas::selectAllObj()
02265 {
02266 QPtrListIterator<KPrObject> it( m_activePage->objectList() );
02267 for ( ; it.current() ; ++it )
02268 {
02269 if ( !objectIsAHeaderFooterHidden(it.current()) )
02270 it.current()->setSelected( true );
02271 }
02272
02273 mouseSelectedObject = true;
02274 _repaint( false );
02275 emit objectSelectedChanged();
02276 }
02277
02278
02279 void KPrCanvas::deSelectAllObj()
02280 {
02281 if( m_activePage->numSelected() == 0 )
02282 return;
02283
02284 lowerObject();
02285
02286 m_activePage->deSelectAllObj();
02287
02288
02289 if(m_currentTextObjectView)
02290 {
02291 m_currentTextObjectView->terminate();
02292 m_currentTextObjectView->kpTextObject()->setEditingTextObj( false );
02293 delete m_currentTextObjectView;
02294 m_currentTextObjectView=0L;
02295 }
02296 mouseSelectedObject = false;
02297 emit objectSelectedChanged();
02298 }
02299
02300 void KPrCanvas::setMouseSelectedObject(bool b)
02301 {
02302 mouseSelectedObject = b;
02303 emit objectSelectedChanged();
02304 }
02305
02306 void KPrCanvas::setupMenus()
02307 {
02308
02309 m_presMenu = new KPopupMenu();
02310 Q_CHECK_PTR( m_presMenu );
02311 m_presMenu->setCheckable( true );
02312 m_presMenu->insertTitle( i18n( "Slide Show" ) );
02313 m_presMenu->insertItem( i18n( "&Continue" ), this, SLOT( setSwitchingMode() ) );
02314 PM_DM = m_presMenu->insertItem( i18n( "&Drawing Mode" ), this, SLOT( setDrawingMode() ) );
02315 m_presMenu->insertSeparator();
02316 m_presMenu->insertItem( SmallIcon("goto"), i18n( "&Goto Slide..." ), this, SLOT( slotGotoPage() ) );
02317 m_presMenu->insertSeparator();
02318 m_presMenu->insertItem( i18n( "&End" ), this, SLOT( slotExitPres() ) );
02319 m_presMenu->setItemChecked( PM_DM, false );
02320 m_presMenu->setMouseTracking( true );
02321 }
02322
02323 void KPrCanvas::clipCut()
02324 {
02325 if ( m_currentTextObjectView )
02326 m_currentTextObjectView->cut();
02327 m_view->editCut();
02328 }
02329
02330 void KPrCanvas::clipCopy()
02331 {
02332 if ( m_currentTextObjectView )
02333 m_currentTextObjectView->copy();
02334 m_view->editCopy();
02335 }
02336
02337 void KPrCanvas::clipPaste()
02338 {
02339 if ( m_currentTextObjectView )
02340 m_currentTextObjectView->paste();
02341 m_view->editPaste();
02342 }
02343
02344 void KPrCanvas::chPic()
02345 {
02346 m_activePage->chPic( m_view );
02347 }
02348
02349 bool KPrCanvas::exportPage( int nPage,
02350 int nWidth,
02351 int nHeight,
02352 const KURL& _fileURL,
02353 const char* format,
02354 int quality )
02355 {
02356 bool res = false;
02357 const QCursor oldCursor( cursor() );
02358 setCursor( waitCursor );
02359 QPixmap pix( nWidth, nHeight );
02360 drawPageInPix( pix, nPage, 0, true, nWidth, nHeight );
02361 if( !pix.isNull() ){
02362
02363
02364
02365
02366
02367
02368 const QSize desiredSize(nWidth, nHeight);
02369 if( desiredSize != pix.size() )
02370 pix.resize( desiredSize );
02371
02372 KURL fileURL(_fileURL);
02373 if( fileURL.protocol().isEmpty() )
02374 fileURL.setProtocol( "file" );
02375 const bool bLocalFile = fileURL.isLocalFile();
02376 KTempFile* tmpFile = bLocalFile ? NULL : new KTempFile();
02377 if( !bLocalFile )
02378 tmpFile->setAutoDelete( true );
02379 if( bLocalFile || 0 == tmpFile->status() ){
02380 QFile file( bLocalFile ? fileURL.path(0) : tmpFile->name() );
02381 if ( file.open( IO_ReadWrite ) ) {
02382 res = pix.save( &file, format, quality );
02383 file.close();
02384 }
02385 if( !bLocalFile ){
02386 if( res ){
02387 res = KIO::NetAccess::upload( tmpFile->name(), fileURL, this );
02388 }
02389 }
02390 }
02391 if( !bLocalFile ){
02392 delete tmpFile;
02393 }
02394 }
02395 setCursor( oldCursor );
02396 return res;
02397 }
02398
02399 void KPrCanvas::savePicture()
02400 {
02401 m_activePage->savePicture( m_view );
02402 }
02403
02404 void KPrCanvas::setTextFormat(const KoTextFormat &format, int flags)
02405 {
02406 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02407 if ( lst.isEmpty() ) return;
02408 KMacroCommand* macroCmd = new KMacroCommand( i18n("Change Text Font") );
02409 QPtrListIterator<KoTextFormatInterface> it( lst );
02410 for ( ; it.current() ; ++it ) {
02411 KCommand *cmd = it.current()->setFormatCommand(&format, flags, true);
02412
02413 if (cmd)
02414 macroCmd->addCommand( cmd );
02415 }
02416 m_view->kPresenterDoc()->addCommand( macroCmd );
02417 }
02418
02419 void KPrCanvas::setTextColor( const QColor &color )
02420 {
02421 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02422 if ( lst.isEmpty() ) return;
02423 QPtrListIterator<KoTextFormatInterface> it( lst );
02424 KMacroCommand* macroCmd = new KMacroCommand( i18n("Set Text Color") );
02425 for ( ; it.current() ; ++it ) {
02426 KCommand* cmd = it.current()->setTextColorCommand( color );
02427 if (cmd)
02428 macroCmd->addCommand( cmd );
02429 }
02430 m_view->kPresenterDoc()->addCommand( macroCmd );
02431 }
02432
02433 void KPrCanvas::setTextBackgroundColor( const QColor &color )
02434 {
02435 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02436 if ( lst.isEmpty() ) return;
02437 QPtrListIterator<KoTextFormatInterface> it( lst );
02438 KMacroCommand* macroCmd = 0L;
02439 for ( ; it.current() ; ++it ) {
02440 KCommand* cmd = it.current()->setTextBackgroundColorCommand( color );
02441 if ( cmd )
02442 {
02443 if ( !macroCmd )
02444 macroCmd = new KMacroCommand( i18n("Set Text Background Color") );
02445 macroCmd->addCommand( cmd );
02446 }
02447 }
02448 if (macroCmd )
02449 m_view->kPresenterDoc()->addCommand( macroCmd );
02450 }
02451
02452 void KPrCanvas::setTextBold( bool b )
02453 {
02454 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02455 if ( lst.isEmpty() ) return;
02456 QPtrListIterator<KoTextFormatInterface> it( lst );
02457 KMacroCommand* macroCmd = 0L;
02458 for ( ; it.current() ; ++it ) {
02459 KCommand* cmd = it.current()->setBoldCommand( b );
02460 if ( cmd )
02461 {
02462 if ( !macroCmd )
02463 macroCmd = new KMacroCommand( i18n("Make Text Bold") );
02464 macroCmd->addCommand( cmd );
02465 }
02466 }
02467 if ( macroCmd )
02468 m_view->kPresenterDoc()->addCommand( macroCmd );
02469 }
02470
02471 void KPrCanvas::setTextItalic( bool b )
02472 {
02473 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02474 if ( lst.isEmpty() ) return;
02475 QPtrListIterator<KoTextFormatInterface> it( lst );
02476 KMacroCommand* macroCmd = 0L;
02477 for ( ; it.current() ; ++it ) {
02478 KCommand* cmd = it.current()->setItalicCommand( b );
02479 if ( cmd )
02480 {
02481 if ( !macroCmd )
02482 macroCmd = new KMacroCommand( i18n("Make Text Italic") );
02483 macroCmd->addCommand( cmd );
02484 }
02485 }
02486 if (macroCmd )
02487 m_view->kPresenterDoc()->addCommand( macroCmd );
02488 }
02489
02490 void KPrCanvas::setTextUnderline( bool b )
02491 {
02492 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02493 if ( lst.isEmpty() ) return;
02494 QPtrListIterator<KoTextFormatInterface> it( lst );
02495 KMacroCommand* macroCmd = 0L;
02496 for ( ; it.current() ; ++it ) {
02497 KCommand* cmd = it.current()->setUnderlineCommand( b );
02498 if ( cmd )
02499 {
02500 if ( !macroCmd )
02501 macroCmd = new KMacroCommand( i18n("Underline Text") );
02502 macroCmd->addCommand( cmd );
02503 }
02504 }
02505 if ( macroCmd )
02506 m_view->kPresenterDoc()->addCommand( macroCmd );
02507 }
02508
02509 void KPrCanvas::setTextStrikeOut( bool b )
02510 {
02511 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02512 if ( lst.isEmpty() ) return;
02513 KMacroCommand* macroCmd = 0L;
02514 QPtrListIterator<KoTextFormatInterface> it( lst );
02515 for ( ; it.current() ; ++it ) {
02516 KCommand *cmd = it.current()->setStrikeOutCommand( b );
02517 if ( cmd )
02518 {
02519 if ( !macroCmd )
02520 macroCmd = new KMacroCommand( i18n("Make Text Italic") );
02521 macroCmd->addCommand( cmd );
02522 }
02523 }
02524 if ( macroCmd )
02525 m_view->kPresenterDoc()->addCommand( macroCmd );
02526 }
02527
02528 void KPrCanvas::setTextFamily( const QString &f )
02529 {
02530 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02531 if ( lst.isEmpty() ) return;
02532 KMacroCommand* macroCmd = 0L;
02533 QPtrListIterator<KoTextFormatInterface> it( lst );
02534 for ( ; it.current() ; ++it ) {
02535 KCommand* cmd = it.current()->setFamilyCommand( f );
02536 if ( cmd )
02537 {
02538 if ( !macroCmd )
02539 macroCmd = new KMacroCommand( i18n("Set Text Font") );
02540 macroCmd->addCommand( cmd );
02541 }
02542 }
02543 if ( macroCmd)
02544 m_view->kPresenterDoc()->addCommand( macroCmd );
02545 }
02546
02547 void KPrCanvas::setTextPointSize( int s )
02548 {
02549 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02550 if ( lst.isEmpty() ) return;
02551 KMacroCommand* macroCmd = 0L;
02552 QPtrListIterator<KoTextFormatInterface> it( lst );
02553 for ( ; it.current() ; ++it ) {
02554 KCommand* cmd = it.current()->setPointSizeCommand( s );
02555 if ( cmd )
02556 {
02557 if ( !macroCmd )
02558 macroCmd = new KMacroCommand( i18n("Change Text Size") );
02559 macroCmd->addCommand( cmd );
02560 }
02561
02562 }
02563 if (macroCmd)
02564 m_view->kPresenterDoc()->addCommand( macroCmd );
02565 }
02566
02567 void KPrCanvas::setTextSubScript( bool b )
02568 {
02569 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02570 if ( lst.isEmpty() ) return;
02571 QPtrListIterator<KoTextFormatInterface> it( lst );
02572 KMacroCommand* macroCmd = 0L;
02573 for ( ; it.current() ; ++it ) {
02574 KCommand* cmd = it.current()->setTextSubScriptCommand( b );
02575 if ( cmd )
02576 {
02577 if ( !macroCmd )
02578 macroCmd = new KMacroCommand( i18n("Set Text Subscript") );
02579 macroCmd->addCommand( cmd );
02580 }
02581 }
02582 if ( macroCmd )
02583 m_view->kPresenterDoc()->addCommand( macroCmd );
02584 }
02585
02586 void KPrCanvas::setTextSuperScript( bool b )
02587 {
02588 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02589 if ( lst.isEmpty() ) return;
02590 QPtrListIterator<KoTextFormatInterface> it( lst );
02591 KMacroCommand* macroCmd = 0L;
02592 for ( ; it.current() ; ++it ) {
02593 KCommand* cmd = it.current()->setTextSuperScriptCommand( b );
02594 if ( cmd )
02595 {
02596 if ( !macroCmd )
02597 macroCmd = new KMacroCommand( i18n("Set Text Superscript") );
02598 macroCmd->addCommand( cmd );
02599 }
02600 }
02601 if ( macroCmd )
02602 m_view->kPresenterDoc()->addCommand( macroCmd );
02603 }
02604
02605 void KPrCanvas::setTextDefaultFormat( )
02606 {
02607 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02608 if ( lst.isEmpty() ) return;
02609 QPtrListIterator<KoTextFormatInterface> it( lst );
02610 KMacroCommand* macroCmd = 0L;
02611 for ( ; it.current() ; ++it ) {
02612 KCommand* cmd = it.current()->setDefaultFormatCommand( );
02613 if ( cmd )
02614 {
02615 if ( !macroCmd )
02616 macroCmd = new KMacroCommand( i18n("Apply Default Format") );
02617 macroCmd->addCommand( cmd );
02618 }
02619 }
02620 if (macroCmd)
02621 m_view->kPresenterDoc()->addCommand( macroCmd );
02622 }
02623
02624 void KPrCanvas::setIncreaseFontSize()
02625 {
02626 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02627 if ( lst.isEmpty() ) return;
02628 QPtrListIterator<KoTextFormatInterface> it( lst );
02629 int size = it.current()->currentFormat()->pointSize();
02630 KMacroCommand* macroCmd =0L;
02631 for ( ; it.current() ; ++it ) {
02632 KCommand* cmd = it.current()->setPointSizeCommand( size+1 );
02633 if ( cmd )
02634 {
02635 if ( !macroCmd )
02636 macroCmd = new KMacroCommand( i18n("Increase Font Size") );
02637 macroCmd->addCommand( cmd );
02638 }
02639 }
02640 if ( macroCmd)
02641 m_view->kPresenterDoc()->addCommand( macroCmd );
02642 }
02643
02644 void KPrCanvas::setDecreaseFontSize()
02645 {
02646 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02647 if ( lst.isEmpty() ) return;
02648 QPtrListIterator<KoTextFormatInterface> it( lst );
02649 int size = it.current()->currentFormat()->pointSize();
02650 KMacroCommand* macroCmd = 0L;
02651 for ( ; it.current() ; ++it ) {
02652 KCommand* cmd = it.current()->setPointSizeCommand( size-1 );
02653 if ( cmd )
02654 {
02655 if ( !macroCmd )
02656 macroCmd = new KMacroCommand( i18n("Decrease Font Size") );
02657 macroCmd->addCommand( cmd );
02658 }
02659 }
02660 if ( macroCmd )
02661 m_view->kPresenterDoc()->addCommand( macroCmd );
02662 }
02663
02664 void KPrCanvas::setTextAlign( int align )
02665 {
02666 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02667 if ( lst.isEmpty() ) return;
02668 QPtrListIterator<KoTextFormatInterface> it( lst );
02669 KMacroCommand* macroCmd = 0L;
02670 for ( ; it.current() ; ++it ) {
02671 KCommand* cmd = it.current()->setAlignCommand(align);
02672 if ( cmd )
02673 {
02674 if ( !macroCmd)
02675 macroCmd = new KMacroCommand( i18n("Set Text Align") );
02676 macroCmd->addCommand( cmd );
02677 }
02678 }
02679 if ( macroCmd )
02680 m_view->kPresenterDoc()->addCommand( macroCmd );
02681 }
02682
02683 void KPrCanvas::setTabList( const KoTabulatorList & tabList )
02684 {
02685 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02686 if ( lst.isEmpty() ) return;
02687 QPtrListIterator<KoTextFormatInterface> it( lst );
02688 KMacroCommand* macroCmd = 0L;
02689 for ( ; it.current() ; ++it ) {
02690 KCommand* cmd = it.current()->setTabListCommand(tabList );
02691 if ( cmd )
02692 {
02693 if ( !macroCmd )
02694 macroCmd = new KMacroCommand( i18n("Change Tabulators") );
02695 macroCmd->addCommand( cmd );
02696 }
02697 }
02698 if ( macroCmd)
02699 m_view->kPresenterDoc()->addCommand( macroCmd );
02700 }
02701
02702 void KPrCanvas::setTextDepthPlus()
02703 {
02704 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02705 if ( lst.isEmpty() ) return;
02706 double leftMargin=0.0;
02707 if(!lst.isEmpty())
02708 leftMargin=lst.first()->currentParagLayoutFormat()->margins[QStyleSheetItem::MarginLeft];
02709 double indent = m_view->kPresenterDoc()->getIndentValue();
02710 double newVal = leftMargin + indent;
02711 QPtrListIterator<KoTextFormatInterface> it( lst );
02712 KMacroCommand* macroCmd = 0L;
02713 for ( ; it.current() ; ++it ) {
02714 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginLeft, newVal);
02715 if ( cmd )
02716 {
02717 if ( !macroCmd )
02718 macroCmd = new KMacroCommand( i18n("Increase Paragraph Depth") );
02719 macroCmd->addCommand( cmd );
02720 }
02721 }
02722 if ( macroCmd )
02723 m_view->kPresenterDoc()->addCommand( macroCmd );
02724 if(!lst.isEmpty())
02725 {
02726 const KoParagLayout *layout=lst.first()->currentParagLayoutFormat();
02727 m_view->showRulerIndent( layout->margins[QStyleSheetItem::MarginLeft], layout->margins[QStyleSheetItem::MarginFirstLine],
02728 layout->margins[QStyleSheetItem::MarginRight], lst.first()->rtl());
02729 }
02730 }
02731
02732 void KPrCanvas::setTextDepthMinus()
02733 {
02734 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02735 if ( lst.isEmpty() ) return;
02736 double leftMargin=0.0;
02737 if(!lst.isEmpty())
02738 leftMargin=lst.first()->currentParagLayoutFormat()->margins[QStyleSheetItem::MarginLeft];
02739 double indent = m_view->kPresenterDoc()->getIndentValue();
02740 QPtrListIterator<KoTextFormatInterface> it( lst );
02741 double newVal = leftMargin - indent;
02742 KMacroCommand* macroCmd = 0L;
02743 for ( ; it.current() ; ++it ) {
02744 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginLeft, QMAX( newVal, 0 ));
02745 if ( cmd )
02746 {
02747 if ( !macroCmd )
02748 macroCmd = new KMacroCommand( i18n("Decrease Paragraph Depth") );
02749 macroCmd->addCommand( cmd );
02750 }
02751 }
02752 if (macroCmd )
02753 m_view->kPresenterDoc()->addCommand( macroCmd );
02754 if(!lst.isEmpty())
02755 {
02756 const KoParagLayout *layout=lst.first()->currentParagLayoutFormat();
02757 m_view->showRulerIndent( layout->margins[QStyleSheetItem::MarginLeft], layout->margins[QStyleSheetItem::MarginFirstLine],
02758 layout->margins[QStyleSheetItem::MarginRight], lst.first()->rtl());
02759 }
02760 }
02761
02762 void KPrCanvas::setNewFirstIndent(double _firstIndent)
02763 {
02764 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02765 if ( lst.isEmpty() ) return;
02766 QPtrListIterator<KoTextFormatInterface> it( lst );
02767 KMacroCommand* macroCmd = 0L;
02768 for ( ; it.current() ; ++it ) {
02769 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginFirstLine, _firstIndent);
02770 if ( cmd )
02771 {
02772 if ( !macroCmd )
02773 macroCmd = new KMacroCommand( i18n("Change First Line Indent") );
02774 macroCmd->addCommand( cmd );
02775 }
02776 }
02777 if ( macroCmd )
02778 m_view->kPresenterDoc()->addCommand( macroCmd );
02779 }
02780
02781 void KPrCanvas::setNewLeftIndent(double _leftIndent)
02782 {
02783 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02784 if ( lst.isEmpty() ) return;
02785 QPtrListIterator<KoTextFormatInterface> it( lst );
02786 KMacroCommand* macroCmd = 0L;
02787 for ( ; it.current() ; ++it ) {
02788 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginLeft, _leftIndent);
02789 if ( cmd )
02790 {
02791 if ( !macroCmd )
02792 macroCmd = new KMacroCommand( i18n("Change Left Indent") );
02793 macroCmd->addCommand( cmd );
02794 }
02795 }
02796 if ( macroCmd )
02797 m_view->kPresenterDoc()->addCommand( macroCmd );
02798 }
02799
02800 void KPrCanvas::setNewRightIndent(double _rightIndent)
02801 {
02802 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02803 if ( lst.isEmpty() ) return;
02804 QPtrListIterator<KoTextFormatInterface> it( lst );
02805 KMacroCommand* macroCmd = 0L;
02806 for ( ; it.current() ; ++it ) {
02807 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginRight, _rightIndent);
02808 if ( cmd )
02809 {
02810 if ( !macroCmd )
02811 macroCmd = new KMacroCommand( i18n("Change Right Indent") );
02812 macroCmd->addCommand( cmd );
02813 }
02814 }
02815 if ( macroCmd )
02816 m_view->kPresenterDoc()->addCommand( macroCmd );
02817 }
02818
02819
02820
02821
02822
02823
02824
02825
02826
02827
02828
02829
02830
02831
02832
02833
02834
02835
02836
02837
02838 #ifndef NDEBUG
02839 void KPrCanvas::printRTDebug( int info )
02840 {
02841 KPrTextObject *kpTxtObj = 0;
02842 if ( m_currentTextObjectView )
02843 kpTxtObj = m_currentTextObjectView->kpTextObject();
02844 else
02845 kpTxtObj = selectedTextObjs().first();
02846 if ( kpTxtObj )
02847 kpTxtObj->textObject()->printRTDebug( info );
02848 }
02849 #endif
02850
02851 bool KPrCanvas::haveASelectedPartObj() const
02852 {
02853 return m_activePage->haveASelectedPartObj();
02854 }
02855
02856 bool KPrCanvas::haveASelectedGroupObj() const
02857 {
02858 return m_activePage->haveASelectedGroupObj();
02859 }
02860
02861 bool KPrCanvas::haveASelectedPixmapObj() const
02862 {
02863 return m_activePage->haveASelectedPixmapObj();
02864 }
02865
02866 QPtrList<KPrTextObject> KPrCanvas::applicableTextObjects() const
02867 {
02868 QPtrList<KPrTextObject> lst;
02869
02870 if ( m_currentTextObjectView )
02871 lst.append( m_currentTextObjectView->kpTextObject() );
02872 else
02873 lst = selectedTextObjs();
02874 return lst;
02875 }
02876
02877 QPtrList<KoTextFormatInterface> KPrCanvas::applicableTextInterfaces() const
02878 {
02879 QPtrList<KoTextFormatInterface> lst;
02880 QPtrList<KPrObject> lstObj;
02881
02882 if ( m_currentTextObjectView )
02883 {
02884 if ( !m_currentTextObjectView->kpTextObject()->isProtectContent())
02885 lst.append( m_currentTextObjectView );
02886 }
02887 else
02888 {
02889 m_activePage->getAllObjectSelectedList(lstObj);
02890 QPtrListIterator<KPrObject> it(lstObj);
02891 for ( ; it.current(); ++it ) {
02892 if ( it.current()->getType() == OT_TEXT )
02893 {
02894 KPrTextObject * obj = static_cast<KPrTextObject*>( it.current() );
02895 if ( !obj->isProtectContent() )
02896 lst.append( obj->textObject() );
02897 }
02898 }
02899 }
02900 return lst;
02901 }
02902
02903 QPtrList<KPrTextObject> KPrCanvas::selectedTextObjs() const
02904 {
02905 QPtrList<KPrTextObject> lst;
02906 QPtrListIterator<KPrObject> it(getObjectList());
02907 for ( ; it.current(); ++it ) {
02908 if ( it.current()->isSelected() && it.current()->getType() == OT_TEXT )
02909 lst.append( static_cast<KPrTextObject*>( it.current() ) );
02910 }
02911 return lst;
02912 }
02913
02914 void KPrCanvas::startScreenPresentation( double zoomX, double zoomY, int curPgNum )
02915 {
02916
02917
02918
02919 m_presMenu->setItemChecked( PM_DM, false );
02920
02921 setCursor( waitCursor );
02922
02923 exitEditMode();
02924
02925 KPrDocument * doc = m_view->kPresenterDoc();
02926
02927
02928
02929 double zoom = kMin( zoomX, zoomY );
02930
02931 kdDebug() << "zoomX=" << zoomX << " zoomY=" << zoomY << " zoom=" << zoom << endl;
02932
02933 m_zoomBeforePresentation = doc->zoomHandler()->zoom();
02934 kdDebug() << "old zoomed resolutions =" << doc->zoomHandler()->zoomedResolutionX() << "," << doc->zoomHandler()->zoomedResolutionY() << endl;
02935
02936
02937
02938
02939 doc->zoomHandler()->setZoomAndResolution( qRound( zoom * m_zoomBeforePresentation ),
02940 KoGlobal::dpiX(), KoGlobal::dpiY() );
02941
02942 doc->newZoomAndResolution( false, false );
02943
02944
02945 m_presentationSlides.clear();
02946 QValueList<int> selected = doc->displaySelectedSlides();
02947 for ( QValueList<int>::Iterator it = selected.begin() ; it != selected.end(); ++ it )
02948 {
02949
02950
02951 int slideno = *it + 1;
02952 m_presentationSlides.append( slideno );
02953 }
02954
02955
02956 if( !m_presentationSlides.count() )
02957 {
02958
02959 stopScreenPresentation();
02960 return;
02961 }
02962
02963
02964 unsigned slide = 0;
02965 for( unsigned i = 0; i<m_presentationSlides.count(); i++ )
02966 if( m_presentationSlides[i] >= curPgNum )
02967 {
02968 slide = m_presentationSlides[i];
02969 break;
02970 }
02971
02972 setCursor( blankCursor );
02973
02974 m_step.m_pageNumber = (unsigned int) -1;
02975 gotoPage( slide );
02976
02977 }
02978
02979 void KPrCanvas::stopScreenPresentation()
02980 {
02981
02982 setCursor( waitCursor );
02983
02984 KPrDocument * doc = m_view->kPresenterDoc();
02985 doc->zoomHandler()->setZoomAndResolution( m_zoomBeforePresentation,
02986 KoGlobal::dpiX(), KoGlobal::dpiY() );
02987 doc->newZoomAndResolution(false,false);
02988 goingBack = false;
02989 m_step.m_pageNumber = 0;
02990 editMode = true;
02991 m_drawMode = false;
02992 repaint( false );
02993 setToolEditMode( toolEditMode );
02994 setWFlags( WResizeNoErase );
02995 }
02996
02997 bool KPrCanvas::pNext( bool gotoNextPage )
02998 {
02999 goingBack = false;
03000
03001 bool objectEffectFinished = finishObjectEffects();
03002
03003 KPrDocument * doc = m_view->kPresenterDoc();
03004
03005 if ( !gotoNextPage )
03006 {
03007 if ( finishPageEffect() )
03008 return false;
03009
03010
03011 m_drawModeLines.clear();
03012
03013
03014
03015
03016
03017 QPtrListIterator<KPrObject> oit( doc->pageList().at( m_step.m_pageNumber )->objectList() );
03018 for ( int i = 0 ; oit.current(); ++oit, ++i )
03019 {
03020 KPrObject *kpobject = oit.current();
03021 if ( kpobject->getAppearStep() == static_cast<int>( m_step.m_step )
03022 && kpobject->getType() == OT_TEXT && kpobject->getEffect2() != EF2_NONE )
03023 {
03024 if ( static_cast<int>( m_step.m_subStep + 1 ) < kpobject->getSubPresSteps() )
03025 {
03026 m_step.m_subStep++;
03027
03028 doObjEffects();
03029 return false;
03030 }
03031 }
03032 }
03033
03034
03035 if ( m_step.m_step < *( --m_pageEffectSteps.end() ) )
03036 {
03037 QValueList<int>::ConstIterator it = m_pageEffectSteps.find( m_step.m_step );
03038 m_step.m_step = *( ++it );
03039 m_step.m_subStep = 0;
03040
03041
03042
03043 if ( m_step.m_step == 0 )
03044 {
03045 QPainter p;
03046 p.begin( this );
03047 drawBackground( &p,
03048 QRect( 0, 0, kapp->desktop()->width(), kapp->desktop()->height() ),
03049 doc->pageList().at( m_step.m_pageNumber ) );
03050 p.end();
03051 }
03052
03053 doObjEffects();
03054 return false;
03055 }
03056
03057
03058
03059
03060
03061 if ( objectEffectFinished )
03062 return false;
03063 }
03064
03065
03066 QValueList<int>::ConstIterator test( m_presentationSlidesIterator );
03067 if ( ++test != m_presentationSlides.end() )
03068 {
03069 if ( !spManualSwitch() && m_setPageTimer )
03070 {
03071
03072 m_view->setAutoPresTimer( doc->pageList().at( (*m_presentationSlidesIterator) - 1 )->getPageTimer() / 1 );
03073 m_setPageTimer = false;
03074 return false;
03075 }
03076 m_setPageTimer = true;
03077
03078 QRect desk = KGlobalSettings::desktopGeometry(this);
03079 QPixmap _pix1( desk.width(), desk.height() );
03080 drawCurrentPageInPix( _pix1 );
03081
03082 m_view->setPageDuration( m_step.m_pageNumber );
03083
03084 m_step.m_pageNumber = *( ++m_presentationSlidesIterator ) - 1;
03085 m_step.m_subStep = 0;
03086
03087 m_pageEffectSteps = doc->getPageEffectSteps( m_step.m_pageNumber );
03088 m_step.m_step = *m_pageEffectSteps.begin();
03089
03090 QPixmap _pix2( desk.width(), desk.height() );
03091 drawCurrentPageInPix( _pix2 );
03092
03093 QValueList<int>::ConstIterator it( m_presentationSlidesIterator );
03094 --it;
03095
03096 KPrPage * page = doc->pageList().at( ( *it ) - 1 );
03097 PageEffect _pageEffect = page->getPageEffect();
03098
03099 bool _soundEffect = page->getPageSoundEffect();
03100 QString _soundFileName = page->getPageSoundFileName();
03101
03102 if ( _soundEffect && !_soundFileName.isEmpty() ) {
03103 stopSound();
03104 playSound( _soundFileName );
03105 }
03106
03107 if ( m_pageEffect )
03108 finishPageEffect();
03109
03110 m_pageEffect = new KPrPageEffects( this, _pix2, _pageEffect, page->getPageEffectSpeed() );
03111 if ( m_pageEffect->doEffect() )
03112 {
03113 delete m_pageEffect;
03114 m_pageEffect = 0;
03115
03116 doObjEffects( true );
03117 }
03118 else
03119 {
03120 connect( &m_pageEffectTimer, SIGNAL( timeout() ), SLOT( slotDoPageEffect() ) );
03121 m_pageEffectTimer.start( 50, true );
03122 }
03123
03124 return true;
03125 }
03126
03127
03128
03129
03130
03131 if ( ( spManualSwitch() || !spInfiniteLoop() ) && !showingLastSlide && spShowEndOfPresentationSlide() )
03132 {
03133 m_view->setPageDuration( m_step.m_pageNumber );
03134
03135 QRect desk = KGlobalSettings::desktopGeometry(this);
03136 QPixmap lastSlide( desk.width(), desk.height() );
03137 QFont font( m_view->kPresenterDoc()->defaultFont().family() );
03138 QPainter p( &lastSlide );
03139
03140 p.setFont( font );
03141 p.setPen( white );
03142 p.fillRect( p.viewport(), black );
03143 p.drawText( 50, 50, i18n( "End of presentation. Click to exit." ) );
03144 bitBlt( this, 0, 0, &lastSlide, 0, 0, lastSlide.width(), lastSlide.height() );
03145 showingLastSlide = true;
03146 emit stopAutomaticPresentation();
03147 }
03148 else if ( showingLastSlide || !spShowEndOfPresentationSlide() )
03149 {
03150 showingLastSlide = false;
03151 m_view->screenStop();
03152 }
03153 else
03154 {
03155 m_view->setPageDuration( m_step.m_pageNumber );
03156 emit restartPresentation();
03157 m_view->setAutoPresTimer( 1 );
03158 }
03159
03160 return false;
03161 }
03162
03163 bool KPrCanvas::pPrev( bool gotoPreviousPage )
03164 {
03165 goingBack = true;
03166 m_step.m_subStep = 0;
03167
03168
03169 m_drawModeLines.clear();
03170
03171 if ( !gotoPreviousPage && m_step.m_step > *m_pageEffectSteps.begin() ) {
03172 QValueList<int>::ConstIterator it = m_pageEffectSteps.find( m_step.m_step );
03173 m_step.m_step = *( --it );
03174
03175 m_step.m_subStep = 1000;
03176 repaint( false );
03177 return false;
03178 } else {
03179
03180 if ( m_presentationSlidesIterator == m_presentationSlides.begin() ) {
03181 m_pageEffectSteps = m_view->kPresenterDoc()->getPageEffectSteps( m_step.m_pageNumber );
03182 m_step.m_step = *m_pageEffectSteps.begin();
03183 goingBack = false;
03184 doObjEffects();
03185 return false;
03186 }
03187 m_view->setPageDuration( m_step.m_pageNumber );
03188
03189 m_step.m_pageNumber = *( --m_presentationSlidesIterator ) - 1;
03190
03191 KPrDocument * doc = m_view->kPresenterDoc();
03192
03193 m_pageEffectSteps = doc->getPageEffectSteps( m_step.m_pageNumber );
03194
03195 if ( gotoPreviousPage )
03196 {
03197 m_step.m_step = *( m_pageEffectSteps.begin() );
03198 goingBack = false;
03199 doObjEffects();
03200 }
03201 else
03202 {
03203 m_step.m_step = *( --m_pageEffectSteps.end() );
03204 repaint( false );
03205 }
03206
03207 return true;
03208 }
03209
03210 return false;
03211 }
03212
03213 bool KPrCanvas::canAssignEffect( QPtrList<KPrObject> &objs ) const
03214 {
03215 QPtrListIterator<KPrObject> oIt( m_activePage->objectList() );
03216 for (; oIt.current(); ++oIt )
03217 {
03218
03219 if(m_view->kPresenterDoc()->isHeaderFooter(oIt.current()))
03220 continue;
03221 if ( oIt.current()->isSelected() )
03222 objs.append( oIt.current() );
03223 }
03224 return !objs.isEmpty();
03225 }
03226
03227 bool KPrCanvas::isOneObjectSelected() const
03228 {
03229 return m_activePage->isOneObjectSelected();
03230 }
03231
03232
03233
03234
03235
03236
03237
03238 void KPrCanvas::drawPageInPix( QPixmap &_pix, int pgnum, int zoom,
03239 bool forceRealVariableValue,
03240 int forceWidth,
03241 int forceHeight )
03242 {
03243
03244
03245 KPrDocument *doc = m_view->kPresenterDoc();
03246 int oldZoom = doc->zoomHandler()->zoom();
03247 bool oldDisplayFieldValue = false;
03248
03249 if( 0 < forceWidth || 0 < forceHeight )
03250 {
03251 const QRect rect( doc->getPageRect( true ) );
03252 const double dRectHeight = static_cast<double>(rect.height());
03253 const double dRectWidth = static_cast<double>(rect.width());
03254 double dForceHeight = static_cast<double>(forceHeight);
03255 double dForceWidth = static_cast<double>(forceWidth);
03256
03257
03258 if( 0 >= forceWidth )
03259 dForceWidth = dForceHeight * dRectWidth / dRectHeight;
03260 else if( 0 >= forceHeight )
03261 dForceHeight = dForceWidth * dRectHeight / dRectWidth;
03262
03263
03264
03265 doc->zoomHandler()->setResolution( dForceWidth / dRectWidth,
03266 dForceHeight / dRectHeight );
03267
03268
03269 doc->newZoomAndResolution( false, false );
03270 }else{
03271 m_view->zoomDocument(zoom);
03272 }
03273
03274 if ( forceRealVariableValue )
03275 {
03276 oldDisplayFieldValue = m_view->kPresenterDoc()->getVariableCollection()->variableSetting()->displayFieldCode();
03277 if ( oldDisplayFieldValue )
03278 {
03279 m_view->kPresenterDoc()->getVariableCollection()->variableSetting()->setDisplayFieldCode(false);
03280 m_view->kPresenterDoc()->recalcVariables( VT_ALL );
03281 }
03282 }
03283
03284 KPrPage * page = m_view->kPresenterDoc()->pageList().at(pgnum);
03285 QRect rect = page->getZoomPageRect( );
03286 _pix.resize( rect.size() );
03287 _pix.fill( Qt::white );
03288
03289 QPainter p;
03290 p.begin( &_pix );
03291
03292 bool _editMode = editMode;
03293 editMode = false;
03294
03295 drawBackground( &p, _pix.rect(), page, true );
03296
03297
03298 if ( page->masterPage() && page->displayObjectFromMasterPage() )
03299 drawAllObjectsInPage( &p, page->masterPage()->objectList(), pgnum );
03300
03301
03302 drawAllObjectsInPage( &p, page->objectList(), pgnum );
03303
03304 editMode = _editMode;
03305 p.end();
03306
03307 if ( forceRealVariableValue )
03308 {
03309 if ( oldDisplayFieldValue )
03310 {
03311 m_view->kPresenterDoc()->getVariableCollection()->variableSetting()->setDisplayFieldCode(true);
03312 m_view->kPresenterDoc()->recalcVariables( VT_ALL );
03313 }
03314 }
03315
03316 m_view->zoomDocument(oldZoom);
03317 }
03318
03319
03320
03321 void KPrCanvas::drawCurrentPageInPix( QPixmap &_pix ) const
03322 {
03323
03324
03325
03326 _pix.fill(Qt::black);
03327
03328 QPainter p;
03329 p.begin( &_pix );
03330
03331 drawBackground( &p, _pix.rect(), m_view->kPresenterDoc()->pageList().at( m_step.m_pageNumber ) );
03332 PresStep step( m_step.m_pageNumber, m_step.m_step, m_step.m_subStep, true, true );
03333 drawPresPage( &p, _pix.rect(), step );
03334
03335 p.end();
03336 }
03337
03338 void KPrCanvas::printPage( QPainter* painter, PresStep step, KPrinter *printer, int rows, int cols )
03339 {
03340
03341 KPrDocument *doc = m_view->kPresenterDoc();
03342 KPrPage* page = doc->pageList().at( step.m_pageNumber );
03343 QRect const rect = page->getZoomPageRect();
03344 bool const drawBorder = printer->option("kde-kpresenter-printslideborders").toInt() && rows>1 && cols>1;
03345
03346 int height = rect.height();
03347 int width = rect.width();
03348
03349 QPaintDeviceMetrics metrics( printer );
03350 int begin_left = ( metrics.width() - rect.width() );
03351 int begin_top = ( metrics.height() - rect.height() );
03352
03353 rows = cols = QMAX( rows, cols );
03354
03355 if ( rows > 1 )
03356 {
03357 height = ( ( height - 80 ) / rows ) - 20;
03358 begin_top = 40;
03359 }
03360 if ( cols > 1 )
03361 {
03362 width = (width -5) / cols;
03363 begin_left = 5;
03364 }
03365 int top = begin_top;
03366 int left = begin_left;
03367 for (int r = 0; r < rows; r++ )
03368 {
03369 for (int c = 0; c < cols; c++ )
03370 {
03371 page = doc->pageList().at( step.m_pageNumber );
03372 if ( !page )
03373 return;
03374 painter->setViewport( QRect(left, top, width, height) );
03375 drawBackground( painter, rect, page, true );
03376 drawPresPage( painter, rect, step );
03377 if ( drawBorder )
03378 painter->drawRect( rect );
03379 step.m_pageNumber++;
03380 left += width;
03381 }
03382 top += height + 20;
03383 left = begin_left;
03384 }
03385
03386 }
03387
03388 void KPrCanvas::doObjEffects( bool isAllreadyPainted )
03389 {
03390 if ( m_effectHandler )
03391 {
03392 m_effectTimer.stop();
03393 QObject::disconnect( &m_effectTimer, SIGNAL( timeout() ), this, SLOT( slotDoEffect() ) );
03394
03395 m_effectHandler->finish();
03396 delete m_effectHandler;
03397 m_effectHandler = 0;
03398 }
03399
03400 QPixmap screen_orig( kapp->desktop()->width(), kapp->desktop()->height() );
03401
03402 KPrPage *page = m_view->kPresenterDoc()->pageList().at( m_step.m_pageNumber );
03403
03404 if ( m_step.m_subStep == 0 && !isAllreadyPainted && isUpdatesEnabled() )
03405 {
03406
03407 QPainter p;
03408 p.begin( &screen_orig );
03409 QRect desktopRect = QRect( 0, 0, kapp->desktop()->width(), kapp->desktop()->height() );
03410 drawBackground( &p, desktopRect, page );
03411 PresStep step( m_step.m_pageNumber, m_step.m_step, m_step.m_subStep, true, true );
03412 drawPresPage( &p, desktopRect ,step );
03413 p.end();
03414 bitBlt( this, 0, 0, &screen_orig );
03415 }
03416 else
03417 {
03418 bitBlt( &screen_orig, 0, 0, this );
03419 }
03420
03421 QPtrList<KPrObject> allObjects;
03422
03423 if ( page->displayObjectFromMasterPage() )
03424 {
03425 QPtrListIterator<KPrObject> it( page->masterPage()->objectList() );
03426 for ( ; it.current(); ++it ) {
03427 if ( objectIsAHeaderFooterHidden( it.current() ) )
03428 continue;
03429 else
03430 allObjects.append( it.current() );
03431 }
03432 }
03433
03434 QPtrListIterator<KPrObject> it( page->objectList() );
03435 for ( ; it.current(); ++it )
03436 {
03437 allObjects.append( it.current() );
03438 }
03439
03440
03441 m_effectHandler = new KPrEffectHandler( m_step, goingBack, this, &screen_orig, allObjects, m_view, 1 );
03442 if ( m_effectHandler->doEffect() )
03443 {
03444 delete m_effectHandler;
03445 m_effectHandler = 0;
03446 }
03447 else
03448 {
03449 connect( &m_effectTimer, SIGNAL( timeout() ), SLOT( slotDoEffect() ) );
03450 m_effectTimer.start( 50, true );
03451 }
03452
03453 }
03454
03455 void KPrCanvas::slotDoEffect()
03456 {
03457 if ( m_effectHandler->doEffect() )
03458 {
03459 m_effectTimer.stop();
03460 QObject::disconnect( &m_effectTimer, SIGNAL( timeout() ), this, SLOT( slotDoEffect() ) );
03461 delete m_effectHandler;
03462 m_effectHandler = 0;
03463 }
03464 else
03465 {
03466 m_effectTimer.start( 50, true );
03467 }
03468 }
03469
03470
03471 void KPrCanvas::slotDoPageEffect()
03472 {
03473 if ( m_pageEffect->doEffect() )
03474 {
03475 m_pageEffectTimer.stop();
03476 QObject::disconnect( &m_pageEffectTimer, SIGNAL( timeout() ), this, SLOT( slotDoPageEffect() ) );
03477 delete m_pageEffect;
03478 m_pageEffect = 0;
03479
03480 doObjEffects( true );
03481 }
03482 else
03483 {
03484 m_pageEffectTimer.start( 50, true );
03485 }
03486 }
03487
03488 void KPrCanvas::slotAutoScroll(const QPoint &scrollDistance)
03489 {
03490
03491 QPoint d = scrollDistance;
03492 m_view->getHScrollBar()->setValue( m_view->getHScrollBar()->value() + d.x() );
03493 m_view->getVScrollBar()->setValue( m_view->getVScrollBar()->value() + d.y() );
03494 }
03495
03496
03497 bool KPrCanvas::finishObjectEffects()
03498 {
03499 bool finished = false;
03500 if ( m_effectHandler )
03501 {
03502 m_effectTimer.stop();
03503 QObject::disconnect( &m_effectTimer, SIGNAL( timeout() ), this, SLOT( slotDoEffect() ) );
03504 m_effectHandler->finish();
03505 delete m_effectHandler;
03506 m_effectHandler = 0;
03507 finished = true;
03508 }
03509 return finished;
03510 }
03511
03512
03513 bool KPrCanvas::finishPageEffect( bool cancel )
03514 {
03515 bool finished = false;
03516 if ( m_pageEffect )
03517 {
03518 m_pageEffectTimer.stop();
03519 QObject::disconnect( &m_pageEffectTimer, SIGNAL( timeout() ), this, SLOT( slotDoPageEffect() ) );
03520 if ( !cancel )
03521 m_pageEffect->finish();
03522 delete m_pageEffect;
03523 m_pageEffect = 0;
03524
03525 if ( !cancel )
03526 {
03527 doObjEffects( true );
03528 }
03529 else if ( !spManualSwitch() )
03530 {
03531 m_view->setAutoPresTimer( 1 );
03532 m_setPageTimer = true;
03533 }
03534
03535 finished = true;
03536 }
03537 return finished;
03538 }
03539
03540
03541 void KPrCanvas::print( QPainter *painter, KPrinter *printer, float , float )
03542 {
03543 PresStep step( 0, 1000, 1000 );
03544
03545 int i = 0;
03546
03547 repaint( false );
03548 kapp->processEvents();
03549
03550 editMode = false;
03551 fillBlack = false;
03552
03553
03554
03555
03556
03557
03558
03559 QProgressDialog progress( i18n( "Printing..." ), i18n( "Cancel" ),
03560 printer->pageList().count() + 2, this );
03561
03562 int j = 0;
03563 progress.setProgress( 0 );
03564
03565
03566 int rows = 1;
03567 int cols = 1;
03568 if ( !printer->previewOnly() )
03569 {
03570 rows = printer->option("kde-kpresenter-printrows").toInt();
03571 cols = printer->option("kde-kpresenter-printcolumns").toInt();
03572 }
03573 int const slides_per_page = rows * cols;
03574
03575
03576
03577
03578 int current_slide = 0;
03579 QValueList<int> list=printer->pageList();
03580 QValueList<int>::iterator it;
03581 for( it=list.begin();it!=list.end();++it)
03582 {
03583 i=(*it);
03584 progress.setProgress( ++j );
03585 kapp->processEvents();
03586
03587 if ( progress.wasCancelled() )
03588 break;
03589
03590 step.m_pageNumber = i - 1;
03591
03592 if ( step.m_pageNumber != current_slide )
03593 continue;
03594
03595 if ( !list.isEmpty() && i > list.first() )
03596 printer->newPage();
03597
03598 painter->resetXForm();
03599 painter->fillRect( m_view->kPresenterDoc()->pageList().at( m_step.m_pageNumber )->getZoomPageRect(), white );
03600
03601 printPage( painter, step, printer, rows, cols );
03602 kapp->processEvents();
03603
03604 painter->resetXForm();
03605 kapp->processEvents();
03606
03607 current_slide += slides_per_page;
03608
03609
03610
03611 }
03612
03613 KConfig *config=KPrFactory::global()->config();
03614 config->setGroup("Misc");
03615 bool printNotes = config->readBoolEntry("PrintNotes", true);
03616
03617 KPrNoteBar *noteBar = m_view->getNoteBar();
03618
03619 if ( noteBar && !noteBar->getNotesTextForPrinting(list).isEmpty()
03620 && !progress.wasCancelled() && printNotes )
03621 {
03622 printer->newPage();
03623 painter->resetXForm();
03624 noteBar->printNotes( painter, printer, list );
03625 painter->resetXForm();
03626 }
03627
03628 setToolEditMode( toolEditMode );
03629
03630
03631
03632 progress.setProgress( printer->pageList().count() + 2 );
03633
03634 fillBlack = true;
03635 editMode = true;
03636 repaint( false );
03637 }
03638
03639
03640 void KPrCanvas::updateInsertRect( const KoPoint &point, Qt::ButtonState state )
03641 {
03642 if ( state & AltButton )
03643 {
03644 m_insertRect.moveBottomRight( point );
03645 }
03646 else
03647 {
03648 m_insertRect.setRight( point.x() );
03649 m_insertRect.setBottom( point.y() );
03650 }
03651 }
03652
03653
03654 KPrTextObject* KPrCanvas::insertTextObject( const KoRect &rect )
03655 {
03656 KPrTextObject* obj = m_activePage->insertTextObject( rect );
03657 selectObj( obj );
03658 return obj;
03659 }
03660
03661 void KPrCanvas::insertLine( const KoPoint &startPoint, const KoPoint &endPoint )
03662 {
03663 KoRect rect( startPoint, endPoint );
03664 bool rev = rect.width() < 0 || rect.height() < 0;
03665 rect = rect.normalize();
03666 LineType lt = LT_LU_RD;
03667 if ( startPoint.x() == endPoint.x() )
03668 {
03669 lt = LT_VERT;
03670 rect.setLeft( rect.left() - 5.0 );
03671 rect.setRight( rect.right() + 5.0 );
03672 }
03673 else if ( startPoint.y() == endPoint.y() )
03674 {
03675 lt = LT_HORZ;
03676 rect.setTop( startPoint.y() - 5.0 );
03677 rect.setBottom( startPoint.y() + 5.0 );
03678 }
03679 else if ( ( startPoint.x() < endPoint.x() && startPoint.y() > endPoint.y() ) ||
03680 ( startPoint.x() > endPoint.x() && startPoint.y() < endPoint.y() ) )
03681 {
03682 lt = LT_LD_RU;
03683 }
03684 m_activePage->insertLine( rect, m_view->getPen(),
03685 !rev ? m_view->getLineBegin() : m_view->getLineEnd(), !rev ? m_view->getLineEnd() : m_view->getLineBegin(),
03686 lt );
03687 }
03688
03689
03690 void KPrCanvas::insertRect( const KoRect &rect )
03691 {
03692 m_activePage->insertRectangle( rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03693 m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(), m_view->getRndX(), m_view->getRndY(),
03694 m_view->getGUnbalanced(), m_view->getGXFactor(), m_view->getGYFactor() );
03695 }
03696
03697 void KPrCanvas::insertEllipse( const KoRect &rect )
03698 {
03699 m_activePage->insertCircleOrEllipse( rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03700 m_view->getGColor1(), m_view->getGColor2(),
03701 m_view->getGType(), m_view->getGUnbalanced(), m_view->getGXFactor(), m_view->getGYFactor() );
03702 }
03703
03704 void KPrCanvas::insertPie( const KoRect &rect )
03705 {
03706 m_activePage->insertPie( rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03707 m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(),
03708 m_view->getPieType(), m_view->getPieAngle(), m_view->getPieLength(),
03709 m_view->getLineBegin(), m_view->getLineEnd(), m_view->getGUnbalanced(), m_view->getGXFactor(),
03710 m_view->getGYFactor() );
03711 }
03712
03713 void KPrCanvas::insertAutoform( const KoRect &rect )
03714 {
03715 m_activePage->insertAutoform( rect, m_view->getPen(), m_view->getBrush(),
03716 m_view->getLineBegin(), m_view->getLineEnd(),
03717 m_view->getFillType(), m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(),
03718 autoform, m_view->getGUnbalanced(), m_view->getGXFactor(), m_view->getGYFactor() );
03719 }
03720
03721 KPrPartObject* KPrCanvas::insertObject( const KoRect &rect )
03722 {
03723 KPrPartObject *kpPartObject = m_activePage->insertObject( rect, partEntry );
03724 return kpPartObject;
03725 }
03726
03727 void KPrCanvas::insertFreehand( const KoPointArray &_pointArray )
03728 {
03729 KoRect rect = _pointArray.boundingRect();
03730
03731 m_activePage->insertFreehand( getObjectPoints( _pointArray ), rect, m_view->getPen(), m_view->getLineBegin(),
03732 m_view->getLineEnd() );
03733
03734 m_pointArray = KoPointArray();
03735 m_indexPointArray = 0;
03736 }
03737
03738 void KPrCanvas::insertPolyline( const KoPointArray &_pointArray )
03739 {
03740 if( _pointArray.count()> 1)
03741 {
03742 KoRect rect = _pointArray.boundingRect();
03743 m_activePage->insertPolyline( getObjectPoints( _pointArray ), rect, m_view->getPen(), m_view->getLineBegin(),
03744 m_view->getLineEnd() );
03745 }
03746 m_pointArray = KoPointArray();
03747 m_indexPointArray = 0;
03748 }
03749
03750 void KPrCanvas::insertCubicBezierCurve( const KoPointArray &_pointArray )
03751 {
03752 if ( _pointArray.count() > 1 )
03753 {
03754 KoPointArray points( _pointArray );
03755 KoPointArray bezierPoints( KPrBezierCurveObject::bezier2polyline( _pointArray ) );
03756 KoRect rect = bezierPoints.boundingRect();
03757 points = getObjectPoints( points );
03758 bezierPoints = getObjectPoints( bezierPoints );
03759
03760 if ( toolEditMode == INS_CUBICBEZIERCURVE )
03761 {
03762 m_activePage->insertCubicBezierCurve( points, bezierPoints, rect, m_view->getPen(),
03763 m_view->getLineBegin(), m_view->getLineEnd() );
03764 }
03765 else if ( toolEditMode == INS_QUADRICBEZIERCURVE )
03766 {
03767 m_activePage->insertQuadricBezierCurve( points, bezierPoints, rect, m_view->getPen(),
03768 m_view->getLineBegin(), m_view->getLineEnd() );
03769 }
03770 else if ( toolEditMode == INS_CLOSED_CUBICBEZIERCURVE ||
03771 toolEditMode == INS_CLOSED_QUADRICBEZIERCURVE )
03772 {
03773 m_activePage->insertClosedLine( bezierPoints, rect, m_view->getPen(), m_view->getBrush(),
03774 m_view->getFillType(), m_view->getGColor1(), m_view->getGColor2(),
03775 m_view->getGType(), m_view->getGUnbalanced(),
03776 m_view->getGXFactor(), m_view->getGYFactor(), toolEditMode );
03777 }
03778 }
03779 m_pointArray = KoPointArray();
03780 m_indexPointArray = 0;
03781 }
03782
03783 void KPrCanvas::insertPolygon( const KoPointArray &_pointArray )
03784 {
03785 KoRect rect = _pointArray.boundingRect();
03786
03787 m_activePage->insertPolygon( getObjectPoints( _pointArray ), rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03788 m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(), m_view->getGUnbalanced(),
03789 m_view->getGXFactor(), m_view->getGYFactor(),
03790 m_view->getCheckConcavePolygon(), m_view->getCornersValue(), m_view->getSharpnessValue() );
03791
03792 m_pointArray = KoPointArray();
03793 m_indexPointArray = 0;
03794 }
03795
03796 void KPrCanvas::insertPicture( const KoRect &rect )
03797 {
03798 QString file = m_activePage->insPictureFile();
03799
03800 QCursor c = cursor();
03801 setCursor( waitCursor );
03802 if ( !file.isEmpty() ) {
03803 if ( rect.width() > 10 && rect.height() > 10 )
03804 {
03805 m_activePage->insertPicture( file, rect );
03806 }
03807 else
03808 {
03809 KoPoint tl( rect.topLeft() );
03810 m_activePage->insertPicture( file, tl );
03811 }
03812 m_activePage->setInsPictureFile( QString::null );
03813 }
03814 setCursor( c );
03815 }
03816
03817 void KPrCanvas::insertClosedLine( const KoPointArray &_pointArray )
03818 {
03819 KoRect rect = _pointArray.boundingRect();
03820
03821 m_activePage->insertClosedLine( getObjectPoints( _pointArray ), rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03822 m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(), m_view->getGUnbalanced(),
03823 m_view->getGXFactor(), m_view->getGYFactor(), toolEditMode );
03824
03825 m_pointArray = KoPointArray();
03826 m_indexPointArray = 0;
03827 }
03828
03829 void KPrCanvas::setToolEditMode( ToolEditMode _m, bool updateView )
03830 {
03831
03832 if ( ( toolEditMode == INS_POLYLINE || toolEditMode == INS_CLOSED_POLYLINE ) && !m_pointArray.isNull())
03833 endDrawPolyline();
03834
03835 if ( ( toolEditMode == INS_CUBICBEZIERCURVE || toolEditMode == INS_QUADRICBEZIERCURVE
03836 || toolEditMode == INS_CLOSED_CUBICBEZIERCURVE || toolEditMode == INS_CLOSED_QUADRICBEZIERCURVE ) && !m_pointArray.isNull() )
03837 endDrawCubicBezierCurve();
03838
03839 exitEditMode();
03840 toolEditMode = _m;
03841
03842 if ( toolEditMode == TEM_MOUSE )
03843 {
03844 setCursor( arrowCursor );
03845 QPoint pos = QCursor::pos();
03846
03847 KoPoint docPoint( m_view->zoomHandler()->unzoomPoint( pos ) );
03848 KPrObject *obj=m_activePage->getCursor( pos);
03849 if(obj)
03850 setCursor( obj->getCursor( docPoint, modType, m_view->kPresenterDoc() ) );
03851 }
03852 else if ( toolEditMode == INS_FREEHAND || toolEditMode == INS_CLOSED_FREEHAND )
03853 setCursor( KPrUtils::penCursor() );
03854 else if ( toolEditMode == TEM_ROTATE )
03855 setCursor( KPrUtils::rotateCursor() );
03856 else
03857 setCursor( crossCursor );
03858
03859 if ( updateView )
03860 m_view->setTool( toolEditMode );
03861 }
03862
03863
03864 void KPrCanvas::endDrawPolyline()
03865 {
03866 m_drawPolyline = false;
03867
03868 if ( toolEditMode == INS_POLYLINE )
03869 insertPolyline( m_pointArray );
03870 else if ( toolEditMode == INS_CLOSED_POLYLINE )
03871 insertClosedLine( m_pointArray );
03872
03873 emit objectSelectedChanged();
03874 if ( toolEditMode != TEM_MOUSE && editMode )
03875 repaint( false );
03876 m_view->disableAutoScroll();
03877 mousePressed = false;
03878 modType = MT_NONE;
03879 }
03880
03881 void KPrCanvas::endDrawCubicBezierCurve()
03882 {
03883 m_drawCubicBezierCurve = false;
03884 m_oldCubicBezierPointArray = KoPointArray();
03885 insertCubicBezierCurve( m_pointArray );
03886 emit objectSelectedChanged();
03887 if ( toolEditMode != TEM_MOUSE && editMode )
03888 repaint( false );
03889 m_view->disableAutoScroll();
03890 mousePressed = false;
03891 modType = MT_NONE;
03892 }
03893
03894 void KPrCanvas::selectNext()
03895 {
03896 if ( objectList().count() == 0 ) return;
03897
03898 if ( m_activePage->numSelected() == 0 )
03899 objectList().at( 0 )->setSelected( true );
03900 else {
03901 int i = objectList().findRef( m_activePage->getSelectedObj() );
03902 if ( i < static_cast<int>( objectList().count() ) - 1 ) {
03903 m_view->kPresenterDoc()->deSelectAllObj();
03904 objectList().at( ++i )->setSelected( true );
03905 } else {
03906 m_view->kPresenterDoc()->deSelectAllObj();
03907 objectList().at( 0 )->setSelected( true );
03908 }
03909 }
03910 m_view->showObjectRect( m_activePage->getSelectedObj() );
03911 _repaint( false );
03912 }
03913
03914 void KPrCanvas::selectPrev()
03915 {
03916 if ( objectList().count() == 0 ) return;
03917 if ( m_activePage->numSelected() == 0 )
03918 objectList().at( objectList().count() - 1 )->setSelected( true );
03919 else {
03920 int i = objectList().findRef( m_activePage->getSelectedObj() );
03921 if ( i > 0 ) {
03922 m_view->kPresenterDoc()->deSelectAllObj();
03923 objectList().at( --i )->setSelected( true );
03924 } else {
03925 m_view->kPresenterDoc()->deSelectAllObj();
03926 objectList().at( objectList().count() - 1 )->setSelected( true );
03927 }
03928 }
03929 m_view->showObjectRect( m_activePage->getSelectedObj() );
03930 _repaint( false );
03931 }
03932
03933 void KPrCanvas::dragEnterEvent( QDragEnterEvent *e )
03934 {
03935 if ( m_currentTextObjectView )
03936 m_currentTextObjectView->dragEnterEvent( e );
03937 else if ( QTextDrag::canDecode( e )
03938 || QImageDrag::canDecode( e )
03939 || KURLDrag::canDecode(e)) {
03940 e->accept();
03941 }
03942 else
03943 e->ignore();
03944 }
03945
03946 void KPrCanvas::dragMoveEvent( QDragMoveEvent *e )
03947 {
03948 if( m_currentTextObjectView)
03949 {
03950 KPrTextObject * obj = textUnderMouse( e->pos());
03951 bool emitChanged = false;
03952 if ( obj )
03953 emitChanged = checkCurrentTextEdit( obj );
03954 if ( m_currentTextObjectView )
03955 {
03956 m_currentTextObjectView->dragMoveEvent( e, QPoint() );
03957 if ( emitChanged )
03958 emit currentObjectEditChanged();
03959 }
03960 }
03961 else if ( QTextDrag::canDecode( e )
03962 || QImageDrag::canDecode( e )
03963 || KURLDrag::canDecode(e)) {
03964 e->accept();
03965 }
03966 else
03967 e->ignore();
03968 }
03969
03970 void KPrCanvas::dropImage( QMimeSource * data, bool resizeImageToOriginalSize, int posX, int posY )
03971 {
03972 setToolEditMode( TEM_MOUSE );
03973 deSelectAllObj();
03974
03975 QImage pix;
03976 QImageDrag::decode( data, pix );
03977
03978 KTempFile tmpFile;
03979 tmpFile.setAutoDelete(true);
03980
03981 if( tmpFile.status() != 0 )
03982 return;
03983
03984 pix.save( tmpFile.name(), "PNG" );
03985 QCursor c = cursor();
03986 setCursor( waitCursor );
03987
03988 QPoint pos( posX + diffx(), posY + diffy() );
03989 KoPoint docPoint( m_view->zoomHandler()->unzoomPoint( pos ) );
03990
03991 m_activePage->insertPicture( tmpFile.name(), docPoint );
03992
03993 tmpFile.close();
03994
03995 if ( resizeImageToOriginalSize )
03996 picViewOriginalSize();
03997 setCursor( c );
03998 }
03999
04000 void KPrCanvas::dropEvent( QDropEvent *e )
04001 {
04002
04003 KoPoint docPoint = m_view->zoomHandler()->unzoomPoint( e->pos()+QPoint(diffx(),diffy()) );
04004 if ( !m_activePage->getZoomPageRect().contains(e->pos()))
04005 return;
04006
04007 if ( QImageDrag::canDecode( e ) ) {
04008 dropImage( e, true, e->pos().x(), e->pos().y() );
04009 e->accept();
04010 } else if ( KURLDrag::canDecode( e ) ) {
04011 setToolEditMode( TEM_MOUSE );
04012 deSelectAllObj();
04013
04014 KURL::List lst;
04015 KURLDrag::decode( e, lst );
04016
04017 KURL::List::ConstIterator it = lst.begin();
04018 for ( ; it != lst.end(); ++it ) {
04019 const KURL &url( *it );
04020
04021 QString filename;
04022 if ( !url.isLocalFile() ) {
04023 if ( !KIO::NetAccess::download( url, filename, this ) )
04024 continue;
04025 } else {
04026 filename = url.path();
04027 }
04028
04029 KMimeMagicResult *res = KMimeMagic::self()->findFileType( filename );
04030
04031 if ( res && res->isValid() ) {
04032 QString mimetype = res->mimeType();
04033 if ( mimetype.contains( "image" ) ) {
04034 QCursor c = cursor();
04035 setCursor( waitCursor );
04036 m_activePage->insertPicture( filename, docPoint );
04037 setCursor( c );
04038 } else if ( mimetype.contains( "text" ) ) {
04039 QCursor c = cursor();
04040 setCursor( waitCursor );
04041 QFile f( filename );
04042 QTextStream t( &f );
04043 QString text = QString::null, tmp;
04044 kdDebug()<<" filename :"<<filename<<endl;
04045 if ( f.open( IO_ReadOnly ) ) {
04046 while ( !t.eof() ) {
04047 tmp = t.readLine();
04048 tmp += "\n";
04049 text.append( tmp );
04050 }
04051 f.close();
04052 }
04053 kdDebug()<<" text :"<<endl;
04054 m_activePage->insertTextObject( m_view->zoomHandler()->unzoomRect(QRect( e->pos().x(), e->pos().y(), 250, 250 )),
04055 text, m_view );
04056
04057 setCursor( c );
04058 }
04059 }
04060 KIO::NetAccess::removeTempFile( filename );
04061 }
04062 }
04063 else if (m_currentTextObjectView)
04064 {
04065 m_currentTextObjectView->dropEvent( e );
04066 }
04067 else if ( QTextDrag::canDecode( e ) ) {
04068 setToolEditMode( TEM_MOUSE );
04069 deSelectAllObj();
04070
04071 QString text;
04072 QTextDrag::decode( e, text );
04073
04074 m_activePage->insertTextObject( m_view->zoomHandler()->unzoomRect( QRect( e->pos().x(), e->pos().y(), 250, 250 )),
04075 text, m_view );
04076 e->accept();
04077 } else
04078 e->ignore();
04079
04080 }
04081
04082 void KPrCanvas::slotGotoPage()
04083 {
04084 setSwitchingMode( false );
04085
04086 int pg = m_step.m_pageNumber + 1;
04087
04088 m_view->setPageDuration( m_step.m_pageNumber );
04089
04090 pg = KPrGotoPage::gotoPage( m_view->kPresenterDoc(), m_presentationSlides, pg, this );
04091 gotoPage( pg );
04092
04093 if ( !spManualSwitch() ) {
04094 m_view->setAutoPresTimer( 1 );
04095 m_setPageTimer = true;
04096 }
04097 }
04098
04099 void KPrCanvas::gotoPage( int pg )
04100 {
04101 int page = pg - 1;
04102 if ( page != m_step.m_pageNumber || m_step.m_step != *m_pageEffectSteps.begin() || m_step.m_subStep != 0 ) {
04103
04104 m_drawModeLines.clear();
04105 goingBack = false;
04106
04107 m_step.m_pageNumber = page;
04108 kdDebug(33001) << "Page::gotoPage m_step.m_pageNumber =" << m_step.m_pageNumber << endl;
04109 m_presentationSlidesIterator = m_presentationSlides.find( m_step.m_pageNumber + 1 );
04110 editMode = false;
04111 m_drawMode = false;
04112 m_pageEffectSteps = m_view->kPresenterDoc()->getPageEffectSteps( m_step.m_pageNumber );
04113 m_step.m_step = *m_pageEffectSteps.begin();
04114 m_step.m_subStep = 0;
04115 #if 0
04116 QRect desk = KGlobalSettings::desktopGeometry(this);
04117 resize( desk.width(), desk.height() );
04118 #endif
04119 doObjEffects();
04120 setFocus();
04121 m_view->refreshPageButton();
04122 }
04123 }
04124
04125 void KPrCanvas::presGotoFirstPage()
04126 {
04127 gotoPage( *m_presentationSlides.begin() );
04128 }
04129
04130 KPrTextObject* KPrCanvas::kpTxtObj() const
04131 {
04132 return ( ( m_editObject && m_editObject->getType() == OT_TEXT ) ?
04133 dynamic_cast<KPrTextObject*>( m_editObject ) : 0 );
04134
04135 }
04136
04137 void KPrCanvas::copyOasisObjs()
04138 {
04139
04140 KoStoreDrag *kd = new KoStoreDrag( "application/vnd.oasis.opendocument.presentation", 0L );
04141 QDragObject* dragObject = kd;
04142 QByteArray arr;
04143 QBuffer buffer(arr);
04144 KoStore* store = KoStore::createStore( &buffer, KoStore::Write, "application/vnd.oasis.opendocument.presentation" );
04145
04146 delete store;
04147 kd->setEncodedData( arr );
04148 QApplication::clipboard()->setData( dragObject, QClipboard::Clipboard );
04149 }
04150
04151 void KPrCanvas::copyObjs()
04152 {
04153 QDomDocument doc("DOC");
04154 QDomElement presenter=doc.createElement("DOC");
04155 presenter.setAttribute("editor", "KPresenter");
04156 presenter.setAttribute("mime", "application/x-kpresenter");
04157
04158 doc.appendChild(presenter);
04159
04160 QPtrList<KoDocumentChild> embeddedObjectsActivePage;
04161
04162 KoStoreDrag *kd = new KoStoreDrag( "application/x-kpresenter", 0L );
04163 QDragObject* dragObject = kd;
04164 QByteArray arr;
04165 QBuffer buffer(arr);
04166 KoStore* store = KoStore::createStore( &buffer, KoStore::Write, "application/x-kpresenter" );
04167
04168 m_activePage->getAllEmbeddedObjectSelected(embeddedObjectsActivePage );
04169
04170
04171 int i = 0;
04172 QValueList<KoPictureKey> savePictures;
04173 QPtrListIterator<KoDocumentChild> chl( embeddedObjectsActivePage );
04174 for( ; chl.current(); ++chl ) {
04175 KoDocument* childDoc = chl.current()->document();
04176 if ( childDoc && !childDoc->isStoredExtern() )
04177 (void) childDoc->saveToStore( store, QString::number( i++ ) );
04178 }
04179
04180 m_activePage->copyObjs(doc, presenter, savePictures);
04181
04182 KPrDocument* kprdoc = m_view->kPresenterDoc();
04183 if ( !embeddedObjectsActivePage.isEmpty())
04184 {
04185 kprdoc->saveEmbeddedObject(m_activePage, embeddedObjectsActivePage,doc,presenter);
04186 }
04187
04188 if ( !savePictures.isEmpty() ) {
04189
04190 presenter.appendChild( kprdoc->pictureCollection()->saveXML( KoPictureCollection::CollectionPicture, doc, savePictures ) );
04191
04192 kprdoc->pictureCollection()->saveToStore( KoPictureCollection::CollectionPicture, store, savePictures );
04193
04194 if ( savePictures.count() == 1 )
04195 {
04196 KoPicture pic = kprdoc->pictureCollection()->findPicture( savePictures.first() );
04197 QDragObject* picDrag = pic.dragObject( 0L );
04198 if ( picDrag ) {
04199 KMultipleDrag* multipleDrag = new KMultipleDrag( 0L );
04200 multipleDrag->addDragObject( kd );
04201 multipleDrag->addDragObject( picDrag );
04202 dragObject = multipleDrag;
04203 }
04204 }
04205 }
04206
04207 if ( store->open( "root" ) )
04208 {
04209 QCString s = doc.toCString();
04210
04211 (void)store->write( s.data(), s.size()-1 );
04212 store->close();
04213 }
04214
04215 delete store;
04216 kd->setEncodedData( arr );
04217 QApplication::clipboard()->setData( dragObject, QClipboard::Clipboard );
04218 }
04219
04220 void KPrCanvas::deleteObjs()
04221 {
04222 lowerObject();
04223 KCommand *cmd=m_activePage->deleteSelectedObjects();
04224 m_view->kPresenterDoc()->deSelectAllObj();
04225 if( cmd )
04226 m_view->kPresenterDoc()->addCommand( cmd );
04227 emit objectSelectedChanged();
04228 setToolEditMode( toolEditMode );
04229 }
04230
04231
04232 void KPrCanvas::enterEvent( QEvent *e )
04233 {
04234 m_view->setRulerMousePos( ( ( QMouseEvent* )e )->x(), ( ( QMouseEvent* )e )->y() );
04235 m_view->setRulerMouseShow( true );
04236 }
04237
04238 void KPrCanvas::leaveEvent( QEvent * )
04239 {
04240 m_view->setRulerMouseShow( false );
04241 }
04242
04243 QPtrList<KPrObject> KPrCanvas::objectList() const
04244 {
04245 return m_activePage->objectList();
04246 }
04247
04248 const QPtrList<KPrObject> &KPrCanvas::getObjectList() const
04249 {
04250 return m_activePage->objectList();
04251 }
04252
04253 unsigned int KPrCanvas::currPgNum() const
04254 {
04255 return m_view->getCurrPgNum();
04256 }
04257
04258 QColor KPrCanvas::txtBackCol() const
04259 {
04260 return m_view->kPresenterDoc()->txtBackCol();
04261 }
04262
04263 bool KPrCanvas::spInfiniteLoop() const
04264 {
04265 return m_view->kPresenterDoc()->spInfiniteLoop();
04266 }
04267
04268 bool KPrCanvas::spShowEndOfPresentationSlide() const
04269 {
04270 return m_view->kPresenterDoc()->spShowEndOfPresentationSlide();
04271 }
04272
04273 bool KPrCanvas::spManualSwitch() const
04274 {
04275 return m_view->kPresenterDoc()->spManualSwitch();
04276 }
04277
04278 QRect KPrCanvas::getPageRect( bool decBorders ) const
04279 {
04280 return m_view->kPresenterDoc()->getPageRect( decBorders );
04281 }
04282
04283 unsigned int KPrCanvas::pageNums() const
04284 {
04285 return m_view->kPresenterDoc()->getPageNums();
04286 }
04287
04288 void KPrCanvas::_repaint( bool )
04289 {
04290 m_view->kPresenterDoc()->repaint( false );
04291 }
04292
04293 void KPrCanvas::_repaint( const QRect &r )
04294 {
04295 m_view->kPresenterDoc()->repaint( r );
04296 }
04297
04298 void KPrCanvas::_repaint( KPrObject *o )
04299 {
04300 m_view->kPresenterDoc()->repaint( o );
04301 }
04302
04303 void KPrCanvas::slotExitPres()
04304 {
04305 m_view->screenStop();
04306 }
04307
04308 void KPrCanvas::setDrawingMode()
04309 {
04310 m_presMenu->setItemChecked( PM_DM, true );
04311 m_drawMode = true;
04312
04313 setCursor( KPrUtils::penCursor() );
04314 }
04315
04316 void KPrCanvas::setSwitchingMode( bool continueTimer )
04317 {
04318 m_presMenu->setItemChecked( PM_DM, false );
04319
04320
04321
04322 m_drawMode = false;
04323 m_drawLineInDrawMode = false;
04324 setCursor( blankCursor );
04325
04326 if ( continueTimer && !spManualSwitch() )
04327 m_view->continueAutoPresTimer();
04328 }
04329
04330 void KPrCanvas::exitEditMode( bool repaint )
04331 {
04332 if ( m_editObject )
04333 {
04334 if ( m_editObject->getType() == OT_TEXT )
04335 {
04336 if(m_currentTextObjectView)
04337 {
04338 m_currentTextObjectView->clearSelection();
04339
04340 if ( repaint )
04341 {
04342 m_currentTextObjectView->drawCursor( false );
04343 m_currentTextObjectView->terminate();
04344 }
04345 KPrTextObject *kpTextObj = m_currentTextObjectView->kpTextObject();
04346 kpTextObj->setEditingTextObj( false );
04347 delete m_currentTextObjectView;
04348 m_currentTextObjectView = 0;
04349
04350 if ( repaint )
04351 _repaint( static_cast<KPrObject*>( kpTextObj ) );
04352 }
04353
04354 m_view->kPresenterDoc()->updateSideBarItem( m_activePage );
04355 emit objectSelectedChanged();
04356 m_editObject = 0;
04357 }
04358 else if (m_editObject->getType() == OT_PART )
04359 {
04360 static_cast<KPrPartObject *>(m_editObject)->deactivate();
04361 _repaint( m_editObject );
04362 m_editObject = 0;
04363 return;
04364 }
04365 }
04366
04367 }
04368
04369 bool KPrCanvas::getPixmapOrigAndCurrentSize( KPrPixmapObject *&obj, KoSize *origSize, KoSize *currentSize )
04370 {
04371 *origSize = KoSize(obj->originalSize().width(),obj->originalSize().height());
04372 *currentSize = obj->getSize();
04373 return true;
04374 }
04375
04376 void KPrCanvas::picViewOriginalSize()
04377 {
04378 KPrDocument *doc = m_view->kPresenterDoc();
04379 KPrPixmapObject *object = m_activePage->picViewOrigHelper();
04380
04381 KoSize newSize( doc->zoomHandler()->pixelXToPt( object->originalSize().width() ),
04382 doc->zoomHandler()->pixelYToPt( object->originalSize().height() ) );
04383
04384 KoRect pageRect = m_activePage->getPageRect();
04385 double fakt = 1.0;
04386
04387 if ( newSize.width() > pageRect.width() )
04388 fakt = pageRect.width() / newSize.width();
04389 if ( newSize.height() > pageRect.height() )
04390 fakt = QMIN( fakt, pageRect.height() / newSize.height() );
04391
04392 KoSize diff( newSize.width() * fakt - object->getSize().width(),
04393 newSize.height() * fakt - object->getSize().height() );
04394
04395 KPrResizeCmd *resizeCmd = new KPrResizeCmd( i18n( "Scale to Original Size" ),
04396 KoPoint( 0, 0 ), diff, object, doc );
04397 resizeCmd->execute();
04398 doc->addCommand( resizeCmd );
04399 }
04400
04401 void KPrCanvas::picViewOrig640x480()
04402 {
04403 picViewOrigHelper(640, 480);
04404 }
04405
04406 void KPrCanvas::picViewOrig800x600()
04407 {
04408 picViewOrigHelper(800, 600);
04409 }
04410
04411 void KPrCanvas::picViewOrig1024x768()
04412 {
04413 picViewOrigHelper(1024, 768);
04414 }
04415
04416 void KPrCanvas::picViewOrig1280x1024()
04417 {
04418 picViewOrigHelper(1280, 1024);
04419 }
04420
04421 void KPrCanvas::picViewOrig1600x1200()
04422 {
04423 picViewOrigHelper(1600, 1200);
04424 }
04425
04426 void KPrCanvas::picViewOrigHelper(int x, int y)
04427 {
04428 KPrPixmapObject *obj = 0;
04429 KoSize origSize;
04430 KoSize currentSize;
04431
04432 obj=m_activePage->picViewOrigHelper();
04433
04434 if ( obj && !getPixmapOrigAndCurrentSize( obj, &origSize, ¤tSize ) )
04435 return;
04436 KoSize pgSize = m_activePage->getPageRect().size();
04437
04438 if ( x == -1 && y == -1 ) {
04439 x = (int)origSize.width();
04440 y = (int)origSize.height();
04441 }
04442
04443 QSize presSize( x, y );
04444
04445 scalePixmapToBeOrigIn( currentSize, pgSize, presSize, obj );
04446 }
04447
04448 void KPrCanvas::picViewOrigFactor()
04449 {
04450 }
04451
04452 void KPrCanvas::scalePixmapToBeOrigIn( const KoSize ¤tSize, const KoSize &pgSize,
04453 const QSize &presSize, KPrPixmapObject *obj )
04454 {
04455 QRect desk = KGlobalSettings::desktopGeometry(this);
04456 double faktX = (double)presSize.width() / (double)desk.width();
04457 double faktY = (double)presSize.height() / (double)desk.height();
04458 double w = pgSize.width() * faktX;
04459 double h = pgSize.height() * faktY;
04460
04461 KPrResizeCmd *resizeCmd = new KPrResizeCmd( i18n( "Scale Picture to Be Shown 1:1 in Presentation Mode" ),
04462 KoPoint( 0, 0 ), KoSize( w - currentSize.width(), h - currentSize.height() ),
04463 obj, m_view->kPresenterDoc() );
04464 resizeCmd->execute();
04465 m_view->kPresenterDoc()->addCommand( resizeCmd );
04466 }
04467
04468 void KPrCanvas::setTextBackground( KPrTextObject * )
04469 {
04470
04471
04472 #if 0
04473 QPixmap pix( m_activePage->getZoomPageRect().size() );
04474 QPainter painter( &pix );
04475 m_activePage->background()->drawBackground( &painter, FALSE );
04476 QPixmap bpix( obj->getSize().toQSize() );
04477 bitBlt( &bpix, 0, 0, &pix, obj->getOrig().x(), obj->getOrig().y() -
04478 m_activePage->getZoomPageRect().height() * ( m_view->getCurrPgNum() - 1 ), bpix.width(), bpix.height() );
04479 QBrush b( white, bpix );
04480 QPalette pal( obj->textObjectView()->palette() );
04481 pal.setBrush( QColorGroup::Base, b );
04482 obj->textObjectView()->setPalette( pal );
04483 #endif
04484 }
04485
04486
04487 KoPoint KPrCanvas::diffGrid( KoRect &rect, double diffx, double diffy )
04488 {
04489 KPrDocument * doc( m_view->kPresenterDoc() );
04490 KoPoint move( 0, 0 );
04491
04492 double tempx = ( int( rect.topLeft().x() / doc->getGridX() ) * doc->getGridX() ) - rect.topLeft().x();
04493 if ( diffx > 0 )
04494 {
04495 tempx += doc->getGridX();
04496 while ( diffx > tempx )
04497 {
04498 move.setX( tempx );
04499 tempx += doc->getGridX();
04500 }
04501 }
04502 else
04503 {
04504 while ( diffx < tempx )
04505 {
04506 move.setX( tempx );
04507 tempx -= doc->getGridX();
04508 }
04509 }
04510 double tempy = ( int( rect.topLeft().y() / doc->getGridY() ) * doc->getGridY() ) - rect.topLeft().y();
04511 if ( diffy > 0 )
04512 {
04513 tempy += doc->getGridY();
04514 while ( diffy > tempy )
04515 {
04516 move.setY( tempy );
04517 tempy += doc->getGridY();
04518 }
04519 }
04520 else
04521 {
04522 while ( diffy < tempy )
04523 {
04524 move.setY( tempy );
04525 tempy -= doc->getGridY();
04526 }
04527 }
04528
04529 return move;
04530 }
04531
04532
04533 void KPrCanvas::moveObjectsByKey( int x, int y )
04534 {
04535 KPrDocument *doc( m_view->kPresenterDoc() );
04536
04537 KoRect rect( objectRect( false ) );
04538 double diffx = m_view->zoomHandler()->unzoomItX( x );
04539 double diffy = m_view->zoomHandler()->unzoomItY( y );
04540 KoPoint move( diffx, diffy );
04541
04542 bool snapToGrid = doc->snapToGrid() && !m_disableSnapping;
04543 bool snapToGuideLines = doc->showGuideLines() && !m_disableSnapping;
04544
04545 if ( snapToGrid )
04546 {
04547
04548
04549
04550
04551
04552 double tempx = int( rect.x() / doc->getGridX() ) * doc->getGridX();
04553 if ( diffx > 0 )
04554 {
04555 move.setX( tempx - rect.x() );
04556 while ( rect.x() - tempx >= -1E-10 )
04557 {
04558 tempx += doc->getGridX();
04559 move.setX( tempx - rect.x() );
04560 }
04561 }
04562 else if ( diffx < 0 )
04563 {
04564 move.setX( tempx - rect.x() );
04565 while ( rect.x() - tempx <= 1E-10 )
04566 {
04567 tempx -= doc->getGridX();
04568 move.setX( tempx - rect.x() );
04569 }
04570 }
04571
04572 double tempy = int( rect.y() / doc->getGridY() ) * doc->getGridY();
04573 if ( diffy > 0 )
04574 {
04575 move.setY( tempy - rect.y() );
04576 while ( rect.y() - tempy >= -1E-10 )
04577 {
04578 tempy += doc->getGridY();
04579 move.setY( tempy - rect.y() );
04580 }
04581 }
04582 else if ( diffy < 0 )
04583 {
04584 move.setY( tempy - rect.y() );
04585 while ( rect.y() - tempy <= 1E-10 )
04586 {
04587 tempy -= doc->getGridY();
04588 move.setY( tempy - rect.y() );
04589 }
04590 }
04591 }
04592
04593 if ( snapToGuideLines )
04594 {
04595 if ( !snapToGrid )
04596 {
04597
04598 KoRect movedRect( rect );
04599 movedRect.moveBy( diffx, diffy );
04600 movedRect.moveBy( -m_moveSnapDiff.x(), -m_moveSnapDiff.y() );
04601 move -= m_moveSnapDiff;
04602
04603 m_moveSnapDiff = KoPoint( 0, 0 );
04604
04605 KoGuides::SnapStatus snapStatus = KoGuides::SNAP_NONE;
04606 m_gl.snapToGuideLines( movedRect, KEY_SNAP_DISTANCE, snapStatus, m_moveSnapDiff );
04607
04608 move += m_moveSnapDiff;
04609 }
04610 else
04611 {
04612 m_gl.diffNextGuide( rect, move );
04613 }
04614 }
04615
04616
04617 KoRect pageRect( m_activePage->getPageRect() );
04618 if ( rect.left() + move.x() < pageRect.left() )
04619 {
04620 move.setX( pageRect.left() - rect.left() );
04621 }
04622 else if ( rect.right() + move.x() > pageRect.right() )
04623 {
04624 move.setX( pageRect.right() - rect.right() );
04625 }
04626 if ( rect.top() + move.y() < pageRect.top() )
04627 {
04628 move.setY( pageRect.top() - rect.top() );
04629 }
04630 else if ( rect.bottom() + move.y() > pageRect.bottom() )
04631 {
04632 move.setY( pageRect.bottom() - rect.bottom() );
04633 }
04634
04635
04636 if ( snapToGuideLines )
04637 {
04638
04639 KoRect movedRect( rect );
04640 movedRect.moveBy( move.x(), move.y() );
04641 m_gl.repaintSnapping( movedRect );
04642 }
04643
04644 if ( move != KoPoint( 0, 0 ) )
04645 {
04646
04647 m_activePage->moveObject( m_view, move, false );
04648 m_view->updateObjectStatusBarItem();
04649 }
04650 }
04651
04652
04653 void KPrCanvas::moveObjectsByMouse( KoPoint &pos, bool keepXorYunchanged )
04654 {
04655 KPrDocument *doc( m_view->kPresenterDoc() );
04656
04657 KoRect rect( objectRect( false ) );
04658 KoPoint move( 0, 0 );
04659 double diffx = pos.x() - m_origMousePos.x();
04660 double diffy = pos.y() - m_origMousePos.y();
04661
04662 bool snapToGrid = doc->snapToGrid() && !m_disableSnapping;
04663 bool snapToGuideLines = doc->showGuideLines() && !m_disableSnapping;
04664
04665 move = KoPoint( diffx, diffy );
04666 m_origMousePos = pos;
04667
04668
04669 KoRect movedRect( rect );
04670 movedRect.moveBy( diffx, diffy );
04671 movedRect.moveBy( -m_moveSnapDiff.x(), -m_moveSnapDiff.y() );
04672 move -= m_moveSnapDiff;
04673
04674 m_moveSnapDiff = KoPoint( 0, 0 );
04675 KoGuides::SnapStatus snapStatus = KoGuides::SNAP_NONE;
04676
04677 if ( snapToGrid )
04678 {
04679 m_moveSnapDiff.setX( qRound( movedRect.topLeft().x() / doc->getGridX()) * doc->getGridX()
04680 - movedRect.topLeft().x() );
04681 m_moveSnapDiff.setY( qRound( movedRect.topLeft().y() / doc->getGridY()) * doc->getGridY()
04682 - movedRect.topLeft().y() );
04683 snapStatus = KoGuides::SNAP_BOTH;
04684 }
04685
04686 if ( snapToGuideLines )
04687 {
04688 m_gl.snapToGuideLines( movedRect, MOUSE_SNAP_DISTANCE, snapStatus, m_moveSnapDiff );
04689 }
04690
04691 move += m_moveSnapDiff;
04692
04693
04694 KoPoint diffDueToBorders(0,0);
04695 KoRect pageRect( m_activePage->getPageRect() );
04696 if ( rect.left() + move.x() < pageRect.left() )
04697 diffDueToBorders.setX( pageRect.left() - (rect.left() + move.x()) );
04698 else if ( rect.right() + move.x() > pageRect.right() )
04699 diffDueToBorders.setX( pageRect.right() - (rect.right() + move.x()) );
04700
04701 if ( rect.top() + move.y() < pageRect.top() )
04702 diffDueToBorders.setY( pageRect.top() - (rect.top() + move.y()) );
04703 else if ( rect.bottom() + move.y() > pageRect.bottom() )
04704 diffDueToBorders.setY( pageRect.bottom() - (rect.bottom() + move.y()) );
04705
04706 m_moveSnapDiff += diffDueToBorders;
04707 move += diffDueToBorders;
04708
04709 movedRect.moveBy( m_moveSnapDiff.x(), m_moveSnapDiff.y() );
04710 if ( keepXorYunchanged )
04711 {
04712 KoPoint diff( m_moveStartPosMouse - movedRect.topLeft() );
04713 if ( fabs( diff.x() ) > fabs( diff.y() ) )
04714 {
04715 m_moveSnapDiff.setY( m_moveSnapDiff.y() + m_moveStartPosMouse.y() - movedRect.y() );
04716 movedRect.moveTopLeft( KoPoint( movedRect.x(), m_moveStartPosMouse.y() ) );
04717 move.setY( movedRect.y() - rect.y() );
04718 }
04719 else
04720 {
04721 m_moveSnapDiff.setX( m_moveSnapDiff.x() + m_moveStartPosMouse.x() - movedRect.x() );
04722 movedRect.moveTopLeft( KoPoint( m_moveStartPosMouse.x(), movedRect.y() ) );
04723 move.setX( movedRect.x() - rect.x() );
04724 }
04725 }
04726
04727 if ( snapToGuideLines )
04728 {
04729
04730 m_gl.repaintSnapping( movedRect );
04731 }
04732
04733 if ( move != KoPoint( 0, 0 ) )
04734 {
04735
04736 m_activePage->moveObject( m_view, move, false );
04737 }
04738 }
04739
04740
04741 void KPrCanvas::resizeObject( ModifyType _modType, const KoPoint & point, bool keepRatio, bool scaleAroundCenter )
04742 {
04743 KPrObject *kpobject = m_resizeObject;
04744
04745 QRect oldBoundingRect( m_view->zoomHandler()->zoomRect( kpobject->getRepaintRect() ) );
04746
04747 KoRect objRect = kpobject->getRealRect();
04748 KoGuides::SnapStatus snapStatus( KoGuides::SNAP_NONE );
04749
04750 bool left = false;
04751 bool right = false;
04752 bool top = false;
04753 bool bottom = false;
04754 if ( _modType == MT_RESIZE_UP || _modType == MT_RESIZE_LU || _modType == MT_RESIZE_RU )
04755 {
04756 top = true;
04757 snapStatus |= KoGuides::SNAP_HORIZ;
04758 }
04759 if ( _modType == MT_RESIZE_DN || _modType == MT_RESIZE_LD || _modType == MT_RESIZE_RD )
04760 {
04761 bottom = true;
04762 snapStatus |= KoGuides::SNAP_HORIZ;
04763 }
04764 if ( _modType == MT_RESIZE_LF || _modType == MT_RESIZE_LU || _modType == MT_RESIZE_LD )
04765 {
04766 left = true;
04767 snapStatus |= KoGuides::SNAP_VERT;
04768 }
04769 if ( _modType == MT_RESIZE_RT || _modType == MT_RESIZE_RU || _modType == MT_RESIZE_RD )
04770 {
04771 right = true;
04772 snapStatus |= KoGuides::SNAP_VERT;
04773 }
04774
04775 double newLeft = objRect.left();
04776 double newRight = objRect.right();
04777 double newTop = objRect.top();
04778 double newBottom = objRect.bottom();
04779 if ( top )
04780 {
04781 if ( point.y() < objRect.bottom() - MIN_SIZE )
04782 {
04783 newTop = point.y();
04784 }
04785 else
04786 {
04787 newTop = objRect.bottom() - MIN_SIZE;
04788 }
04789 }
04790 if ( bottom )
04791 {
04792 if ( point.y() > objRect.top() + MIN_SIZE )
04793 {
04794 newBottom = point.y();
04795 }
04796 else
04797 {
04798 newBottom = objRect.top() + MIN_SIZE;
04799 }
04800 }
04801 if ( left )
04802 {
04803 if ( point.x() < objRect.right() - MIN_SIZE )
04804 {
04805 newLeft = point.x();
04806 }
04807 else
04808 {
04809 newLeft = objRect.right() - MIN_SIZE;
04810 }
04811 }
04812 if ( right )
04813 {
04814 if ( point.x() > objRect.left() + MIN_SIZE )
04815 {
04816 newRight = point.x();
04817 }
04818 else
04819 {
04820 newRight = objRect.left() + MIN_SIZE;
04821 }
04822 }
04823
04824 double width = newRight - newLeft;
04825 double height = newBottom - newTop;
04826
04827 if ( keepRatio && m_ratio != 0 )
04828 {
04829 if ( ( top || bottom ) && ( right || left ) )
04830 {
04831 if ( height * height * m_ratio > width * width / m_ratio )
04832 {
04833 width = height * m_ratio;
04834 }
04835 else
04836 {
04837 height = width / m_ratio;
04838 }
04839 }
04840 else if ( top || bottom )
04841 {
04842 width = height * m_ratio;
04843 }
04844 else
04845 {
04846 height = width / m_ratio;
04847 }
04848
04849 if ( top )
04850 {
04851 newTop = objRect.bottom() - height;
04852 }
04853 else
04854 {
04855 newBottom = objRect.top() + height;
04856 }
04857 if ( left )
04858 {
04859 newLeft = objRect.right() - width;
04860 }
04861 else
04862 {
04863 newRight = objRect.left() + width;
04864 }
04865 }
04866
04867 if ( scaleAroundCenter )
04868 {
04869 KoPoint center( m_rectBeforeResize.center() );
04870
04871 if ( newLeft != objRect.left() )
04872 {
04873 width = 2 * ( center.x() - newLeft );
04874 }
04875 else if ( newRight != objRect.right() )
04876 {
04877 width = 2 * ( newRight - center.x() );
04878 }
04879
04880
04881 if ( keepRatio )
04882 {
04883 height = width / m_ratio;
04884 }
04885 else
04886 {
04887 if ( newTop != objRect.top() )
04888 {
04889 height = 2 * ( center.y() - newTop );
04890 }
04891 else if ( newBottom != objRect.bottom() )
04892 {
04893 height = 2 * ( newBottom - center.y() );
04894 }
04895 }
04896
04897 if ( width < MIN_SIZE )
04898 {
04899 width = MIN_SIZE;
04900 }
04901 if ( height < MIN_SIZE )
04902 {
04903 height = MIN_SIZE;
04904 }
04905
04906 newLeft = center.x() - width / 2;
04907 newRight = newLeft + width;
04908 newTop = center.y() - height / 2;
04909 newBottom = newTop + height;
04910 }
04911
04912 if ( newLeft != objRect.left() || newRight != objRect.right() || newTop != objRect.top() || newBottom != objRect.bottom() )
04913 {
04914
04915 kpobject->resizeBy( width - objRect.width(), height - objRect.height() );
04916
04917 if ( objRect.left() != newLeft || objRect.top() != newTop )
04918 {
04919 kpobject->moveBy( KoPoint( newLeft - objRect.left(), newTop - objRect.top() ) );
04920 }
04921
04922 if ( m_view->kPresenterDoc()->showGuideLines() && !m_disableSnapping )
04923 {
04924 KoRect rect( kpobject->getRealRect() );
04925 KoPoint sp( rect.topLeft() );
04926 if ( right )
04927 {
04928 sp.setX( rect.right() );
04929 }
04930 if ( bottom )
04931 {
04932 sp.setY( rect.bottom() );
04933 }
04934 m_gl.repaintSnapping( sp, snapStatus );
04935 }
04936
04937 _repaint( oldBoundingRect );
04938 _repaint( kpobject );
04939 emit objectSizeChanged();
04940 }
04941 }
04942
04943
04944 void KPrCanvas::finishResizeObject( const QString &name, bool layout )
04945 {
04946 if ( m_resizeObject )
04947 {
04948 KoPoint move = KoPoint( m_resizeObject->getOrig().x() - m_rectBeforeResize.x(),
04949 m_resizeObject->getOrig().y() - m_rectBeforeResize.y() );
04950 KoSize size = KoSize( m_resizeObject->getSize().width() - m_rectBeforeResize.width(),
04951 m_resizeObject->getSize().height() - m_rectBeforeResize.height() );
04952
04953 if ( ( m_resizeObject->getRect() ) != m_rectBeforeResize )
04954 {
04955 KPrResizeCmd *resizeCmd = new KPrResizeCmd( name, move, size, m_resizeObject,
04956 m_view->kPresenterDoc() );
04957
04958 m_view->kPresenterDoc()->addCommand( resizeCmd );
04959 }
04960
04961 if ( layout )
04962 m_view->kPresenterDoc()->layout( m_resizeObject );
04963
04964 m_ratio = 0.0;
04965 m_isResizing = false;
04966 _repaint( m_resizeObject );
04967 m_resizeObject = NULL;
04968 }
04969 }
04970
04971 void KPrCanvas::raiseObject( KPrObject *object )
04972 {
04973 if ( objectList().count() <= 1 )
04974 return;
04975
04976 if ( m_objectDisplayAbove == 0 )
04977 {
04978 if ( m_activePage->numSelected() == 1 )
04979 {
04980 m_objectDisplayAbove = object;
04981 }
04982 }
04983 }
04984
04985 void KPrCanvas::lowerObject()
04986 {
04987 m_objectDisplayAbove = 0;
04988 }
04989
04990 const QPtrList<KPrObject> KPrCanvas::displayObjectList() const
04991 {
04992 QPtrList<KPrObject> list = objectList();
04993 list.setAutoDelete( false );
04994
04995 if ( m_objectDisplayAbove )
04996 {
04997
04998
04999 int pos = objectList().findRef( m_objectDisplayAbove );
05000 if ( pos != -1 && m_objectDisplayAbove->isSelected() )
05001 {
05002 list.take( pos );
05003 list.append( m_objectDisplayAbove );
05004 }
05005 else
05006 {
05007
05008
05009 }
05010 }
05011 return list;
05012 }
05013
05014 void KPrCanvas::playSound( const QString &soundFileName )
05015 {
05016 if(soundPlayer)
05017 delete soundPlayer;
05018 soundPlayer = new KPrSoundPlayer( soundFileName );
05019 soundPlayer->play();
05020 }
05021
05022 void KPrCanvas::stopSound()
05023 {
05024 if ( soundPlayer ) {
05025 soundPlayer->stop();
05026 delete soundPlayer;
05027 soundPlayer = 0;
05028 }
05029 }
05030
05031 void KPrCanvas::setXimPosition( int x, int y, int w, int h, QFont *f )
05032 {
05033 QWidget::setMicroFocusHint( x - diffx(), y - diffy(), w, h, true, f );
05034 }
05035
05036 void KPrCanvas::createEditing( KPrTextObject *textObj )
05037 {
05038 if( m_currentTextObjectView)
05039 {
05040 m_currentTextObjectView->terminate();
05041 delete m_currentTextObjectView;
05042 m_currentTextObjectView = 0;
05043 m_editObject = 0;
05044 }
05045 m_currentTextObjectView = textObj->createKPTextView( this );
05046 m_editObject = textObj;
05047 }
05048
05049 void KPrCanvas::terminateEditing( KPrTextObject *textObj )
05050 {
05051 if ( m_currentTextObjectView && m_currentTextObjectView->kpTextObject() == textObj )
05052 {
05053 m_currentTextObjectView->terminate();
05054 delete m_currentTextObjectView;
05055 m_currentTextObjectView = 0;
05056 m_editObject = 0;
05057 }
05058 }
05059
05060 void KPrCanvas::drawCubicBezierCurve( QPainter &p, KoPointArray &points )
05061 {
05062 p.save();
05063 if ( !m_drawLineWithCubicBezierCurve )
05064 {
05065 QPen pen = QPen( Qt::black, 1, Qt::DashLine );
05066 p.setPen( pen );
05067 double angle = KoPoint::getAngle( m_endPoint, m_startPoint );
05068 drawFigure( L_SQUARE, &p, m_endPoint, pen.color(), pen.width(), angle,m_view->zoomHandler() );
05069
05070 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
05071 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
05072
05073 KoPoint symmetricEndPoint = m_startPoint * 2 - m_endPoint;
05074
05075 angle = KoPoint::getAngle( symmetricEndPoint, m_startPoint );
05076 drawFigure( L_SQUARE, &p, symmetricEndPoint, pen.color(), pen.width(), angle,m_view->zoomHandler() );
05077
05078
05079 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
05080 m_view->zoomHandler()->zoomPoint( symmetricEndPoint ) );
05081
05082 p.save();
05083 p.setPen( QPen( Qt::black, 1, Qt::SolidLine ) );
05084 p.drawCubicBezier( points.zoomPointArray( m_view->zoomHandler() ) );
05085 p.restore();
05086 }
05087 else
05088 {
05089 KoPoint startPoint( m_pointArray.at( m_indexPointArray - 1 ) );
05090
05091 p.drawLine( m_view->zoomHandler()->zoomPoint( startPoint ),
05092 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
05093 }
05094 p.restore();
05095 }
05096
05097
05098 void KPrCanvas::redrawCubicBezierCurve( QPainter &p )
05099 {
05100 if ( m_indexPointArray > 0 )
05101 {
05102 for ( int count = 0; count < m_indexPointArray - 4; count += 4 )
05103 {
05104 double _firstX = m_pointArray.at( count ).x();
05105 double _firstY = m_pointArray.at( count ).y();
05106
05107 double _fourthX = m_pointArray.at( count + 1 ).x();
05108 double _fourthY = m_pointArray.at( count + 1 ).y();
05109
05110 double _secondX = m_pointArray.at( count + 2 ).x();
05111 double _secondY = m_pointArray.at( count + 2 ).y();
05112
05113 double _thirdX = m_pointArray.at( count + 3 ).x();
05114 double _thirdY = m_pointArray.at( count + 3 ).y();
05115
05116 KoPointArray points;
05117 points.putPoints( 0, 4, _firstX,_firstY, _secondX,_secondY, _thirdX,_thirdY, _fourthX,_fourthY );
05118
05119 p.drawCubicBezier( points.zoomPointArray( m_view->zoomHandler() ) );
05120 }
05121 }
05122 }
05123
05124
05125 void KPrCanvas::drawPolygon( QPainter &p, const KoRect &rect )
05126 {
05127 KoRect nRect = rect.normalize();
05128 bool checkConcavePolygon = m_view->getCheckConcavePolygon();
05129 int cornersValue = m_view->getCornersValue();
05130 int sharpnessValue = m_view->getSharpnessValue();
05131
05132 KoRect _rect( 0, 0, nRect.width(), nRect.height() );
05133 double angle = 2 * M_PI / cornersValue;
05134 double diameter = static_cast<double>( QMAX( _rect.width(), _rect.height() ) );
05135 double radius = diameter * 0.5;
05136
05137 KoPointArray _points( checkConcavePolygon ? cornersValue * 2 : cornersValue );
05138 _points.setPoint( 0, 0, qRound( -radius ) );
05139
05140 double xmin = 0;
05141 double ymin = qRound( -radius );
05142
05143 if ( checkConcavePolygon ) {
05144 angle = angle / 2.0;
05145 double a = angle;
05146 double r = radius - ( sharpnessValue / 100.0 * radius );
05147 for ( int i = 1; i < cornersValue * 2; ++i ) {
05148 double xp, yp;
05149 if ( i % 2 ) {
05150 xp = r * sin( a );
05151 yp = -r * cos( a );
05152 }
05153 else {
05154 xp = radius * sin( a );
05155 yp = -radius * cos( a );
05156 }
05157 a += angle;
05158 _points.setPoint( i, xp, yp );
05159 if (xp < xmin)
05160 xmin = xp;
05161 if (yp < ymin)
05162 ymin = yp;
05163 }
05164 }
05165 else {
05166 double a = angle;
05167 for ( int i = 1; i < cornersValue; ++i ) {
05168 double xp = radius * sin( a );
05169 double yp = -radius * cos( a );
05170 a += angle;
05171 _points.setPoint( i, xp, yp );
05172 if (xp < xmin)
05173 xmin = xp;
05174 if (yp < ymin)
05175 ymin = yp;
05176 }
05177 }
05178
05179
05180 KoRect _changRect = _points.boundingRect();
05181 double fx = _rect.width() / _changRect.width();
05182 double fy = _rect.height() / _changRect.height();
05183
05184 int _index = 0;
05185 KoPointArray tmpPoints;
05186 KoPointArray::ConstIterator it;
05187 for ( it = _points.begin(); it != _points.end(); ++it ) {
05188 KoPoint point = (*it);
05189 double tmpX = ( point.x() - xmin) * fx + nRect.x();
05190 double tmpY = ( point.y() - ymin) * fy + nRect.y();
05191
05192 tmpPoints.putPoints( _index, 1, tmpX,tmpY );
05193 ++_index;
05194 }
05195 p.drawPolygon( tmpPoints.zoomPointArray( m_view->zoomHandler() ) );
05196 m_pointArray = tmpPoints;
05197 }
05198
05199
05200 bool KPrCanvas::oneObjectTextSelected() const
05201 {
05202 return m_activePage->oneObjectTextSelected();
05203 }
05204
05205 bool KPrCanvas::oneObjectTextExist() const
05206 {
05207 return m_activePage->oneObjectTextExist();
05208 }
05209
05210 KPrPage* KPrCanvas::activePage() const
05211 {
05212 return m_activePage;
05213 }
05214
05215 void KPrCanvas::setActivePage( KPrPage* active )
05216 {
05217 Q_ASSERT(active);
05218
05219
05220 m_objectDisplayAbove = 0;
05221 m_activePage = active;
05222 }
05223
05224 void KPrCanvas::setPaintGuides( bool state )
05225 {
05226 m_paintGuides = state;
05227 }
05228
05229 bool KPrCanvas::objectIsAHeaderFooterHidden(KPrObject *obj) const
05230 {
05231 if (( m_view->kPresenterDoc()->isHeader(obj) && !m_activePage->hasHeader() )
05232 || ( m_view->kPresenterDoc()->isFooter(obj) && !m_activePage->hasFooter() ) )
05233 return true;
05234 return false;
05235 }
05236
05237 int KPrCanvas::numberOfObjectSelected() const
05238 {
05239 int nb = m_activePage->numSelected();
05240 return nb;
05241 }
05242
05243 KPrObject *KPrCanvas::getSelectedObj() const
05244 {
05245 KPrObject *obj = m_activePage->getSelectedObj();
05246 return obj;
05247 }
05248
05249 void KPrCanvas::ungroupObjects()
05250 {
05251 KMacroCommand *macro = 0;
05252 m_activePage->ungroupObjects( ¯o );
05253 if ( macro )
05254 m_view->kPresenterDoc()->addCommand( macro );
05255 }
05256
05257 void KPrCanvas::groupObjects()
05258 {
05259 m_activePage->groupObjects();
05260 }
05261
05262 KoRect KPrCanvas::objectRect( bool all ) const
05263 {
05264 return m_activePage->getRealRect( all );
05265 }
05266
05267 void KPrCanvas::scrollTopLeftPoint( const QPoint & pos )
05268 {
05269 m_view->getHScrollBar()->setValue( pos.x() );
05270 m_view->getVScrollBar()->setValue( pos.y() );
05271 }
05272
05273 void KPrCanvas::changePicture( const KURL & url, QWidget *window )
05274 {
05275 m_activePage->changePicture( url, window );
05276 }
05277
05278 unsigned int KPrCanvas::objNums() const
05279 {
05280 return m_activePage->objNums();
05281 }
05282
05283
05284 void KPrCanvas::ensureVisible( int x, int y, int xmargin, int ymargin )
05285 {
05286
05287 int newy= (y+ymargin)-(visibleRect().bottom()+diffy());
05288
05289 if( newy > 0)
05290 m_view->getVScrollBar()->setValue(m_view->getVScrollBar()->value()+newy);
05291 else
05292 {
05293 newy= (y )-(visibleRect().top()+diffy());
05294 if( newy < 0)
05295 m_view->getVScrollBar()->setValue(m_view->getVScrollBar()->value()+newy - ymargin);
05296 }
05297
05298 int newx= (x+xmargin)-(visibleRect().right()+diffx());
05299 if( newx > 0)
05300 m_view->getHScrollBar()->setValue(m_view->getHScrollBar()->value()+newx);
05301 else
05302 {
05303 newx= x -(visibleRect().left()+diffx());
05304 if( newx < 0)
05305 m_view->getHScrollBar()->setValue(m_view->getHScrollBar()->value()+newx - xmargin );
05306 }
05307 }
05308
05309
05310 void KPrCanvas::textContentsToHeight()
05311 {
05312 QPtrList<KPrTextObject> lst = applicableTextObjects();
05313 if ( lst.isEmpty() )
05314 return;
05315 QPtrListIterator<KPrTextObject> it( lst );
05316 KMacroCommand * macro = 0L;
05317 for ( ; it.current() ; ++it ) {
05318 KCommand *cmd= it.current()->textContentsToHeight();
05319 if( cmd )
05320 {
05321 if ( !macro )
05322 macro = new KMacroCommand(i18n("Extend Text Contents to Height"));
05323 macro->addCommand( cmd);
05324 _repaint( it.current() );
05325 }
05326 }
05327 if( macro )
05328 {
05329 macro->execute();
05330 m_view->kPresenterDoc()->addCommand( macro );
05331 m_view->kPresenterDoc()->repaint(this);
05332 }
05333 }
05334
05335
05336 void KPrCanvas::textObjectToContents()
05337 {
05338 QPtrList<KPrTextObject> lst = applicableTextObjects();
05339 if ( lst.isEmpty() )
05340 return;
05341 QPtrListIterator<KPrTextObject> it( lst );
05342 KMacroCommand * macro = 0L;
05343 for ( ; it.current() ; ++it ) {
05344 KCommand *cmd= it.current()->textObjectToContents();
05345 if( cmd )
05346 {
05347 if (!macro )
05348 macro = new KMacroCommand(i18n("Extend Text to Contents"));
05349 macro->addCommand( cmd);
05350 }
05351 }
05352
05353 if( macro)
05354 {
05355 macro->execute();
05356 m_view->kPresenterDoc()->addCommand( macro );
05357 m_view->kPresenterDoc()->repaint(this);
05358 }
05359
05360 }
05361
05362 void KPrCanvas::flipObject( bool _horizontal )
05363 {
05364 QPtrList<KPrObject> lst;
05365 QPtrListIterator<KPrObject> it(getObjectList());
05366 for ( ; it.current(); ++it ) {
05367 if ( it.current()->isSelected() &&
05368 it.current()->getType() != OT_AUTOFORM &&
05369 it.current()->getType() != OT_PART &&
05370 it.current()->getType() != OT_TEXT )
05371 {
05372 lst.append( it.current() );
05373 }
05374 }
05375 if ( lst.isEmpty() )
05376 return;
05377
05378 KPrFlipObjectCommand *flipCmd = new KPrFlipObjectCommand( i18n("Flip Objects"),
05379 m_view->kPresenterDoc(),
05380 _horizontal, lst );
05381 flipCmd->execute();
05382 m_view->kPresenterDoc()->addCommand( flipCmd );
05383 }
05384
05385 void KPrCanvas::lowerObjs( bool backward )
05386 {
05387 lowerObject();
05388 m_activePage->lowerObjs( backward );
05389 }
05390
05391 void KPrCanvas::raiseObjs( bool forward )
05392 {
05393 lowerObject();
05394 m_activePage->raiseObjs( forward );
05395 }
05396
05397 QPtrList<KPrTextObject> KPrCanvas::listOfTextObjs() const
05398 {
05399 QPtrList<KPrTextObject> lst;
05400 QPtrListIterator<KPrObject> it(getObjectList());
05401 for ( ; it.current(); ++it ) {
05402 if ( it.current()->getType() == OT_TEXT )
05403 {
05404 if ( objectIsAHeaderFooterHidden(it.current()))
05405 continue;
05406 else
05407 lst.append( static_cast<KPrTextObject*>( it.current() ));
05408 }
05409 }
05410 return lst;
05411 }
05412
05413 KPrTextObject* KPrCanvas::textUnderMouse( const QPoint & point )
05414 {
05415 QPtrList<KPrTextObject> obj = listOfTextObjs();
05416 QPtrListIterator<KPrTextObject> it2(obj );
05417 for ( ; it2.current() ; ++it2 ) {
05418 QRect outerRect( m_view->kPresenterDoc()->zoomHandler()->zoomRect( it2.current()->getRect()) );
05419 if ( !it2.current()->isProtectContent() && outerRect.contains( point) )
05420 return it2.current();
05421 }
05422 return 0L;
05423 }
05424
05425 void KPrCanvas::speakTextUnderMouse(QWidget* w, const QPoint& p, uint flags)
05426 {
05427 Q_UNUSED( flags );
05428 if ( w != this ) return;
05429
05430
05431 if ( p == QPoint() ) return;
05432 KPrTextObject *to = textUnderMouse( w->mapFromGlobal( p ) );
05433 if ( to == m_prevSpokenTO ) return;
05434 m_prevSpokenTO = to;
05435 if ( to ) {
05436 QString text = to->textObject()->textDocument()->plainText();
05437 if ( !text.isEmpty() ) kospeaker->sayWidget( text );
05438 }
05439 }
05440
05441 bool KPrCanvas::checkCurrentTextEdit( KPrTextObject * textObj )
05442 {
05443 bool emitChanged = false;
05444 if ( textObj && m_currentTextObjectView && m_currentTextObjectView->kpTextObject() != textObj )
05445 {
05446 m_currentTextObjectView->kpTextObject()->setEditingTextObj( false );
05447 _repaint( m_currentTextObjectView->kpTextObject() );
05448
05449 m_currentTextObjectView->terminate(false);
05450 delete m_currentTextObjectView;
05451 m_currentTextObjectView = 0L;
05452 emitChanged = true;
05453 }
05454
05455
05456 if ( textObj && !m_currentTextObjectView )
05457 {
05458 m_currentTextObjectView = textObj->createKPTextView( this );
05459 emitChanged = true;
05460 }
05461 return emitChanged;
05462 }
05463
05464 void KPrCanvas::alignObjects( AlignType at )
05465 {
05466 KPrDocument * doc = m_view->kPresenterDoc();
05467
05468 QString name;
05469
05470 switch ( at )
05471 {
05472 case AT_LEFT:
05473 name = i18n( "Align Objects Left" );
05474 break;
05475 case AT_TOP:
05476 name = i18n( "Align Objects Top" );
05477 break;
05478 case AT_RIGHT:
05479 name = i18n( "Align Objects Right" );
05480 break;
05481 case AT_BOTTOM:
05482 name = i18n( "Align Objects Bottom" );
05483 break;
05484 case AT_HCENTER:
05485 name = i18n( "Align Objects Centered (horizontal)" );
05486 break;
05487 case AT_VCENTER:
05488 name = i18n( "Align Objects Center/Vertical" );
05489 break;
05490 }
05491
05492 QPtrList<KPrObject> objects;
05493
05494 QPtrListIterator<KPrObject> it( m_activePage->objectList() );
05495 for ( ; it.current() ; ++it )
05496 {
05497 if ( it.current() == m_view->kPresenterDoc()->header() ||
05498 it.current() == m_view->kPresenterDoc()->footer() )
05499 continue;
05500
05501 if( it.current()->isSelected() && !it.current()->isProtect() ) {
05502 objects.append( it.current() );
05503 }
05504 }
05505
05506 if ( objects.count() )
05507 {
05508 KCommand * cmd = new KPrAlignCmd( name, objects, at, doc );
05509 cmd->execute();
05510 doc->addCommand( cmd );
05511 }
05512 }
05513
05514 bool KPrCanvas::canMoveOneObject() const
05515 {
05516 return m_activePage->canMoveOneObject();
05517 }
05518
05519 void KPrCanvas::closeObject(bool )
05520 {
05521 QPtrList<KPrObject> lst;
05522 QPtrListIterator<KPrObject> it(getObjectList());
05523 for ( ; it.current(); ++it ) {
05524 if ( it.current()->isSelected()
05525 && (it.current()->getType() == OT_POLYLINE || it.current()->getType() == OT_FREEHAND
05526 || it.current()->getType() == OT_QUADRICBEZIERCURVE
05527 || it.current()->getType() == OT_CUBICBEZIERCURVE ))
05528 lst.append( it.current() );
05529 }
05530 if ( lst.isEmpty())
05531 return;
05532
05533 KCommand * cmd= new KPrCloseObjectCommand( i18n("Close Object"), lst, m_view->kPresenterDoc() );
05534 cmd->execute();
05535 m_view->kPresenterDoc()->addCommand( cmd );
05536 }
05537
05538 void KPrCanvas::layout()
05539 {
05540 QPtrListIterator<KPrObject> it(getObjectList());
05541 for ( ; it.current(); ++it ) {
05542 if ( it.current()->getType() == OT_TEXT )
05543 static_cast<KPrTextObject *>( it.current() )->layout();
05544 }
05545 }
05546
05547 KoPoint KPrCanvas::snapPoint( KoPoint &pos, bool repaintSnapping )
05548 {
05549 KoPoint sp( pos );
05550 KPrDocument * doc( m_view->kPresenterDoc() );
05551
05552 bool snapToGrid = doc->snapToGrid() && !m_disableSnapping;
05553 bool snapToGuideLines = doc->showGuideLines() && !m_disableSnapping;
05554
05555 KoPoint snapDiff = KoPoint( 0, 0 );
05556 KoGuides::SnapStatus snapStatus = KoGuides::SNAP_NONE;
05557
05558 if ( snapToGrid )
05559 {
05560 snapDiff.setX( qRound( sp.x() / doc->getGridX()) * doc->getGridX() - sp.x() );
05561 snapDiff.setY( qRound( sp.y() / doc->getGridY()) * doc->getGridY() - sp.y() );
05562 snapStatus = KoGuides::SNAP_BOTH;
05563 }
05564
05565 if ( snapToGuideLines )
05566 {
05567 m_gl.snapToGuideLines( sp, MOUSE_SNAP_DISTANCE, snapStatus, snapDiff );
05568 }
05569
05570 sp += snapDiff;
05571
05572
05573 KoRect pageRect( m_activePage->getPageRect() );
05574 if ( sp.x() < pageRect.left() )
05575 sp.setX( pageRect.left() );
05576 else if ( sp.x() > pageRect.right() )
05577 sp.setX( pageRect.right() );
05578
05579 if ( sp.y() < pageRect.top() )
05580 sp.setY( pageRect.top() );
05581 else if ( sp.y() > pageRect.bottom() )
05582 sp.setY( pageRect.bottom() );
05583
05584
05585 if ( repaintSnapping && snapToGuideLines )
05586 {
05587 m_gl.repaintSnapping( sp, KoGuides::SNAP_BOTH );
05588 }
05589
05590 return sp;
05591 }
05592
05593
05594 void KPrCanvas::alignVertical( VerticalAlignmentType _type )
05595 {
05596 KCommand *cmd = m_activePage->alignVertical( _type );
05597 if ( cmd )
05598 m_view->kPresenterDoc()->addCommand( cmd );
05599 }
05600
05601 KPrPixmapObject * KPrCanvas::getSelectedImage() const
05602 {
05603 return m_activePage->getSelectedImage();
05604 }
05605
05606
05607 KoPointArray KPrCanvas::getObjectPoints( const KoPointArray &pointArray )
05608 {
05609 KoRect rect = pointArray.boundingRect();
05610
05611 KoPointArray points( pointArray );
05612 points.translate( -rect.x(), -rect.y() );
05613
05614 return points;
05615 }
05616
05617 void KPrCanvas::objectPopup( KPrObject *object, const QPoint &point )
05618 {
05619 switch ( object->getType() )
05620 {
05621 case OT_PICTURE:
05622 case OT_CLIPART:
05623 m_view->openPopupMenuObject( "picmenu_popup", point );
05624 break;
05625 case OT_TEXT:
05626 {
05627 KPrTextObject *obj=dynamic_cast<KPrTextObject *>(object);
05628 if ( obj )
05629 m_view->changeVerticalAlignmentStatus( obj->verticalAlignment() );
05630 m_view->openPopupMenuObject( "textobject_popup", point );
05631 } break;
05632 case OT_PIE:
05633 m_view->openPopupMenuObject( "piemenu_popup", point );
05634 break;
05635 case OT_RECT:
05636 case OT_ELLIPSE:
05637 m_view->openPopupMenuObject( "rectangleobject_popup", point );
05638 break;
05639 case OT_PART:
05640 m_view->openPopupMenuObject( "partobject_popup", point );
05641 break;
05642 case OT_POLYGON:
05643 m_view->openPopupMenuObject( "polygonobject_popup", point );
05644 break;
05645 case OT_POLYLINE:
05646 case OT_CUBICBEZIERCURVE:
05647 case OT_QUADRICBEZIERCURVE:
05648 case OT_FREEHAND:
05649 m_view->openPopupMenuObject( "closed_popup", point );
05650 break;
05651 case OT_LINE:
05652 case OT_CLOSED_LINE:
05653 m_view->openPopupMenuObject( "flip_popup", point );
05654 break;
05655 case OT_GROUP:
05656 if ( oneObjectTextSelected())
05657 m_view->openPopupMenuObject( "textobject_popup", point );
05658 else
05659 m_view->openPopupMenuObject( "flip_popup", point );
05660 break;
05661 default:
05662 m_view->openPopupMenuObject( "graphmenu_popup", point );
05663 break;
05664 }
05665 }
05666
05667 void KPrCanvas::popupContextMenu()
05668 {
05669 if ( !editMode ) {
05670 if ( !m_drawMode && !spManualSwitch() )
05671 {
05672 finishObjectEffects();
05673 finishPageEffect();
05674 m_view->stopAutoPresTimer();
05675 }
05676 setCursor( arrowCursor );
05677 QPoint p( width()/2, height()/2 );
05678 int ret = m_presMenu->exec( p );
05679
05680 if ( ret == -1 && !m_presMenu->isItemChecked( PM_DM ) && !spManualSwitch() )
05681 m_view->continueAutoPresTimer();
05682 return;
05683 }
05684 if ( m_currentTextObjectView ) {
05685
05686
05687 KoPoint kop = m_currentTextObjectView->kpTextObject()->getOrig();
05688 QPoint p = m_view->zoomHandler()->zoomPoint( kop );
05689 p = mapToGlobal( p );
05690 m_currentTextObjectView->showPopup( m_view, p, m_view->actionList() );
05691 return;
05692 }
05693 if (!m_activePage) return;
05694 KPrObject* obj = m_activePage->getSelectedObj();
05695 if (obj) {
05696 KoPoint kop = obj->getOrig();
05697 QPoint p = m_view->zoomHandler()->zoomPoint( kop );
05698 p = mapToGlobal( p );
05699 objectPopup( obj, p );
05700 } else {
05701 QPoint p = mapToGlobal( QPoint() );
05702 m_view->openPopupMenuMenuPage( p );
05703 }
05704 }