Subversion Repositories Scribus


Rev 18589 | Rev 20681 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

 For general Scribus (>=1.3.2) copyright and licensing information please refer
 to the COPYING file provided with the program. Following this notice may exist
 a copyright and/or license notice that predates the release of Scribus 1.3.2
 for which a new license (GPL+exception) is in place.

scribusview.h  -  description
    begin                : Fre Apr  6 21:47:55 CEST 2001
    copyright            : (C) 2001 by Franz Schmid
    email                :

*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *

#ifndef CANVAS_H
#define CANVAS_H

#include <QApplication>
//#include <QDebug>
#include <QPolygon>
#include <QRect>
#include <QRectF>
#include <QWidget>

#include "scribusapi.h"

#include "commonstrings.h"
#include "fpoint.h"
#include "fpointarray.h"
#include "pageitempointer.h"

class ScPage;
class PageItem;
class ScLayer;
class ScPainter;
class ScribusDoc;
class ScribusView;

struct CanvasViewMode
        void init();
        double scale;

        bool previewMode;
        bool viewAsPreview;
        int previewVisual;

        bool m_MouseButtonPressed;
        bool operItemMoving;
        bool operItemResizing;
        bool operItemSelecting;
        bool operTextSelecting;
        QPolygon redrawPolygon;
        QList<PageItemPointer> linkedFramesToShow;
        /** if true, selected objects will not be drawn by drawContents() */
        bool drawSelectedItemsWithControls;
        /** if true, drawContents() will draw framelinks even if View->Show Framelinks is false */
        bool drawFramelinksWithContents;
        // used for buffering:
        bool forceRedraw;

QDataStream &operator<<(QDataStream & ds, const CanvasViewMode & vm);
QDataStream &operator>>(QDataStream & ds, CanvasViewMode & vm);

class SCRIBUS_API Canvas : public QWidget
        static const uint moveWithFullOutlinesThreshold = 21;
        static const uint moveWithBoxesOnlyThreshold = 41;

        Canvas(ScribusDoc* doc, ScribusView* parent);
        friend class ScribusView; // for now...
        friend class CanvasMode;
        friend class CanvasMode_CopyProperties;
        friend class CanvasMode_Edit;
        friend class CanvasMode_EditArc;
        friend class CanvasMode_EditGradient;
        friend class CanvasMode_EditMeshGradient;
        friend class CanvasMode_EditMeshPatch;
        friend class CanvasMode_EditWeldPoint;
        friend class CanvasMode_EditPolygon;
        friend class CanvasMode_EditSpiral;
        friend class CanvasMode_EditTable;
        friend class CanvasMode_EyeDropper;
        friend class CanvasMode_FrameLinks;
        friend class CanvasMode_ImageImport;
        friend class CanvasMode_Magnifier;
        friend class CanvasMode_NodeEdit;
        friend class CanvasMode_ObjImport;
        friend class CanvasMode_Panning;
        friend class CanvasMode_Normal;
        friend class CanvasMode_Rotate;
        friend class FreehandMode;
        friend class CalligraphicMode;
        /* Dont rely on these codes!
         * 2 8 3
         * 7   6
         * 4 5 1
         * But always OUTSIDE < 0, INSIDE >= 0 and any specific handle > 0.

        enum FrameHandle {
                OUTSIDE = -1,
                INSIDE = 0,
                NORTHWEST = 2,
                NORTH = 8,
                NORTHEAST = 3,
                EAST = 6,
                SOUTHEAST = 1,
                SOUTH = 5,
                SOUTHWEST = 4,
                WEST = 7
        enum RenderMode {
                RENDER_NORMAL,                // update buffer, paint buffer: expensive for large regions
                RENDER_BUFFERED,              // just paint buffer: fast, but only controls may change (eg. resize mode)
                // in the following two modes, only the selected objects are updated. Might not be exact.
                RENDER_SELECTION_SEPARATE,    // paint buffer w/o selection, then paint selection (eg. img edit, nodeedit, rotate, beziercurve)
                RENDER_SELECTION_BUFFERED,    // paint buffer w/o selection, update selection buffer, then paint selection buffer (eg. move, text edit)
        void setRenderMode(RenderMode m);
        void clearBuffers();              // very expensive
        // deprecated:
        void resetRenderMode() { m_renderMode = RENDER_NORMAL; clearBuffers(); }
        void setRenderModeFillBuffer() { m_renderMode = RENDER_BUFFERED; }
        void setRenderModeUseBuffer(bool use) { m_renderMode = (use ? RENDER_BUFFERED : RENDER_NORMAL) ; }

        double scale() const { return m_viewMode.scale; }
        void setScale(double scale);
        QPoint canvasToLocal(FPoint p) const;
        QPoint canvasToGlobal(FPoint p) const;
        QPoint canvasToLocal(QPointF p) const;
        QPoint canvasToGlobal(QPointF p) const;
        QRect canvasToLocal(QRectF p) const;
        QRect canvasToGlobal(QRectF p) const;
        FPoint localToCanvas(QPoint p) const;
//      FPoint localToCanvas(QPointF p) const;
        FPoint globalToCanvas(QPoint p) const;
//      FPoint globalToCanvas(QPointF p) const;
        QRectF globalToCanvas(QRect p) const;
//      QRectF globalToCanvas(QRectF p) const;
        bool hitsCanvasPoint(QPoint globalPoint, FPoint canvasPoint) const;
        bool hitsCanvasPoint(QPoint globalPoint, QPointF canvasPoint) const;
        bool hitsCanvasPoint(FPoint globalPoint, QPointF canvasPoint) const;
        QRect exposedRect() const;
        bool cursorOverTextFrameControl(QPoint globalPos, PageItem* frame);
        bool cursorOverFrameControl(QPoint globalPos, QRectF targetRect, PageItem* frame);
        /** Returns the framehandle or INSIDE if the position falls into the frame. */
        FrameHandle frameHitTest(QPointF canvasPoint, PageItem* frame) const;
        FrameHandle frameHitTest(QPointF point, QRectF frame) const;
                Returns the item under the cursor or NULL if none found.
         Does *not* change the selection.
         If itemAbove is given, it will look for an item under itemAbove, allowing select under.
         The flag 'allowInGroup' controls if single items within a group or only whole groups are considered.
         The flag 'allowMasterItems' controls if items from a masterpage are considered.
         (this flag is ignored in masterpage mode, since all items are masterpage items then).

        PageItem* itemUnderCursor(QPoint globalPos, PageItem* itemAbove=NULL, bool allowInGroup=false, bool allowMasterItems=false) const;
        PageItem* itemInGroup(PageItem* group, QRectF mouseArea) const;
        PageItem* itemUnderItem(PageItem* item, int& index) const;
        const QPolygon& redrawPolygon() const { return m_viewMode.redrawPolygon; }
        QPolygon& newRedrawPolygon()
                return m_viewMode.redrawPolygon;
        void setForcedRedraw(bool on) { m_viewMode.forceRedraw = on; }
        void setPreviewMode(bool on) { m_viewMode.previewMode = on; }
        bool isPreviewMode() const { return m_viewMode.previewMode || m_viewMode.viewAsPreview; }
        bool usePreviewVisual() const { return m_viewMode.viewAsPreview && m_viewMode.previewVisual != 0; }
        int previewVisual() const { return m_viewMode.previewVisual; }
        void setPreviewVisual(int mode);
        void DrawMasterItems(ScPainter *painter, ScPage *page, ScLayer& layer, QRect clip);
        //notesFramesPass determine if notes frames are drawed or not
        void DrawPageItems(ScPainter *painter, ScLayer& layer, QRect clip, bool notesFramesPass);
        virtual void paintEvent ( QPaintEvent * p );
        void displayXYHUD(QPoint m);
        void displayCorrectedXYHUD(QPoint m, double x, double y);
        void displayCorrectedSingleHUD(QPoint m, double val, bool isX);
        void displayXYHUD(QPoint m, double x, double y);
        void displaySizeHUD(QPoint m, double x, double y, bool isLine = false);
        void displayRotHUD(QPoint m, double rot);
        void displayRealRotHUD(QPoint m, double rot);
         * Displays a tooltip of the format <code>{label}: {N} {unit}</code> where <code>N</code> is
         * @a value converted to the current document unit and <code>unit</code> the current document
         * unit. The tooltip will be displayed nearby the global point @a point.

                void displayDoubleHUD(QPoint point, const QString& label, double value);

        void setupEditHRuler(PageItem * item, bool forceAndReset = false);
        void DrawPageBorderSub(ScPainter *p, ScPage *page);
        void DrawPageBorder(ScPainter *p, QRectF clip, bool master = false);
        void DrawPageMarginsGridSub(ScPainter *p, ScPage *page);
        void DrawPageMargins(ScPainter *p, QRectF clip, bool master = false);
        void DrawPageBaselineGridSub(ScPainter *p, ScPage *page);
        void DrawPageBaselineGrid(ScPainter *p, QRectF clip, bool master = false);
        void DrawPageGridSub(ScPainter *p, ScPage *page, QRectF clip);
        void DrawPageGrid(ScPainter *p, QRectF clip, bool master = false);
        void DrawPageGuidesSub(ScPainter *p, ScPage *page);
        void DrawPageGuides(ScPainter *p, QRectF clip, bool master = false);
        void DrawPageIndicatorSub(ScPainter *p, ScPage *page);
        void DrawPageIndicator(ScPainter *p, QRectF clip, bool master = false);
        void drawLinkFrameLine(ScPainter* painter, FPoint &start, FPoint &end);
        void PaintSizeRect(QRect neu);
        void PaintSizeRect(QPolygon neu);
        void Transform(PageItem *currItem, QPainter *p);
        void Transform(PageItem *currItem, QTransform& m);
        void TransformM(PageItem *currItem, QPainter *p);
        void getGroupRectScreen(double *x, double *y, double *w, double *h);

                Enlarges the buffer such that it contains the viewport.

        bool adjustBuffer();
                Fills the given buffer with contents.
            bufferOrigin and clipRect are in local coordinates

        void fillBuffer(QPaintDevice* buffer, QPoint bufferOrigin, QRect clipRect);
        void drawContents(QPainter *p, int clipx, int clipy, int clipw, int cliph);
        void drawBackgroundMasterpage(ScPainter* painter, int clipx, int clipy, int clipw, int cliph);
        void drawBackgroundPageOutlines(ScPainter* painter, int clipx, int clipy, int clipw, int cliph);
        void drawFrameLinks(ScPainter* painter);
        void drawControls(QPainter* p);
        void drawControlsMovingItemsRect(QPainter* pp);
        void drawControlsBezierCurve(QPainter* pp, PageItem* currItem);
        void drawControlsMeasurementLine(QPainter* pp);
        void drawControlsDrawLine(QPainter* pp);
        void drawControlsFreehandLine(QPainter* pp);
        void getClipPathForPages(FPointArray* PoLine);
        void calculateFrameLinkPoints(PageItem* pi1, PageItem* pi2, FPoint& start, FPoint& end);
        ScribusDoc* m_doc;
        ScribusView* m_view;
        CanvasViewMode m_viewMode;
        RenderMode m_renderMode;
        QPixmap m_buffer;
        QRect   m_bufferRect;
        QPixmap m_selectionBuffer;
        QRect   m_selectionRect;
        QPoint  m_oldMinCanvasCoordinate;