kpresenter

KPrCanvas.cpp

00001 /* This file is part of the KDE project
00002    Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
00003    Copyright (C) 2002-2005 Thorsten Zachmann <zachmann@kde.org>
00004    Copyright (C) 2005 Casper Boemann Rasmussen <cbr@boemann.dk>
00005 
00006    This library is free software; you can redistribute it and/or
00007    modify it under the terms of the GNU Library General Public
00008    License as published by the Free Software Foundation; either
00009    version 2 of the License, or (at your option) any later version.
00010 
00011    This library is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014    Library General Public License for more details.
00015 
00016    You should have received a copy of the GNU Library General Public License
00017    along with this library; see the file COPYING.LIB.  If not, write to
00018    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00019  * Boston, MA 02110-1301, USA.
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 ); // ensure using the InputMethod
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     // block all signals (save for destroyed()) to avoid crashes on exit
00179     // (exitEditMode) emits signals
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     // Relative movement
00194     int dx = m_xOffset - x;
00195     // new position
00196     m_xOffset = x;
00197     bitBlt( &buffer, dx, 0, &buffer );
00198     scroll( dx, 0 );
00199 }
00200 
00201 void KPrCanvas::scrollY( int y )
00202 {
00203     // Relative movement
00204     int dy = m_yOffset - y;
00205     // new position
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         // Debug keys
00254         if ( ( keyev->state() & ControlButton ) && ( keyev->state() & ShiftButton ) )
00255         {
00256             switch ( keyev->key() ) {
00257             case Qt::Key_P: // 'P' -> paragraph debug
00258                 printRTDebug( 0 );
00259                 keyev->accept();
00260                 break;
00261             case Qt::Key_V: // 'V' -> verbose parag debug
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; // Don't allow to go out of the canvas widget by pressing "Tab"
00281 }
00282 
00283 void KPrCanvas::paintEvent( QPaintEvent* paintEvent )
00284 {
00285     if ( isUpdatesEnabled() )
00286     {
00287         //kdDebug(33001) << "KPrCanvas::paintEvent m_paintGuides = " << m_paintGuides << endl; //<< " " << kdBacktrace( 10 ) << endl;
00288         KPrDocument *doc =m_view->kPresenterDoc();
00289 
00290         if ( ! m_paintGuides  )
00291         {
00292             //kdDebug(33001) << "KPrCanvas::paintEvent" << endl;
00293             QPainter bufPainter;
00294             bufPainter.begin( &buffer, this ); // double-buffering - (the buffer is as big as the widget)
00295             bufPainter.translate( -diffx(), -diffy() );
00296             bufPainter.setBrushOrigin( -diffx(), -diffy() );
00297 
00298             QRect crect( paintEvent->rect() ); // the rectangle that needs to be repainted, in widget coordinates
00299             bufPainter.setClipRect( crect );
00300 
00301             //kdDebug(33001) << "KPrCanvas::paintEvent " << DEBUGRECT( crect ) << ", " << size() << endl;
00302 
00303             crect.moveBy( diffx(), diffy() ); // now in contents coordinates
00304             //kdDebug(33001) << "KPrCanvas::paintEvent after applying diffx/diffy: " << DEBUGRECT( crect ) << endl;
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                 // Center the slide in the screen, if it's smaller...
00333 #if 0 // this works but isn't enough - e.g. object effects need the same offsets
00334                 // so we should store them, but they don't work like diffx/diffy...
00335                 // (e.g. the painter mustn't be translated when painting the background)
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     //else kdDebug(33001) << "KPrCanvas::paintEvent with updates disabled" << endl;
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         // Include the border
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         // In edit mode we also want to draw the gray area out of the pages
00483         if ( !grayRegion.isEmpty() )
00484             eraseEmptySpace( painter, grayRegion, QApplication::palette().active().brush( QColorGroup::Mid ) );
00485     }
00486     else
00487     {
00488         // Old code, left a black area if zoomX != zoomY
00489         //page->background()->draw( painter, m_view->zoomHandler(), rect, false );
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 // 100% stolen from KWord
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     //kdDebug(33001) << "KWDocument::eraseEmptySpace emptySpaceRegion: " << DEBUGRECT( emptySpaceRegion.boundingRect() ) << endl;
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 /*onlyChanged. Pass as param ?*/,
00539                                                textView->cursor(), true /* idem */ );
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     //objects on master page
00607     if ( page->masterPage() && page->displayObjectFromMasterPage() )
00608         drawObjectsEdit( painter, rect, page->masterPage()->objectList(), selectionMode, pageNum );
00609     //objects on current page
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     //objects on master page
00620     if ( page->masterPage() && page->displayObjectFromMasterPage() )
00621         drawObjectsPres( painter, page->masterPage()->objectList(), step );
00622     //objects on current page
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 // This one is used to generate the pixmaps for the HTML presentation,
00652 // for the pres-structure-dialog, for the sidebar previews, for template icons.
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(); // in pt, but now translated into the object's coordinate system
00697             // This is common to all mouse buttons, so that RMB and MMB place the cursor too
00698             m_currentTextObjectView->mousePressEvent(e, m_view->zoomHandler()->ptToLayoutUnitPix( pos ) ); // in LU pixels
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() ); // erase old figure
00777 
00778                     p.restore();
00779 
00780                     p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
00781                                 m_view->zoomHandler()->zoomPoint( endPoint ) );// erase old line
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() ); // erase old figure
00789 
00790                     p.restore();
00791 
00792                     p.drawLine( m_view->zoomHandler()->zoomPoint( m_startPoint ),
00793                                 m_view->zoomHandler()->zoomPoint( m_symmetricEndPoint ) );// erase old line
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                     // use ctrl + Button to select / deselect object
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                     // start resizing
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(); // needed because the messagebox 'eats' the mouseRelease
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                 // clear old selections even if shift or control are pressed
00907                 // we don't support rotating multiple objects yet
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                     // set center of selected object bounding rect
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                 // remove old line
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             //deactivate tools when you click on right button
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             // we have to continue the timer if the menu was canceled and we draw mode is not active
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     // ME: I have no idea why this is needed at all
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                 // used for selecting multiple object in with the mouse
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             // User-friendlyness: automatically start editing this textobject
01256             createEditing( kptextobject );
01257             //setTextBackground( kptextobject );
01258             //setCursor( arrowCursor );
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             /* As the object is allready rotated set the angle to
01294              * the m_angleBeforeRotate for the creation of the command, and
01295              * back afterwards. No need for executing the command */
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 ) ); // in LU pixels
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                     // angle to mouse pos
01533                     double angle = KoPoint::getAngle( m_rotateCenter, docPoint );
01534                     // angle to start of mouse pos
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                 //remove the old line
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                 // print the new line
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                         // erase
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                         // draw
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                 //remove the old line
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                     // erase
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                     // draw
01704                     p.drawPolyline( pointArray );
01705                     m_startPoint += m_endPoint - oldEndPoint;
01706                 }
01707 
01708                 // print the new line
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                     // erase
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                     // draw
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                 // erase old
01794                 drawPolygon( p, m_insertRect );
01795                 updateInsertRect( sp, e->state() );
01796                 // print new
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             //pos=m_view->zoomHandler()->pixelToLayoutUnit(QPoint(pos.x(),pos.y()));
01831             m_currentTextObjectView->mouseDoubleClickEvent( e, m_view->zoomHandler()->ptToLayoutUnitPix( pos ) );
01832             return;
01833         }
01834     }
01835 
01836     //disallow activating objects outside the "page"
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                 //setTextBackground( kptextobject );
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 )     // wheel down
01918             m_view->screenNext();
01919         else if ( e->delta() == 120 ) // wheel up
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             // setSwitchingMode( false ) not needed as it is allready done in slotGotoPage;
01961             if ( !spManualSwitch() )
01962                 m_view->stopAutoPresTimer();
01963             slotGotoPage();
01964             break;
01965         case Qt::Key_Home:  // go to first page
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:  // go to last page
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:  // go to first page
02008                 m_view->screenFirst();
02009                 break;
02010             case Qt::Key_End:  // go to first page
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                     // undo snapping for move by mouse
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     //desactivate kptextview when we switch of page
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     // create right button presentation menu
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         // Depending on the desired target size due to rounding
02350         // errors during zoom the resulting pixmap *might* be
02351         // 1 pixel or 2 pixels wider/higher than desired: we just
02352         // remove the additional columns/rows.  This can be done
02353         // since KPresenter is leaving a minimal border below/at
02354         // the right of the image anyway.
02355         const QSize desiredSize(nWidth, nHeight);
02356         if( desiredSize != pix.size() )
02357             pix.resize( desiredSize );
02358         // save the pixmap to the desired file
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 /*void KPrCanvas::setTextCounter(KoParagCounter counter)
02807 {
02808     QPtrList<KoTextFormatInterface> lst = applicableTextInterfaces();
02809     if ( lst.isEmpty() ) return;
02810     QPtrListIterator<KoTextFormatInterface> it( lst );
02811     KMacroCommand* macroCmd = 0L;
02812     for ( ; it.current() ; ++it ) {
02813         KCommand* cmd = it.current()->setCounterCommand(counter );
02814         if ( cmd )
02815         {
02816             if ( !macroCmd )
02817                 macroCmd = new KMacroCommand( i18n("Change Paragraph Type") );
02818             macroCmd->addCommand( cmd );
02819         }
02820     }
02821     if ( macroCmd )
02822         m_view->kPresenterDoc()->addCommand( macroCmd );
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     // If we're editing a text object, then that's the one we return
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     // If we're editing a text object, then that's the one we return
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 /* 1-based */)
02902 {
02903     //kdDebug(33001) << "KPrCanvas::startScreenPresentation curPgNum=" << curPgNum << endl;
02904 
02905     //setup presentation menu
02906     m_presMenu->setItemChecked( PM_DM, false );
02907 
02908     setCursor( waitCursor );
02909 
02910     exitEditMode();
02911 
02912     KPrDocument * doc = m_view->kPresenterDoc();
02913 
02914     // Text can't zoom with a different x and y factor, yet.
02915     // So we have to choose the smallest zoom (but still paint background everywhere)
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     // Seems to fail (Qt uses the wrong font sizes...)
02923     //doc->zoomHandler()->setZoomedResolution( zoomX * doc->zoomHandler()->zoomedResolutionX(),
02924     //                                         zoomY * doc->zoomHandler()->zoomedResolutionY() );
02925     // Apply the new zooming to the existing one
02926     doc->zoomHandler()->setZoomAndResolution( qRound( zoom * m_zoomBeforePresentation ),
02927                                               KoGlobal::dpiX(), KoGlobal::dpiY() );
02928 
02929     doc->newZoomAndResolution( false, false );
02930 
02931     // add all selected slides
02932     m_presentationSlides.clear();
02933     QValueList<int> selected = doc->displaySelectedSlides();
02934     for ( QValueList<int>::Iterator it = selected.begin() ; it != selected.end(); ++ it )
02935     {
02936         // ARGLLLRGLRLGRLG selectedSlides gets us 0-based numbers,
02937         // and here we want 1-based numbers !
02938         int slideno = *it + 1;
02939         m_presentationSlides.append( slideno );
02940     }
02941 
02942     // no slide selected ? end the slide show immediately...
02943     if( !m_presentationSlides.count() )
02944     {
02945         //kdDebug(33001) << "No slide: end the slide show" << endl;
02946         stopScreenPresentation();
02947         return;
02948     }
02949 
02950     // find first selected slide after curPgNum
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; // force gotoPage to do something
02962     gotoPage( slide );
02963     //kdDebug(33001) << "Page::startScreenPresentation - done" << endl;
02964 }
02965 
02966 void KPrCanvas::stopScreenPresentation()
02967 {
02968     //kdDebug(33001) << "KPrCanvas::stopScreenPresentation m_showOnlyPage=" << m_showOnlyPage << endl;
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         // clear drawed lines
02998         m_drawModeLines.clear();
02999 
03000         //kdDebug(33001) << "\n-------\nKPrCanvas::pNext m_step =" << m_step.m_step << " m_subStep =" << m_step.m_subStep << endl;
03001 
03002         // First try to go one sub-step further, if any object requires it
03003         // ### should we also objects on the sticky page be checked for sub steps?
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                     //kdDebug(33001) << "Page::pNext addSubPres m_subStep is now " << m_subStep << endl;
03015                     doObjEffects();
03016                     return false;
03017                 }
03018             }
03019         }
03020 
03021         // Then try to see if there is still one step to do in the current page
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             //kdDebug(33001) << "Page::pNext setting currentEffectStep to " << m_step.m_step << endl;
03028 
03029             // if first step on page, draw background
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          * don't go to next slide if we have finished an object effect
03046          * so that we can see the hole slide before going to the next
03047          */
03048         if ( objectEffectFinished )
03049             return false;
03050     }
03051 
03052     // No more steps in this page, try to go to the next page
03053     QValueList<int>::ConstIterator test(  m_presentationSlidesIterator );
03054     if ( ++test != m_presentationSlides.end() )
03055     {
03056         if ( !spManualSwitch() && m_setPageTimer )
03057         {
03058             //TODO add global presentation speed
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     //kdDebug(33001) << "Page::pNext last slide -> End of presentation" << endl;
03115 
03116     // When we are in manual mode or in automatic mode with no infinite loop
03117     // we display the 'End of presentation' slide.
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(); // no automatic mode for last slide
03134     }
03135     else if ( showingLastSlide ) // after last slide stop presentation
03136     {
03137         showingLastSlide = false;
03138         m_view->screenStop();
03139     }
03140     else
03141     {
03142         m_view->setPageDuration( m_step.m_pageNumber );
03143         emit restartPresentation(); // tells automatic mode to restart
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     // clear drawed lines
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         //hopefully there are never more than 1000 sub steps :-)
03162         m_step.m_subStep = 1000;
03163         repaint( false );
03164         return false;
03165     } else {
03166         // when we go back on the first slide, thats like starting the presentation again
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         //can't assign a effect to header/footer
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 // This one is used to generate the pixmaps for the HTML presentation,
03220 // for the pres-structure-dialog, for the sidebar previews, for template icons.
03221 // Set forceWidth and/or forceHeight to override the zoom factor
03222 // and obtain a pixmap of the specified width and/or height.
03223 // By omitting one of them you make sure that the aspect ratio
03224 // of your page is used for the resulting image.
03225 void KPrCanvas::drawPageInPix( QPixmap &_pix, int pgnum, int zoom,
03226                                bool forceRealVariableValue,
03227                                int forceWidth,
03228                                int forceHeight )
03229 {
03230     //kdDebug(33001) << "Page::drawPageInPix" << endl;
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         // adjust width or height, in case one of them is missing
03245         if( 0 >= forceWidth )
03246             dForceWidth = dForceHeight * dRectWidth / dRectHeight;
03247         else if( 0 >= forceHeight )
03248             dForceHeight = dForceWidth * dRectHeight / dRectWidth;
03249 
03250         // set the stretching values
03251         // ### TODO: this should probably be setZoomedResolution, please test
03252         doc->zoomHandler()->setResolution( dForceWidth / dRectWidth,
03253                                            dForceHeight / dRectHeight );
03254         // As of yet (Feb. 2004) the following call results
03255         // in a NOP but be prepared for the future...
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     // draw objects on master slide
03285     if ( page->masterPage() && page->displayObjectFromMasterPage() )
03286         drawAllObjectsInPage( &p, page->masterPage()->objectList(), pgnum );
03287 
03288     //objects in current page
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 // This one is used in fullscreenmode, to generate the pixmaps used for the
03307 // page effects.
03308 void KPrCanvas::drawCurrentPageInPix( QPixmap &_pix ) const
03309 {
03310     //kdDebug(33001) << "Page::drawCurrentPageInPix" << endl;
03311 
03312     // avoid garbage on "weird" DPIs
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     //kdDebug(33001) << "KPrCanvas::printPage" << endl;
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 ); // all slides have the same size
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; // some y-space between the slides
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     // YABADABADOOOOOOO.... That's a hack :-)
03391     if ( m_step.m_subStep == 0 && !isAllreadyPainted && isUpdatesEnabled() )
03392     {
03393         //kdDebug(33001) << "Page::doObjEffects - in the strange hack" << endl;
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     // master slide objects are below the objects of the normal slide
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     //TODO add global presentation speed
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     //QPoint d = m_view->zoomHandler()->zoomPoint( scrollDistance );
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 /*left_margin*/, float /*top_margin*/ )
03529 {
03530     PresStep step( 0, 1000, 1000 );
03531     //deSelectAllObj(); // already done in KPrView::setupPrinter
03532     int i = 0;
03533 
03534     repaint( false );
03535     kapp->processEvents();
03536 
03537     editMode = false;
03538     fillBlack = false;
03539 
03540     //int _xOffset = diffx();
03541     //int _yOffset = diffy();
03542 
03543     //m_view->setDiffX( -static_cast<int>( MM_TO_POINT( left_margin ) ) );
03544     //m_view->setDiffY( -static_cast<int>( MM_TO_POINT( top_margin ) ) );
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     /*if ( printer->fromPage() > 1 )
03563       m_view->setDiffY( ( printer->fromPage() - 1 ) * ( getPageRect( 1, 1.0, false ).height() ) -
03564       (int)MM_TO_POINT( top_margin ) );*/
03565     int current_slide = 0;
03566     QValueList<int> list=printer->pageList(); // 1-based
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         /*m_view->setDiffY( i * ( getPageRect( 1, 1.0, false ).height() )
03597           - static_cast<int>( MM_TO_POINT( top_margin ) ) );*/
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     //don't print notes when there is no note to print or it's disabled
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     //m_view->setDiffX( _xOffset );
03617     //m_view->setDiffY( _yOffset );
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     //store m_pointArray if !m_pointArray.isNull()
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         // ### missing some coord transformation here?
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     //disallow dropping objects outside the "page"
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         //kdDebug()<<" QTextDrag::decode( e, text ); :"<<text<<endl;
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     //setCursor( blankCursor );
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         // clear drawed lines
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     // ### return m_currentTextObjectView->kpTextObject()
04122 }
04123 
04124 void KPrCanvas::copyOasisObjs()
04125 {
04126     //todo copy object from selected object
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     // Save internal embedded objects first, since it might change their URL
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         // Save picture list at the end of the main XML
04177         presenter.appendChild( kprdoc->pictureCollection()->saveXML( KoPictureCollection::CollectionPicture, doc, savePictures ) );
04178         // Save the actual picture data into the store
04179         kprdoc->pictureCollection()->saveToStore( KoPictureCollection::CollectionPicture, store, savePictures );
04180         // Single image -> put it in dragobject too
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(); // this is already Utf8!
04197         //kdDebug(33001) << "KPrCanvas::copyObject: " << s << endl;
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 * /*e*/ )
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 /*erase*/ )
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     // the following have to be done even when nothing changed
04303     // we don't want to see the cursor nor the automatic pesentation stopped
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                 //hide cursor when we desactivate textObjectView
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             // Title of slide may have changed
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     //modType = MT_NONE;
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, &currentSize ) )
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 &currentSize, 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 */*obj*/ )
04451 {
04452     // This is called when double-clicking on a text object.
04453     // What should happen exactly ? (DF)
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() ); // ## zoom it !
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          * Find the distance to the next grid pos.
04531          * The 1E-10 is needed when the object is on the grid when finding the next one, as
04532          * calcualtion with doubles is tricky.
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             // unwind last snapping
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     // don't move object from canvas
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     // we only want a repaint if we have guide lines
04618     if ( snapToGuideLines )
04619     {
04620         // redraw guidelines (intentionally always)
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         //kdDebug(33001) << "moveObjectsByKey move = " << move << endl;
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     // unwind last snapping
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 ); // needed if all snapping is off
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     // don't move object off canvas
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         // redraw guidelines (intentionally always)
04712         m_gl.repaintSnapping( movedRect );
04713     }
04714 
04715     if ( move != KoPoint( 0, 0 ) )
04716     {
04717         //kdDebug(33001) << "moveObjectsByMouse move = " << move << endl;
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         // if keep ratio is set caluclate witdh by ratio
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         // resizeBy and moveBy have to been used to make it work with rotated objects
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             // the command is not executed as the object is allready resized.
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         // it can happen that the object is no longer there e.g. when 
04980         // the insert of the object is undone
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             //tz not possible due to const. should const be removed?
04990             //m_objectDisplayAbove = 0;
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         // TODO only 1 draw line
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     // calculate the points as offsets to 0,0
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     //kdDebug(33001)<<"KPrCanvas::setActivePage( KPrPage* active) :"<<active<<endl;
05201     // reset the m_objectDisplayAbove so that it is not display wrong on the other page
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( &macro );
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 // "Extend Contents to Object Height"
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 // "Resize Object to fit Contents"
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     // Since text objects can't get focus without clicking with the mouse,
05412     // no point in supporting focus speaking.
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         //don't remove selection otherwise break dnd.
05431         m_currentTextObjectView->terminate(false);
05432         delete m_currentTextObjectView;
05433         m_currentTextObjectView = 0L;
05434         emitChanged = true;
05435     }
05436 
05437     // Edit the frameset under the mouse, if any
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 /*close*/)
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 ); // needed if all snapping is off
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     // don't snap out of canvas
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     // redraw guidelines (intentionally always)
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         // we have to continue the timer if the menu was canceled and draw mode is not active
05662         if ( ret == -1 && !m_presMenu->isItemChecked( PM_DM ) && !spManualSwitch() )
05663             m_view->continueAutoPresTimer();
05664         return;
05665     }
05666     if ( m_currentTextObjectView ) {
05667         // TODO: Better to popup at caret position.
05668         // KoTextCursor* cursor = m_currentTextObjectView->cursor();
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 }
KDE Home | KDE Accessibility Home | Description of Access Keys