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