Scribus Developer Documentation - API
logo-pen

Scribus Developer Documentation - API

scribusview.cpp

Go to the documentation of this file.
00001 /*
00002 For general Scribus (>=1.3.2) copyright and licensing information please refer
00003 to the COPYING file provided with the program. Following this notice may exist
00004 a copyright and/or license notice that predates the release of Scribus 1.3.2
00005 for which a new license (GPL+exception) is in place.
00006 */
00007 /***************************************************************************
00008                           scribusview.cpp  -  description
00009                              -------------------
00010     begin                : Fre Apr  6 21:47:55 CEST 2001
00011     copyright            : (C) 2001 by Franz Schmid
00012     email                : Franz.Schmid@altmuehlnet.de
00013  ***************************************************************************/
00014 
00015 /***************************************************************************
00016  *                                                                         *
00017  *   This program is free software; you can redistribute it and/or modify  *
00018  *   it under the terms of the GNU General Public License as published by  *
00019  *   the Free Software Foundation; either version 2 of the License, or     *
00020  *   (at your option) any later version.                                   *
00021  *                                                                         *
00022  ***************************************************************************/
00023 
00024 #include "scribusview.h"
00025 
00026 #include "scconfig.h"
00027 
00028 #include <QColor>
00029 #include <QDrag>
00030 #include <QDragEnterEvent>
00031 #include <QDragLeaveEvent>
00032 #include <QDragMoveEvent>
00033 #include <QDropEvent>
00034 #include <QEvent>
00035 #include <QFile>
00036 #include <QFileInfo>
00037 #include <QFont>
00038 #include <QFontMetrics>
00039 #include <QImage>
00040 #include <QImageReader>
00041 #include <QLabel>
00042 #include <QList>
00043 #include <QMenu>
00044 #include <QMimeData>
00045 #include <QMouseEvent>
00046 #include <QPaintEvent>
00047 #include <QPixmap>
00048 #include <QPolygon>
00049 #include <QStack>
00050 #include <QStringList>
00051 #include <QWheelEvent>
00052 #include <QWidgetAction>
00053 
00054 #include <cmath>
00055 #include <cstdio>
00056 #include <cstdlib>
00057 
00058 #ifdef HAVE_UNISTD_H
00059 #include <unistd.h>
00060 #endif
00061 
00062 #include <QUrl>
00063 #include <QDir>
00064 #include <QEvent>
00065 #include <QSizeGrip>
00066 #if QT_VERSION  > 0x030102
00067     #define SPLITVC Qt::SplitHCursor
00068     #define SPLITHC Qt::SplitVCursor
00069 #else
00070     #define SPLITVC Qt::SplitVCursor
00071     #define SPLITHC Qt::SplitHCursor
00072 #endif
00073 #include "scribus.h"
00074 
00075 #include "canvas.h"
00076 #include "canvasgesture.h"
00077 #include "canvasmode.h"
00078 #include "actionmanager.h"
00079 #include "commonstrings.h"
00080 #include "extimageprops.h"
00081 #include "filewatcher.h"
00082 #include "guidemanager.h"
00083 #include "hruler.h"
00084 #include "hyphenator.h"
00085 #include "insertTable.h"
00086 #include "oneclick.h"
00087 #include "page.h"
00088 #include "pageitem_imageframe.h"
00089 #include "pageitem_line.h"
00090 #include "pageitem_pathtext.h"
00091 #include "pageitem_polygon.h"
00092 #include "pageitem_polyline.h"
00093 #include "pageitem_textframe.h"
00094 #include "pageitem_latexframe.h"
00095 #include "pageitemattributes.h"
00096 #include "pageselector.h"
00097 #include "prefscontext.h"
00098 #include "prefsfile.h"
00099 #include "prefsmanager.h"
00100 #include "propertiespalette.h"
00101 #include "rulermover.h"
00102 #include "scmessagebox.h"
00103 #include "scpainter.h"
00104 #include "scpaths.h"
00105 #include "scrapbookpalette.h"
00106 #include "scribusXml.h"
00107 #include "selection.h"
00108 #include "serializer.h"
00109 #include "stencilreader.h"
00110 #include "story.h"
00111 #include "text/nlsconfig.h"
00112 #include "undomanager.h"
00113 #include "units.h"
00114 #include "util.h"
00115 #include "util_color.h"
00116 #include "util_formats.h"
00117 #include "util_icon.h"
00118 #include "util_math.h"
00119 #include "vruler.h"
00120 #include "loadsaveplugin.h"
00121 #include "fileloader.h"
00122 #include "plugins/formatidlist.h"
00123 #include <tiffio.h>
00124 #include CMS_INC
00125 
00126 
00127 using namespace std;
00128 
00129 
00130 
00131 ScribusView::ScribusView(QWidget* win, ScribusMainWindow* mw, ScribusDoc *doc) :
00132     QScrollArea(win),
00133     Doc(doc),
00134     m_canvas(new Canvas(doc, this)),
00135     Prefs(&(PrefsManager::instance()->appPrefs)),
00136     undoManager(UndoManager::instance()),
00137     OldScale(0),
00138     dragX(0), dragY(0), dragW(0), dragH(0),
00139     oldW(-1), // oldCp(-1),
00140 //  Mxp(-1), Myp(-1), Dxp(-1), Dyp(-1),
00141 //  frameResizeHandle(-1),
00142 //  SeRx(-1), SeRy(-1), GyM(-1), GxM(-1),
00143 //  ClRe(-1), ClRe2(-1),
00144 //  SegP1(-1), SegP2(-1),
00145     RotMode(0),
00146     DrHY(-1), DrVX(-1),
00147 //  EdPoints(true),
00148 //  m_MouseButtonPressed(false),    
00149 //  operItemMoving(false),
00150 //  MoveGY(false), MoveGX(false),
00151     HaveSelRect(false),
00152 //  operItemResizing(false),
00153 //  EditContour(false),
00154     //GroupSel(false),
00155     DraggedGroup(false),
00156     DraggedGroupFirst(false),
00157 //  operItemResizeInEditMode(false),
00158     MidButt(false),
00159     updateOn(true),
00160     FirstPoly(true),
00161     Magnify(false),
00162 //  MoveSym(false),
00163 //  previewMode(false),
00164     RCenter(-1,-1),
00165 //  RecordP(),
00166     Ready(false),
00167     oldX(0), oldY(0),
00168     m_groupTransactions(0),
00169     m_groupTransaction(NULL),
00170     _isGlobalMode(true),
00171 //  evSpon(false),
00172 //  forceRedraw(false),
00173 //  Scale(Prefs->DisScale),
00174 //  oldClip(0),
00175     m_vhRulerHW(17),
00176     m_ScMW(mw)
00177 {
00178     setObjectName("s");
00179     setAttribute(Qt::WA_StaticContents);
00180     setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
00181     setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
00182     setViewportMargins(m_vhRulerHW, m_vhRulerHW, 0, 0);
00183     setWidgetResizable(false);
00184     m_canvasMode = CanvasMode::createForAppMode(this, Doc->appMode);
00185     setWidget(m_canvas);
00186     //already done by QScrollArea: widget()->installEventFilter(this);
00187     installEventFilter(this); // FIXME:av
00188 //  viewport()->setBackgroundMode(Qt::PaletteBackground);
00189     setFocusPolicy(Qt::ClickFocus);
00190     QFont fo = QFont(font());
00191     int posi = fo.pointSize()-2;
00192     fo.setPointSize(posi);
00193     unitSwitcher = new QComboBox( this );
00194     unitSwitcher->setFocusPolicy(Qt::NoFocus);
00195     unitSwitcher->setFont(fo);
00196     int maxUindex = unitGetMaxIndex() - 2;
00197     for (int i = 0; i <= maxUindex; ++i)
00198         unitSwitcher->addItem(unitGetStrFromIndex(i));
00199     zoomSpinBox = new ScrSpinBox( 10, 3200, this, 6 );
00200     zoomSpinBox->setTabAdvance(false);
00201     zoomSpinBox->setFont(fo);
00202     zoomSpinBox->setValue( 100 );
00203     zoomSpinBox->setSingleStep(10);
00204     zoomSpinBox->setFocusPolicy(Qt::ClickFocus);
00205     zoomSpinBox->setSuffix( tr( " %" ) );
00206 #if OPTION_USE_QTOOLBUTTON
00207     zoomOutToolbarButton = new QToolButton(this);
00208     zoomDefaultToolbarButton = new QToolButton(this);
00209     zoomInToolbarButton = new QToolButton(this);
00210     cmsToolbarButton = new QToolButton(this);
00211     previewToolbarButton = new QToolButton(this);
00212     zoomDefaultToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
00213     zoomOutToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
00214     zoomInToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
00215     cmsToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
00216     cmsToolbarButton->setCheckable(true);
00217     QIcon ic2;
00218     ic2.addPixmap(loadIcon("cmsOff.png"), QIcon::Normal, QIcon::Off);
00219     ic2.addPixmap(loadIcon("cmsOn.png"), QIcon::Normal, QIcon::On);
00220     cmsToolbarButton->setIcon(ic2);
00221     previewToolbarButton->setAutoRaise(OPTION_FLAT_BUTTON);
00222     previewToolbarButton->setCheckable(true);
00223     QIcon ic;
00224     ic.addPixmap(loadIcon("previewOff.png"), QIcon::Normal, QIcon::Off);
00225     ic.addPixmap(loadIcon("previewOn.png"), QIcon::Normal, QIcon::On);
00226     previewToolbarButton->setIcon(ic);
00227 #else
00228     zoomDefaultToolbarButton = new QPushButton(this);
00229     zoomDefaultToolbarButton->setFocusPolicy(Qt::NoFocus);
00230     zoomDefaultToolbarButton->setDefault( false );
00231     zoomDefaultToolbarButton->setAutoDefault( false );
00232     zoomDefaultToolbarButton->setFlat(OPTION_FLAT_BUTTON);
00233     zoomOutToolbarButton = new QPushButton(this);
00234     zoomOutToolbarButton->setFocusPolicy(Qt::NoFocus);
00235     zoomOutToolbarButton->setDefault( false );
00236     zoomOutToolbarButton->setAutoDefault( false );
00237     zoomOutToolbarButton->setFlat(OPTION_FLAT_BUTTON);
00238     zoomInToolbarButton = new QPushButton(this);
00239     zoomInToolbarButton->setFocusPolicy(Qt::NoFocus);
00240     zoomInToolbarButton->setDefault( false );
00241     zoomInToolbarButton->setAutoDefault( false );
00242     zoomInToolbarButton->setFlat(OPTION_FLAT_BUTTON);
00243     previewToolbarButton = new QPushButton(this);
00244     cmsToolbarButton->setFocusPolicy(Qt::NoFocus);
00245     cmsToolbarButton->setDefault( false );
00246     cmsToolbarButton->setAutoDefault( false );
00247     cmsToolbarButton->setFlat(OPTION_FLAT_BUTTON);
00248     cmsToolbarButton->setPixmap(loadIcon("cmsOn.png"));
00249     previewToolbarButton = new QPushButton(this);
00250     previewToolbarButton->setFocusPolicy(Qt::NoFocus);
00251     previewToolbarButton->setDefault( false );
00252     previewToolbarButton->setAutoDefault( false );
00253     previewToolbarButton->setFlat(OPTION_FLAT_BUTTON);
00254     previewToolbarButton->setPixmap(loadIcon("previewOn.png"));
00255 #endif
00256     //zoomDefaultToolbarButton->setText("1:1");
00257     zoomDefaultToolbarButton->setIcon(QIcon(loadIcon("16/zoom-original.png")));
00258     zoomOutToolbarButton->setIcon(QIcon(loadIcon("16/zoom-out.png")));
00259     zoomInToolbarButton->setIcon(QIcon(loadIcon("16/zoom-in.png")));
00260     pageSelector = new PageSelector(this, Doc->Pages->count());
00261     pageSelector->setFont(fo);
00262     pageSelector->setFocusPolicy(Qt::ClickFocus);
00263     layerMenu = new QComboBox( this );
00264     layerMenu->setEditable(false);
00265     layerMenu->setFont(fo);
00266     layerMenu->setFocusPolicy(Qt::NoFocus);
00267     visualMenu = new QComboBox( this );
00268     visualMenu->setFocusPolicy(Qt::NoFocus);
00269     visualMenu->setFont(fo);
00270     visualMenu->setEnabled(false);
00271     horizRuler = new Hruler(this, Doc);
00272     vertRuler = new Vruler(this, Doc);
00273     horizRuler->installEventFilter(this);
00274     vertRuler->installEventFilter(this);
00275     rulerMover = new RulerMover(this);
00276     rulerMover->setFocusPolicy(Qt::NoFocus);
00277     horizRuler->setGeometry(m_vhRulerHW, 1, width()-m_vhRulerHW-1, m_vhRulerHW);
00278     vertRuler->setGeometry(1, m_vhRulerHW, m_vhRulerHW, height()-m_vhRulerHW-1);
00279     rulerMover->setGeometry(1, 1, m_vhRulerHW, m_vhRulerHW);
00280     Ready = true;
00281     m_canvas->setMouseTracking(true);
00282     setAcceptDrops(true);
00283     m_canvas->setAcceptDrops(true);
00284     // FIXME setDragAutoScroll(false);
00285     Doc->DragP = false;
00286     Doc->leaveDrag = false;
00287     Doc->SubMode = -1;
00288     storedFramesShown = Doc->guidesSettings.framesShown;
00289     storedShowControls = Doc->guidesSettings.showControls;
00290     m_canvas->m_viewMode.viewAsPreview = false;
00291     m_canvas->setPreviewVisual(-1);
00292 //  shiftSelItems = false;
00293 //  inItemCreation = false;
00294     m_previousMode = -1;
00295     redrawMode = 0;
00296     redrawCount = 0;
00297     redrawMarker = new QRubberBand(QRubberBand::Rectangle);
00298     redrawMarker->hide();
00299     m_canvas->newRedrawPolygon();
00300     m_canvas->resetRenderMode();
00301     m_ScMW->scrActions["viewFitPreview"]->setChecked(m_canvas->m_viewMode.viewAsPreview);
00302 //  m_SnapCounter = 0;
00303     
00304     Doc->regionsChanged()->connectObserver(this);
00305     connect(zoomOutToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomOut()));
00306     connect(zoomInToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoomIn()));
00307     connect(zoomDefaultToolbarButton, SIGNAL(clicked()), this, SLOT(slotZoom100()));
00308     connect(zoomSpinBox, SIGNAL(valueChanged(double)), this, SLOT(setZoom()));
00309     connect(pageSelector, SIGNAL(GotoPage(int)), this, SLOT(GotoPa(int)));
00310     connect(layerMenu, SIGNAL(activated(int)), this, SLOT(GotoLa(int)));
00311     connect(unitSwitcher, SIGNAL(activated(int)), this, SLOT(ChgUnit(int)));
00312     connect(previewToolbarButton, SIGNAL(clicked()), this, SLOT(togglePreview()));
00313     connect(cmsToolbarButton, SIGNAL(clicked()), this, SLOT(toggleCMS()));
00314     connect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
00315     connect(this, SIGNAL(HaveSel(int)), this, SLOT(selectionChanged()));
00316     languageChange();
00317     m_dragTimer = new QTimer(this);
00318     connect(m_dragTimer, SIGNAL(timeout()), this, SLOT(dragTimerTimeOut()));
00319     m_dragTimer->stop();
00320     m_dragTimerFired = false;
00321 }
00322 
00323 ScribusView::~ScribusView()
00324 {
00325     while (m_canvasMode)
00326     {
00327         m_canvasMode->deactivate(false);
00328         m_canvasMode = m_canvasMode->delegate();
00329     }
00330 }
00331 
00332 void ScribusView::changeEvent(QEvent *e)
00333 {
00334     if (e->type() == QEvent::LanguageChange)
00335     {
00336         languageChange();
00337     }
00338     else
00339         QWidget::changeEvent(e);
00340 }
00341 
00342 void ScribusView::languageChange()
00343 {
00344     cmsToolbarButton->setToolTip("");
00345     previewToolbarButton->setToolTip("");
00346     visualMenu->setToolTip("");
00347     cmsToolbarButton->setToolTip( tr("Switches Color Management on or off"));
00348     previewToolbarButton->setToolTip( tr("Enables the Preview Mode"));
00349     visualMenu->setToolTip( tr("Here you can select the visual appearance of the display\nYou can choose between normal and several color blindness forms"));
00350     disconnect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
00351     visualMenu->clear();
00352     visualMenu->addItem(CommonStrings::trVisionNormal);
00353     visualMenu->addItem(CommonStrings::trVisionProtanopia);
00354     visualMenu->addItem(CommonStrings::trVisionDeuteranopia);
00355     visualMenu->addItem(CommonStrings::trVisionTritanopia);
00356     visualMenu->addItem(CommonStrings::trVisionFullColorBlind);
00357     visualMenu->setCurrentIndex(m_canvas->previewVisual());
00358     connect(visualMenu, SIGNAL(activated(int)), this, SLOT(switchPreviewVisual(int)));
00359 }
00360 
00361 void ScribusView::toggleCMS()
00362 {
00363     Doc->enableCMS(!Doc->HasCMS);
00364 //  repaintContents(QRect());
00365     DrawNew();
00366 }
00367 
00368 void ScribusView::switchPreviewVisual(int vis)
00369 {
00370     m_canvas->setPreviewVisual(vis);
00371     Doc->recalculateColors();
00372     Doc->recalcPicturesRes();
00373 //  repaintContents(QRect());
00374     DrawNew();
00375 }
00376 
00377 void ScribusView::togglePreview()
00378 {
00379     m_canvas->m_viewMode.viewAsPreview = !m_canvas->m_viewMode.viewAsPreview;
00380     if (m_canvas->m_viewMode.viewAsPreview)
00381     {
00382         storedFramesShown = Doc->guidesSettings.framesShown;
00383         Doc->guidesSettings.framesShown = false;
00384         storedShowControls = Doc->guidesSettings.showControls;
00385         Doc->guidesSettings.showControls = false;
00386         // warning popping up in case colour management and out-of-gamut-display are active
00387         // as from #4346: Add a preview for daltonian - PV
00388         if (Doc->HasCMS && Doc->Gamut)
00389             QMessageBox::information(m_ScMW, tr("Preview Mode"),
00390                         "<qt>" + tr("CMS is active. Therefore the color display may not match the perception by visually impaired") + "</qt>",
00391                         QMessageBox::Ok);
00392     }
00393     else
00394     {
00395         Doc->guidesSettings.framesShown = storedFramesShown;
00396         Doc->guidesSettings.showControls = storedShowControls;
00397     }
00398     m_ScMW->scrActions["viewFitPreview"]->setChecked(m_canvas->m_viewMode.viewAsPreview);
00399     m_ScMW->scrActions["viewShowMargins"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
00400     m_ScMW->scrActions["viewShowFrames"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
00401     m_ScMW->scrActions["viewShowLayerMarkers"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
00402     m_ScMW->scrActions["viewShowGrid"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
00403     m_ScMW->scrActions["viewShowGuides"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
00404     m_ScMW->scrActions["viewShowColumnBorders"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
00405     m_ScMW->scrActions["viewShowBaseline"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
00406     m_ScMW->scrActions["viewShowTextChain"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
00407     m_ScMW->scrActions["viewShowTextControls"]->setEnabled(!m_canvas->m_viewMode.viewAsPreview);
00408 #if OPTION_USE_QTOOLBUTTON
00409     previewToolbarButton->setChecked(m_canvas->m_viewMode.viewAsPreview);
00410 #endif
00411     visualMenu->setEnabled(m_canvas->m_viewMode.viewAsPreview);
00412     Doc->recalculateColors();
00413     Doc->recalcPicturesRes();
00414 //  repaintContents(QRect());
00415     DrawNew();
00416 }
00417 
00418 void ScribusView::changed(QRectF re)
00419 {
00420     if (!Doc->isLoading())
00421     {
00422         qDebug() << "ScribusView-changed(): changed region:" << re;
00423         m_canvas->m_viewMode.forceRedraw = true;
00424         updateCanvas(re);
00425     }
00426 }
00427 
00428 void ScribusView::startGesture(CanvasGesture* gesture)
00429 {
00430     qDebug() << "start gesture" << typeid(*m_canvasMode).name() 
00431             << "---->" 
00432             << typeid(*gesture).name();
00433     m_canvasMode->deactivate(true);
00434     gesture->setDelegate(m_canvasMode);
00435     m_canvasMode = gesture;
00436     m_canvasMode->activate(false);
00437     if (Doc->appMode != modeEditClip)
00438         m_canvas->repaint();
00439 }
00440 
00441 void ScribusView::stopGesture()
00442 {
00443     qDebug() << "stop gesture" << typeid(*m_canvasMode).name() << (m_canvasMode->delegate() != 0);
00444     if (m_canvasMode->delegate())
00445     {
00446         m_canvasMode->deactivate(false);
00447         m_canvasMode = m_canvasMode->delegate();
00448         m_canvasMode->activate(true);
00449         if (PrefsManager::instance()->appPrefs.stickyTools)
00450         {
00451             m_canvas->m_viewMode.forceRedraw = true;
00452             m_canvas->resetRenderMode();
00453             updateContents();
00454         }
00455         else
00456             m_canvas->repaint();
00457     }
00458 }
00459 
00467 void ScribusView::requestMode(int appMode)
00468 {
00469     bool updateNecessary = false;
00470     qDebug() << "request mode:" << appMode;
00471     switch(appMode) // filter submodes
00472     {
00473         case submodePaintingDone:   // return to normal mode
00474 //          appMode = m_previousMode < 0 ? modeNormal : m_previousMode;
00475             appMode = modeNormal;
00476             m_previousMode = -1;
00477             updateNecessary = true;
00478             break;          
00479         case submodeEndNodeEdit:     // return from node/shape editing
00480 //          appMode = m_previousMode < 0 ? modeNormal : m_previousMode;
00481             appMode = modeNormal;
00482             m_previousMode = -1;
00483             updateNecessary = true;
00484             break;
00485             /*
00486              case submodeToggleNodeEdit:
00487                  if (Doc->appMode == modeEditClip)
00488                  {
00489                      m_ScMW->setAppMode(m_previousMode < 0 ? modeNormal : m_previousMode);
00490                      m_previousMode = -1;
00491                  }
00492                  else
00493                  {
00494                      m_previousMode = Doc->appMode;
00495                      m_ScMW->setAppMode(modeEditClip);
00496                  }
00497                  return;
00498                  */
00499         case submodeLoadPic:         // open GetImage dialog
00500             appMode = Doc->appMode;
00501             m_previousMode = appMode;
00502             m_ScMW->slotGetContent();
00503             break;
00504         case submodeStatusPic:       // open ManageImages dialog
00505             appMode = Doc->appMode;
00506             m_previousMode = appMode;
00507             m_ScMW->StatusPic();
00508             break;
00509         case submodeEditExternal:    // open external image editor
00510             appMode = Doc->appMode;
00511             m_previousMode = appMode;
00512             m_ScMW->callImageEditor();
00513             break;
00514         case submodeAnnotProps: 
00515             appMode = Doc->appMode;
00516             m_previousMode = appMode;
00517             m_ScMW->ModifyAnnot();
00518             break;
00519         default:
00520             if (appMode < 0 || appMode > submodeFirstSubmode)
00521             {
00522                 qDebug() << "request mode: UNKNOWN" << appMode;
00523                 appMode = modeNormal;
00524             }
00525             m_previousMode = appMode;           
00526             break;
00527     }
00528 
00529     qDebug() << "request mode" << Doc->appMode << "-->" << appMode;
00530     if (Doc->appMode != appMode)
00531     {
00532         m_ScMW->setAppMode(appMode);
00533         CanvasMode* newCanvasMode = modeInstances.value(appMode);
00534         if (!newCanvasMode)
00535         {
00536             newCanvasMode = CanvasMode::createForAppMode(this, appMode);
00537             modeInstances[appMode] = newCanvasMode;
00538         }
00539         if (newCanvasMode)
00540         {
00541             qDebug() << "request canvas mode" << typeid(*newCanvasMode).name();
00542             m_canvasMode->deactivate(false);
00543             m_canvasMode = newCanvasMode;
00544             m_canvasMode->activate(false);
00545         }
00546         updateNecessary = true;
00547     }
00548     else
00549         m_ScMW->setAppMode(appMode);
00550 //  if (appMode == modeEdit)
00551 //  {
00552 //      m_ScMW->activateWindow();
00553 //  }
00554     if (updateNecessary)
00555         updateCanvas();
00556 }
00557 
00558 
00559 
00560 /*
00561 void ScribusView::paintEvent ( QPaintEvent * p )
00562 {
00563     #ifndef _WIN32
00564     if (p->spontaneous())
00565         evSpon = true;
00566     #endif
00567     QScrollArea::paintEvent(p);
00568 //  QPainter qp(viewport());
00569 //  drawContents(&qp, p->rect().x(), p->rect().y(), p->rect().width(), p->rect().height());
00570 }
00571 */
00572 
00573 void ScribusView::enterEvent(QEvent * e)
00574 {
00575     m_canvasMode->enterEvent(e);
00576     return;
00577     /*
00578     if (!m_canvas->m_viewMode.m_MouseButtonPressed)
00579     {
00580         switch (Doc->appMode)
00581         {
00582             case modeDrawShapes:
00583                 qApp->changeOverrideCursor(QCursor(loadIcon("DrawFrame.xpm")));
00584                 break;
00585             case modeDrawImage:
00586                 qApp->changeOverrideCursor(QCursor(loadIcon("DrawImageFrame.xpm")));
00587                 break;
00588             case modeDrawLatex:
00589                 qApp->changeOverrideCursor(QCursor(loadIcon("DrawLatexFrame.xpm")));
00590                 break;
00591             case modeDrawText:
00592                 qApp->changeOverrideCursor(QCursor(loadIcon("DrawTextFrame.xpm")));
00593                 break;
00594             case modeDrawTable:
00595                 qApp->changeOverrideCursor(QCursor(loadIcon("DrawTable.xpm")));
00596                 break;
00597             case modeDrawRegularPolygon:
00598                 qApp->changeOverrideCursor(QCursor(loadIcon("DrawPolylineFrame.xpm")));
00599                 break;
00600             case modeDrawLine:
00601             case modeDrawBezierLine:
00602                 qApp->changeOverrideCursor(QCursor(Qt::CrossCursor));
00603                 break;
00604             case modeDrawFreehandLine:
00605                 qApp->changeOverrideCursor(QCursor(loadIcon("DrawFreeLine.png"), 0, 32));
00606                 break;
00607             case modeMagnifier:
00608                 if (Magnify)
00609                     qApp->changeOverrideCursor(QCursor(loadIcon("LupeZ.xpm")));
00610                 else
00611                     qApp->changeOverrideCursor(QCursor(loadIcon("LupeZm.xpm")));
00612                 break;
00613             case modePanning:
00614                 qApp->changeOverrideCursor(QCursor(loadIcon("HandC.xpm")));
00615                 break;
00616             case modeMeasurementTool:
00617             case modeEditGradientVectors:
00618             case modeInsertPDFButton:
00619             case modeInsertPDFTextfield:
00620             case modeInsertPDFCheckbox:
00621             case modeInsertPDFCombobox:
00622             case modeInsertPDFListbox:
00623             case modeInsertPDFTextAnnotation:
00624             case modeInsertPDFLinkAnnotation:
00625                 qApp->changeOverrideCursor(QCursor(Qt::CrossCursor));
00626                 break;
00627             default:
00628                 qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
00629             break;
00630         }
00631     }*/
00632 }
00633 
00634 void ScribusView::leaveEvent(QEvent *e)
00635 {
00636     m_canvasMode->leaveEvent(e);
00637     return;
00638     
00639 /*  if (BlockLeave)
00640         return; */
00641     if (!m_canvas->m_viewMode.m_MouseButtonPressed)
00642         qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
00643 /*  else
00644     {
00645         if ((SelItem.count() != 0) && (m_canvas->m_viewMode.m_MouseButtonPressed) && (!doku->DragP) && (doku->appMode == 1))
00646         {
00647             PageItem *currItem = SelItem.at(0);
00648             if ((b->Locked) || (b->Sizing))
00649                 return;
00650             doku->DragP = true;
00651             doku->leaveDrag = true;
00652             doku->DraggedElem = b;
00653             doku->DragElements.clear();
00654             for (uint dre=0; dre<SelItem.count(); ++dre)
00655                 doku->DragElements.append(SelItem.at(dre)->ItemNr);
00656             ScriXmlDoc *ss = new ScriXmlDoc();
00657             QDragObject *dr = new QTextDrag(ss->WriteElem(&SelItem, doku), this);
00658             dr->setPixmap(loadIcon("DragPix.xpm"));
00659             dr->drag();
00660             delete ss;
00661             ss=NULL;
00662             doku->DragP = false;
00663             doku->leaveDrag = false;
00664             m_canvas->m_viewMode.m_MouseButtonPressed = false;
00665             doku->DraggedElem = 0;
00666             doku->DragElements.clear();
00667         }
00668     } */
00669 }
00670 
00671 void ScribusView::contentsDragEnterEvent(QDragEnterEvent *e)
00672 {
00673     QString text;
00674     e->accept();
00675     if (e->mimeData()->hasText())
00676     {
00677         e->acceptProposedAction();
00678         text = e->mimeData()->text();
00679         double gx, gy, gw, gh;
00680         QUrl ur(text);
00681         QFileInfo fi = QFileInfo(ur.path());
00682         ScriXmlDoc *ss = new ScriXmlDoc();
00683         if (fi.exists())
00684             text = ur.path();
00685         if(ss->ReadElemHeader(text,fi.exists(), &gx, &gy, &gw, &gh))
00686         {
00687             FPoint dragPosDoc = m_canvas->globalToCanvas(widget()->mapToGlobal(e->pos()));
00688             dragX = dragPosDoc.x(); //e->pos().x() / m_canvas->scale();
00689             dragY = dragPosDoc.y(); //e->pos().y() / m_canvas->scale();
00690             dragW = gw;
00691             dragH = gh;
00692             DraggedGroup = true;
00693             DraggedGroupFirst = true;
00694             getDragRectScreen(&gx, &gy, &gw, &gh);
00695 //          QPoint evP = viewport()->mapToGlobal(e->pos());
00696 //          evP -= QPoint(contentsX(), contentsY());
00697 //          redrawMarker->setGeometry(QRect(evP.x() + 1, evP.y() + 1, qRound(gw), qRound(gh)).normalized());
00698 //          if (!redrawMarker->isVisible())
00699 //              redrawMarker->show();
00700             emit ItemGeom(gw, gh);
00701         }
00702         delete ss;
00703         ss=NULL;
00704     }
00705 }
00706 
00707 void ScribusView::contentsDragMoveEvent(QDragMoveEvent *e)
00708 {
00709     QString text;
00710     e->accept();
00711     if (e->mimeData()->hasText())
00712     {
00713         e->acceptProposedAction();
00714         text = e->mimeData()->text();
00715         if (DraggedGroup)
00716         {
00717 //          double gx, gy, gw, gh;
00718             FPoint dragPosDoc = m_canvas->globalToCanvas(widget()->mapToGlobal(e->pos()));
00719             dragX = dragPosDoc.x(); //e->pos().x() / m_canvas->scale();
00720             dragY = dragPosDoc.y(); //e->pos().y() / m_canvas->scale();
00721 //          getDragRectScreen(&gx, &gy, &gw, &gh);
00722 //          QPoint evP = viewport()->mapToGlobal(e->pos());
00723 //          evP -= QPoint(contentsX(), contentsY());
00724 //          redrawMarker->setGeometry(QRect(evP.x() + 2, evP.y() + 2, qRound(gw - 2), qRound(gh - 2)).normalized());
00725 //          if (!redrawMarker->isVisible())
00726 //              redrawMarker->show();
00727             DraggedGroupFirst = false;
00728             emit MousePos(dragX, dragY); //+Doc->minCanvasCoordinate.x(), dragY+Doc->minCanvasCoordinate.y());
00729             QPoint pos = m_canvas->canvasToLocal(dragPosDoc);
00730             horizRuler->Draw(pos.x());
00731             vertRuler->Draw(pos.y());
00732 //          return;
00733         }
00734 /*      QUrl ur(text);
00735         QFileInfo fi = QFileInfo(ur.path());
00736         QString ext = fi.extension(false).toUpper();
00737         QStrList imfo = QImageIO::inputFormats();
00738         if (ext == "JPG")
00739             ext = "JPEG";
00740         img = ((imfo.contains(ext))||(ext=="PS")||(ext=="EPS")||(ext=="TIF"));
00741         if (!SeleItemPos(e->pos()))
00742         {
00743             if (SelItem.count() != 0)
00744                 Deselect(true);
00745         }
00746         else
00747         {
00748             b = SelItem.at(0);
00749             if (img)
00750             {
00751                 if (b->PType != 2)
00752                     Deselect(true);
00753             }
00754             else
00755             {
00756                 if (b->PType != 4)
00757                     Deselect(true);
00758             }
00759         } */
00760     }
00761 }
00762 
00763 void ScribusView::contentsDragLeaveEvent(QDragLeaveEvent *)
00764 {
00765     if (DraggedGroup)
00766     {
00767         DraggedGroup = false;
00768         DraggedGroupFirst = false;
00769         m_canvas->resetRenderMode();
00770 //      redrawMarker->hide();
00771         updateContents();
00772     }
00773 }
00774 
00775 void ScribusView::contentsDropEvent(QDropEvent *e)
00776 {
00777     QString text;
00778     QUrl url;
00779     PageItem *currItem;
00780     UndoTransaction* activeTransaction = NULL;
00781     bool img = false;
00782     m_canvas->resetRenderMode();
00783     redrawMode = 0;
00784 //  redrawMarker->hide();
00785 //  struct ScText *hg;
00786 //  uint a;
00787     int re = 0;
00788 //  e->accept(Q3TextDrag::canDecode(e));
00789     e->accept();
00790     DraggedGroupFirst = false;
00791     FPoint dropPosDoc = m_canvas->globalToCanvas(widget()->mapToGlobal(e->pos()));
00792     QPointF dropPosDocQ(dropPosDoc.x(), dropPosDoc.y());
00793 //  int ex = qRound(e->pos().x()/m_canvas->scale());// + Doc->minCanvasCoordinate.x());
00794 //      int ey = qRound(e->pos().y()/m_canvas->scale());// + Doc->minCanvasCoordinate.y());
00795 
00796     if (e->mimeData()->hasText())
00797     {
00798         text = e->mimeData()->text();
00799         url = QUrl(text);
00800     }
00801     else if (e->mimeData()->hasUrls())
00802     {
00803         url = e->mimeData()->urls().at(0);
00804         text = "";
00805     }
00806     qDebug() << "ScribusView::contentsDropEvent" << e->mimeData()->formats() << url;
00807     if (!url.isEmpty())
00808     {
00809         e->acceptProposedAction();
00810         //<<#3524
00811         activateWindow();
00812         raise();
00813         m_ScMW->newActWin(Doc->WinHan);
00814         updateContents();
00815         //>>
00816         QFileInfo fi = QFileInfo(url.path());
00817         QString ext = fi.suffix().toUpper();
00818         QStringList imfo;
00819         QList<QByteArray> imgs = QImageReader::supportedImageFormats();
00820         for (int i = 0; i < imgs.count(); ++i )
00821         {
00822             imfo.append(QString(imgs.at(i)).toUpper());
00823         }
00824         if (ext == "JPG")
00825             ext = "JPEG";
00826         //CB Need to handle this ugly file extension list elsewhere... some capabilities class perhaps
00827         img = ((imfo.contains(ext)) || extensionIndicatesPDF(ext) || extensionIndicatesEPSorPS(ext) || extensionIndicatesTIFF(ext) || extensionIndicatesJPEG(ext) || extensionIndicatesPSD(ext));
00828         bool selectedItemByDrag=false;
00829 //      int pscx=qRound(e->pos().x()/m_canvas->scale()), pscy=qRound(e->pos().y()/m_canvas->scale());
00830         //Loop through all items and see which one(s) were under the drop point on the current layer
00831         //Should make a nice function for this.
00832         for (int i=0; i<Doc->Items->count(); ++i)
00833         {
00834             if (Doc->Items->at(i)->LayerNr==Doc->activeLayer())
00835             {
00836                 if (m_canvas->frameHitTest(dropPosDocQ, Doc->Items->at(i)) >= Canvas::INSIDE)
00837                 {
00838                     Deselect(false);
00839                     SelectItem(Doc->Items->at(i));
00840                     selectedItemByDrag=true;
00841                     break;
00842                 }
00843             }
00844         }
00845 //      qDebug() << "drop - img:" << img << "file:" << fi.exists() << "suffix:" << fi.suffix() << "select by drag:" << selectedItemByDrag;
00846         //CB When we drag an image to a page from outside
00847         //SeleItemPos is from 1.2.x. Needs reenabling for dragging *TO* a frame
00848         if ((fi.exists()) && (img) && !selectedItemByDrag)// && (!SeleItemPos(e->pos())))
00849         {
00850             int z = Doc->itemAdd(PageItem::ImageFrame, PageItem::Unspecified, dropPosDoc.x(), dropPosDoc.y(), 1, 1, 1, Doc->toolSettings.dBrushPict, CommonStrings::None, true);
00851             PageItem *b = Doc->Items->at(z);
00852             Doc->LoadPict(url.path(), b->ItemNr);
00853             b->setWidth(static_cast<double>(b->OrigW * 72.0 / b->pixm.imgInfo.xres));
00854             b->setHeight(static_cast<double>(b->OrigH * 72.0 / b->pixm.imgInfo.yres));
00855             b->OldB2 = b->width();
00856             b->OldH2 = b->height();
00857             b->updateClip();
00858             emit DocChanged();
00859             update();
00860             return;
00861         }
00862         //if ((SeleItemPos(e->pos())) && (!text.startsWith("<SCRIBUSELEM")))
00863         if (Doc->m_Selection->count()>0 && (m_canvas->frameHitTest(dropPosDocQ, Doc->m_Selection->itemAt(0)) >= Canvas::INSIDE) && (img))
00864         {
00865             PageItem *b = Doc->m_Selection->itemAt(0);
00866             if (b->itemType() == PageItem::ImageFrame)
00867             {
00868                 if ((fi.exists()) && (img))
00869                 {
00870                     Doc->LoadPict(url.path(), b->ItemNr);
00871                     updateContents();
00872                 }
00873             }
00874             /* CB leaving this out for now...
00875             if (b->PType == 4)
00876             {
00877                 if ((b->BackBox != 0) && (b->itemText.count() == 0))
00878                     return;
00879                 if ((fi.exists()) && (!img) && (fi.size() < 500000))
00880                 {
00881                     Serializer *ss = new Serializer(ur.path());
00882                     if (ss->Read())
00883