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 KPrObject * KPrCanvas::getObjectAt( const KoPoint &pos, bool withoutProtected )
02222 {
02223 KPrObject *object = m_activePage->getObjectAt( pos, withoutProtected );
02224 if ( objectIsAHeaderFooterHidden( object ) )
02225 object = 0;
02226
02227 return object;
02228 }
02229
02230 void KPrCanvas::selectObj( KPrObject *kpobject )
02231 {
02232 kpobject->setSelected( true );
02233 _repaint( kpobject );
02234 emit objectSelectedChanged();
02235
02236 mouseSelectedObject = true;
02237 }
02238
02239 void KPrCanvas::deSelectObj( KPrObject *kpobject )
02240 {
02241 kpobject->setSelected( false );
02242 _repaint( kpobject );
02243
02244 if ( !m_activePage->isOneObjectSelected() )
02245 {
02246 mouseSelectedObject = false;
02247 }
02248 emit objectSelectedChanged();
02249 }
02250
02251 void KPrCanvas::selectAllObj()
02252 {
02253 QPtrListIterator<KPrObject> it( m_activePage->objectList() );
02254 for ( ; it.current() ; ++it )
02255 {
02256 if ( !objectIsAHeaderFooterHidden(it.current()) )
02257 it.current()->setSelected( true );
02258 }
02259
02260 mouseSelectedObject = true;
02261 _repaint( false );
02262 emit objectSelectedChanged();
02263 }
02264
02265
02266 void KPrCanvas::deSelectAllObj()
02267 {
02268 if( m_activePage->numSelected() == 0 )
02269 return;
02270
02271 lowerObject();
02272
02273 m_activePage->deSelectAllObj();
02274
02275
02276 if(m_currentTextObjectView)
02277 {
02278 m_currentTextObjectView->terminate();
02279 m_currentTextObjectView->kpTextObject()->setEditingTextObj( false );
02280 delete m_currentTextObjectView;
02281 m_currentTextObjectView=0L;
02282 }
02283 mouseSelectedObject = false;
02284 emit objectSelectedChanged();
02285 }
02286
02287 void KPrCanvas::setMouseSelectedObject(bool b)
02288 {
02289 mouseSelectedObject = b;
02290 emit objectSelectedChanged();
02291 }
02292
02293 void KPrCanvas::setupMenus()
02294 {
02295
02296 m_presMenu = new KPopupMenu();
02297 Q_CHECK_PTR( m_presMenu );
02298 m_presMenu->setCheckable( true );
02299 m_presMenu->insertTitle( i18n( "Slide Show" ) );
02300 m_presMenu->insertItem( i18n( "&Continue" ), this, SLOT( setSwitchingMode() ) );
02301 PM_DM = m_presMenu->insertItem( i18n( "&Drawing Mode" ), this, SLOT( setDrawingMode() ) );
02302 m_presMenu->insertSeparator();
02303 m_presMenu->insertItem( SmallIcon("goto"), i18n( "&Goto Slide..." ), this, SLOT( slotGotoPage() ) );
02304 m_presMenu->insertSeparator();
02305 m_presMenu->insertItem( i18n( "&End" ), this, SLOT( slotExitPres() ) );
02306 m_presMenu->setItemChecked( PM_DM, false );
02307 m_presMenu->setMouseTracking( true );
02308 }
02309
02310 void KPrCanvas::clipCut()
02311 {
02312 if ( m_currentTextObjectView )
02313 m_currentTextObjectView->cut();
02314 m_view->editCut();
02315 }
02316
02317 void KPrCanvas::clipCopy()
02318 {
02319 if ( m_currentTextObjectView )
02320 m_currentTextObjectView->copy();
02321 m_view->editCopy();
02322 }
02323
02324 void KPrCanvas::clipPaste()
02325 {
02326 if ( m_currentTextObjectView )
02327 m_currentTextObjectView->paste();
02328 m_view->editPaste();
02329 }
02330
02331 void KPrCanvas::chPic()
02332 {
02333 m_activePage->chPic( m_view );
02334 }
02335
02336 bool KPrCanvas::exportPage( int nPage,
02337 int nWidth,
02338 int nHeight,
02339 const KURL& _fileURL,
02340 const char* format,
02341 int quality )
02342 {
02343 bool res = false;
02344 const QCursor oldCursor( cursor() );
02345 setCursor( waitCursor );
02346 QPixmap pix( nWidth, nHeight );
02347 drawPageInPix( pix, nPage, 0, true, nWidth, nHeight );
02348 if( !pix.isNull() ){
02349
02350
02351
02352
02353
02354
02355 const QSize desiredSize(nWidth, nHeight);
02356 if( desiredSize != pix.size() )
02357 pix.resize( desiredSize );
02358
02359 KURL fileURL(_fileURL);
02360 if( fileURL.protocol().isEmpty() )
02361 fileURL.setProtocol( "file" );
02362 const bool bLocalFile = fileURL.isLocalFile();
02363 KTempFile* tmpFile = bLocalFile ? NULL : new KTempFile();
02364 if( !bLocalFile )
02365 tmpFile->setAutoDelete( true );
02366 if( bLocalFile || 0 == tmpFile->status() ){
02367 QFile file( bLocalFile ? fileURL.path(0) : tmpFile->name() );
02368 if ( file.open( IO_ReadWrite ) ) {
02369 res = pix.save( &file, format, quality );
02370 file.close();
02371 }
02372 if( !bLocalFile ){
02373 if( res ){
02374 res = KIO::NetAccess::upload( tmpFile->name(), fileURL, this );
02375 }
02376 }
02377 }
02378 if( !bLocalFile ){
02379 delete tmpFile;
02380 }
02381 }
02382 setCursor( oldCursor );
02383 return res;
02384 }
02385
02386 void KPrCanvas::savePicture()
02387 {
02388 m_activePage->savePicture( m_view );
02389 }
02390
02391 void KPrCanvas::setTextFormat(const KoTextFormat &format, int flags)
02392 {
02393 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02394 if ( lst.isEmpty() ) return;
02395 KMacroCommand* macroCmd = new KMacroCommand( i18n("Change Text Font") );
02396 QPtrListIterator<KoTextFormatInterface> it( lst );
02397 for ( ; it.current() ; ++it ) {
02398 KCommand *cmd = it.current()->setFormatCommand(&format, flags, true);
02399
02400 if (cmd)
02401 macroCmd->addCommand( cmd );
02402 }
02403 m_view->kPresenterDoc()->addCommand( macroCmd );
02404 }
02405
02406 void KPrCanvas::setTextColor( const QColor &color )
02407 {
02408 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02409 if ( lst.isEmpty() ) return;
02410 QPtrListIterator<KoTextFormatInterface> it( lst );
02411 KMacroCommand* macroCmd = new KMacroCommand( i18n("Set Text Color") );
02412 for ( ; it.current() ; ++it ) {
02413 KCommand* cmd = it.current()->setTextColorCommand( color );
02414 if (cmd)
02415 macroCmd->addCommand( cmd );
02416 }
02417 m_view->kPresenterDoc()->addCommand( macroCmd );
02418 }
02419
02420 void KPrCanvas::setTextBackgroundColor( const QColor &color )
02421 {
02422 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02423 if ( lst.isEmpty() ) return;
02424 QPtrListIterator<KoTextFormatInterface> it( lst );
02425 KMacroCommand* macroCmd = 0L;
02426 for ( ; it.current() ; ++it ) {
02427 KCommand* cmd = it.current()->setTextBackgroundColorCommand( color );
02428 if ( cmd )
02429 {
02430 if ( !macroCmd )
02431 macroCmd = new KMacroCommand( i18n("Set Text Background Color") );
02432 macroCmd->addCommand( cmd );
02433 }
02434 }
02435 if (macroCmd )
02436 m_view->kPresenterDoc()->addCommand( macroCmd );
02437 }
02438
02439 void KPrCanvas::setTextBold( bool b )
02440 {
02441 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02442 if ( lst.isEmpty() ) return;
02443 QPtrListIterator<KoTextFormatInterface> it( lst );
02444 KMacroCommand* macroCmd = 0L;
02445 for ( ; it.current() ; ++it ) {
02446 KCommand* cmd = it.current()->setBoldCommand( b );
02447 if ( cmd )
02448 {
02449 if ( !macroCmd )
02450 macroCmd = new KMacroCommand( i18n("Make Text Bold") );
02451 macroCmd->addCommand( cmd );
02452 }
02453 }
02454 if ( macroCmd )
02455 m_view->kPresenterDoc()->addCommand( macroCmd );
02456 }
02457
02458 void KPrCanvas::setTextItalic( bool b )
02459 {
02460 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02461 if ( lst.isEmpty() ) return;
02462 QPtrListIterator<KoTextFormatInterface> it( lst );
02463 KMacroCommand* macroCmd = 0L;
02464 for ( ; it.current() ; ++it ) {
02465 KCommand* cmd = it.current()->setItalicCommand( b );
02466 if ( cmd )
02467 {
02468 if ( !macroCmd )
02469 macroCmd = new KMacroCommand( i18n("Make Text Italic") );
02470 macroCmd->addCommand( cmd );
02471 }
02472 }
02473 if (macroCmd )
02474 m_view->kPresenterDoc()->addCommand( macroCmd );
02475 }
02476
02477 void KPrCanvas::setTextUnderline( bool b )
02478 {
02479 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02480 if ( lst.isEmpty() ) return;
02481 QPtrListIterator<KoTextFormatInterface> it( lst );
02482 KMacroCommand* macroCmd = 0L;
02483 for ( ; it.current() ; ++it ) {
02484 KCommand* cmd = it.current()->setUnderlineCommand( b );
02485 if ( cmd )
02486 {
02487 if ( !macroCmd )
02488 macroCmd = new KMacroCommand( i18n("Underline Text") );
02489 macroCmd->addCommand( cmd );
02490 }
02491 }
02492 if ( macroCmd )
02493 m_view->kPresenterDoc()->addCommand( macroCmd );
02494 }
02495
02496 void KPrCanvas::setTextStrikeOut( bool b )
02497 {
02498 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02499 if ( lst.isEmpty() ) return;
02500 KMacroCommand* macroCmd = 0L;
02501 QPtrListIterator<KoTextFormatInterface> it( lst );
02502 for ( ; it.current() ; ++it ) {
02503 KCommand *cmd = it.current()->setStrikeOutCommand( b );
02504 if ( cmd )
02505 {
02506 if ( !macroCmd )
02507 macroCmd = new KMacroCommand( i18n("Make Text Italic") );
02508 macroCmd->addCommand( cmd );
02509 }
02510 }
02511 if ( macroCmd )
02512 m_view->kPresenterDoc()->addCommand( macroCmd );
02513 }
02514
02515 void KPrCanvas::setTextFamily( const QString &f )
02516 {
02517 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02518 if ( lst.isEmpty() ) return;
02519 KMacroCommand* macroCmd = 0L;
02520 QPtrListIterator<KoTextFormatInterface> it( lst );
02521 for ( ; it.current() ; ++it ) {
02522 KCommand* cmd = it.current()->setFamilyCommand( f );
02523 if ( cmd )
02524 {
02525 if ( !macroCmd )
02526 macroCmd = new KMacroCommand( i18n("Set Text Font") );
02527 macroCmd->addCommand( cmd );
02528 }
02529 }
02530 if ( macroCmd)
02531 m_view->kPresenterDoc()->addCommand( macroCmd );
02532 }
02533
02534 void KPrCanvas::setTextPointSize( int s )
02535 {
02536 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02537 if ( lst.isEmpty() ) return;
02538 KMacroCommand* macroCmd = 0L;
02539 QPtrListIterator<KoTextFormatInterface> it( lst );
02540 for ( ; it.current() ; ++it ) {
02541 KCommand* cmd = it.current()->setPointSizeCommand( s );
02542 if ( cmd )
02543 {
02544 if ( !macroCmd )
02545 macroCmd = new KMacroCommand( i18n("Change Text Size") );
02546 macroCmd->addCommand( cmd );
02547 }
02548
02549 }
02550 if (macroCmd)
02551 m_view->kPresenterDoc()->addCommand( macroCmd );
02552 }
02553
02554 void KPrCanvas::setTextSubScript( bool b )
02555 {
02556 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02557 if ( lst.isEmpty() ) return;
02558 QPtrListIterator<KoTextFormatInterface> it( lst );
02559 KMacroCommand* macroCmd = 0L;
02560 for ( ; it.current() ; ++it ) {
02561 KCommand* cmd = it.current()->setTextSubScriptCommand( b );
02562 if ( cmd )
02563 {
02564 if ( !macroCmd )
02565 macroCmd = new KMacroCommand( i18n("Set Text Subscript") );
02566 macroCmd->addCommand( cmd );
02567 }
02568 }
02569 if ( macroCmd )
02570 m_view->kPresenterDoc()->addCommand( macroCmd );
02571 }
02572
02573 void KPrCanvas::setTextSuperScript( bool b )
02574 {
02575 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02576 if ( lst.isEmpty() ) return;
02577 QPtrListIterator<KoTextFormatInterface> it( lst );
02578 KMacroCommand* macroCmd = 0L;
02579 for ( ; it.current() ; ++it ) {
02580 KCommand* cmd = it.current()->setTextSuperScriptCommand( b );
02581 if ( cmd )
02582 {
02583 if ( !macroCmd )
02584 macroCmd = new KMacroCommand( i18n("Set Text Superscript") );
02585 macroCmd->addCommand( cmd );
02586 }
02587 }
02588 if ( macroCmd )
02589 m_view->kPresenterDoc()->addCommand( macroCmd );
02590 }
02591
02592 void KPrCanvas::setTextDefaultFormat( )
02593 {
02594 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02595 if ( lst.isEmpty() ) return;
02596 QPtrListIterator<KoTextFormatInterface> it( lst );
02597 KMacroCommand* macroCmd = 0L;
02598 for ( ; it.current() ; ++it ) {
02599 KCommand* cmd = it.current()->setDefaultFormatCommand( );
02600 if ( cmd )
02601 {
02602 if ( !macroCmd )
02603 macroCmd = new KMacroCommand( i18n("Apply Default Format") );
02604 macroCmd->addCommand( cmd );
02605 }
02606 }
02607 if (macroCmd)
02608 m_view->kPresenterDoc()->addCommand( macroCmd );
02609 }
02610
02611 void KPrCanvas::setIncreaseFontSize()
02612 {
02613 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02614 if ( lst.isEmpty() ) return;
02615 QPtrListIterator<KoTextFormatInterface> it( lst );
02616 int size = it.current()->currentFormat()->pointSize();
02617 KMacroCommand* macroCmd =0L;
02618 for ( ; it.current() ; ++it ) {
02619 KCommand* cmd = it.current()->setPointSizeCommand( size+1 );
02620 if ( cmd )
02621 {
02622 if ( !macroCmd )
02623 macroCmd = new KMacroCommand( i18n("Increase Font Size") );
02624 macroCmd->addCommand( cmd );
02625 }
02626 }
02627 if ( macroCmd)
02628 m_view->kPresenterDoc()->addCommand( macroCmd );
02629 }
02630
02631 void KPrCanvas::setDecreaseFontSize()
02632 {
02633 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02634 if ( lst.isEmpty() ) return;
02635 QPtrListIterator<KoTextFormatInterface> it( lst );
02636 int size = it.current()->currentFormat()->pointSize();
02637 KMacroCommand* macroCmd = 0L;
02638 for ( ; it.current() ; ++it ) {
02639 KCommand* cmd = it.current()->setPointSizeCommand( size-1 );
02640 if ( cmd )
02641 {
02642 if ( !macroCmd )
02643 macroCmd = new KMacroCommand( i18n("Decrease Font Size") );
02644 macroCmd->addCommand( cmd );
02645 }
02646 }
02647 if ( macroCmd )
02648 m_view->kPresenterDoc()->addCommand( macroCmd );
02649 }
02650
02651 void KPrCanvas::setTextAlign( int align )
02652 {
02653 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02654 if ( lst.isEmpty() ) return;
02655 QPtrListIterator<KoTextFormatInterface> it( lst );
02656 KMacroCommand* macroCmd = 0L;
02657 for ( ; it.current() ; ++it ) {
02658 KCommand* cmd = it.current()->setAlignCommand(align);
02659 if ( cmd )
02660 {
02661 if ( !macroCmd)
02662 macroCmd = new KMacroCommand( i18n("Set Text Align") );
02663 macroCmd->addCommand( cmd );
02664 }
02665 }
02666 if ( macroCmd )
02667 m_view->kPresenterDoc()->addCommand( macroCmd );
02668 }
02669
02670 void KPrCanvas::setTabList( const KoTabulatorList & tabList )
02671 {
02672 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02673 if ( lst.isEmpty() ) return;
02674 QPtrListIterator<KoTextFormatInterface> it( lst );
02675 KMacroCommand* macroCmd = 0L;
02676 for ( ; it.current() ; ++it ) {
02677 KCommand* cmd = it.current()->setTabListCommand(tabList );
02678 if ( cmd )
02679 {
02680 if ( !macroCmd )
02681 macroCmd = new KMacroCommand( i18n("Change Tabulators") );
02682 macroCmd->addCommand( cmd );
02683 }
02684 }
02685 if ( macroCmd)
02686 m_view->kPresenterDoc()->addCommand( macroCmd );
02687 }
02688
02689 void KPrCanvas::setTextDepthPlus()
02690 {
02691 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02692 if ( lst.isEmpty() ) return;
02693 double leftMargin=0.0;
02694 if(!lst.isEmpty())
02695 leftMargin=lst.first()->currentParagLayoutFormat()->margins[QStyleSheetItem::MarginLeft];
02696 double indent = m_view->kPresenterDoc()->getIndentValue();
02697 double newVal = leftMargin + indent;
02698 QPtrListIterator<KoTextFormatInterface> it( lst );
02699 KMacroCommand* macroCmd = 0L;
02700 for ( ; it.current() ; ++it ) {
02701 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginLeft, newVal);
02702 if ( cmd )
02703 {
02704 if ( !macroCmd )
02705 macroCmd = new KMacroCommand( i18n("Increase Paragraph Depth") );
02706 macroCmd->addCommand( cmd );
02707 }
02708 }
02709 if ( macroCmd )
02710 m_view->kPresenterDoc()->addCommand( macroCmd );
02711 if(!lst.isEmpty())
02712 {
02713 const KoParagLayout *layout=lst.first()->currentParagLayoutFormat();
02714 m_view->showRulerIndent( layout->margins[QStyleSheetItem::MarginLeft], layout->margins[QStyleSheetItem::MarginFirstLine],
02715 layout->margins[QStyleSheetItem::MarginRight], lst.first()->rtl());
02716 }
02717 }
02718
02719 void KPrCanvas::setTextDepthMinus()
02720 {
02721 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02722 if ( lst.isEmpty() ) return;
02723 double leftMargin=0.0;
02724 if(!lst.isEmpty())
02725 leftMargin=lst.first()->currentParagLayoutFormat()->margins[QStyleSheetItem::MarginLeft];
02726 double indent = m_view->kPresenterDoc()->getIndentValue();
02727 QPtrListIterator<KoTextFormatInterface> it( lst );
02728 double newVal = leftMargin - indent;
02729 KMacroCommand* macroCmd = 0L;
02730 for ( ; it.current() ; ++it ) {
02731 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginLeft, QMAX( newVal, 0 ));
02732 if ( cmd )
02733 {
02734 if ( !macroCmd )
02735 macroCmd = new KMacroCommand( i18n("Decrease Paragraph Depth") );
02736 macroCmd->addCommand( cmd );
02737 }
02738 }
02739 if (macroCmd )
02740 m_view->kPresenterDoc()->addCommand( macroCmd );
02741 if(!lst.isEmpty())
02742 {
02743 const KoParagLayout *layout=lst.first()->currentParagLayoutFormat();
02744 m_view->showRulerIndent( layout->margins[QStyleSheetItem::MarginLeft], layout->margins[QStyleSheetItem::MarginFirstLine],
02745 layout->margins[QStyleSheetItem::MarginRight], lst.first()->rtl());
02746 }
02747 }
02748
02749 void KPrCanvas::setNewFirstIndent(double _firstIndent)
02750 {
02751 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02752 if ( lst.isEmpty() ) return;
02753 QPtrListIterator<KoTextFormatInterface> it( lst );
02754 KMacroCommand* macroCmd = 0L;
02755 for ( ; it.current() ; ++it ) {
02756 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginFirstLine, _firstIndent);
02757 if ( cmd )
02758 {
02759 if ( !macroCmd )
02760 macroCmd = new KMacroCommand( i18n("Change First Line Indent") );
02761 macroCmd->addCommand( cmd );
02762 }
02763 }
02764 if ( macroCmd )
02765 m_view->kPresenterDoc()->addCommand( macroCmd );
02766 }
02767
02768 void KPrCanvas::setNewLeftIndent(double _leftIndent)
02769 {
02770 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02771 if ( lst.isEmpty() ) return;
02772 QPtrListIterator<KoTextFormatInterface> it( lst );
02773 KMacroCommand* macroCmd = 0L;
02774 for ( ; it.current() ; ++it ) {
02775 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginLeft, _leftIndent);
02776 if ( cmd )
02777 {
02778 if ( !macroCmd )
02779 macroCmd = new KMacroCommand( i18n("Change Left Indent") );
02780 macroCmd->addCommand( cmd );
02781 }
02782 }
02783 if ( macroCmd )
02784 m_view->kPresenterDoc()->addCommand( macroCmd );
02785 }
02786
02787 void KPrCanvas::setNewRightIndent(double _rightIndent)
02788 {
02789 QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02790 if ( lst.isEmpty() ) return;
02791 QPtrListIterator<KoTextFormatInterface> it( lst );
02792 KMacroCommand* macroCmd = 0L;
02793 for ( ; it.current() ; ++it ) {
02794 KCommand* cmd = it.current()->setMarginCommand(QStyleSheetItem::MarginRight, _rightIndent);
02795 if ( cmd )
02796 {
02797 if ( !macroCmd )
02798 macroCmd = new KMacroCommand( i18n("Change Right Indent") );
02799 macroCmd->addCommand( cmd );
02800 }
02801 }
02802 if ( macroCmd )
02803 m_view->kPresenterDoc()->addCommand( macroCmd );
02804 }
02805
02806
02807
02808
02809
02810
02811
02812
02813
02814
02815
02816
02817
02818
02819
02820
02821
02822
02823
02824
02825 #ifndef NDEBUG
02826 void KPrCanvas::printRTDebug( int info )
02827 {
02828 KPrTextObject *kpTxtObj = 0;
02829 if ( m_currentTextObjectView )
02830 kpTxtObj = m_currentTextObjectView->kpTextObject();
02831 else
02832 kpTxtObj = selectedTextObjs().first();
02833 if ( kpTxtObj )
02834 kpTxtObj->textObject()->printRTDebug( info );
02835 }
02836 #endif
02837
02838 bool KPrCanvas::haveASelectedPartObj() const
02839 {
02840 return m_activePage->haveASelectedPartObj();
02841 }
02842
02843 bool KPrCanvas::haveASelectedGroupObj() const
02844 {
02845 return m_activePage->haveASelectedGroupObj();
02846 }
02847
02848 bool KPrCanvas::haveASelectedPixmapObj() const
02849 {
02850 return m_activePage->haveASelectedPixmapObj();
02851 }
02852
02853 QPtrList<KPrTextObject> KPrCanvas::applicableTextObjects() const
02854 {
02855 QPtrList<KPrTextObject> lst;
02856
02857 if ( m_currentTextObjectView )
02858 lst.append( m_currentTextObjectView->kpTextObject() );
02859 else
02860 lst = selectedTextObjs();
02861 return lst;
02862 }
02863
02864 QPtrList<KoTextFormatInterface> KPrCanvas::applicableTextInterfaces() const
02865 {
02866 QPtrList<KoTextFormatInterface> lst;
02867 QPtrList<KPrObject> lstObj;
02868
02869 if ( m_currentTextObjectView )
02870 {
02871 if ( !m_currentTextObjectView->kpTextObject()->isProtectContent())
02872 lst.append( m_currentTextObjectView );
02873 }
02874 else
02875 {
02876 m_activePage->getAllObjectSelectedList(lstObj);
02877 QPtrListIterator<KPrObject> it(lstObj);
02878 for ( ; it.current(); ++it ) {
02879 if ( it.current()->getType() == OT_TEXT )
02880 {
02881 KPrTextObject * obj = static_cast<KPrTextObject*>( it.current() );
02882 if ( !obj->isProtectContent() )
02883 lst.append( obj->textObject() );
02884 }
02885 }
02886 }
02887 return lst;
02888 }
02889
02890 QPtrList<KPrTextObject> KPrCanvas::selectedTextObjs() const
02891 {
02892 QPtrList<KPrTextObject> lst;
02893 QPtrListIterator<KPrObject> it(getObjectList());
02894 for ( ; it.current(); ++it ) {
02895 if ( it.current()->isSelected() && it.current()->getType() == OT_TEXT )
02896 lst.append( static_cast<KPrTextObject*>( it.current() ) );
02897 }
02898 return lst;
02899 }
02900
02901 void KPrCanvas::startScreenPresentation( double zoomX, double zoomY, int curPgNum )
02902 {
02903
02904
02905
02906 m_presMenu->setItemChecked( PM_DM, false );
02907
02908 setCursor( waitCursor );
02909
02910 exitEditMode();
02911
02912 KPrDocument * doc = m_view->kPresenterDoc();
02913
02914
02915
02916 double zoom = kMin( zoomX, zoomY );
02917
02918 kdDebug() << "zoomX=" << zoomX << " zoomY=" << zoomY << " zoom=" << zoom << endl;
02919
02920 m_zoomBeforePresentation = doc->zoomHandler()->zoom();
02921 kdDebug() << "old zoomed resolutions =" << doc->zoomHandler()->zoomedResolutionX() << "," << doc->zoomHandler()->zoomedResolutionY() << endl;
02922
02923
02924
02925
02926 doc->zoomHandler()->setZoomAndResolution( qRound( zoom * m_zoomBeforePresentation ),
02927 KoGlobal::dpiX(), KoGlobal::dpiY() );
02928
02929 doc->newZoomAndResolution( false, false );
02930
02931
02932 m_presentationSlides.clear();
02933 QValueList<int> selected = doc->displaySelectedSlides();
02934 for ( QValueList<int>::Iterator it = selected.begin() ; it != selected.end(); ++ it )
02935 {
02936
02937
02938 int slideno = *it + 1;
02939 m_presentationSlides.append( slideno );
02940 }
02941
02942
02943 if( !m_presentationSlides.count() )
02944 {
02945
02946 stopScreenPresentation();
02947 return;
02948 }
02949
02950
02951 unsigned slide = 0;
02952 for( unsigned i = 0; i<m_presentationSlides.count(); i++ )
02953 if( m_presentationSlides[i] >= curPgNum )
02954 {
02955 slide = m_presentationSlides[i];
02956 break;
02957 }
02958
02959 setCursor( blankCursor );
02960
02961 m_step.m_pageNumber = (unsigned int) -1;
02962 gotoPage( slide );
02963
02964 }
02965
02966 void KPrCanvas::stopScreenPresentation()
02967 {
02968
02969 setCursor( waitCursor );
02970
02971 KPrDocument * doc = m_view->kPresenterDoc();
02972 doc->zoomHandler()->setZoomAndResolution( m_zoomBeforePresentation,
02973 KoGlobal::dpiX(), KoGlobal::dpiY() );
02974 doc->newZoomAndResolution(false,false);
02975 goingBack = false;
02976 m_step.m_pageNumber = 0;
02977 editMode = true;
02978 m_drawMode = false;
02979 repaint( false );
02980 setToolEditMode( toolEditMode );
02981 setWFlags( WResizeNoErase );
02982 }
02983
02984 bool KPrCanvas::pNext( bool gotoNextPage )
02985 {
02986 goingBack = false;
02987
02988 bool objectEffectFinished = finishObjectEffects();
02989
02990 KPrDocument * doc = m_view->kPresenterDoc();
02991
02992 if ( !gotoNextPage )
02993 {
02994 if ( finishPageEffect() )
02995 return false;
02996
02997
02998 m_drawModeLines.clear();
02999
03000
03001
03002
03003
03004 QPtrListIterator<KPrObject> oit( doc->pageList().at( m_step.m_pageNumber )->objectList() );
03005 for ( int i = 0 ; oit.current(); ++oit, ++i )
03006 {
03007 KPrObject *kpobject = oit.current();
03008 if ( kpobject->getAppearStep() == static_cast<int>( m_step.m_step )
03009 && kpobject->getType() == OT_TEXT && kpobject->getEffect2() != EF2_NONE )
03010 {
03011 if ( static_cast<int>( m_step.m_subStep + 1 ) < kpobject->getSubPresSteps() )
03012 {
03013 m_step.m_subStep++;
03014
03015 doObjEffects();
03016 return false;
03017 }
03018 }
03019 }
03020
03021
03022 if ( m_step.m_step < *( --m_pageEffectSteps.end() ) )
03023 {
03024 QValueList<int>::ConstIterator it = m_pageEffectSteps.find( m_step.m_step );
03025 m_step.m_step = *( ++it );
03026 m_step.m_subStep = 0;
03027
03028
03029
03030 if ( m_step.m_step == 0 )
03031 {
03032 QPainter p;
03033 p.begin( this );
03034 drawBackground( &p,
03035 QRect( 0, 0, kapp->desktop()->width(), kapp->desktop()->height() ),
03036 doc->pageList().at( m_step.m_pageNumber ) );
03037 p.end();
03038 }
03039
03040 doObjEffects();
03041 return false;
03042 }
03043
03044
03045
03046
03047
03048 if ( objectEffectFinished )
03049 return false;
03050 }
03051
03052
03053 QValueList<int>::ConstIterator test( m_presentationSlidesIterator );
03054 if ( ++test != m_presentationSlides.end() )
03055 {
03056 if ( !spManualSwitch() && m_setPageTimer )
03057 {
03058
03059 m_view->setAutoPresTimer( doc->pageList().at( (*m_presentationSlidesIterator) - 1 )->getPageTimer() / 1 );
03060 m_setPageTimer = false;
03061 return false;
03062 }
03063 m_setPageTimer = true;
03064
03065 QRect desk = KGlobalSettings::desktopGeometry(this);
03066 QPixmap _pix1( desk.width(), desk.height() );
03067 drawCurrentPageInPix( _pix1 );
03068
03069 m_view->setPageDuration( m_step.m_pageNumber );
03070
03071 m_step.m_pageNumber = *( ++m_presentationSlidesIterator ) - 1;
03072 m_step.m_subStep = 0;
03073
03074 m_pageEffectSteps = doc->getPageEffectSteps( m_step.m_pageNumber );
03075 m_step.m_step = *m_pageEffectSteps.begin();
03076
03077 QPixmap _pix2( desk.width(), desk.height() );
03078 drawCurrentPageInPix( _pix2 );
03079
03080 QValueList<int>::ConstIterator it( m_presentationSlidesIterator );
03081 --it;
03082
03083 KPrPage * page = doc->pageList().at( ( *it ) - 1 );
03084 PageEffect _pageEffect = page->getPageEffect();
03085
03086 bool _soundEffect = page->getPageSoundEffect();
03087 QString _soundFileName = page->getPageSoundFileName();
03088
03089 if ( _soundEffect && !_soundFileName.isEmpty() ) {
03090 stopSound();
03091 playSound( _soundFileName );
03092 }
03093
03094 if ( m_pageEffect )
03095 finishPageEffect();
03096
03097 m_pageEffect = new KPrPageEffects( this, _pix2, _pageEffect, page->getPageEffectSpeed() );
03098 if ( m_pageEffect->doEffect() )
03099 {
03100 delete m_pageEffect;
03101 m_pageEffect = 0;
03102
03103 doObjEffects( true );
03104 }
03105 else
03106 {
03107 connect( &m_pageEffectTimer, SIGNAL( timeout() ), SLOT( slotDoPageEffect() ) );
03108 m_pageEffectTimer.start( 50, true );
03109 }
03110
03111 return true;
03112 }
03113
03114
03115
03116
03117
03118 if ( ( spManualSwitch() || !spInfiniteLoop() ) && !showingLastSlide )
03119 {
03120 m_view->setPageDuration( m_step.m_pageNumber );
03121
03122 QRect desk = KGlobalSettings::desktopGeometry(this);
03123 QPixmap lastSlide( desk.width(), desk.height() );
03124 QFont font( m_view->kPresenterDoc()->defaultFont().family() );
03125 QPainter p( &lastSlide );
03126
03127 p.setFont( font );
03128 p.setPen( white );
03129 p.fillRect( p.viewport(), black );
03130 p.drawText( 50, 50, i18n( "End of presentation. Click to exit." ) );
03131 bitBlt( this, 0, 0, &lastSlide, 0, 0, lastSlide.width(), lastSlide.height() );
03132 showingLastSlide = true;
03133 emit stopAutomaticPresentation();
03134 }
03135 else if ( showingLastSlide )
03136 {
03137 showingLastSlide = false;
03138 m_view->screenStop();
03139 }
03140 else
03141 {
03142 m_view->setPageDuration( m_step.m_pageNumber );
03143 emit restartPresentation();
03144 m_view->setAutoPresTimer( 1 );
03145 }
03146
03147 return false;
03148 }
03149
03150 bool KPrCanvas::pPrev( bool gotoPreviousPage )
03151 {
03152 goingBack = true;
03153 m_step.m_subStep = 0;
03154
03155
03156 m_drawModeLines.clear();
03157
03158 if ( !gotoPreviousPage && m_step.m_step > *m_pageEffectSteps.begin() ) {
03159 QValueList<int>::ConstIterator it = m_pageEffectSteps.find( m_step.m_step );
03160 m_step.m_step = *( --it );
03161
03162 m_step.m_subStep = 1000;
03163 repaint( false );
03164 return false;
03165 } else {
03166
03167 if ( m_presentationSlidesIterator == m_presentationSlides.begin() ) {
03168 m_pageEffectSteps = m_view->kPresenterDoc()->getPageEffectSteps( m_step.m_pageNumber );
03169 m_step.m_step = *m_pageEffectSteps.begin();
03170 goingBack = false;
03171 doObjEffects();
03172 return false;
03173 }
03174 m_view->setPageDuration( m_step.m_pageNumber );
03175
03176 m_step.m_pageNumber = *( --m_presentationSlidesIterator ) - 1;
03177
03178 KPrDocument * doc = m_view->kPresenterDoc();
03179
03180 m_pageEffectSteps = doc->getPageEffectSteps( m_step.m_pageNumber );
03181
03182 if ( gotoPreviousPage )
03183 {
03184 m_step.m_step = *( m_pageEffectSteps.begin() );
03185 goingBack = false;
03186 doObjEffects();
03187 }
03188 else
03189 {
03190 m_step.m_step = *( --m_pageEffectSteps.end() );
03191 repaint( false );
03192 }
03193
03194 return true;
03195 }
03196
03197 return false;
03198 }
03199
03200 bool KPrCanvas::canAssignEffect( QPtrList<KPrObject> &objs ) const
03201 {
03202 QPtrListIterator<KPrObject> oIt( m_activePage->objectList() );
03203 for (; oIt.current(); ++oIt )
03204 {
03205
03206 if(m_view->kPresenterDoc()->isHeaderFooter(oIt.current()))
03207 continue;
03208 if ( oIt.current()->isSelected() )
03209 objs.append( oIt.current() );
03210 }
03211 return !objs.isEmpty();
03212 }
03213
03214 bool KPrCanvas::isOneObjectSelected() const
03215 {
03216 return m_activePage->isOneObjectSelected();
03217 }
03218
03219
03220
03221
03222
03223
03224
03225 void KPrCanvas::drawPageInPix( QPixmap &_pix, int pgnum, int zoom,
03226 bool forceRealVariableValue,
03227 int forceWidth,
03228 int forceHeight )
03229 {
03230
03231
03232 KPrDocument *doc = m_view->kPresenterDoc();
03233 int oldZoom = doc->zoomHandler()->zoom();
03234 bool oldDisplayFieldValue = false;
03235
03236 if( 0 < forceWidth || 0 < forceHeight )
03237 {
03238 const QRect rect( doc->getPageRect( true ) );
03239 const double dRectHeight = static_cast<double>(rect.height());
03240 const double dRectWidth = static_cast<double>(rect.width());
03241 double dForceHeight = static_cast<double>(forceHeight);
03242 double dForceWidth = static_cast<double>(forceWidth);
03243
03244
03245 if( 0 >= forceWidth )
03246 dForceWidth = dForceHeight * dRectWidth / dRectHeight;
03247 else if( 0 >= forceHeight )
03248 dForceHeight = dForceWidth * dRectHeight / dRectWidth;
03249
03250
03251
03252 doc->zoomHandler()->setResolution( dForceWidth / dRectWidth,
03253 dForceHeight / dRectHeight );
03254
03255
03256 doc->newZoomAndResolution( false, false );
03257 }else{
03258 m_view->zoomDocument(zoom);
03259 }
03260
03261 if ( forceRealVariableValue )
03262 {
03263 oldDisplayFieldValue = m_view->kPresenterDoc()->getVariableCollection()->variableSetting()->displayFieldCode();
03264 if ( oldDisplayFieldValue )
03265 {
03266 m_view->kPresenterDoc()->getVariableCollection()->variableSetting()->setDisplayFieldCode(false);
03267 m_view->kPresenterDoc()->recalcVariables( VT_ALL );
03268 }
03269 }
03270
03271 KPrPage * page = m_view->kPresenterDoc()->pageList().at(pgnum);
03272 QRect rect = page->getZoomPageRect( );
03273 _pix.resize( rect.size() );
03274 _pix.fill( Qt::white );
03275
03276 QPainter p;
03277 p.begin( &_pix );
03278
03279 bool _editMode = editMode;
03280 editMode = false;
03281
03282 drawBackground( &p, _pix.rect(), page, true );
03283
03284
03285 if ( page->masterPage() && page->displayObjectFromMasterPage() )
03286 drawAllObjectsInPage( &p, page->masterPage()->objectList(), pgnum );
03287
03288
03289 drawAllObjectsInPage( &p, page->objectList(), pgnum );
03290
03291 editMode = _editMode;
03292 p.end();
03293
03294 if ( forceRealVariableValue )
03295 {
03296 if ( oldDisplayFieldValue )
03297 {
03298 m_view->kPresenterDoc()->getVariableCollection()->variableSetting()->setDisplayFieldCode(true);
03299 m_view->kPresenterDoc()->recalcVariables( VT_ALL );
03300 }
03301 }
03302
03303 m_view->zoomDocument(oldZoom);
03304 }
03305
03306
03307
03308 void KPrCanvas::drawCurrentPageInPix( QPixmap &_pix ) const
03309 {
03310
03311
03312
03313 _pix.fill(Qt::black);
03314
03315 QPainter p;
03316 p.begin( &_pix );
03317
03318 drawBackground( &p, _pix.rect(), m_view->kPresenterDoc()->pageList().at( m_step.m_pageNumber ) );
03319 PresStep step( m_step.m_pageNumber, m_step.m_step, m_step.m_subStep, true, true );
03320 drawPresPage( &p, _pix.rect(), step );
03321
03322 p.end();
03323 }
03324
03325 void KPrCanvas::printPage( QPainter* painter, PresStep step, KPrinter *printer, int rows, int cols )
03326 {
03327
03328 KPrDocument *doc = m_view->kPresenterDoc();
03329 KPrPage* page = doc->pageList().at( step.m_pageNumber );
03330 QRect const rect = page->getZoomPageRect();
03331 bool const drawBorder = printer->option("kde-kpresenter-printslideborders").toInt() && rows>1 && cols>1;
03332
03333 int height = rect.height();
03334 int width = rect.width();
03335
03336 QPaintDeviceMetrics metrics( printer );
03337 int begin_left = ( metrics.width() - rect.width() );
03338 int begin_top = ( metrics.height() - rect.height() );
03339
03340 rows = cols = QMAX( rows, cols );
03341
03342 if ( rows > 1 )
03343 {
03344 height = ( ( height - 80 ) / rows ) - 20;
03345 begin_top = 40;
03346 }
03347 if ( cols > 1 )
03348 {
03349 width = (width -5) / cols;
03350 begin_left = 5;
03351 }
03352 int top = begin_top;
03353 int left = begin_left;
03354 for (int r = 0; r < rows; r++ )
03355 {
03356 for (int c = 0; c < cols; c++ )
03357 {
03358 page = doc->pageList().at( step.m_pageNumber );
03359 if ( !page )
03360 return;
03361 painter->setViewport( QRect(left, top, width, height) );
03362 drawBackground( painter, rect, page, true );
03363 drawPresPage( painter, rect, step );
03364 if ( drawBorder )
03365 painter->drawRect( rect );
03366 step.m_pageNumber++;
03367 left += width;
03368 }
03369 top += height + 20;
03370 left = begin_left;
03371 }
03372
03373 }
03374
03375 void KPrCanvas::doObjEffects( bool isAllreadyPainted )
03376 {
03377 if ( m_effectHandler )
03378 {
03379 m_effectTimer.stop();
03380 QObject::disconnect( &m_effectTimer, SIGNAL( timeout() ), this, SLOT( slotDoEffect() ) );
03381
03382 m_effectHandler->finish();
03383 delete m_effectHandler;
03384 m_effectHandler = 0;
03385 }
03386
03387 QPixmap screen_orig( kapp->desktop()->width(), kapp->desktop()->height() );
03388
03389 KPrPage *page = m_view->kPresenterDoc()->pageList().at( m_step.m_pageNumber );
03390
03391 if ( m_step.m_subStep == 0 && !isAllreadyPainted && isUpdatesEnabled() )
03392 {
03393
03394 QPainter p;
03395 p.begin( &screen_orig );
03396 QRect desktopRect = QRect( 0, 0, kapp->desktop()->width(), kapp->desktop()->height() );
03397 drawBackground( &p, desktopRect, page );
03398 PresStep step( m_step.m_pageNumber, m_step.m_step, m_step.m_subStep, true, true );
03399 drawPresPage( &p, desktopRect ,step );
03400 p.end();
03401 bitBlt( this, 0, 0, &screen_orig );
03402 }
03403 else
03404 {
03405 bitBlt( &screen_orig, 0, 0, this );
03406 }
03407
03408 QPtrList<KPrObject> allObjects;
03409
03410 if ( page->displayObjectFromMasterPage() )
03411 {
03412 QPtrListIterator<KPrObject> it( page->masterPage()->objectList() );
03413 for ( ; it.current(); ++it ) {
03414 if ( objectIsAHeaderFooterHidden( it.current() ) )
03415 continue;
03416 else
03417 allObjects.append( it.current() );
03418 }
03419 }
03420
03421 QPtrListIterator<KPrObject> it( page->objectList() );
03422 for ( ; it.current(); ++it )
03423 {
03424 allObjects.append( it.current() );
03425 }
03426
03427
03428 m_effectHandler = new KPrEffectHandler( m_step, goingBack, this, &screen_orig, allObjects, m_view, 1 );
03429 if ( m_effectHandler->doEffect() )
03430 {
03431 delete m_effectHandler;
03432 m_effectHandler = 0;
03433 }
03434 else
03435 {
03436 connect( &m_effectTimer, SIGNAL( timeout() ), SLOT( slotDoEffect() ) );
03437 m_effectTimer.start( 50, true );
03438 }
03439
03440 }
03441
03442 void KPrCanvas::slotDoEffect()
03443 {
03444 if ( m_effectHandler->doEffect() )
03445 {
03446 m_effectTimer.stop();
03447 QObject::disconnect( &m_effectTimer, SIGNAL( timeout() ), this, SLOT( slotDoEffect() ) );
03448 delete m_effectHandler;
03449 m_effectHandler = 0;
03450 }
03451 else
03452 {
03453 m_effectTimer.start( 50, true );
03454 }
03455 }
03456
03457
03458 void KPrCanvas::slotDoPageEffect()
03459 {
03460 if ( m_pageEffect->doEffect() )
03461 {
03462 m_pageEffectTimer.stop();
03463 QObject::disconnect( &m_pageEffectTimer, SIGNAL( timeout() ), this, SLOT( slotDoPageEffect() ) );
03464 delete m_pageEffect;
03465 m_pageEffect = 0;
03466
03467 doObjEffects( true );
03468 }
03469 else
03470 {
03471 m_pageEffectTimer.start( 50, true );
03472 }
03473 }
03474
03475 void KPrCanvas::slotAutoScroll(const QPoint &scrollDistance)
03476 {
03477
03478 QPoint d = scrollDistance;
03479 m_view->getHScrollBar()->setValue( m_view->getHScrollBar()->value() + d.x() );
03480 m_view->getVScrollBar()->setValue( m_view->getVScrollBar()->value() + d.y() );
03481 }
03482
03483
03484 bool KPrCanvas::finishObjectEffects()
03485 {
03486 bool finished = false;
03487 if ( m_effectHandler )
03488 {
03489 m_effectTimer.stop();
03490 QObject::disconnect( &m_effectTimer, SIGNAL( timeout() ), this, SLOT( slotDoEffect() ) );
03491 m_effectHandler->finish();
03492 delete m_effectHandler;
03493 m_effectHandler = 0;
03494 finished = true;
03495 }
03496 return finished;
03497 }
03498
03499
03500 bool KPrCanvas::finishPageEffect( bool cancel )
03501 {
03502 bool finished = false;
03503 if ( m_pageEffect )
03504 {
03505 m_pageEffectTimer.stop();
03506 QObject::disconnect( &m_pageEffectTimer, SIGNAL( timeout() ), this, SLOT( slotDoPageEffect() ) );
03507 if ( !cancel )
03508 m_pageEffect->finish();
03509 delete m_pageEffect;
03510 m_pageEffect = 0;
03511
03512 if ( !cancel )
03513 {
03514 doObjEffects( true );
03515 }
03516 else if ( !spManualSwitch() )
03517 {
03518 m_view->setAutoPresTimer( 1 );
03519 m_setPageTimer = true;
03520 }
03521
03522 finished = true;
03523 }
03524 return finished;
03525 }
03526
03527
03528 void KPrCanvas::print( QPainter *painter, KPrinter *printer, float , float )
03529 {
03530 PresStep step( 0, 1000, 1000 );
03531
03532 int i = 0;
03533
03534 repaint( false );
03535 kapp->processEvents();
03536
03537 editMode = false;
03538 fillBlack = false;
03539
03540
03541
03542
03543
03544
03545
03546 QProgressDialog progress( i18n( "Printing..." ), i18n( "Cancel" ),
03547 printer->pageList().count() + 2, this );
03548
03549 int j = 0;
03550 progress.setProgress( 0 );
03551
03552
03553 int rows = 1;
03554 int cols = 1;
03555 if ( !printer->previewOnly() )
03556 {
03557 rows = printer->option("kde-kpresenter-printrows").toInt();
03558 cols = printer->option("kde-kpresenter-printcolumns").toInt();
03559 }
03560 int const slides_per_page = rows * cols;
03561
03562
03563
03564
03565 int current_slide = 0;
03566 QValueList<int> list=printer->pageList();
03567 QValueList<int>::iterator it;
03568 for( it=list.begin();it!=list.end();++it)
03569 {
03570 i=(*it);
03571 progress.setProgress( ++j );
03572 kapp->processEvents();
03573
03574 if ( progress.wasCancelled() )
03575 break;
03576
03577 step.m_pageNumber = i - 1;
03578
03579 if ( step.m_pageNumber != current_slide )
03580 continue;
03581
03582 if ( !list.isEmpty() && i > list.first() )
03583 printer->newPage();
03584
03585 painter->resetXForm();
03586 painter->fillRect( m_view->kPresenterDoc()->pageList().at( m_step.m_pageNumber )->getZoomPageRect(), white );
03587
03588 printPage( painter, step, printer, rows, cols );
03589 kapp->processEvents();
03590
03591 painter->resetXForm();
03592 kapp->processEvents();
03593
03594 current_slide += slides_per_page;
03595
03596
03597
03598 }
03599
03600 KConfig *config=KPrFactory::global()->config();
03601 config->setGroup("Misc");
03602 bool printNotes = config->readBoolEntry("PrintNotes", true);
03603
03604 KPrNoteBar *noteBar = m_view->getNoteBar();
03605
03606 if ( noteBar && !noteBar->getNotesTextForPrinting(list).isEmpty()
03607 && !progress.wasCancelled() && printNotes )
03608 {
03609 printer->newPage();
03610 painter->resetXForm();
03611 noteBar->printNotes( painter, printer, list );
03612 painter->resetXForm();
03613 }
03614
03615 setToolEditMode( toolEditMode );
03616
03617
03618
03619 progress.setProgress( printer->pageList().count() + 2 );
03620
03621 fillBlack = true;
03622 editMode = true;
03623 repaint( false );
03624 }
03625
03626
03627 void KPrCanvas::updateInsertRect( const KoPoint &point, Qt::ButtonState state )
03628 {
03629 if ( state & AltButton )
03630 {
03631 m_insertRect.moveBottomRight( point );
03632 }
03633 else
03634 {
03635 m_insertRect.setRight( point.x() );
03636 m_insertRect.setBottom( point.y() );
03637 }
03638 }
03639
03640
03641 KPrTextObject* KPrCanvas::insertTextObject( const KoRect &rect )
03642 {
03643 KPrTextObject* obj = m_activePage->insertTextObject( rect );
03644 selectObj( obj );
03645 return obj;
03646 }
03647
03648 void KPrCanvas::insertLine( const KoPoint &startPoint, const KoPoint &endPoint )
03649 {
03650 KoRect rect( startPoint, endPoint );
03651 bool rev = rect.width() < 0 || rect.height() < 0;
03652 rect = rect.normalize();
03653 LineType lt = LT_LU_RD;
03654 if ( startPoint.x() == endPoint.x() )
03655 {
03656 lt = LT_VERT;
03657 rect.setLeft( rect.left() - 5.0 );
03658 rect.setRight( rect.right() + 5.0 );
03659 }
03660 else if ( startPoint.y() == endPoint.y() )
03661 {
03662 lt = LT_HORZ;
03663 rect.setTop( startPoint.y() - 5.0 );
03664 rect.setBottom( startPoint.y() + 5.0 );
03665 }
03666 else if ( ( startPoint.x() < endPoint.x() && startPoint.y() > endPoint.y() ) ||
03667 ( startPoint.x() > endPoint.x() && startPoint.y() < endPoint.y() ) )
03668 {
03669 lt = LT_LD_RU;
03670 }
03671 m_activePage->insertLine( rect, m_view->getPen(),
03672 !rev ? m_view->getLineBegin() : m_view->getLineEnd(), !rev ? m_view->getLineEnd() : m_view->getLineBegin(),
03673 lt );
03674 }
03675
03676
03677 void KPrCanvas::insertRect( const KoRect &rect )
03678 {
03679 m_activePage->insertRectangle( rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03680 m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(), m_view->getRndX(), m_view->getRndY(),
03681 m_view->getGUnbalanced(), m_view->getGXFactor(), m_view->getGYFactor() );
03682 }
03683
03684 void KPrCanvas::insertEllipse( const KoRect &rect )
03685 {
03686 m_activePage->insertCircleOrEllipse( rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03687 m_view->getGColor1(), m_view->getGColor2(),
03688 m_view->getGType(), m_view->getGUnbalanced(), m_view->getGXFactor(), m_view->getGYFactor() );
03689 }
03690
03691 void KPrCanvas::insertPie( const KoRect &rect )
03692 {
03693 m_activePage->insertPie( rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03694 m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(),
03695 m_view->getPieType(), m_view->getPieAngle(), m_view->getPieLength(),
03696 m_view->getLineBegin(), m_view->getLineEnd(), m_view->getGUnbalanced(), m_view->getGXFactor(),
03697 m_view->getGYFactor() );
03698 }
03699
03700 void KPrCanvas::insertAutoform( const KoRect &rect )
03701 {
03702 m_activePage->insertAutoform( rect, m_view->getPen(), m_view->getBrush(),
03703 m_view->getLineBegin(), m_view->getLineEnd(),
03704 m_view->getFillType(), m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(),
03705 autoform, m_view->getGUnbalanced(), m_view->getGXFactor(), m_view->getGYFactor() );
03706 }
03707
03708 KPrPartObject* KPrCanvas::insertObject( const KoRect &rect )
03709 {
03710 KPrPartObject *kpPartObject = m_activePage->insertObject( rect, partEntry );
03711 return kpPartObject;
03712 }
03713
03714 void KPrCanvas::insertFreehand( const KoPointArray &_pointArray )
03715 {
03716 KoRect rect = _pointArray.boundingRect();
03717
03718 m_activePage->insertFreehand( getObjectPoints( _pointArray ), rect, m_view->getPen(), m_view->getLineBegin(),
03719 m_view->getLineEnd() );
03720
03721 m_pointArray = KoPointArray();
03722 m_indexPointArray = 0;
03723 }
03724
03725 void KPrCanvas::insertPolyline( const KoPointArray &_pointArray )
03726 {
03727 if( _pointArray.count()> 1)
03728 {
03729 KoRect rect = _pointArray.boundingRect();
03730 m_activePage->insertPolyline( getObjectPoints( _pointArray ), rect, m_view->getPen(), m_view->getLineBegin(),
03731 m_view->getLineEnd() );
03732 }
03733 m_pointArray = KoPointArray();
03734 m_indexPointArray = 0;
03735 }
03736
03737 void KPrCanvas::insertCubicBezierCurve( const KoPointArray &_pointArray )
03738 {
03739 if ( _pointArray.count() > 1 )
03740 {
03741 KoPointArray points( _pointArray );
03742 KoPointArray bezierPoints( KPrBezierCurveObject::bezier2polyline( _pointArray ) );
03743 KoRect rect = bezierPoints.boundingRect();
03744 points = getObjectPoints( points );
03745 bezierPoints = getObjectPoints( bezierPoints );
03746
03747 if ( toolEditMode == INS_CUBICBEZIERCURVE )
03748 {
03749 m_activePage->insertCubicBezierCurve( points, bezierPoints, rect, m_view->getPen(),
03750 m_view->getLineBegin(), m_view->getLineEnd() );
03751 }
03752 else if ( toolEditMode == INS_QUADRICBEZIERCURVE )
03753 {
03754 m_activePage->insertQuadricBezierCurve( points, bezierPoints, rect, m_view->getPen(),
03755 m_view->getLineBegin(), m_view->getLineEnd() );
03756 }
03757 else if ( toolEditMode == INS_CLOSED_CUBICBEZIERCURVE ||
03758 toolEditMode == INS_CLOSED_QUADRICBEZIERCURVE )
03759 {
03760 m_activePage->insertClosedLine( bezierPoints, rect, m_view->getPen(), m_view->getBrush(),
03761 m_view->getFillType(), m_view->getGColor1(), m_view->getGColor2(),
03762 m_view->getGType(), m_view->getGUnbalanced(),
03763 m_view->getGXFactor(), m_view->getGYFactor(), toolEditMode );
03764 }
03765 }
03766 m_pointArray = KoPointArray();
03767 m_indexPointArray = 0;
03768 }
03769
03770 void KPrCanvas::insertPolygon( const KoPointArray &_pointArray )
03771 {
03772 KoRect rect = _pointArray.boundingRect();
03773
03774 m_activePage->insertPolygon( getObjectPoints( _pointArray ), rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03775 m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(), m_view->getGUnbalanced(),
03776 m_view->getGXFactor(), m_view->getGYFactor(),
03777 m_view->getCheckConcavePolygon(), m_view->getCornersValue(), m_view->getSharpnessValue() );
03778
03779 m_pointArray = KoPointArray();
03780 m_indexPointArray = 0;
03781 }
03782
03783 void KPrCanvas::insertPicture( const KoRect &rect )
03784 {
03785 QString file = m_activePage->insPictureFile();
03786
03787 QCursor c = cursor();
03788 setCursor( waitCursor );
03789 if ( !file.isEmpty() ) {
03790 if ( rect.width() > 10 && rect.height() > 10 )
03791 {
03792 m_activePage->insertPicture( file, rect );
03793 }
03794 else
03795 {
03796 KoPoint tl( rect.topLeft() );
03797 m_activePage->insertPicture( file, tl );
03798 }
03799 m_activePage->setInsPictureFile( QString::null );
03800 }
03801 setCursor( c );
03802 }
03803
03804 void KPrCanvas::insertClosedLine( const KoPointArray &_pointArray )
03805 {
03806 KoRect rect = _pointArray.boundingRect();
03807
03808 m_activePage->insertClosedLine( getObjectPoints( _pointArray ), rect, m_view->getPen(), m_view->getBrush(), m_view->getFillType(),
03809 m_view->getGColor1(), m_view->getGColor2(), m_view->getGType(), m_view->getGUnbalanced(),
03810 m_view->getGXFactor(), m_view->getGYFactor(), toolEditMode );
03811
03812 m_pointArray = KoPointArray();
03813 m_indexPointArray = 0;
03814 }
03815
03816 void KPrCanvas::setToolEditMode( ToolEditMode _m, bool updateView )
03817 {
03818
03819 if ( ( toolEditMode == INS_POLYLINE || toolEditMode == INS_CLOSED_POLYLINE ) && !m_pointArray.isNull())
03820 endDrawPolyline();
03821
03822 if ( ( toolEditMode == INS_CUBICBEZIERCURVE || toolEditMode == INS_QUADRICBEZIERCURVE
03823 || toolEditMode == INS_CLOSED_CUBICBEZIERCURVE || toolEditMode == INS_CLOSED_QUADRICBEZIERCURVE ) && !m_pointArray.isNull() )
03824 endDrawCubicBezierCurve();
03825
03826 exitEditMode();
03827 toolEditMode = _m;
03828
03829 if ( toolEditMode == TEM_MOUSE )
03830 {
03831 setCursor( arrowCursor );
03832 QPoint pos = QCursor::pos();
03833
03834 KoPoint docPoint( m_view->zoomHandler()->unzoomPoint( pos ) );
03835 KPrObject *obj=m_activePage->getCursor( pos);
03836 if(obj)
03837 setCursor( obj->getCursor( docPoint, modType, m_view->kPresenterDoc() ) );
03838 }
03839 else if ( toolEditMode == INS_FREEHAND || toolEditMode == INS_CLOSED_FREEHAND )
03840 setCursor( KPrUtils::penCursor() );
03841 else if ( toolEditMode == TEM_ROTATE )
03842 setCursor( KPrUtils::rotateCursor() );
03843 else
03844 setCursor( crossCursor );
03845
03846 if ( updateView )
03847 m_view->setTool( toolEditMode );
03848 }
03849
03850
03851 void KPrCanvas::endDrawPolyline()
03852 {
03853 m_drawPolyline = false;
03854
03855 if ( toolEditMode == INS_POLYLINE )
03856 insertPolyline( m_pointArray );
03857 else if ( toolEditMode == INS_CLOSED_POLYLINE )
03858 insertClosedLine( m_pointArray );
03859
03860 emit objectSelectedChanged();
03861 if ( toolEditMode != TEM_MOUSE && editMode )
03862 repaint( false );
03863 m_view->disableAutoScroll();
03864 mousePressed = false;
03865 modType = MT_NONE;
03866 }
03867
03868 void KPrCanvas::endDrawCubicBezierCurve()
03869 {
03870 m_drawCubicBezierCurve = false;
03871 m_oldCubicBezierPointArray = KoPointArray();
03872 insertCubicBezierCurve( m_pointArray );
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::selectNext()
03882 {
03883 if ( objectList().count() == 0 ) return;
03884
03885 if ( m_activePage->numSelected() == 0 )
03886 objectList().at( 0 )->setSelected( true );
03887 else {
03888 int i = objectList().findRef( m_activePage->getSelectedObj() );
03889 if ( i < static_cast<int>( objectList().count() ) - 1 ) {
03890 m_view->kPresenterDoc()->deSelectAllObj();
03891 objectList().at( ++i )->setSelected( true );
03892 } else {
03893 m_view->kPresenterDoc()->deSelectAllObj();
03894 objectList().at( 0 )->setSelected( true );
03895 }
03896 }
03897 m_view->showObjectRect( m_activePage->getSelectedObj() );
03898 _repaint( false );
03899 }
03900
03901 void KPrCanvas::selectPrev()
03902 {
03903 if ( objectList().count() == 0 ) return;
03904 if ( m_activePage->numSelected() == 0 )
03905 objectList().at( objectList().count() - 1 )->setSelected( true );
03906 else {
03907 int i = objectList().findRef( m_activePage->getSelectedObj() );
03908 if ( i > 0 ) {
03909 m_view->kPresenterDoc()->deSelectAllObj();
03910 objectList().at( --i )->setSelected( true );
03911 } else {
03912 m_view->kPresenterDoc()->deSelectAllObj();
03913 objectList().at( objectList().count() - 1 )->setSelected( true );
03914 }
03915 }
03916 m_view->showObjectRect( m_activePage->getSelectedObj() );
03917 _repaint( false );
03918 }
03919
03920 void KPrCanvas::dragEnterEvent( QDragEnterEvent *e )
03921 {
03922 if ( m_currentTextObjectView )
03923 m_currentTextObjectView->dragEnterEvent( e );
03924 else if ( QTextDrag::canDecode( e )
03925 || QImageDrag::canDecode( e )
03926 || KURLDrag::canDecode(e)) {
03927 e->accept();
03928 }
03929 else
03930 e->ignore();
03931 }
03932
03933 void KPrCanvas::dragMoveEvent( QDragMoveEvent *e )
03934 {
03935 if( m_currentTextObjectView)
03936 {
03937 KPrTextObject * obj = textUnderMouse( e->pos());
03938 bool emitChanged = false;
03939 if ( obj )
03940 emitChanged = checkCurrentTextEdit( obj );
03941 if ( m_currentTextObjectView )
03942 {
03943 m_currentTextObjectView->dragMoveEvent( e, QPoint() );
03944 if ( emitChanged )
03945 emit currentObjectEditChanged();
03946 }
03947 }
03948 else if ( QTextDrag::canDecode( e )
03949 || QImageDrag::canDecode( e )
03950 || KURLDrag::canDecode(e)) {
03951 e->accept();
03952 }
03953 else
03954 e->ignore();
03955 }
03956
03957 void KPrCanvas::dropImage( QMimeSource * data, bool resizeImageToOriginalSize, int posX, int posY )
03958 {
03959 setToolEditMode( TEM_MOUSE );
03960 deSelectAllObj();
03961
03962 QImage pix;
03963 QImageDrag::decode( data, pix );
03964
03965 KTempFile tmpFile;
03966 tmpFile.setAutoDelete(true);
03967
03968 if( tmpFile.status() != 0 )
03969 return;
03970
03971 pix.save( tmpFile.name(), "PNG" );
03972 QCursor c = cursor();
03973 setCursor( waitCursor );
03974
03975 QPoint pos( posX + diffx(), posY + diffy() );
03976 KoPoint docPoint( m_view->zoomHandler()->unzoomPoint( pos ) );
03977
03978 m_activePage->insertPicture( tmpFile.name(), docPoint );
03979
03980 tmpFile.close();
03981
03982 if ( resizeImageToOriginalSize )
03983 picViewOriginalSize();
03984 setCursor( c );
03985 }
03986
03987 void KPrCanvas::dropEvent( QDropEvent *e )
03988 {
03989
03990 KoPoint docPoint = m_view->zoomHandler()->unzoomPoint( e->pos()+QPoint(diffx(),diffy()) );
03991 if ( !m_activePage->getZoomPageRect().contains(e->pos()))
03992 return;
03993
03994 if ( QImageDrag::canDecode( e ) ) {
03995 dropImage( e, true, e->pos().x(), e->pos().y() );
03996 e->accept();
03997 } else if ( KURLDrag::canDecode( e ) ) {
03998 setToolEditMode( TEM_MOUSE );
03999 deSelectAllObj();
04000
04001 KURL::List lst;
04002 KURLDrag::decode( e, lst );
04003
04004 KURL::List::ConstIterator it = lst.begin();
04005 for ( ; it != lst.end(); ++it ) {
04006 const KURL &url( *it );
04007
04008 QString filename;
04009 if ( !url.isLocalFile() ) {
04010 if ( !KIO::NetAccess::download( url, filename, this ) )
04011 continue;
04012 } else {
04013 filename = url.path();
04014 }
04015
04016 KMimeMagicResult *res = KMimeMagic::self()->findFileType( filename );
04017
04018 if ( res && res->isValid() ) {
04019 QString mimetype = res->mimeType();
04020 if ( mimetype.contains( "image" ) ) {
04021 QCursor c = cursor();
04022 setCursor( waitCursor );
04023 m_activePage->insertPicture( filename, docPoint );
04024 setCursor( c );
04025 } else if ( mimetype.contains( "text" ) ) {
04026 QCursor c = cursor();
04027 setCursor( waitCursor );
04028 QFile f( filename );
04029 QTextStream t( &f );
04030 QString text = QString::null, tmp;
04031 kdDebug()<<" filename :"<<filename<<endl;
04032 if ( f.open( IO_ReadOnly ) ) {
04033 while ( !t.eof() ) {
04034 tmp = t.readLine();
04035 tmp += "\n";
04036 text.append( tmp );
04037 }
04038 f.close();
04039 }
04040 kdDebug()<<" text :"<<endl;
04041 m_activePage->insertTextObject( m_view->zoomHandler()->unzoomRect(QRect( e->pos().x(), e->pos().y(), 250, 250 )),
04042 text, m_view );
04043
04044 setCursor( c );
04045 }
04046 }
04047 KIO::NetAccess::removeTempFile( filename );
04048 }
04049 }
04050 else if (m_currentTextObjectView)
04051 {
04052 m_currentTextObjectView->dropEvent( e );
04053 }
04054 else if ( QTextDrag::canDecode( e ) ) {
04055 setToolEditMode( TEM_MOUSE );
04056 deSelectAllObj();
04057
04058 QString text;
04059 QTextDrag::decode( e, text );
04060
04061 m_activePage->insertTextObject( m_view->zoomHandler()->unzoomRect( QRect( e->pos().x(), e->pos().y(), 250, 250 )),
04062 text, m_view );
04063 e->accept();
04064 } else
04065 e->ignore();
04066
04067 }
04068
04069 void KPrCanvas::slotGotoPage()
04070 {
04071 setSwitchingMode( false );
04072
04073 int pg = m_step.m_pageNumber + 1;
04074
04075 m_view->setPageDuration( m_step.m_pageNumber );
04076
04077 pg = KPrGotoPage::gotoPage( m_view->kPresenterDoc(), m_presentationSlides, pg, this );
04078 gotoPage( pg );
04079
04080 if ( !spManualSwitch() ) {
04081 m_view->setAutoPresTimer( 1 );
04082 m_setPageTimer = true;
04083 }
04084 }
04085
04086 void KPrCanvas::gotoPage( int pg )
04087 {
04088 int page = pg - 1;
04089 if ( page != m_step.m_pageNumber || m_step.m_step != *m_pageEffectSteps.begin() || m_step.m_subStep != 0 ) {
04090
04091 m_drawModeLines.clear();
04092 goingBack = false;
04093
04094 m_step.m_pageNumber = page;
04095 kdDebug(33001) << "Page::gotoPage m_step.m_pageNumber =" << m_step.m_pageNumber << endl;
04096 m_presentationSlidesIterator = m_presentationSlides.find( m_step.m_pageNumber + 1 );
04097 editMode = false;
04098 m_drawMode = false;
04099 m_pageEffectSteps = m_view->kPresenterDoc()->getPageEffectSteps( m_step.m_pageNumber );
04100 m_step.m_step = *m_pageEffectSteps.begin();
04101 m_step.m_subStep = 0;
04102 #if 0
04103 QRect desk = KGlobalSettings::desktopGeometry(this);
04104 resize( desk.width(), desk.height() );
04105 #endif
04106 doObjEffects();
04107 setFocus();
04108 m_view->refreshPageButton();
04109 }
04110 }
04111
04112 void KPrCanvas::presGotoFirstPage()
04113 {
04114 gotoPage( *m_presentationSlides.begin() );
04115 }
04116
04117 KPrTextObject* KPrCanvas::kpTxtObj() const
04118 {
04119 return ( ( m_editObject && m_editObject->getType() == OT_TEXT ) ?
04120 dynamic_cast<KPrTextObject*>( m_editObject ) : 0 );
04121
04122 }
04123
04124 void KPrCanvas::copyOasisObjs()
04125 {
04126
04127 KoStoreDrag *kd = new KoStoreDrag( "application/vnd.oasis.opendocument.presentation", 0L );
04128 QDragObject* dragObject = kd;
04129 QByteArray arr;
04130 QBuffer buffer(arr);
04131 KoStore* store = KoStore::createStore( &buffer, KoStore::Write, "application/vnd.oasis.opendocument.presentation" );
04132
04133 delete store;
04134 kd->setEncodedData( arr );
04135 QApplication::clipboard()->setData( dragObject, QClipboard::Clipboard );
04136 }
04137
04138 void KPrCanvas::copyObjs()
04139 {
04140 QDomDocument doc("DOC");
04141 QDomElement presenter=doc.createElement("DOC");
04142 presenter.setAttribute("editor", "KPresenter");
04143 presenter.setAttribute("mime", "application/x-kpresenter");
04144
04145 doc.appendChild(presenter);
04146
04147 QPtrList<KoDocumentChild> embeddedObjectsActivePage;
04148
04149 KoStoreDrag *kd = new KoStoreDrag( "application/x-kpresenter", 0L );
04150 QDragObject* dragObject = kd;
04151 QByteArray arr;
04152 QBuffer buffer(arr);
04153 KoStore* store = KoStore::createStore( &buffer, KoStore::Write, "application/x-kpresenter" );
04154
04155 m_activePage->getAllEmbeddedObjectSelected(embeddedObjectsActivePage );
04156
04157
04158 int i = 0;
04159 QValueList<KoPictureKey> savePictures;
04160 QPtrListIterator<KoDocumentChild> chl( embeddedObjectsActivePage );
04161 for( ; chl.current(); ++chl ) {
04162 KoDocument* childDoc = chl.current()->document();
04163 if ( childDoc && !childDoc->isStoredExtern() )
04164 (void) childDoc->saveToStore( store, QString::number( i++ ) );
04165 }
04166
04167 m_activePage->copyObjs(doc, presenter, savePictures);
04168
04169 KPrDocument* kprdoc = m_view->kPresenterDoc();
04170 if ( !embeddedObjectsActivePage.isEmpty())
04171 {
04172 kprdoc->saveEmbeddedObject(m_activePage, embeddedObjectsActivePage,doc,presenter);
04173 }
04174
04175 if ( !savePictures.isEmpty() ) {
04176
04177 presenter.appendChild( kprdoc->pictureCollection()->saveXML( KoPictureCollection::CollectionPicture, doc, savePictures ) );
04178
04179 kprdoc->pictureCollection()->saveToStore( KoPictureCollection::CollectionPicture, store, savePictures );
04180
04181 if ( savePictures.count() == 1 )
04182 {
04183 KoPicture pic = kprdoc->pictureCollection()->findPicture( savePictures.first() );
04184 QDragObject* picDrag = pic.dragObject( 0L );
04185 if ( picDrag ) {
04186 KMultipleDrag* multipleDrag = new KMultipleDrag( 0L );
04187 multipleDrag->addDragObject( kd );
04188 multipleDrag->addDragObject( picDrag );
04189 dragObject = multipleDrag;
04190 }
04191 }
04192 }
04193
04194 if ( store->open( "root" ) )
04195 {
04196 QCString s = doc.toCString();
04197
04198 (void)store->write( s.data(), s.size()-1 );
04199 store->close();
04200 }
04201
04202 delete store;
04203 kd->setEncodedData( arr );
04204 QApplication::clipboard()->setData( dragObject, QClipboard::Clipboard );
04205 }
04206
04207 void KPrCanvas::deleteObjs()
04208 {
04209 lowerObject();
04210 KCommand *cmd=m_activePage->deleteSelectedObjects();
04211 m_view->kPresenterDoc()->deSelectAllObj();
04212 if( cmd )
04213 m_view->kPresenterDoc()->addCommand( cmd );
04214 emit objectSelectedChanged();
04215 setToolEditMode( toolEditMode );
04216 }
04217
04218
04219 void KPrCanvas::enterEvent( QEvent *e )
04220 {
04221 m_view->setRulerMousePos( ( ( QMouseEvent* )e )->x(), ( ( QMouseEvent* )e )->y() );
04222 m_view->setRulerMouseShow( true );
04223 }
04224
04225 void KPrCanvas::leaveEvent( QEvent * )
04226 {
04227 m_view->setRulerMouseShow( false );
04228 }
04229
04230 QPtrList<KPrObject> KPrCanvas::objectList() const
04231 {
04232 return m_activePage->objectList();
04233 }
04234
04235 const QPtrList<KPrObject> &KPrCanvas::getObjectList() const
04236 {
04237 return m_activePage->objectList();
04238 }
04239
04240 unsigned int KPrCanvas::currPgNum() const
04241 {
04242 return m_view->getCurrPgNum();
04243 }
04244
04245 QColor KPrCanvas::txtBackCol() const
04246 {
04247 return m_view->kPresenterDoc()->txtBackCol();
04248 }
04249
04250 bool KPrCanvas::spInfiniteLoop() const
04251 {
04252 return m_view->kPresenterDoc()->spInfiniteLoop();
04253 }
04254
04255 bool KPrCanvas::spManualSwitch() const
04256 {
04257 return m_view->kPresenterDoc()->spManualSwitch();
04258 }
04259
04260 QRect KPrCanvas::getPageRect( bool decBorders ) const
04261 {
04262 return m_view->kPresenterDoc()->getPageRect( decBorders );
04263 }
04264
04265 unsigned int KPrCanvas::pageNums() const
04266 {
04267 return m_view->kPresenterDoc()->getPageNums();
04268 }
04269
04270 void KPrCanvas::_repaint( bool )
04271 {
04272 m_view->kPresenterDoc()->repaint( false );
04273 }
04274
04275 void KPrCanvas::_repaint( const QRect &r )
04276 {
04277 m_view->kPresenterDoc()->repaint( r );
04278 }
04279
04280 void KPrCanvas::_repaint( KPrObject *o )
04281 {
04282 m_view->kPresenterDoc()->repaint( o );
04283 }
04284
04285 void KPrCanvas::slotExitPres()
04286 {
04287 m_view->screenStop();
04288 }
04289
04290 void KPrCanvas::setDrawingMode()
04291 {
04292 m_presMenu->setItemChecked( PM_DM, true );
04293 m_drawMode = true;
04294
04295 setCursor( KPrUtils::penCursor() );
04296 }
04297
04298 void KPrCanvas::setSwitchingMode( bool continueTimer )
04299 {
04300 m_presMenu->setItemChecked( PM_DM, false );
04301
04302
04303
04304 m_drawMode = false;
04305 m_drawLineInDrawMode = false;
04306 setCursor( blankCursor );
04307
04308 if ( continueTimer && !spManualSwitch() )
04309 m_view->continueAutoPresTimer();
04310 }
04311
04312 void KPrCanvas::exitEditMode( bool repaint )
04313 {
04314 if ( m_editObject )
04315 {
04316 if ( m_editObject->getType() == OT_TEXT )
04317 {
04318 if(m_currentTextObjectView)
04319 {
04320 m_currentTextObjectView->clearSelection();
04321
04322 if ( repaint )
04323 {
04324 m_currentTextObjectView->drawCursor( false );
04325 m_currentTextObjectView->terminate();
04326 }
04327 KPrTextObject *kpTextObj = m_currentTextObjectView->kpTextObject();
04328 kpTextObj->setEditingTextObj( false );
04329 delete m_currentTextObjectView;
04330 m_currentTextObjectView = 0;
04331
04332 if ( repaint )
04333 _repaint( static_cast<KPrObject*>( kpTextObj ) );
04334 }
04335
04336 m_view->kPresenterDoc()->updateSideBarItem( m_activePage );
04337 emit objectSelectedChanged();
04338 m_editObject = 0;
04339 }
04340 else if (m_editObject->getType() == OT_PART )
04341 {
04342 static_cast<KPrPartObject *>(m_editObject)->deactivate();
04343 _repaint( m_editObject );
04344 m_editObject = 0;
04345 return;
04346 }
04347 }
04348
04349 }
04350
04351 bool KPrCanvas::getPixmapOrigAndCurrentSize( KPrPixmapObject *&obj, KoSize *origSize, KoSize *currentSize )
04352 {
04353 *origSize = KoSize(obj->originalSize().width(),obj->originalSize().height());
04354 *currentSize = obj->getSize();
04355 return true;
04356 }
04357
04358 void KPrCanvas::picViewOriginalSize()
04359 {
04360 KPrDocument *doc = m_view->kPresenterDoc();
04361 KPrPixmapObject *object = m_activePage->picViewOrigHelper();
04362
04363 KoSize newSize( doc->zoomHandler()->pixelXToPt( object->originalSize().width() ),
04364 doc->zoomHandler()->pixelYToPt( object->originalSize().height() ) );
04365
04366 KoRect pageRect = m_activePage->getPageRect();
04367 double fakt = 1.0;
04368
04369 if ( newSize.width() > pageRect.width() )
04370 fakt = pageRect.width() / newSize.width();
04371 if ( newSize.height() > pageRect.height() )
04372 fakt = QMIN( fakt, pageRect.height() / newSize.height() );
04373
04374 KoSize diff( newSize.width() * fakt - object->getSize().width(),
04375 newSize.height() * fakt - object->getSize().height() );
04376
04377 KPrResizeCmd *resizeCmd = new KPrResizeCmd( i18n( "Scale to Original Size" ),
04378 KoPoint( 0, 0 ), diff, object, doc );
04379 resizeCmd->execute();
04380 doc->addCommand( resizeCmd );
04381 }
04382
04383 void KPrCanvas::picViewOrig640x480()
04384 {
04385 picViewOrigHelper(640, 480);
04386 }
04387
04388 void KPrCanvas::picViewOrig800x600()
04389 {
04390 picViewOrigHelper(800, 600);
04391 }
04392
04393 void KPrCanvas::picViewOrig1024x768()
04394 {
04395 picViewOrigHelper(1024, 768);
04396 }
04397
04398 void KPrCanvas::picViewOrig1280x1024()
04399 {
04400 picViewOrigHelper(1280, 1024);
04401 }
04402
04403 void KPrCanvas::picViewOrig1600x1200()
04404 {
04405 picViewOrigHelper(1600, 1200);
04406 }
04407
04408 void KPrCanvas::picViewOrigHelper(int x, int y)
04409 {
04410 KPrPixmapObject *obj = 0;
04411 KoSize origSize;
04412 KoSize currentSize;
04413
04414 obj=m_activePage->picViewOrigHelper();
04415
04416 if ( obj && !getPixmapOrigAndCurrentSize( obj, &origSize, ¤tSize ) )
04417 return;
04418 KoSize pgSize = m_activePage->getPageRect().size();
04419
04420 if ( x == -1 && y == -1 ) {
04421 x = (int)origSize.width();
04422 y = (int)origSize.height();
04423 }
04424
04425 QSize presSize( x, y );
04426
04427 scalePixmapToBeOrigIn( currentSize, pgSize, presSize, obj );
04428 }
04429
04430 void KPrCanvas::picViewOrigFactor()
04431 {
04432 }
04433
04434 void KPrCanvas::scalePixmapToBeOrigIn( const KoSize ¤tSize, const KoSize &pgSize,
04435 const QSize &presSize, KPrPixmapObject *obj )
04436 {
04437 QRect desk = KGlobalSettings::desktopGeometry(this);
04438 double faktX = (double)presSize.width() / (double)desk.width();
04439 double faktY = (double)presSize.height() / (double)desk.height();
04440 double w = pgSize.width() * faktX;
04441 double h = pgSize.height() * faktY;
04442
04443 KPrResizeCmd *resizeCmd = new KPrResizeCmd( i18n( "Scale Picture to Be Shown 1:1 in Presentation Mode" ),
04444 KoPoint( 0, 0 ), KoSize( w - currentSize.width(), h - currentSize.height() ),
04445 obj, m_view->kPresenterDoc() );
04446 resizeCmd->execute();
04447 m_view->kPresenterDoc()->addCommand( resizeCmd );
04448 }
04449
04450 void KPrCanvas::setTextBackground( KPrTextObject * )
04451 {
04452
04453
04454 #if 0
04455 QPixmap pix( m_activePage->getZoomPageRect().size() );
04456 QPainter painter( &pix );
04457 m_activePage->background()->drawBackground( &painter, FALSE );
04458 QPixmap bpix( obj->getSize().toQSize() );
04459 bitBlt( &bpix, 0, 0, &pix, obj->getOrig().x(), obj->getOrig().y() -
04460 m_activePage->getZoomPageRect().height() * ( m_view->getCurrPgNum() - 1 ), bpix.width(), bpix.height() );
04461 QBrush b( white, bpix );
04462 QPalette pal( obj->textObjectView()->palette() );
04463 pal.setBrush( QColorGroup::Base, b );
04464 obj->textObjectView()->setPalette( pal );
04465 #endif
04466 }
04467
04468
04469 KoPoint KPrCanvas::diffGrid( KoRect &rect, double diffx, double diffy )
04470 {
04471 KPrDocument * doc( m_view->kPresenterDoc() );
04472 KoPoint move( 0, 0 );
04473
04474 double tempx = ( int( rect.topLeft().x() / doc->getGridX() ) * doc->getGridX() ) - rect.topLeft().x();
04475 if ( diffx > 0 )
04476 {
04477 tempx += doc->getGridX();
04478 while ( diffx > tempx )
04479 {
04480 move.setX( tempx );
04481 tempx += doc->getGridX();
04482 }
04483 }
04484 else
04485 {
04486 while ( diffx < tempx )
04487 {
04488 move.setX( tempx );
04489 tempx -= doc->getGridX();
04490 }
04491 }
04492 double tempy = ( int( rect.topLeft().y() / doc->getGridY() ) * doc->getGridY() ) - rect.topLeft().y();
04493 if ( diffy > 0 )
04494 {
04495 tempy += doc->getGridY();
04496 while ( diffy > tempy )
04497 {
04498 move.setY( tempy );
04499 tempy += doc->getGridY();
04500 }
04501 }
04502 else
04503 {
04504 while ( diffy < tempy )
04505 {
04506 move.setY( tempy );
04507 tempy -= doc->getGridY();
04508 }
04509 }
04510
04511 return move;
04512 }
04513
04514
04515 void KPrCanvas::moveObjectsByKey( int x, int y )
04516 {
04517 KPrDocument *doc( m_view->kPresenterDoc() );
04518
04519 KoRect rect( objectRect( false ) );
04520 double diffx = m_view->zoomHandler()->unzoomItX( x );
04521 double diffy = m_view->zoomHandler()->unzoomItY( y );
04522 KoPoint move( diffx, diffy );
04523
04524 bool snapToGrid = doc->snapToGrid() && !m_disableSnapping;
04525 bool snapToGuideLines = doc->showGuideLines() && !m_disableSnapping;
04526
04527 if ( snapToGrid )
04528 {
04529
04530
04531
04532
04533
04534 double tempx = int( rect.x() / doc->getGridX() ) * doc->getGridX();
04535 if ( diffx > 0 )
04536 {
04537 move.setX( tempx - rect.x() );
04538 while ( rect.x() - tempx >= -1E-10 )
04539 {
04540 tempx += doc->getGridX();
04541 move.setX( tempx - rect.x() );
04542 }
04543 }
04544 else if ( diffx < 0 )
04545 {
04546 move.setX( tempx - rect.x() );
04547 while ( rect.x() - tempx <= 1E-10 )
04548 {
04549 tempx -= doc->getGridX();
04550 move.setX( tempx - rect.x() );
04551 }
04552 }
04553
04554 double tempy = int( rect.y() / doc->getGridY() ) * doc->getGridY();
04555 if ( diffy > 0 )
04556 {
04557 move.setY( tempy - rect.y() );
04558 while ( rect.y() - tempy >= -1E-10 )
04559 {
04560 tempy += doc->getGridY();
04561 move.setY( tempy - rect.y() );
04562 }
04563 }
04564 else if ( diffy < 0 )
04565 {
04566 move.setY( tempy - rect.y() );
04567 while ( rect.y() - tempy <= 1E-10 )
04568 {
04569 tempy -= doc->getGridY();
04570 move.setY( tempy - rect.y() );
04571 }
04572 }
04573 }
04574
04575 if ( snapToGuideLines )
04576 {
04577 if ( !snapToGrid )
04578 {
04579
04580 KoRect movedRect( rect );
04581 movedRect.moveBy( diffx, diffy );
04582 movedRect.moveBy( -m_moveSnapDiff.x(), -m_moveSnapDiff.y() );
04583 move -= m_moveSnapDiff;
04584
04585 m_moveSnapDiff = KoPoint( 0, 0 );
04586
04587 KoGuides::SnapStatus snapStatus = KoGuides::SNAP_NONE;
04588 m_gl.snapToGuideLines( movedRect, KEY_SNAP_DISTANCE, snapStatus, m_moveSnapDiff );
04589
04590 move += m_moveSnapDiff;
04591 }
04592 else
04593 {
04594 m_gl.diffNextGuide( rect, move );
04595 }
04596 }
04597
04598
04599 KoRect pageRect( m_activePage->getPageRect() );
04600 if ( rect.left() + move.x() < pageRect.left() )
04601 {
04602 move.setX( pageRect.left() - rect.left() );
04603 }
04604 else if ( rect.right() + move.x() > pageRect.right() )
04605 {
04606 move.setX( pageRect.right() - rect.right() );
04607 }
04608 if ( rect.top() + move.y() < pageRect.top() )
04609 {
04610 move.setY( pageRect.top() - rect.top() );
04611 }
04612 else if ( rect.bottom() + move.y() > pageRect.bottom() )
04613 {
04614 move.setY( pageRect.bottom() - rect.bottom() );
04615 }
04616
04617
04618 if ( snapToGuideLines )
04619 {
04620
04621 KoRect movedRect( rect );
04622 movedRect.moveBy( move.x(), move.y() );
04623 m_gl.repaintSnapping( movedRect );
04624 }
04625
04626 if ( move != KoPoint( 0, 0 ) )
04627 {
04628
04629 m_activePage->moveObject( m_view, move, false );
04630 m_view->updateObjectStatusBarItem();
04631 }
04632 }
04633
04634
04635 void KPrCanvas::moveObjectsByMouse( KoPoint &pos, bool keepXorYunchanged )
04636 {
04637 KPrDocument *doc( m_view->kPresenterDoc() );
04638
04639 KoRect rect( objectRect( false ) );
04640 KoPoint move( 0, 0 );
04641 double diffx = pos.x() - m_origMousePos.x();
04642 double diffy = pos.y() - m_origMousePos.y();
04643
04644 bool snapToGrid = doc->snapToGrid() && !m_disableSnapping;
04645 bool snapToGuideLines = doc->showGuideLines() && !m_disableSnapping;
04646
04647 move = KoPoint( diffx, diffy );
04648 m_origMousePos = pos;
04649
04650
04651 KoRect movedRect( rect );
04652 movedRect.moveBy( diffx, diffy );
04653 movedRect.moveBy( -m_moveSnapDiff.x(), -m_moveSnapDiff.y() );
04654 move -= m_moveSnapDiff;
04655
04656 m_moveSnapDiff = KoPoint( 0, 0 );
04657 KoGuides::SnapStatus snapStatus = KoGuides::SNAP_NONE;
04658
04659 if ( snapToGrid )
04660 {
04661 m_moveSnapDiff.setX( qRound( movedRect.topLeft().x() / doc->getGridX()) * doc->getGridX()
04662 - movedRect.topLeft().x() );
04663 m_moveSnapDiff.setY( qRound( movedRect.topLeft().y() / doc->getGridY()) * doc->getGridY()
04664 - movedRect.topLeft().y() );
04665 snapStatus = KoGuides::SNAP_BOTH;
04666 }
04667
04668 if ( snapToGuideLines )
04669 {
04670 m_gl.snapToGuideLines( movedRect, MOUSE_SNAP_DISTANCE, snapStatus, m_moveSnapDiff );
04671 }
04672
04673 move += m_moveSnapDiff;
04674
04675
04676 KoPoint diffDueToBorders(0,0);
04677 KoRect pageRect( m_activePage->getPageRect() );
04678 if ( rect.left() + move.x() < pageRect.left() )
04679 diffDueToBorders.setX( pageRect.left() - (rect.left() + move.x()) );
04680 else if ( rect.right() + move.x() > pageRect.right() )
04681 diffDueToBorders.setX( pageRect.right() - (rect.right() + move.x()) );
04682
04683 if ( rect.top() + move.y() < pageRect.top() )
04684 diffDueToBorders.setY( pageRect.top() - (rect.top() + move.y()) );
04685 else if ( rect.bottom() + move.y() > pageRect.bottom() )
04686 diffDueToBorders.setY( pageRect.bottom() - (rect.bottom() + move.y()) );
04687
04688 m_moveSnapDiff += diffDueToBorders;
04689 move += diffDueToBorders;
04690
04691 movedRect.moveBy( m_moveSnapDiff.x(), m_moveSnapDiff.y() );
04692 if ( keepXorYunchanged )
04693 {
04694 KoPoint diff( m_moveStartPosMouse - movedRect.topLeft() );
04695 if ( fabs( diff.x() ) > fabs( diff.y() ) )
04696 {
04697 m_moveSnapDiff.setY( m_moveSnapDiff.y() + m_moveStartPosMouse.y() - movedRect.y() );
04698 movedRect.moveTopLeft( KoPoint( movedRect.x(), m_moveStartPosMouse.y() ) );
04699 move.setY( movedRect.y() - rect.y() );
04700 }
04701 else
04702 {
04703 m_moveSnapDiff.setX( m_moveSnapDiff.x() + m_moveStartPosMouse.x() - movedRect.x() );
04704 movedRect.moveTopLeft( KoPoint( m_moveStartPosMouse.x(), movedRect.y() ) );
04705 move.setX( movedRect.x() - rect.x() );
04706 }
04707 }
04708
04709 if ( snapToGuideLines )
04710 {
04711
04712 m_gl.repaintSnapping( movedRect );
04713 }
04714
04715 if ( move != KoPoint( 0, 0 ) )
04716 {
04717
04718 m_activePage->moveObject( m_view, move, false );
04719 }
04720 }
04721
04722
04723 void KPrCanvas::resizeObject( ModifyType _modType, const KoPoint & point, bool keepRatio, bool scaleAroundCenter )
04724 {
04725 KPrObject *kpobject = m_resizeObject;
04726
04727 QRect oldBoundingRect( m_view->zoomHandler()->zoomRect( kpobject->getRepaintRect() ) );
04728
04729 KoRect objRect = kpobject->getRealRect();
04730 KoGuides::SnapStatus snapStatus( KoGuides::SNAP_NONE );
04731
04732 bool left = false;
04733 bool right = false;
04734 bool top = false;
04735 bool bottom = false;
04736 if ( _modType == MT_RESIZE_UP || _modType == MT_RESIZE_LU || _modType == MT_RESIZE_RU )
04737 {
04738 top = true;
04739 snapStatus |= KoGuides::SNAP_HORIZ;
04740 }
04741 if ( _modType == MT_RESIZE_DN || _modType == MT_RESIZE_LD || _modType == MT_RESIZE_RD )
04742 {
04743 bottom = true;
04744 snapStatus |= KoGuides::SNAP_HORIZ;
04745 }
04746 if ( _modType == MT_RESIZE_LF || _modType == MT_RESIZE_LU || _modType == MT_RESIZE_LD )
04747 {
04748 left = true;
04749 snapStatus |= KoGuides::SNAP_VERT;
04750 }
04751 if ( _modType == MT_RESIZE_RT || _modType == MT_RESIZE_RU || _modType == MT_RESIZE_RD )
04752 {
04753 right = true;
04754 snapStatus |= KoGuides::SNAP_VERT;
04755 }
04756
04757 double newLeft = objRect.left();
04758 double newRight = objRect.right();
04759 double newTop = objRect.top();
04760 double newBottom = objRect.bottom();
04761 if ( top )
04762 {
04763 if ( point.y() < objRect.bottom() - MIN_SIZE )
04764 {
04765 newTop = point.y();
04766 }
04767 else
04768 {
04769 newTop = objRect.bottom() - MIN_SIZE;
04770 }
04771 }
04772 if ( bottom )
04773 {
04774 if ( point.y() > objRect.top() + MIN_SIZE )
04775 {
04776 newBottom = point.y();
04777 }
04778 else
04779 {
04780 newBottom = objRect.top() + MIN_SIZE;
04781 }
04782 }
04783 if ( left )
04784 {
04785 if ( point.x() < objRect.right() - MIN_SIZE )
04786 {
04787 newLeft = point.x();
04788 }
04789 else
04790 {
04791 newLeft = objRect.right() - MIN_SIZE;
04792 }
04793 }
04794 if ( right )
04795 {
04796 if ( point.x() > objRect.left() + MIN_SIZE )
04797 {
04798 newRight = point.x();
04799 }
04800 else
04801 {
04802 newRight = objRect.left() + MIN_SIZE;
04803 }
04804 }
04805
04806 double width = newRight - newLeft;
04807 double height = newBottom - newTop;
04808
04809 if ( keepRatio && m_ratio != 0 )
04810 {
04811 if ( ( top || bottom ) && ( right || left ) )
04812 {
04813 if ( height * height * m_ratio > width * width / m_ratio )
04814 {
04815 width = height * m_ratio;
04816 }
04817 else
04818 {
04819 height = width / m_ratio;
04820 }
04821 }
04822 else if ( top || bottom )
04823 {
04824 width = height * m_ratio;
04825 }
04826 else
04827 {
04828 height = width / m_ratio;
04829 }
04830
04831 if ( top )
04832 {
04833 newTop = objRect.bottom() - height;
04834 }
04835 else
04836 {
04837 newBottom = objRect.top() + height;
04838 }
04839 if ( left )
04840 {
04841 newLeft = objRect.right() - width;
04842 }
04843 else
04844 {
04845 newRight = objRect.left() + width;
04846 }
04847 }
04848
04849 if ( scaleAroundCenter )
04850 {
04851 KoPoint center( m_rectBeforeResize.center() );
04852
04853 if ( newLeft != objRect.left() )
04854 {
04855 width = 2 * ( center.x() - newLeft );
04856 }
04857 else if ( newRight != objRect.right() )
04858 {
04859 width = 2 * ( newRight - center.x() );
04860 }
04861
04862
04863 if ( keepRatio )
04864 {
04865 height = width / m_ratio;
04866 }
04867 else
04868 {
04869 if ( newTop != objRect.top() )
04870 {
04871 height = 2 * ( center.y() - newTop );
04872 }
04873 else if ( newBottom != objRect.bottom() )
04874 {
04875 height = 2 * ( newBottom - center.y() );
04876 }
04877 }
04878
04879 if ( width < MIN_SIZE )
04880 {
04881 width = MIN_SIZE;
04882 }
04883 if ( height < MIN_SIZE )
04884 {
04885 height = MIN_SIZE;
04886 }
04887
04888 newLeft = center.x() - width / 2;
04889 newRight = newLeft + width;
04890 newTop = center.y() - height / 2;
04891 newBottom = newTop + height;
04892 }
04893
04894 if ( newLeft != objRect.left() || newRight != objRect.right() || newTop != objRect.top() || newBottom != objRect.bottom() )
04895 {
04896
04897 kpobject->resizeBy( width - objRect.width(), height - objRect.height() );
04898
04899 if ( objRect.left() != newLeft || objRect.top() != newTop )
04900 {
04901 kpobject->moveBy( KoPoint( newLeft - objRect.left(), newTop - objRect.top() ) );
04902 }
04903
04904 if ( m_view->kPresenterDoc()->showGuideLines() && !m_disableSnapping )
04905 {
04906 KoRect rect( kpobject->getRealRect() );
04907 KoPoint sp( rect.topLeft() );
04908 if ( right )
04909 {
04910 sp.setX( rect.right() );
04911 }
04912 if ( bottom )
04913 {
04914 sp.setY( rect.bottom() );
04915 }
04916 m_gl.repaintSnapping( sp, snapStatus );
04917 }
04918
04919 _repaint( oldBoundingRect );
04920 _repaint( kpobject );
04921 emit objectSizeChanged();
04922 }
04923 }
04924
04925
04926 void KPrCanvas::finishResizeObject( const QString &name, bool layout )
04927 {
04928 if ( m_resizeObject )
04929 {
04930 KoPoint move = KoPoint( m_resizeObject->getOrig().x() - m_rectBeforeResize.x(),
04931 m_resizeObject->getOrig().y() - m_rectBeforeResize.y() );
04932 KoSize size = KoSize( m_resizeObject->getSize().width() - m_rectBeforeResize.width(),
04933 m_resizeObject->getSize().height() - m_rectBeforeResize.height() );
04934
04935 if ( ( m_resizeObject->getRect() ) != m_rectBeforeResize )
04936 {
04937 KPrResizeCmd *resizeCmd = new KPrResizeCmd( name, move, size, m_resizeObject,
04938 m_view->kPresenterDoc() );
04939
04940 m_view->kPresenterDoc()->addCommand( resizeCmd );
04941 }
04942
04943 if ( layout )
04944 m_view->kPresenterDoc()->layout( m_resizeObject );
04945
04946 m_ratio = 0.0;
04947 m_isResizing = false;
04948 _repaint( m_resizeObject );
04949 m_resizeObject = NULL;
04950 }
04951 }
04952
04953 void KPrCanvas::raiseObject( KPrObject *object )
04954 {
04955 if ( objectList().count() <= 1 )
04956 return;
04957
04958 if ( m_objectDisplayAbove == 0 )
04959 {
04960 if ( m_activePage->numSelected() == 1 )
04961 {
04962 m_objectDisplayAbove = object;
04963 }
04964 }
04965 }
04966
04967 void KPrCanvas::lowerObject()
04968 {
04969 m_objectDisplayAbove = 0;
04970 }
04971
04972 const QPtrList<KPrObject> KPrCanvas::displayObjectList() const
04973 {
04974 QPtrList<KPrObject> list = objectList();
04975 list.setAutoDelete( false );
04976
04977 if ( m_objectDisplayAbove )
04978 {
04979
04980
04981 int pos = objectList().findRef( m_objectDisplayAbove );
04982 if ( pos != -1 && m_objectDisplayAbove->isSelected() )
04983 {
04984 list.take( pos );
04985 list.append( m_objectDisplayAbove );
04986 }
04987 else
04988 {
04989
04990
04991 }
04992 }
04993 return list;
04994 }
04995
04996 void KPrCanvas::playSound( const QString &soundFileName )
04997 {
04998 if(soundPlayer)
04999 delete soundPlayer;
05000 soundPlayer = new KPrSoundPlayer( soundFileName );
05001 soundPlayer->play();
05002 }
05003
05004 void KPrCanvas::stopSound()
05005 {
05006 if ( soundPlayer ) {
05007 soundPlayer->stop();
05008 delete soundPlayer;
05009 soundPlayer = 0;
05010 }
05011 }
05012
05013 void KPrCanvas::setXimPosition( int x, int y, int w, int h, QFont *f )
05014 {
05015 QWidget::setMicroFocusHint( x - diffx(), y - diffy(), w, h, true, f );
05016 }
05017
05018 void KPrCanvas::createEditing( KPrTextObject *textObj )
05019 {
05020 if( m_currentTextObjectView)
05021 {
05022 m_currentTextObjectView->terminate();
05023 delete m_currentTextObjectView;
05024 m_currentTextObjectView = 0;
05025 m_editObject = 0;
05026 }
05027 m_currentTextObjectView = textObj->createKPTextView( this );
05028 m_editObject = textObj;
05029 }
05030
05031 void KPrCanvas::terminateEditing( KPrTextObject *textObj )
05032 {
05033 if ( m_currentTextObjectView && m_currentTextObjectView->kpTextObject() == textObj )
05034 {
05035 m_currentTextObjectView->terminate();
05036 delete m_currentTextObjectView;
05037 m_currentTextObjectView = 0;
05038 m_editObject = 0;
05039 }
05040 }
05041
05042 void KPrCanvas::drawCubicBezierCurve( QPainter &p, KoPointArray &points )
05043 {
05044 p.save();
05045 if ( !m_drawLineWithCubicBezierCurve )
05046 {
05047 QPen pen = QPen( Qt::black, 1, Qt::DashLine );
05048 p.setPen( pen );
05049 double angle = KoPoint::getAngle( m_endPoint, m_startPoint );
05050 drawFigure( L_SQUARE, &p, m_endPoint, pen.color(), pen.width(), angle,m_view->zoomHandler() );
05051
05052 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
05053 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
05054
05055 KoPoint symmetricEndPoint = m_startPoint * 2 - m_endPoint;
05056
05057 angle = KoPoint::getAngle( symmetricEndPoint, m_startPoint );
05058 drawFigure( L_SQUARE, &p, symmetricEndPoint, pen.color(), pen.width(), angle,m_view->zoomHandler() );
05059
05060
05061 p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
05062 m_view->zoomHandler()->zoomPoint( symmetricEndPoint ) );
05063
05064 p.save();
05065 p.setPen( QPen( Qt::black, 1, Qt::SolidLine ) );
05066 p.drawCubicBezier( points.zoomPointArray( m_view->zoomHandler() ) );
05067 p.restore();
05068 }
05069 else
05070 {
05071 KoPoint startPoint( m_pointArray.at( m_indexPointArray - 1 ) );
05072
05073 p.drawLine( m_view->zoomHandler()->zoomPoint( startPoint ),
05074 m_view->zoomHandler()->zoomPoint( m_endPoint ) );
05075 }
05076 p.restore();
05077 }
05078
05079
05080 void KPrCanvas::redrawCubicBezierCurve( QPainter &p )
05081 {
05082 if ( m_indexPointArray > 0 )
05083 {
05084 for ( int count = 0; count < m_indexPointArray - 4; count += 4 )
05085 {
05086 double _firstX = m_pointArray.at( count ).x();
05087 double _firstY = m_pointArray.at( count ).y();
05088
05089 double _fourthX = m_pointArray.at( count + 1 ).x();
05090 double _fourthY = m_pointArray.at( count + 1 ).y();
05091
05092 double _secondX = m_pointArray.at( count + 2 ).x();
05093 double _secondY = m_pointArray.at( count + 2 ).y();
05094
05095 double _thirdX = m_pointArray.at( count + 3 ).x();
05096 double _thirdY = m_pointArray.at( count + 3 ).y();
05097
05098 KoPointArray points;
05099 points.putPoints( 0, 4, _firstX,_firstY, _secondX,_secondY, _thirdX,_thirdY, _fourthX,_fourthY );
05100
05101 p.drawCubicBezier( points.zoomPointArray( m_view->zoomHandler() ) );
05102 }
05103 }
05104 }
05105
05106
05107 void KPrCanvas::drawPolygon( QPainter &p, const KoRect &rect )
05108 {
05109 KoRect nRect = rect.normalize();
05110 bool checkConcavePolygon = m_view->getCheckConcavePolygon();
05111 int cornersValue = m_view->getCornersValue();
05112 int sharpnessValue = m_view->getSharpnessValue();
05113
05114 KoRect _rect( 0, 0, nRect.width(), nRect.height() );
05115 double angle = 2 * M_PI / cornersValue;
05116 double diameter = static_cast<double>( QMAX( _rect.width(), _rect.height() ) );
05117 double radius = diameter * 0.5;
05118
05119 KoPointArray _points( checkConcavePolygon ? cornersValue * 2 : cornersValue );
05120 _points.setPoint( 0, 0, qRound( -radius ) );
05121
05122 double xmin = 0;
05123 double ymin = qRound( -radius );
05124
05125 if ( checkConcavePolygon ) {
05126 angle = angle / 2.0;
05127 double a = angle;
05128 double r = radius - ( sharpnessValue / 100.0 * radius );
05129 for ( int i = 1; i < cornersValue * 2; ++i ) {
05130 double xp, yp;
05131 if ( i % 2 ) {
05132 xp = r * sin( a );
05133 yp = -r * cos( a );
05134 }
05135 else {
05136 xp = radius * sin( a );
05137 yp = -radius * cos( a );
05138 }
05139 a += angle;
05140 _points.setPoint( i, xp, yp );
05141 if (xp < xmin)
05142 xmin = xp;
05143 if (yp < ymin)
05144 ymin = yp;
05145 }
05146 }
05147 else {
05148 double a = angle;
05149 for ( int i = 1; i < cornersValue; ++i ) {
05150 double xp = radius * sin( a );
05151 double yp = -radius * cos( a );
05152 a += angle;
05153 _points.setPoint( i, xp, yp );
05154 if (xp < xmin)
05155 xmin = xp;
05156 if (yp < ymin)
05157 ymin = yp;
05158 }
05159 }
05160
05161
05162 KoRect _changRect = _points.boundingRect();
05163 double fx = _rect.width() / _changRect.width();
05164 double fy = _rect.height() / _changRect.height();
05165
05166 int _index = 0;
05167 KoPointArray tmpPoints;
05168 KoPointArray::ConstIterator it;
05169 for ( it = _points.begin(); it != _points.end(); ++it ) {
05170 KoPoint point = (*it);
05171 double tmpX = ( point.x() - xmin) * fx + nRect.x();
05172 double tmpY = ( point.y() - ymin) * fy + nRect.y();
05173
05174 tmpPoints.putPoints( _index, 1, tmpX,tmpY );
05175 ++_index;
05176 }
05177 p.drawPolygon( tmpPoints.zoomPointArray( m_view->zoomHandler() ) );
05178 m_pointArray = tmpPoints;
05179 }
05180
05181
05182 bool KPrCanvas::oneObjectTextSelected() const
05183 {
05184 return m_activePage->oneObjectTextSelected();
05185 }
05186
05187 bool KPrCanvas::oneObjectTextExist() const
05188 {
05189 return m_activePage->oneObjectTextExist();
05190 }
05191
05192 KPrPage* KPrCanvas::activePage() const
05193 {
05194 return m_activePage;
05195 }
05196
05197 void KPrCanvas::setActivePage( KPrPage* active )
05198 {
05199 Q_ASSERT(active);
05200
05201
05202 m_objectDisplayAbove = 0;
05203 m_activePage = active;
05204 }
05205
05206 void KPrCanvas::setPaintGuides( bool state )
05207 {
05208 m_paintGuides = state;
05209 }
05210
05211 bool KPrCanvas::objectIsAHeaderFooterHidden(KPrObject *obj) const
05212 {
05213 if (( m_view->kPresenterDoc()->isHeader(obj) && !m_activePage->hasHeader() )
05214 || ( m_view->kPresenterDoc()->isFooter(obj) && !m_activePage->hasFooter() ) )
05215 return true;
05216 return false;
05217 }
05218
05219 int KPrCanvas::numberOfObjectSelected() const
05220 {
05221 int nb = m_activePage->numSelected();
05222 return nb;
05223 }
05224
05225 KPrObject *KPrCanvas::getSelectedObj() const
05226 {
05227 KPrObject *obj = m_activePage->getSelectedObj();
05228 return obj;
05229 }
05230
05231 void KPrCanvas::ungroupObjects()
05232 {
05233 KMacroCommand *macro = 0;
05234 m_activePage->ungroupObjects( ¯o );
05235 if ( macro )
05236 m_view->kPresenterDoc()->addCommand( macro );
05237 }
05238
05239 void KPrCanvas::groupObjects()
05240 {
05241 m_activePage->groupObjects();
05242 }
05243
05244 KoRect KPrCanvas::objectRect( bool all ) const
05245 {
05246 return m_activePage->getRealRect( all );
05247 }
05248
05249 void KPrCanvas::scrollTopLeftPoint( const QPoint & pos )
05250 {
05251 m_view->getHScrollBar()->setValue( pos.x() );
05252 m_view->getVScrollBar()->setValue( pos.y() );
05253 }
05254
05255 void KPrCanvas::changePicture( const KURL & url, QWidget *window )
05256 {
05257 m_activePage->changePicture( url, window );
05258 }
05259
05260 unsigned int KPrCanvas::objNums() const
05261 {
05262 return m_activePage->objNums();
05263 }
05264
05265
05266 void KPrCanvas::ensureVisible( int x, int y, int xmargin, int ymargin )
05267 {
05268
05269 int newy= (y+ymargin)-(visibleRect().bottom()+diffy());
05270
05271 if( newy > 0)
05272 m_view->getVScrollBar()->setValue(m_view->getVScrollBar()->value()+newy);
05273 else
05274 {
05275 newy= (y )-(visibleRect().top()+diffy());
05276 if( newy < 0)
05277 m_view->getVScrollBar()->setValue(m_view->getVScrollBar()->value()+newy - ymargin);
05278 }
05279
05280 int newx= (x+xmargin)-(visibleRect().right()+diffx());
05281 if( newx > 0)
05282 m_view->getHScrollBar()->setValue(m_view->getHScrollBar()->value()+newx);
05283 else
05284 {
05285 newx= x -(visibleRect().left()+diffx());
05286 if( newx < 0)
05287 m_view->getHScrollBar()->setValue(m_view->getHScrollBar()->value()+newx - xmargin );
05288 }
05289 }
05290
05291
05292 void KPrCanvas::textContentsToHeight()
05293 {
05294 QPtrList<KPrTextObject> lst = applicableTextObjects();
05295 if ( lst.isEmpty() )
05296 return;
05297 QPtrListIterator<KPrTextObject> it( lst );
05298 KMacroCommand * macro = 0L;
05299 for ( ; it.current() ; ++it ) {
05300 KCommand *cmd= it.current()->textContentsToHeight();
05301 if( cmd )
05302 {
05303 if ( !macro )
05304 macro = new KMacroCommand(i18n("Extend Text Contents to Height"));
05305 macro->addCommand( cmd);
05306 _repaint( it.current() );
05307 }
05308 }
05309 if( macro )
05310 {
05311 macro->execute();
05312 m_view->kPresenterDoc()->addCommand( macro );
05313 m_view->kPresenterDoc()->repaint(this);
05314 }
05315 }
05316
05317
05318 void KPrCanvas::textObjectToContents()
05319 {
05320 QPtrList<KPrTextObject> lst = applicableTextObjects();
05321 if ( lst.isEmpty() )
05322 return;
05323 QPtrListIterator<KPrTextObject> it( lst );
05324 KMacroCommand * macro = 0L;
05325 for ( ; it.current() ; ++it ) {
05326 KCommand *cmd= it.current()->textObjectToContents();
05327 if( cmd )
05328 {
05329 if (!macro )
05330 macro = new KMacroCommand(i18n("Extend Text to Contents"));
05331 macro->addCommand( cmd);
05332 }
05333 }
05334
05335 if( macro)
05336 {
05337 macro->execute();
05338 m_view->kPresenterDoc()->addCommand( macro );
05339 m_view->kPresenterDoc()->repaint(this);
05340 }
05341
05342 }
05343
05344 void KPrCanvas::flipObject( bool _horizontal )
05345 {
05346 QPtrList<KPrObject> lst;
05347 QPtrListIterator<KPrObject> it(getObjectList());
05348 for ( ; it.current(); ++it ) {
05349 if ( it.current()->isSelected() &&
05350 it.current()->getType() != OT_AUTOFORM &&
05351 it.current()->getType() != OT_PART &&
05352 it.current()->getType() != OT_TEXT )
05353 {
05354 lst.append( it.current() );
05355 }
05356 }
05357 if ( lst.isEmpty() )
05358 return;
05359
05360 KPrFlipObjectCommand *flipCmd = new KPrFlipObjectCommand( i18n("Flip Objects"),
05361 m_view->kPresenterDoc(),
05362 _horizontal, lst );
05363 flipCmd->execute();
05364 m_view->kPresenterDoc()->addCommand( flipCmd );
05365 }
05366
05367 void KPrCanvas::lowerObjs( bool backward )
05368 {
05369 lowerObject();
05370 m_activePage->lowerObjs( backward );
05371 }
05372
05373 void KPrCanvas::raiseObjs( bool forward )
05374 {
05375 lowerObject();
05376 m_activePage->raiseObjs( forward );
05377 }
05378
05379 QPtrList<KPrTextObject> KPrCanvas::listOfTextObjs() const
05380 {
05381 QPtrList<KPrTextObject> lst;
05382 QPtrListIterator<KPrObject> it(getObjectList());
05383 for ( ; it.current(); ++it ) {
05384 if ( it.current()->getType() == OT_TEXT )
05385 {
05386 if ( objectIsAHeaderFooterHidden(it.current()))
05387 continue;
05388 else
05389 lst.append( static_cast<KPrTextObject*>( it.current() ));
05390 }
05391 }
05392 return lst;
05393 }
05394
05395 KPrTextObject* KPrCanvas::textUnderMouse( const QPoint & point )
05396 {
05397 QPtrList<KPrTextObject> obj = listOfTextObjs();
05398 QPtrListIterator<KPrTextObject> it2(obj );
05399 for ( ; it2.current() ; ++it2 ) {
05400 QRect outerRect( m_view->kPresenterDoc()->zoomHandler()->zoomRect( it2.current()->getRect()) );
05401 if ( !it2.current()->isProtectContent() && outerRect.contains( point) )
05402 return it2.current();
05403 }
05404 return 0L;
05405 }
05406
05407 void KPrCanvas::speakTextUnderMouse(QWidget* w, const QPoint& p, uint flags)
05408 {
05409 Q_UNUSED( flags );
05410 if ( w != this ) return;
05411
05412
05413 if ( p == QPoint() ) return;
05414 KPrTextObject *to = textUnderMouse( w->mapFromGlobal( p ) );
05415 if ( to == m_prevSpokenTO ) return;
05416 m_prevSpokenTO = to;
05417 if ( to ) {
05418 QString text = to->textObject()->textDocument()->plainText();
05419 if ( !text.isEmpty() ) kospeaker->sayWidget( text );
05420 }
05421 }
05422
05423 bool KPrCanvas::checkCurrentTextEdit( KPrTextObject * textObj )
05424 {
05425 bool emitChanged = false;
05426 if ( textObj && m_currentTextObjectView && m_currentTextObjectView->kpTextObject() != textObj )
05427 {
05428 m_currentTextObjectView->kpTextObject()->setEditingTextObj( false );
05429 _repaint( m_currentTextObjectView->kpTextObject() );
05430
05431 m_currentTextObjectView->terminate(false);
05432 delete m_currentTextObjectView;
05433 m_currentTextObjectView = 0L;
05434 emitChanged = true;
05435 }
05436
05437
05438 if ( textObj && !m_currentTextObjectView )
05439 {
05440 m_currentTextObjectView = textObj->createKPTextView( this );
05441 emitChanged = true;
05442 }
05443 return emitChanged;
05444 }
05445
05446 void KPrCanvas::alignObjects( AlignType at )
05447 {
05448 KPrDocument * doc = m_view->kPresenterDoc();
05449
05450 QString name;
05451
05452 switch ( at )
05453 {
05454 case AT_LEFT:
05455 name = i18n( "Align Objects Left" );
05456 break;
05457 case AT_TOP:
05458 name = i18n( "Align Objects Top" );
05459 break;
05460 case AT_RIGHT:
05461 name = i18n( "Align Objects Right" );
05462 break;
05463 case AT_BOTTOM:
05464 name = i18n( "Align Objects Bottom" );
05465 break;
05466 case AT_HCENTER:
05467 name = i18n( "Align Objects Centered (horizontal)" );
05468 break;
05469 case AT_VCENTER:
05470 name = i18n( "Align Objects Center/Vertical" );
05471 break;
05472 }
05473
05474 QPtrList<KPrObject> objects;
05475
05476 QPtrListIterator<KPrObject> it( m_activePage->objectList() );
05477 for ( ; it.current() ; ++it )
05478 {
05479 if ( it.current() == m_view->kPresenterDoc()->header() ||
05480 it.current() == m_view->kPresenterDoc()->footer() )
05481 continue;
05482
05483 if( it.current()->isSelected() && !it.current()->isProtect() ) {
05484 objects.append( it.current() );
05485 }
05486 }
05487
05488 if ( objects.count() )
05489 {
05490 KCommand * cmd = new KPrAlignCmd( name, objects, at, doc );
05491 cmd->execute();
05492 doc->addCommand( cmd );
05493 }
05494 }
05495
05496 bool KPrCanvas::canMoveOneObject() const
05497 {
05498 return m_activePage->canMoveOneObject();
05499 }
05500
05501 void KPrCanvas::closeObject(bool )
05502 {
05503 QPtrList<KPrObject> lst;
05504 QPtrListIterator<KPrObject> it(getObjectList());
05505 for ( ; it.current(); ++it ) {
05506 if ( it.current()->isSelected()
05507 && (it.current()->getType() == OT_POLYLINE || it.current()->getType() == OT_FREEHAND
05508 || it.current()->getType() == OT_QUADRICBEZIERCURVE
05509 || it.current()->getType() == OT_CUBICBEZIERCURVE ))
05510 lst.append( it.current() );
05511 }
05512 if ( lst.isEmpty())
05513 return;
05514
05515 KCommand * cmd= new KPrCloseObjectCommand( i18n("Close Object"), lst, m_view->kPresenterDoc() );
05516 cmd->execute();
05517 m_view->kPresenterDoc()->addCommand( cmd );
05518 }
05519
05520 void KPrCanvas::layout()
05521 {
05522 QPtrListIterator<KPrObject> it(getObjectList());
05523 for ( ; it.current(); ++it ) {
05524 if ( it.current()->getType() == OT_TEXT )
05525 static_cast<KPrTextObject *>( it.current() )->layout();
05526 }
05527 }
05528
05529 KoPoint KPrCanvas::snapPoint( KoPoint &pos, bool repaintSnapping )
05530 {
05531 KoPoint sp( pos );
05532 KPrDocument * doc( m_view->kPresenterDoc() );
05533
05534 bool snapToGrid = doc->snapToGrid() && !m_disableSnapping;
05535 bool snapToGuideLines = doc->showGuideLines() && !m_disableSnapping;
05536
05537 KoPoint snapDiff = KoPoint( 0, 0 );
05538 KoGuides::SnapStatus snapStatus = KoGuides::SNAP_NONE;
05539
05540 if ( snapToGrid )
05541 {
05542 snapDiff.setX( qRound( sp.x() / doc->getGridX()) * doc->getGridX() - sp.x() );
05543 snapDiff.setY( qRound( sp.y() / doc->getGridY()) * doc->getGridY() - sp.y() );
05544 snapStatus = KoGuides::SNAP_BOTH;
05545 }
05546
05547 if ( snapToGuideLines )
05548 {
05549 m_gl.snapToGuideLines( sp, MOUSE_SNAP_DISTANCE, snapStatus, snapDiff );
05550 }
05551
05552 sp += snapDiff;
05553
05554
05555 KoRect pageRect( m_activePage->getPageRect() );
05556 if ( sp.x() < pageRect.left() )
05557 sp.setX( pageRect.left() );
05558 else if ( sp.x() > pageRect.right() )
05559 sp.setX( pageRect.right() );
05560
05561 if ( sp.y() < pageRect.top() )
05562 sp.setY( pageRect.top() );
05563 else if ( sp.y() > pageRect.bottom() )
05564 sp.setY( pageRect.bottom() );
05565
05566
05567 if ( repaintSnapping && snapToGuideLines )
05568 {
05569 m_gl.repaintSnapping( sp, KoGuides::SNAP_BOTH );
05570 }
05571
05572 return sp;
05573 }
05574
05575
05576 void KPrCanvas::alignVertical( VerticalAlignmentType _type )
05577 {
05578 KCommand *cmd = m_activePage->alignVertical( _type );
05579 if ( cmd )
05580 m_view->kPresenterDoc()->addCommand( cmd );
05581 }
05582
05583 KPrPixmapObject * KPrCanvas::getSelectedImage() const
05584 {
05585 return m_activePage->getSelectedImage();
05586 }
05587
05588
05589 KoPointArray KPrCanvas::getObjectPoints( const KoPointArray &pointArray )
05590 {
05591 KoRect rect = pointArray.boundingRect();
05592
05593 KoPointArray points( pointArray );
05594 points.translate( -rect.x(), -rect.y() );
05595
05596 return points;
05597 }
05598
05599 void KPrCanvas::objectPopup( KPrObject *object, const QPoint &point )
05600 {
05601 switch ( object->getType() )
05602 {
05603 case OT_PICTURE:
05604 case OT_CLIPART:
05605 m_view->openPopupMenuObject( "picmenu_popup", point );
05606 break;
05607 case OT_TEXT:
05608 {
05609 KPrTextObject *obj=dynamic_cast<KPrTextObject *>(object);
05610 if ( obj )
05611 m_view->changeVerticalAlignmentStatus( obj->verticalAlignment() );
05612 m_view->openPopupMenuObject( "textobject_popup", point );
05613 } break;
05614 case OT_PIE:
05615 m_view->openPopupMenuObject( "piemenu_popup", point );
05616 break;
05617 case OT_RECT:
05618 case OT_ELLIPSE:
05619 m_view->openPopupMenuObject( "rectangleobject_popup", point );
05620 break;
05621 case OT_PART:
05622 m_view->openPopupMenuObject( "partobject_popup", point );
05623 break;
05624 case OT_POLYGON:
05625 m_view->openPopupMenuObject( "polygonobject_popup", point );
05626 break;
05627 case OT_POLYLINE:
05628 case OT_CUBICBEZIERCURVE:
05629 case OT_QUADRICBEZIERCURVE:
05630 case OT_FREEHAND:
05631 m_view->openPopupMenuObject( "closed_popup", point );
05632 break;
05633 case OT_LINE:
05634 case OT_CLOSED_LINE:
05635 m_view->openPopupMenuObject( "flip_popup", point );
05636 break;
05637 case OT_GROUP:
05638 if ( oneObjectTextSelected())
05639 m_view->openPopupMenuObject( "textobject_popup", point );
05640 else
05641 m_view->openPopupMenuObject( "flip_popup", point );
05642 break;
05643 default:
05644 m_view->openPopupMenuObject( "graphmenu_popup", point );
05645 break;
05646 }
05647 }
05648
05649 void KPrCanvas::popupContextMenu()
05650 {
05651 if ( !editMode ) {
05652 if ( !m_drawMode && !spManualSwitch() )
05653 {
05654 finishObjectEffects();
05655 finishPageEffect();
05656 m_view->stopAutoPresTimer();
05657 }
05658 setCursor( arrowCursor );
05659 QPoint p( width()/2, height()/2 );
05660 int ret = m_presMenu->exec( p );
05661
05662 if ( ret == -1 && !m_presMenu->isItemChecked( PM_DM ) && !spManualSwitch() )
05663 m_view->continueAutoPresTimer();
05664 return;
05665 }
05666 if ( m_currentTextObjectView ) {
05667
05668
05669 KoPoint kop = m_currentTextObjectView->kpTextObject()->getOrig();
05670 QPoint p = m_view->zoomHandler()->zoomPoint( kop );
05671 p = mapToGlobal( p );
05672 m_currentTextObjectView->showPopup( m_view, p, m_view->actionList() );
05673 return;
05674 }
05675 if (!m_activePage) return;
05676 KPrObject* obj = m_activePage->getSelectedObj();
05677 if (obj) {
05678 KoPoint kop = obj->getOrig();
05679 QPoint p = m_view->zoomHandler()->zoomPoint( kop );
05680 p = mapToGlobal( p );
05681 objectPopup( obj, p );
05682 } else {
05683 QPoint p = mapToGlobal( QPoint() );
05684 m_view->openPopupMenuMenuPage( p );
05685 }
05686 }