Author: craig
Date: Fri Dec 29 18:04:22 2017
New Revision: 22296

URL: http://scribus.net/websvn/listing.php?repname=Scribus&sc=1&rev=22296
Log:
Fix coverity issues relating to undo item state dynamic_casts, rename MeshPoint 
class, code style fixes

Modified:
    trunk/Scribus/scribus/canvasmode_editmeshgradient.cpp
    trunk/Scribus/scribus/canvasmode_editmeshgradient.h
    trunk/Scribus/scribus/canvasmode_editmeshpatch.cpp
    trunk/Scribus/scribus/canvasmode_editmeshpatch.h
    trunk/Scribus/scribus/fpoint.h
    trunk/Scribus/scribus/mesh.cpp
    trunk/Scribus/scribus/mesh.h
    trunk/Scribus/scribus/pageitem.cpp
    trunk/Scribus/scribus/pageitem.h
    trunk/Scribus/scribus/pdflib_core.cpp
    trunk/Scribus/scribus/plugins/fileloader/scribus12format/scribus12format.h
    
trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format.cpp
    
trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format_save.cpp
    trunk/Scribus/scribus/plugins/import/ai/importai.cpp
    trunk/Scribus/scribus/plugins/import/ai/importai.h
    trunk/Scribus/scribus/plugins/import/emf/importemf.cpp
    trunk/Scribus/scribus/plugins/import/revenge/rawpainter.cpp
    trunk/Scribus/scribus/plugins/import/svm/importsvm.cpp
    trunk/Scribus/scribus/plugins/import/viva/importviva.cpp
    trunk/Scribus/scribus/pslib.cpp
    trunk/Scribus/scribus/scpainter.cpp
    trunk/Scribus/scribus/scpainter.h
    trunk/Scribus/scribus/scpainterex_ps2.h
    trunk/Scribus/scribus/scpainterexbase.h
    trunk/Scribus/scribus/scribusdoc.cpp
    trunk/Scribus/scribus/ui/colorsandfills.cpp
    trunk/Scribus/scribus/ui/cpalette.cpp

Modified: trunk/Scribus/scribus/canvasmode_editmeshgradient.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/canvasmode_editmeshgradient.cpp
==============================================================================
--- trunk/Scribus/scribus/canvasmode_editmeshgradient.cpp       (original)
+++ trunk/Scribus/scribus/canvasmode_editmeshgradient.cpp       Fri Dec 29 
18:04:22 2017
@@ -66,7 +66,7 @@
        m_Mxp = m_Myp = -1;
        m_selectedMeshPoints.clear();
        m_gradientPoint = noPointDefined;
-       m_old_mesh = new meshPoint();
+       m_old_mesh = new MeshPoint();
        m_keyRepeat = false;
 }
 
@@ -116,10 +116,10 @@
        {
                for (int gcol = 0; gcol < 
currItem->meshGradientArray[grow].count()-1; gcol++)
                {
-                       meshPoint mp1 = currItem->meshGradientArray[grow][gcol];
-                       meshPoint mp2 = 
currItem->meshGradientArray[grow][gcol+1];
-                       meshPoint mp3 = 
currItem->meshGradientArray[grow+1][gcol+1];
-                       meshPoint mp4 = 
currItem->meshGradientArray[grow+1][gcol];
+                       MeshPoint mp1 = currItem->meshGradientArray[grow][gcol];
+                       MeshPoint mp2 = 
currItem->meshGradientArray[grow][gcol+1];
+                       MeshPoint mp3 = 
currItem->meshGradientArray[grow+1][gcol+1];
+                       MeshPoint mp4 = 
currItem->meshGradientArray[grow+1][gcol];
                        QPainterPath Bez;
                        Bez.moveTo(mp1.gridPoint.x(), mp1.gridPoint.y());
                        Bez.cubicTo(mp1.controlRight.x(), mp1.controlRight.y(), 
mp2.controlLeft.x(), mp2.controlLeft.y(), mp2.gridPoint.x(), mp2.gridPoint.y());
@@ -143,7 +143,7 @@
                                        break;
                                }
                        }
-                       meshPoint mp1 = currItem->meshGradientArray[grow][gcol];
+                       MeshPoint mp1 = currItem->meshGradientArray[grow][gcol];
                        if (m_view->editStrokeGradient == 5)
                        {
                                if (isSelected)
@@ -178,7 +178,7 @@
        {
                int grow = m_selectedMeshPoints[0].first;
                int gcol = m_selectedMeshPoints[0].second;
-               meshPoint mp1 = currItem->meshGradientArray[grow][gcol];
+               MeshPoint mp1 = currItem->meshGradientArray[grow][gcol];
                psx->setPen(p8m);
                if (grow == 0)
                {
@@ -664,7 +664,7 @@
                {
                        for (int gcol = 0; gcol < 
currItem->meshGradientArray[grow].count(); gcol++)
                        {
-                               meshPoint mp = 
currItem->meshGradientArray[grow][gcol];
+                               MeshPoint mp = 
currItem->meshGradientArray[grow][gcol];
                                QPointF gradientPoint = 
QPointF(mp.gridPoint.x(), mp.gridPoint.y());
                                gradientPoint = itemMatrix.map(gradientPoint);
                                if (m_canvas->hitsCanvasPoint(mousePointDoc, 
gradientPoint))
@@ -688,7 +688,7 @@
                {
                        for (int gcol = 0; gcol < 
currItem->meshGradientArray[grow].count(); gcol++)
                        {
-                               meshPoint mp = 
currItem->meshGradientArray[grow][gcol];
+                               MeshPoint mp = 
currItem->meshGradientArray[grow][gcol];
                                QPointF gradientPoint = 
QPointF(mp.gridPoint.x(), mp.gridPoint.y());
                                gradientPoint = itemMatrix.map(gradientPoint);
                                QPointF gradientColorPoint = 
QPointF(mp.controlColor.x(), mp.controlColor.y());
@@ -714,7 +714,7 @@
                {
                        for (int gcol = 0; gcol < 
currItem->meshGradientArray[grow].count(); gcol++)
                        {
-                               meshPoint mp1 = 
currItem->meshGradientArray[grow][gcol];
+                               MeshPoint mp1 = 
currItem->meshGradientArray[grow][gcol];
                                QPointF gradientPoint;
                                if (grow == 0)
                                {
@@ -913,7 +913,7 @@
                        {
                                for (int gcol = 0; gcol < 
currItem->meshGradientArray[grow].count(); gcol++)
                                {
-                                       meshPoint mp = 
currItem->meshGradientArray[grow][gcol];
+                                       MeshPoint mp = 
currItem->meshGradientArray[grow][gcol];
                                        QPointF gradientPoint = 
QPointF(mp.gridPoint.x(), mp.gridPoint.y());
                                        gradientPoint = 
itemMatrix.map(gradientPoint);
                                        if 
(m_canvas->hitsCanvasPoint(mousePointDoc, gradientPoint))
@@ -974,7 +974,7 @@
        PageItem *currItem = m_doc->m_Selection->itemAt(0);
        if (currItem->selectedMeshPointX >=0 && currItem->selectedMeshPointY 
>=0 && UndoManager::undoEnabled())
        {
-               ScItemState<QPair<meshPoint,meshPoint> > *ss = new 
ScItemState<QPair<meshPoint,meshPoint> >(Um::GradPos);
+               ScItemState<QPair<MeshPoint,MeshPoint> > *ss = new 
ScItemState<QPair<MeshPoint,MeshPoint> >(Um::GradPos);
                ss->set("MOVE_MESH_PATCH");
                ss->set("ARRAY",true);
                ss->set("X",currItem->selectedMeshPointX);

Modified: trunk/Scribus/scribus/canvasmode_editmeshgradient.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/canvasmode_editmeshgradient.h
==============================================================================
--- trunk/Scribus/scribus/canvasmode_editmeshgradient.h (original)
+++ trunk/Scribus/scribus/canvasmode_editmeshgradient.h Fri Dec 29 18:04:22 2017
@@ -33,7 +33,7 @@
 class PageItem_TextFrame;
 class ScribusMainWindow;
 class ScribusView;
-class meshPoint;
+class MeshPoint;
 
 
 // This class encapsulate the old code for mouse interaction from 
scribusview.cpp
@@ -71,7 +71,7 @@
 
        inline bool GetItem(PageItem** pi);
 
-       meshPoint *m_old_mesh;
+       MeshPoint *m_old_mesh;
        double m_Mxp, m_Myp;
        ScribusMainWindow* m_ScMW;
        eMGradientPoint m_gradientPoint;

Modified: trunk/Scribus/scribus/canvasmode_editmeshpatch.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/canvasmode_editmeshpatch.cpp
==============================================================================
--- trunk/Scribus/scribus/canvasmode_editmeshpatch.cpp  (original)
+++ trunk/Scribus/scribus/canvasmode_editmeshpatch.cpp  Fri Dec 29 18:04:22 2017
@@ -69,7 +69,7 @@
        m_gradientPoint = noControlPointDefined;
        m_keyRepeat = false;
        m_click_count = 0;
-       m_old_mesh = new meshPoint();
+       m_old_mesh = new MeshPoint();
        m_currItem = NULL;
 }
 
@@ -103,7 +103,7 @@
        p->restore();
 }
 
-void CanvasMode_EditMeshPatch::drawControlsMeshPoint(QPainter* psx, const 
meshPoint& mp, bool isSelected)
+void CanvasMode_EditMeshPatch::drawControlsMeshPoint(QPainter* psx, const 
MeshPoint& mp, bool isSelected)
 {
        QPen p8r = QPen(Qt::red, 8.0 / m_canvas->m_viewMode.scale, 
Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin);
        QPen p8m = QPen(Qt::magenta, 8.0 / m_canvas->m_viewMode.scale, 
Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin);
@@ -150,10 +150,10 @@
        for (int col = 0; col < currItem->meshGradientPatches.count(); col++)
        {
                meshGradientPatch patch = currItem->meshGradientPatches[col];
-               meshPoint mp1 = patch.TL;
-               meshPoint mp2 = patch.TR;
-               meshPoint mp3 = patch.BR;
-               meshPoint mp4 = patch.BL;
+               MeshPoint mp1 = patch.TL;
+               MeshPoint mp2 = patch.TR;
+               MeshPoint mp3 = patch.BR;
+               MeshPoint mp4 = patch.BL;
                if (col != currItem->selectedMeshPointX)
                {
                        QPainterPath Bez;
@@ -169,10 +169,10 @@
        if (currItem->selectedMeshPointX >= 0)
        {
                meshGradientPatch patch = 
currItem->meshGradientPatches[currItem->selectedMeshPointX];
-               meshPoint mp1 = patch.TL;
-               meshPoint mp2 = patch.TR;
-               meshPoint mp3 = patch.BR;
-               meshPoint mp4 = patch.BL;
+               MeshPoint mp1 = patch.TL;
+               MeshPoint mp2 = patch.TR;
+               MeshPoint mp3 = patch.BR;
+               MeshPoint mp4 = patch.BL;
                QPainterPath Bez;
                Bez.moveTo(mp1.gridPoint.x(), mp1.gridPoint.y());
                Bez.cubicTo(mp1.controlRight.x(), mp1.controlRight.y(), 
mp2.controlLeft.x(), mp2.controlLeft.y(), mp2.gridPoint.x(), mp2.gridPoint.y());
@@ -775,7 +775,7 @@
                {
                        const ScColor& col = m_doc->PageColors["Black"];
                        QColor qcol = ScColorEngine::getRGBColor(col, m_doc);
-                       meshPoint mgP;
+                       MeshPoint mgP;
                        meshGradientPatch patch;
                        mgP.resetTo(FPoint(m_clickPointPolygon.value(0).x(), 
m_clickPointPolygon.value(0).y()));
                        mgP.transparency = 1.0;
@@ -804,10 +804,10 @@
                        if (m_view->editStrokeGradient == 8)
                        {
                                meshGradientPatch patch = 
m_currItem->meshGradientPatches[m_currItem->selectedMeshPointX];
-                               meshPoint mp1 = patch.TL;
-                               meshPoint mp2 = patch.TR;
-                               meshPoint mp3 = patch.BR;
-                               meshPoint mp4 = patch.BL;
+                               MeshPoint mp1 = patch.TL;
+                               MeshPoint mp2 = patch.TR;
+                               MeshPoint mp3 = patch.BR;
+                               MeshPoint mp4 = patch.BL;
                                if ((m_canvas->hitsCanvasPoint(mousePointDoc, 
itemMatrix.map(QPointF(mp1.gridPoint.x(), mp1.gridPoint.y())))) || 
(m_canvas->hitsCanvasPoint(mousePointDoc, 
itemMatrix.map(QPointF(mp1.controlColor.x(), mp1.controlColor.y())))))
                                {
                                        m_patchPoint = useTL;
@@ -834,10 +834,10 @@
                        else if (m_view->editStrokeGradient == 9)
                        {
                                meshGradientPatch patch = 
m_currItem->meshGradientPatches[m_currItem->selectedMeshPointX];
-                               meshPoint mp1 = patch.TL;
-                               meshPoint mp2 = patch.TR;
-                               meshPoint mp3 = patch.BR;
-                               meshPoint mp4 = patch.BL;
+                               MeshPoint mp1 = patch.TL;
+                               MeshPoint mp2 = patch.TR;
+                               MeshPoint mp3 = patch.BR;
+                               MeshPoint mp4 = patch.BL;
                                if (m_canvas->hitsCanvasPoint(mousePointDoc, 
itemMatrix.map(QPointF(mp1.gridPoint.x(), mp1.gridPoint.y()))))
                                {
                                        *m_old_mesh = mp1;
@@ -866,10 +866,10 @@
                                if (m_patchPoint != noPointDefined)
                                {
                                        meshGradientPatch patch = 
m_currItem->meshGradientPatches[m_currItem->selectedMeshPointX];
-                                       meshPoint mp1 = patch.TL;
-                                       meshPoint mp2 = patch.TR;
-                                       meshPoint mp3 = patch.BR;
-                                       meshPoint mp4 = patch.BL;
+                                       MeshPoint mp1 = patch.TL;
+                                       MeshPoint mp2 = patch.TR;
+                                       MeshPoint mp3 = patch.BR;
+                                       MeshPoint mp4 = patch.BL;
                                        if (m_patchPoint == useTL)
                                        {
                                                if 
(m_canvas->hitsCanvasPoint(mousePointDoc, 
itemMatrix.map(QPointF(mp1.controlBottom.x(), mp1.controlBottom.y()))))
@@ -907,10 +907,10 @@
                                for (int col = 0; col < 
m_currItem->meshGradientPatches.count(); col++)
                                {
                                        meshGradientPatch patch = 
m_currItem->meshGradientPatches[col];
-                                       meshPoint mp1 = patch.TL;
-                                       meshPoint mp2 = patch.TR;
-                                       meshPoint mp3 = patch.BR;
-                                       meshPoint mp4 = patch.BL;
+                                       MeshPoint mp1 = patch.TL;
+                                       MeshPoint mp2 = patch.TR;
+                                       MeshPoint mp3 = patch.BR;
+                                       MeshPoint mp4 = patch.BL;
                                        QPainterPath Bez;
                                        Bez.moveTo(mp1.gridPoint.x(), 
mp1.gridPoint.y());
                                        Bez.cubicTo(mp1.controlRight.x(), 
mp1.controlRight.y(), mp2.controlLeft.x(), mp2.controlLeft.y(), 
mp2.gridPoint.x(), mp2.gridPoint.y());
@@ -935,10 +935,10 @@
                        for (int col = 0; col < 
m_currItem->meshGradientPatches.count(); col++)
                        {
                                meshGradientPatch patch = 
m_currItem->meshGradientPatches[col];
-                               meshPoint mp1 = patch.TL;
-                               meshPoint mp2 = patch.TR;
-                               meshPoint mp3 = patch.BR;
-                               meshPoint mp4 = patch.BL;
+                               MeshPoint mp1 = patch.TL;
+                               MeshPoint mp2 = patch.TR;
+                               MeshPoint mp3 = patch.BR;
+                               MeshPoint mp4 = patch.BL;
                                QPainterPath Bez;
                                Bez.moveTo(mp1.gridPoint.x(), 
mp1.gridPoint.y());
                                Bez.cubicTo(mp1.controlRight.x(), 
mp1.controlRight.y(), mp2.controlLeft.x(), mp2.controlLeft.y(), 
mp2.gridPoint.x(), mp2.gridPoint.y());
@@ -975,7 +975,7 @@
        m->accept();
        if (m_view->editStrokeGradient != 11 && m_currItem->selectedMeshPointX 
>=0 && m_patchPoint != noPointDefined && UndoManager::undoEnabled())
        {
-               ScItemState<QPair<meshPoint,meshPoint> > *ss = new 
ScItemState<QPair<meshPoint,meshPoint> >(Um::GradPos);
+               ScItemState<QPair<MeshPoint,MeshPoint> > *ss = new 
ScItemState<QPair<MeshPoint,MeshPoint> >(Um::GradPos);
                ss->set("MOVE_MESH_PATCH");
                ss->set("X",m_currItem->selectedMeshPointX);
                ss->set("Y",m_currItem->selectedMeshPointY);

Modified: trunk/Scribus/scribus/canvasmode_editmeshpatch.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/canvasmode_editmeshpatch.h
==============================================================================
--- trunk/Scribus/scribus/canvasmode_editmeshpatch.h    (original)
+++ trunk/Scribus/scribus/canvasmode_editmeshpatch.h    Fri Dec 29 18:04:22 2017
@@ -30,7 +30,7 @@
 #include "canvasmode.h"
 #include "fpointarray.h"
 
-class meshPoint;
+class MeshPoint;
 class PageItem;
 class PageItem_TextFrame;
 class ScribusMainWindow;
@@ -57,7 +57,7 @@
        virtual void keyPressEvent(QKeyEvent *e);
        virtual bool handleKeyEvents() { return true; }
        virtual void drawControls(QPainter* p);
-       void drawControlsMeshPoint(QPainter* psx, const meshPoint& mp, bool 
isSelected);
+       void drawControlsMeshPoint(QPainter* psx, const MeshPoint& mp, bool 
isSelected);
        void drawControlsMeshPatch(QPainter* pp, PageItem* currItem);
 
 private:
@@ -83,7 +83,7 @@
 
        inline bool GetItem(PageItem** pi);
 
-       meshPoint* m_old_mesh;
+       MeshPoint* m_old_mesh;
        double m_Mxp, m_Myp;
        ScribusMainWindow* m_ScMW;
        eMPatchPoint m_patchPoint;

Modified: trunk/Scribus/scribus/fpoint.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/fpoint.h
==============================================================================
--- trunk/Scribus/scribus/fpoint.h      (original)
+++ trunk/Scribus/scribus/fpoint.h      Fri Dec 29 18:04:22 2017
@@ -43,15 +43,15 @@
 class SCRIBUS_API FPoint
 {
 public: 
-       FPoint() : xp(0), yp(0) {};
-       FPoint(double x, double y) : xp(x), yp(y) {};
-       FPoint(const QPoint & p) : xp(p.x()), yp(p.y()) {};
-       FPoint(const QPointF & p) : xp(p.x()), yp(p.y()) {};
-       FPoint(const FPoint & p) : xp(p.xp), yp(p.yp) {};
+       FPoint() : xp(0), yp(0) {}
+       FPoint(double x, double y) : xp(x), yp(y) {}
+       FPoint(const QPoint & p) : xp(p.x()), yp(p.y()) {}
+       FPoint(const QPointF & p) : xp(p.x()), yp(p.y()) {}
+       FPoint(const FPoint & p) : xp(p.xp), yp(p.yp) {}
        //Creates a transformed point, replaces ScribusView::transformPoint()
        FPoint(const double x, const double y, const double dx, const double 
dy, const double rot, const double sx, const double sy, const bool 
invert=false);
 //  ~FPoint() {};
-       FPoint &  operator=(const FPoint & rhs);
+       FPoint& operator=(const FPoint & rhs);
        double x() const;
        double y() const;
        void setX(double x);
@@ -82,60 +82,73 @@
 };
 
 
-inline const FPoint operator+( const FPoint &p1, const FPoint &p2 ) { 
+inline const FPoint operator+( const FPoint &p1, const FPoint &p2 )
+{
        return FPoint(p1.xp+p2.xp, p1.yp+p2.yp); 
 }
 
-inline const FPoint operator-( const FPoint &p1, const FPoint &p2 ) { 
+inline const FPoint operator-( const FPoint &p1, const FPoint &p2 )
+{
        return FPoint(p1.xp-p2.xp, p1.yp-p2.yp); 
 }
 
-inline const FPoint operator*( const FPoint &p, const double &c ) { 
+inline const FPoint operator*( const FPoint &p, const double &c )
+{
        return FPoint(p.xp*c, p.yp*c); 
 }
 
-inline const FPoint operator*( const double &c, const FPoint &p ) { 
+inline const FPoint operator*( const double &c, const FPoint &p )
+{
        return FPoint(p.xp*c, p.yp*c); 
 }
 
-inline double operator*( const FPoint &a, const FPoint &b ) {
+inline double operator*( const FPoint &a, const FPoint &b )
+{
        return a.xp * b.xp + a.yp * b.yp; 
 }
 
-inline FPoint &  FPoint::operator=(const FPoint & rhs)  { 
+inline FPoint &  FPoint::operator=(const FPoint & rhs)
+{
        xp = rhs.xp; 
        yp = rhs.yp; 
        return *this; 
 }
 
-inline double FPoint::x() const { 
+inline double FPoint::x() const
+{
        return xp; 
 }
 
-inline double FPoint::y() const { 
+inline double FPoint::y() const
+{
        return yp; 
 }
 
-inline void FPoint::setX(double x) { 
+inline void FPoint::setX(double x)
+{
        xp = x; 
 }
 
-inline void FPoint::setY(double y) { 
+inline void FPoint::setY(double y)
+{
        yp = y; 
 }
 
-inline void FPoint::setXY(double x, double y) { 
+inline void FPoint::setXY(double x, double y)
+{
        xp = x;
        yp = y; 
 }
  
-inline FPoint & FPoint::operator+=( const FPoint &p ) { 
+inline FPoint & FPoint::operator+=(const FPoint &p)
+{
        xp += p.xp; 
        yp += p.yp; 
        return *this; 
 }
 
-inline FPoint & FPoint::operator-=( const FPoint &p ) { 
+inline FPoint & FPoint::operator-=(const FPoint &p)
+{
        xp -= p.xp; 
        yp -= p.yp; 
        return *this; 

Modified: trunk/Scribus/scribus/mesh.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/mesh.cpp
==============================================================================
--- trunk/Scribus/scribus/mesh.cpp      (original)
+++ trunk/Scribus/scribus/mesh.cpp      Fri Dec 29 18:04:22 2017
@@ -24,13 +24,13 @@
 #include "mesh.h"
 #include "fpointarray.h"
 
-meshPoint::meshPoint()
+MeshPoint::MeshPoint()
 {
-       shade = 100;
+       shade = 100;
        transparency = 1.0;
 }
 
-void meshPoint::moveRel(double dx, double dy)
+void MeshPoint::moveRel(double dx, double dy)
 {
        gridPoint += FPoint(dx, dy);
        controlTop += FPoint(dx, dy);
@@ -40,7 +40,7 @@
        controlColor += FPoint(dx, dy);
 }
 
-void meshPoint::moveAbs(double x, double y)
+void MeshPoint::moveAbs(double x, double y)
 {
        FPoint delta = gridPoint - FPoint(x, y);
        gridPoint = FPoint(x, y);
@@ -51,7 +51,7 @@
        controlColor -= delta;
 }
 
-void meshPoint::transform(QTransform t)
+void MeshPoint::transform(QTransform t)
 {
        FPointArray gr;
        gr.addPoint(gridPoint);
@@ -69,7 +69,7 @@
        controlColor = gr.point(5);
 }
 
-void meshPoint::resetTo(FPoint p)
+void MeshPoint::resetTo(FPoint p)
 {
        gridPoint = p;
        controlLeft = gridPoint;
@@ -79,10 +79,11 @@
        controlColor = gridPoint;
 }
 
-bool meshPoint::operator ==(const meshPoint& p)
+bool MeshPoint::operator ==(const MeshPoint& p)
 {
        return ((gridPoint == p.gridPoint) && (controlTop == p.controlTop) && 
(controlBottom == p.controlBottom)
                        && (controlLeft == p.controlLeft) && (controlRight == 
p.controlRight) &&
                        (controlColor == p.controlColor) && (color == p.color) 
&& (colorName == p.colorName) &&
                        (transparency == p.transparency) && (shade == p.shade));
 }
+

Modified: trunk/Scribus/scribus/mesh.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/mesh.h
==============================================================================
--- trunk/Scribus/scribus/mesh.h        (original)
+++ trunk/Scribus/scribus/mesh.h        Fri Dec 29 18:04:22 2017
@@ -30,15 +30,15 @@
 #include "fpoint.h"
 #include "scribusapi.h"
 
-class SCRIBUS_API meshPoint
+class SCRIBUS_API MeshPoint
 {
 public:
-       meshPoint();
+       MeshPoint();
        void moveRel(double dx, double dy);
        void moveAbs(double x, double y);
        void transform(QTransform t);
        void resetTo(FPoint p);
-       bool operator ==(const meshPoint& p);
+       bool operator ==(const MeshPoint& p);
        FPoint gridPoint;
        FPoint controlTop;
        FPoint controlBottom;
@@ -46,17 +46,17 @@
        FPoint controlRight;
        FPoint controlColor;
        double transparency;
-       int    shade;
+       int shade;
        QString colorName;
-       QColor  color;
+       QColor color;
 };
 
 struct meshGradientPatch
 {
-       meshPoint TL;
-       meshPoint TR;
-       meshPoint BL;
-       meshPoint BR;
+       MeshPoint TL;
+       MeshPoint TR;
+       MeshPoint BL;
+       MeshPoint BR;
 };
 
 #endif

Modified: trunk/Scribus/scribus/pageitem.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/pageitem.cpp
==============================================================================
--- trunk/Scribus/scribus/pageitem.cpp  (original)
+++ trunk/Scribus/scribus/pageitem.cpp  Fri Dec 29 18:04:22 2017
@@ -777,8 +777,8 @@
        mask_gradient.addStop(qcol, 0.0, 0.5, 1.0, "Black", 100);
        mask_gradient.addStop(qcol, 1.0, 0.5, 1.0, "Black", 100);
 
-       QList<meshPoint> mgList;
-       meshPoint mgP;
+       QList<MeshPoint> mgList;
+       MeshPoint mgP;
        meshGradientPatch patch;
        mgP.resetTo(FPoint(0.0, 0.0));
        mgP.transparency = 1.0;
@@ -2609,7 +2609,7 @@
                return;
        if (UndoManager::undoEnabled())
        {
-               ScItemState<QPair<VGradient,VGradient> > *is = new 
ScItemState<QPair<VGradient,VGradient> >(Um::GradVal);
+               ScItemState<QPair<VGradient, VGradient> >* is = new 
ScItemState<QPair<VGradient,VGradient> >(Um::GradVal);
                is->set("MASK_GRAD");
                is->setItem(qMakePair(mask_gradient,grad));
                undoManager->action(this,is);
@@ -2888,7 +2888,7 @@
 
 void PageItem::setMeshPointColor(int x, int y, QString color, int shade, 
double transparency, bool forPatch)
 {
-       QString MColor = color;
+       QString MColor(color);
        QColor MQColor;
        if (MColor != CommonStrings::None)
        {
@@ -2928,7 +2928,7 @@
                VisionDefectColor defect;
                MQColor = defect.convertDefect(MQColor, m_Doc->previewVisual);
        }
-       meshPoint *mp = NULL;
+       MeshPoint *mp = NULL;
        if (forPatch)
        {
                meshGradientPatch *patch = &meshGradientPatches[x];
@@ -2951,8 +2951,8 @@
                UndoTransaction trans;
                if (UndoManager::undoEnabled())
                {
-                       trans = 
undoManager->beginTransaction(Um::Selection,Um::IFill,Um::GradVal,"",Um::IFill);
-                       ScItemState<QPair<QColor,QColor> > *ss = new 
ScItemState<QPair<QColor,QColor> >(Um::GradVal);
+                       trans = undoManager->beginTransaction(Um::Selection, 
Um::IFill, Um::GradVal, "", Um::IFill);
+                       ScItemState<QPair<QColor, QColor> >* ss = new 
ScItemState<QPair<QColor,QColor> >(Um::GradVal);
                        ss->set("GRAD_MESH_COLOR");
                        ss->set("X",x);
                        ss->set("Y",y);
@@ -2980,7 +2980,7 @@
                                        mp = &(meshGradientPatches[col].TL);
                                        if (UndoManager::undoEnabled())
                                        {
-                                               
ScItemState<QPair<QColor,QColor> > *ss = new ScItemState<QPair<QColor,QColor> 
>(Um::GradVal);
+                                               ScItemState<QPair<QColor, 
QColor> >* ss = new ScItemState<QPair<QColor,QColor> >(Um::GradVal);
                                                ss->set("GRAD_MESH_COLOR");
                                                ss->set("X",col);
                                                ss->set("Y",1);
@@ -3004,7 +3004,7 @@
                                        mp = &(meshGradientPatches[col].TR);
                                        if (UndoManager::undoEnabled())
                                        {
-                                               
ScItemState<QPair<QColor,QColor> > *ss = new ScItemState<QPair<QColor,QColor> 
>(Um::GradVal);
+                                               ScItemState<QPair<QColor, 
QColor> >* ss = new ScItemState<QPair<QColor,QColor> >(Um::GradVal);
                                                ss->set("GRAD_MESH_COLOR");
                                                ss->set("X",col);
                                                ss->set("Y",2);
@@ -3028,7 +3028,7 @@
                                        mp = &(meshGradientPatches[col].BR);
                                        if (UndoManager::undoEnabled())
                                        {
-                                               
ScItemState<QPair<QColor,QColor> > *ss = new ScItemState<QPair<QColor,QColor> 
>(Um::GradVal);
+                                               ScItemState<QPair<QColor, 
QColor> >* ss = new ScItemState<QPair<QColor,QColor> >(Um::GradVal);
                                                ss->set("GRAD_MESH_COLOR");
                                                ss->set("X",col);
                                                ss->set("Y",3);
@@ -3052,7 +3052,7 @@
                                        mp = &(meshGradientPatches[col].BL);
                                        if (UndoManager::undoEnabled())
                                        {
-                                               
ScItemState<QPair<QColor,QColor> > *ss = new ScItemState<QPair<QColor,QColor> 
>(Um::GradVal);
+                                               ScItemState<QPair<QColor, 
QColor> >* ss = new ScItemState<QPair<QColor,QColor> >(Um::GradVal);
                                                ss->set("GRAD_MESH_COLOR");
                                                ss->set("X",col);
                                                ss->set("Y",4);
@@ -3083,7 +3083,7 @@
                        mp = &(meshGradientArray[x][y]);
                        if (UndoManager::undoEnabled())
                        {
-                               ScItemState<QPair<QColor,QColor> > *ss = new 
ScItemState<QPair<QColor,QColor> >(Um::GradVal);
+                               ScItemState<QPair<QColor, QColor> >* ss = new 
ScItemState<QPair<QColor,QColor> >(Um::GradVal);
                                ss->set("GRAD_MESH_COLOR");
                                ss->set("X",x);
                                ss->set("Y",y);
@@ -3149,7 +3149,7 @@
        }
        if (UndoManager::undoEnabled())
        {
-               ScItemState<QList<QList<meshPoint> > > *is = new 
ScItemState<QList<QList<meshPoint> > >(Um::MeshGradient);
+               ScItemState<QList<QList<MeshPoint> > >* is = new 
ScItemState<QList<QList<MeshPoint> > >(Um::MeshGradient);
                is->set("CREATE_MESH_GRAD");
                is->set("ROW",rows);
                is->set("COL",cols);
@@ -3157,14 +3157,16 @@
                undoManager->action(this,is);
        }
        meshGradientArray.clear();
+       if (rows == 0 || cols == 0)
+               qFatal("PageItem::createGradientMesh: rows or cols is 0");
        double xoffs = m_width / static_cast<double>(cols);
        double yoffs = m_height / static_cast<double>(rows);
        for (int x = 0; x < rows + 1; x++)
        {
-               QList<meshPoint> mgList;
+               QList<MeshPoint> mgList;
                for (int y = 0; y < cols + 1; y++)
                {
-                       meshPoint mgP;
+                       MeshPoint mgP;
                        mgP.resetTo(FPoint(y * xoffs, x * yoffs));
                        mgP.transparency = 1.0;
                        mgP.shade = 100;
@@ -3182,7 +3184,7 @@
        int cols = meshGradientArray[0].count();
        if (UndoManager::undoEnabled())
        {
-               ScItemState<QList<QList<meshPoint> > > *is = new 
ScItemState<QList<QList<meshPoint> > >(Um::ResetControlPoints);
+               ScItemState<QList<QList<MeshPoint> > > *is = new 
ScItemState<QList<QList<MeshPoint> > >(Um::ResetControlPoints);
                is->set("RESET_MESH_GRAD");
                is->setItem(meshGradientArray);
                undoManager->action(this,is);
@@ -3201,7 +3203,7 @@
        Coords.svgInit();
        int rows = meshGradientArray.count() - 1;
        int cols = meshGradientArray[0].count() - 1;
-       QList<meshPoint> mpList;
+       QList<MeshPoint> mpList;
        mpList = meshGradientArray[0];
        Coords.svgMoveTo(mpList[0].gridPoint.x(), mpList[0].gridPoint.y());
        for (int m = 0; m < mpList.count()-1; m++)
@@ -3234,7 +3236,7 @@
        if (UndoManager::undoEnabled())
        {
                trans = 
undoManager->beginTransaction(Um::Selection,Um::IFill,Um::ChangeMeshGradient,"",Um::IFill);
-               ScItemState<QPair<QList<QList<meshPoint> >,FPointArray> > *ism 
= new ScItemState<QPair<QList<QList<meshPoint> >,FPointArray> 
>(Um::ChangeMeshGradient, "",Um::IFill);
+               ScItemState<QPair<QList<QList<MeshPoint> >,FPointArray> > *ism 
= new ScItemState<QPair<QList<QList<MeshPoint> >,FPointArray> 
>(Um::ChangeMeshGradient, "",Um::IFill);
                ism->set("MOVE_MESH_GRAD");
                ism->setItem(qMakePair(meshGradientArray,PoLine));
                ism->set("OLDB",OldB2);
@@ -3242,7 +3244,7 @@
                ism->set("FRAME_TYPE",FrameType);
                undoManager->action(this, ism);
        }
-       QList<QList<meshPoint> > meshGradientArrayOld = meshGradientArray;
+       QList<QList<MeshPoint> > meshGradientArrayOld = meshGradientArray;
        PoLine = Coords.copy();
        double oldX = m_xPos;
        double oldY = m_yPos;
@@ -3356,9 +3358,9 @@
                lastStop = actualStop;
        }
        meshGradientArray.clear();
-       QList<meshPoint> mgList1;
-       QList<meshPoint> mgList2;
-       meshPoint mgP1, mgP2, mgP3, mgP4;
+       QList<MeshPoint> mgList1;
+       QList<MeshPoint> mgList2;
+       MeshPoint mgP1, mgP2, mgP3, mgP4;
        QPainterPath path;
        FPointArray arcPath;
        QLineF angLin = QLineF(QPointF(GrStartX, GrStartY), QPointF(GrEndX, 
GrEndY));
@@ -5986,7 +5988,7 @@
 
 void PageItem::restoreRemoveMeshPatch(SimpleState *state, bool isUndo)
 {
-       ScItemState<meshGradientPatch> *is = 
dynamic_cast<ScItemState<meshGradientPatch> *>(state);
+       ScItemState<meshGradientPatch>* is = 
dynamic_cast<ScItemState<meshGradientPatch> *>(state);
        if (!is)
                qFatal("PageItem::restoreRemoveMeshPatch: dynamic cast failed");
        if (isUndo)
@@ -6004,19 +6006,19 @@
 
 void PageItem::restoreCreateMeshGrad(SimpleState *state, bool isUndo)
 {
-       ScItemState<QList<QList<meshPoint> > > *is = 
dynamic_cast<ScItemState<QList<QList<meshPoint> > > *>(state);
+       ScItemState<QList<QList<MeshPoint> > >* is = 
dynamic_cast<ScItemState<QList<QList<MeshPoint> > > *>(state);
        if (!is)
                qFatal("PageItem::restoreCreateMeshGrad: dynamic cast failed");
        if (isUndo)
                meshGradientArray = is->getItem();
        else
-               createGradientMesh(is->getInt("ROW"),is->getInt("COL"));
+               createGradientMesh(is->getInt("ROW"), is->getInt("COL"));
        update();
 }
 
 void PageItem::restoreMoveMeshGrad(SimpleState *state, bool isUndo)
 {
-       ScItemState<QPair<QList<QList<meshPoint> >,FPointArray> > *is = 
dynamic_cast<ScItemState<QPair<QList<QList<meshPoint> >,FPointArray> > 
*>(state);
+       ScItemState<QPair<QList<QList<MeshPoint> >,FPointArray> > *is = 
dynamic_cast<ScItemState<QPair<QList<QList<MeshPoint> >,FPointArray> > 
*>(state);
        if (!is)
                qFatal("PageItem::restoreMoveMeshGrad: dynamic cast failed");
        if (isUndo)
@@ -6039,7 +6041,7 @@
 
 void PageItem::restoreResetMeshGrad(SimpleState *state, bool isUndo)
 {
-       ScItemState<QList<QList<meshPoint> > > *is = 
dynamic_cast<ScItemState<QList<QList<meshPoint> > > *>(state);
+       ScItemState<QList<QList<MeshPoint> > > *is = 
dynamic_cast<ScItemState<QList<QList<MeshPoint> > > *>(state);
        if (!is)
                qFatal("PageItem::restoreResetMeshGrad: dynamic cast failed");
        if (isUndo)
@@ -6087,7 +6089,7 @@
 
 void PageItem::restoreMoveMeshPatch(SimpleState *state, bool isUndo)
 {
-       ScItemState<QPair<meshPoint,meshPoint> > *is = 
dynamic_cast<ScItemState<QPair<meshPoint,meshPoint> > *>(state);
+       ScItemState<QPair<MeshPoint,MeshPoint> > *is = 
dynamic_cast<ScItemState<QPair<MeshPoint,MeshPoint> > *>(state);
        if (!is)
                qFatal("PageItem::restoreMoveMeshPatch: dynamic cast failed");
        int x = is->getInt("X");
@@ -6181,7 +6183,7 @@
                qFatal("PageItem::restoreGradientMeshColor: dynamic cast 
failed");
        int x = is->getInt("X");
        int y = is->getInt("Y");
-       meshPoint *mp=NULL;
+       MeshPoint *mp=NULL;
        if (is->getBool("PATCH"))
        {
                meshGradientPatch *patch = &meshGradientPatches[x];
@@ -6203,6 +6205,8 @@
        }
        else
                mp = &meshGradientArray[x][y];
+       if (mp == NULL)
+               qFatal("PageItem::restoreGradientMeshColor: mp is NULL");
        if (isUndo)
        {
                mp->colorName = is->get("OLD_COLOR_NAME");
@@ -6521,7 +6525,7 @@
 void PageItem::restorePastePlainText(SimpleState *ss, bool isUndo)
 {
        int start = ss->getInt("START");
-       QString text = ss->get("TEXT");
+       QString text(ss->get("TEXT"));
 
        itemText.deselectAll();
        if (isUndo)
@@ -6541,8 +6545,8 @@
        ScItemState<StoryText> *is = dynamic_cast<ScItemState<StoryText>*>(ss);
        if (!is)
                qFatal("PageItem::restorePasteText: dynamic cast failed");
+
        int start = is->getInt("START");
-
        itemText.deselectAll();
        if (isUndo)
        {
@@ -6694,9 +6698,9 @@
        ScItemState<CharStyle> *is = dynamic_cast<ScItemState<CharStyle> *>(ss);
        if (!is)
                qFatal("PageItem::restoreDeleteFrameText: dynamic cast failed");
-       QString text = is->get("TEXT_STR");
+
+       QString text(is->get("TEXT_STR"));
        int start = is->getInt("START");
-
        itemText.deselectAll();
        if (isUndo)
        {
@@ -6719,8 +6723,8 @@
        ScItemState<ParagraphStyle> *is = 
dynamic_cast<ScItemState<ParagraphStyle> *>(ss);
        if (!is)
                qFatal("PageItem::restoreDeleteFrameParagraph: dynamic cast 
failed");
+
        int start = is->getInt("START");
-       
        itemText.deselectAll();
        if (isUndo)
        {
@@ -6740,7 +6744,7 @@
 
 void PageItem::restoreInsertFrameText(SimpleState *ss, bool isUndo)
 {
-       QString text = ss->get("TEXT_STR");
+       QString text(ss->get("TEXT_STR"));
        int start = ss->getInt("START");
 
        itemText.deselectAll();
@@ -6761,8 +6765,8 @@
        ScItemState<ParagraphStyle> *is = 
dynamic_cast<ScItemState<ParagraphStyle> *>(ss);
        if (!is)
                qFatal("PageItem::restoreInsertFrameParagraph: dynamic cast 
failed");
+
        int start = is->getInt("START");
-       
        itemText.deselectAll();
        if (isUndo)
        {
@@ -6896,7 +6900,7 @@
 
 void PageItem::restoreFill(SimpleState *state, bool isUndo)
 {
-       QString fill = state->get("OLD_FILL");
+       QString fill(state->get("OLD_FILL"));
        if (!isUndo)
                fill = state->get("NEW_FILL");
        select();
@@ -6923,7 +6927,7 @@
 
 void PageItem::restoreLineColor(SimpleState *state, bool isUndo)
 {
-       QString fill = state->get("OLD_COLOR");
+       QString fill(state->get("OLD_COLOR"));
        if (!isUndo)
                fill = state->get("NEW_COLOR");
        select();
@@ -6996,7 +7000,7 @@
 
 void PageItem::restoreCustomLineStyle(SimpleState *state, bool isUndo)
 {
-       QString style = state->get("OLD_STYLE");
+       QString style(state->get("OLD_STYLE"));
        if (!isUndo)
                style = state->get("NEW_STYLE");
        setCustomLineStyle(style);
@@ -7004,7 +7008,7 @@
 
 void PageItem::restoreName(SimpleState *state, bool isUndo)
 {
-       QString name = state->get("OLD_NAME");
+       QString name(state->get("OLD_NAME"));
        if (!isUndo)
                name = state->get("NEW_NAME");
        setItemName(name);
@@ -7066,17 +7070,15 @@
        
        QList<PageItem*> pList;
        int id = m_Doc->Items->indexOf(this) - 1;
-       for(int idx = id; idx >= 0 ; --idx)
-       {
-               pList << m_Doc->Items->at(idx);
-       }
+       for(int i = id; i >= 0 ; --i)
+               pList << m_Doc->Items->at(i);
                
        QRectF baseRect(getBoundingRect());
-       for(int idx(0); idx < pList.count(); ++idx)
-       {
-               QRectF uRect(pList.at(idx)->getBoundingRect());
+       for(int i = 0; i < pList.count(); ++i)
+       {
+               QRectF uRect(pList.at(i)->getBoundingRect());
                if (baseRect.intersects(uRect))
-                       pList.at(idx)->update();
+                       pList.at(i)->update();
        }
 }
 
@@ -7157,7 +7159,9 @@
                return;
        if (isUndo)
        {
-               ScItemState<ScImageEffectList> *is = 
dynamic_cast<ScItemState<ScImageEffectList>*>(state);
+               ScItemState<ScImageEffectList>* is = 
dynamic_cast<ScItemState<ScImageEffectList>*>(state);
+               if (!is)
+                       qFatal("PageItem::restoreClearImage: dynamic cast 
failed");
                Pfile = is->get("CI_PFILE");
                loadImage(Pfile, false);
                effectsInUse = is->getItem();
@@ -7183,7 +7187,9 @@
 {
        if (!isTextFrame())
                return;
-       ScItemState<QPair<PageItem*, PageItem*> > *is = 
dynamic_cast<ScItemState<QPair<PageItem*, PageItem*> >*>(state);
+       ScItemState<QPair<PageItem*, PageItem*> >* is = 
dynamic_cast<ScItemState<QPair<PageItem*, PageItem*> >*>(state);
+       if (!is)
+               qFatal("PageItem::restoreDropLinks: dynamic cast failed");
        if (isUndo)
        {
                PageItem* prev = is->getItem().first;
@@ -7242,6 +7248,8 @@
                unlink(false);
                //restore properly text if frame was linked at beginning of 
chain
                ScItemState<QPair<PageItem*, PageItem*> > *is = 
dynamic_cast<ScItemState<QPair<PageItem*, PageItem*> >*>(state);
+               if (!is)
+                       qFatal("PageItem::restoreLinkTextFrame 1: dynamic cast 
failed");
                int joinPos = is->getInt("JOIN_POS");
                int parSep = is->getBool("ADDPARSEP") ? 1 : 0;
                if (is->getBool("FIRST"))
@@ -7278,6 +7286,8 @@
        else
        {
                ScItemState<QPair<PageItem*, PageItem*> > *is = 
dynamic_cast<ScItemState<QPair<PageItem*, PageItem*> >*>(state);
+               if (!is)
+                       qFatal("PageItem::restoreLinkTextFrame 2: dynamic cast 
failed");
                asTextFrame()->link(is->getItem().second->asTextFrame());
        }
 }
@@ -7286,7 +7296,9 @@
 {
        if (!isTextFrame())
                return;
-       ScItemState<QPair<PageItem*, PageItem*> > *is = 
dynamic_cast<ScItemState<QPair<PageItem*, PageItem*> >*>(state);
+       ScItemState<QPair<PageItem*, PageItem*> >* is = 
dynamic_cast<ScItemState<QPair<PageItem*, PageItem*> >*>(state);
+       if (!is)
+               qFatal("PageItem::restoreUnlinkTextFrame: dynamic cast failed");
        if (is->contains("CUT_TEXT"))
        {
                bool cutText = is->getBool("CUT_TEXT");
@@ -7333,36 +7345,36 @@
 void PageItem::restorePathOperation(UndoState *state, bool isUndo)
 {//PATH_OPERATION
        ScItemState<QPair<QPair<FPointArray, FPointArray>, QPair<FPointArray, 
FPointArray> > >*is = dynamic_cast<ScItemState<QPair<QPair<FPointArray, 
FPointArray>, QPair<FPointArray, FPointArray> > >*>(state);
-       if (is)
-       {
-               if (isUndo)
-               {
-                       this->ClipEdited=is->getBool("PATH_OP_OLD_CLIPEDITED");
-                       this->FrameType=is->getInt("PATH_OP_OLD_FRAMETYPE");
-                       this->OldB2=is->getDouble("PATH_OP_OLD_OLDB2");
-                       this->OldH2=is->getDouble("PATH_OP_OLD_OLDH2");
-                       QPair<FPointArray, FPointArray> 
oldLines=is->getItem().first;
-                       this->PoLine = oldLines.first;
-                       this->ContourLine = oldLines.second;
-               }
-               else
-               {
-                       this->ClipEdited=is->getBool("PATH_OP_NEW_CLIPEDITED");
-                       this->FrameType=is->getInt("PATH_OP_NEW_FRAMETYPE");
-                       this->OldB2=is->getDouble("PATH_OP_NEW_OLDB2");
-                       this->OldH2=is->getDouble("PATH_OP_NEW_OLDH2");
-                       QPair<FPointArray, FPointArray> 
newLines=is->getItem().second;
-                       this->PoLine = newLines.first;
-                       this->ContourLine = newLines.second;
-               }
-               this->updateClip();
-       }
+       if (!is)
+               qFatal("PageItem::restorePathOperation: dynamic cast failed");
+
+       if (isUndo)
+       {
+               this->ClipEdited=is->getBool("PATH_OP_OLD_CLIPEDITED");
+               this->FrameType=is->getInt("PATH_OP_OLD_FRAMETYPE");
+               this->OldB2=is->getDouble("PATH_OP_OLD_OLDB2");
+               this->OldH2=is->getDouble("PATH_OP_OLD_OLDH2");
+               QPair<FPointArray, FPointArray> oldLines=is->getItem().first;
+               this->PoLine = oldLines.first;
+               this->ContourLine = oldLines.second;
+       }
+       else
+       {
+               this->ClipEdited=is->getBool("PATH_OP_NEW_CLIPEDITED");
+               this->FrameType=is->getInt("PATH_OP_NEW_FRAMETYPE");
+               this->OldB2=is->getDouble("PATH_OP_NEW_OLDB2");
+               this->OldH2=is->getDouble("PATH_OP_NEW_OLDH2");
+               QPair<FPointArray, FPointArray> newLines=is->getItem().second;
+               this->PoLine = newLines.first;
+               this->ContourLine = newLines.second;
+       }
+       this->updateClip();
 }
 
 void PageItem::restorePoly(SimpleState *state, bool isUndo, bool isContour)
 {
-       int mode    = state->getInt("MODE");
-       int rot     = state->getInt("ROT");
+       int mode = state->getInt("MODE");
+       int rot  = state->getInt("ROT");
        ScribusView* view = m_Doc->view();
        double scaling = state->getDouble("SCALING");
        bool editContour = m_Doc->nodeEdit.isContourLine();
@@ -7386,71 +7398,70 @@
 void PageItem::restoreUniteItem(SimpleState *state, bool isUndo)
 {
        ScItemState< QPair<QList<PageItem*>,QList<QTransform> > > *is = 
dynamic_cast<ScItemState< QPair<QList<PageItem*>,QList<QTransform> > >*>(state);
-       if (is)
-       {
-               m_Doc->view()->Deselect(true);
-               if (isUndo)
-               {
-                       int pts = 0;
-                       select();
-                       for (int i = 0; i < is->getItem().first.size(); ++i)
-                       {
-                               PageItem* myItem = is->getItem().first.at(i);
-                               
myItem->PoLine.map(is->getItem().second.at(i).inverted());
-                               pts += myItem->PoLine.size();
-                               pts+=4;
-                               doc()->m_Selection->addItem(myItem);
-                       }
-                       PoLine.resize(PoLine.size()-pts);
-                       Segments.clear();
-                       FrameType = is->getInt("FRAMETYPE");
-                       ClipEdited = is->getBool("CLIPEDITED");
-                       bool oldRotMode = doc()->rotationMode();
-                       doc()->setRotationMode(0);
-                       doc()->adjustItemSize(this);
-                       doc()->setRotationMode(oldRotMode);
-               }
-               else
-               {
-                       select();
-                       for (int i = 0; i < is->getItem().first.size(); ++i)
-                               
doc()->view()->SelectItem(is->getItem().first.at(i));
-                       doc()->itemSelection_UniteItems();
-                       select();
-               }
+       if (!is)
+               qFatal("PageItem::restoreUniteItem: dynamic cast failed");
+
+       m_Doc->view()->Deselect(true);
+       if (isUndo)
+       {
+               int pts = 0;
+               select();
+               for (int i = 0; i < is->getItem().first.size(); ++i)
+               {
+                       PageItem* myItem = is->getItem().first.at(i);
+                       
myItem->PoLine.map(is->getItem().second.at(i).inverted());
+                       pts += myItem->PoLine.size();
+                       pts+=4;
+                       doc()->m_Selection->addItem(myItem);
+               }
+               PoLine.resize(PoLine.size()-pts);
+               Segments.clear();
+               FrameType = is->getInt("FRAMETYPE");
+               ClipEdited = is->getBool("CLIPEDITED");
+               bool oldRotMode = doc()->rotationMode();
+               doc()->setRotationMode(0);
+               doc()->adjustItemSize(this);
+               doc()->setRotationMode(oldRotMode);
+       }
+       else
+       {
+               select();
+               for (int i = 0; i < is->getItem().first.size(); ++i)
+                       doc()->view()->SelectItem(is->getItem().first.at(i));
+               doc()->itemSelection_UniteItems();
+               select();
        }
 }
 
 void PageItem::restoreSplitItem(SimpleState *state, bool isUndo)
 {
        ScItemState< QList<int> > *is = dynamic_cast<ScItemState< QList<int> 
>*>(state);
-       if (is)
-       {
-               QList<int> itemsList = is->getItem();
+       if (!is)
+               qFatal("PageItem::restoreSplitItem: dynamic cast failed");
+       
+       QList<int> itemsList = is->getItem();
+       select();
+       if (isUndo)
+       {
+               for (int i = 0; i < itemsList.size(); ++i)
+                       
doc()->view()->SelectItem(doc()->Items->at(itemsList.at(i)));
+               doc()->itemSelection_UniteItems();
                select();
-               if (isUndo)
-               {
-                       for (int i = 0; i < itemsList.size(); ++i)
-                               
doc()->view()->SelectItem(doc()->Items->at(itemsList.at(i)));
-                       doc()->itemSelection_UniteItems();
-                       select();
-               }
-               else
-                       doc()->itemSelection_SplitItems();
-       }
+       }
+       else
+               doc()->itemSelection_SplitItems();
 }
 
 void PageItem::restoreContourLine(SimpleState *state, bool isUndo)
 {
        ScItemState<FPointArray> *is = 
dynamic_cast<ScItemState<FPointArray>*>(state);
-       if (is)
-       {
-               if (isUndo)
-                       ContourLine = is->getItem();
-               else
-                       ContourLine = PoLine.copy();
-               ClipEdited = true;
-       }
+       if (!is)
+               qFatal("PageItem::restoreContourLine: dynamic cast failed");
+       if (isUndo)
+               ContourLine = is->getItem();
+       else
+               ContourLine = PoLine.copy();
+       ClipEdited = true;
 }
 
 void PageItem::restoreShapeType(SimpleState *state, bool isUndo)
@@ -7461,22 +7472,21 @@
        // NEW_FRAME_TYPE - change of frame type
        // binary QPair<FPointArray, FPointArray> - .first original shape, 
.second new shape
        ScItemState<QPair<FPointArray,FPointArray> > *is = 
dynamic_cast<ScItemState<QPair<FPointArray,FPointArray> >*>(state);
-       if (is)
-       {
-               if (isUndo)
-               {
-                       this->FrameType = is->getInt("OLD_FRAME_TYPE");
-                       this->PoLine = is->getItem().first;
-                       ClipEdited = !(FrameType == 0 || FrameType == 1);
-               }
-               else
-               {
-                       this->FrameType = is->getInt("NEW_FRAME_TYPE");
-                       this->PoLine = is->getItem().second;
-                       ClipEdited = (FrameType == 0 || FrameType == 1);
-               }
-               Clip = FlattenPath(PoLine,Segments);
-       }
+       if (!is)
+               qFatal("PageItem::restoreShapeType: dynamic cast failed");
+       if (isUndo)
+       {
+               this->FrameType = is->getInt("OLD_FRAME_TYPE");
+               this->PoLine = is->getItem().first;
+               ClipEdited = !(FrameType == 0 || FrameType == 1);
+       }
+       else
+       {
+               this->FrameType = is->getInt("NEW_FRAME_TYPE");
+               this->PoLine = is->getItem().second;
+               ClipEdited = (FrameType == 0 || FrameType == 1);
+       }
+       Clip = FlattenPath(PoLine,Segments);
 }
 
 void PageItem::restoreLayer(SimpleState *state, bool isUndo)
@@ -7726,7 +7736,7 @@
        {
                for (int gcol = 0; gcol < meshGradientArray[grow].count(); 
gcol++)
                {
-                       meshPoint mp = meshGradientArray[grow][gcol];
+                       MeshPoint mp = meshGradientArray[grow][gcol];
                        it = newNames.colors().find(mp.colorName);
                        if (it != newNames.colors().end())
                                meshGradientArray[grow][gcol].colorName = *it;

Modified: trunk/Scribus/scribus/pageitem.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/pageitem.h
==============================================================================
--- trunk/Scribus/scribus/pageitem.h    (original)
+++ trunk/Scribus/scribus/pageitem.h    Fri Dec 29 18:04:22 2017
@@ -1276,7 +1276,7 @@
        int GrCol3Shade;
        int GrCol4Shade;
        QList<meshGradientPatch> meshGradientPatches;
-       QList<QList<meshPoint> > meshGradientArray;
+       QList<QList<MeshPoint> > meshGradientArray;
        int selectedMeshPointX;
        int selectedMeshPointY;
        int selectedMeshControlPoint;

Modified: trunk/Scribus/scribus/pdflib_core.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/pdflib_core.cpp
==============================================================================
--- trunk/Scribus/scribus/pdflib_core.cpp       (original)
+++ trunk/Scribus/scribus/pdflib_core.cpp       Fri Dec 29 18:04:22 2017
@@ -6777,7 +6777,7 @@
        {
                for (int gcol = 0; gcol < c->meshGradientArray[grow].count(); 
gcol++)
                {
-                       meshPoint mp1 = c->meshGradientArray[grow][gcol];
+                       MeshPoint mp1 = c->meshGradientArray[grow][gcol];
                        colorNames.append(mp1.colorName);
                        if (!doc.PageColors.contains(mp1.colorName))
                        {
@@ -6822,10 +6822,10 @@
                {
                        for (int gcol = 0; gcol < 
c->meshGradientArray[grow].count()-1; gcol++)
                        {
-                               meshPoint mp1 = 
c->meshGradientArray[grow][gcol];
-                               meshPoint mp2 = 
c->meshGradientArray[grow][gcol+1];
-                               meshPoint mp3 = 
c->meshGradientArray[grow+1][gcol+1];
-                               meshPoint mp4 = 
c->meshGradientArray[grow+1][gcol];
+                               MeshPoint mp1 = 
c->meshGradientArray[grow][gcol];
+                               MeshPoint mp2 = 
c->meshGradientArray[grow][gcol+1];
+                               MeshPoint mp3 = 
c->meshGradientArray[grow+1][gcol+1];
+                               MeshPoint mp4 = 
c->meshGradientArray[grow+1][gcol];
                                int colInd1 = grow * 
c->meshGradientArray[grow].count() + gcol;
                                int colInd2 = grow * 
c->meshGradientArray[grow].count() + gcol + 1;
                                int colInd3 = (grow + 1) * 
c->meshGradientArray[grow].count() + gcol + 1;
@@ -6950,10 +6950,10 @@
        {
                for (int gcol = 0; gcol < c->meshGradientArray[grow].count()-1; 
gcol++)
                {
-                       meshPoint mp1 = c->meshGradientArray[grow][gcol];
-                       meshPoint mp2 = c->meshGradientArray[grow][gcol+1];
-                       meshPoint mp3 = c->meshGradientArray[grow+1][gcol+1];
-                       meshPoint mp4 = c->meshGradientArray[grow+1][gcol];
+                       MeshPoint mp1 = c->meshGradientArray[grow][gcol];
+                       MeshPoint mp2 = c->meshGradientArray[grow][gcol+1];
+                       MeshPoint mp3 = c->meshGradientArray[grow+1][gcol+1];
+                       MeshPoint mp4 = c->meshGradientArray[grow+1][gcol];
                        int colInd1 = grow * c->meshGradientArray[grow].count() 
+ gcol;
                        int colInd2 = grow * c->meshGradientArray[grow].count() 
+ gcol + 1;
                        int colInd3 = (grow + 1) * 
c->meshGradientArray[grow].count() + gcol + 1;
@@ -7087,7 +7087,7 @@
        for (int col = 0; col < c->meshGradientPatches.count(); col++)
        {
                meshGradientPatch patch = c->meshGradientPatches[col];
-               meshPoint mp1 = patch.TL;
+               MeshPoint mp1 = patch.TL;
                colorNames.append(mp1.colorName);
                colorShades.append(mp1.shade);
                TransVec.append(mp1.transparency);
@@ -7099,7 +7099,7 @@
                                spotColorSet.append(mp1.colorName);
                }
                Gcolors.append(SetGradientColor(mp1.colorName, mp1.shade));
-               meshPoint mp2 = patch.TR;
+               MeshPoint mp2 = patch.TR;
                colorNames.append(mp2.colorName);
                colorShades.append(mp2.shade);
                TransVec.append(mp2.transparency);
@@ -7111,7 +7111,7 @@
                                spotColorSet.append(mp2.colorName);
                }
                Gcolors.append(SetGradientColor(mp2.colorName, mp2.shade));
-               meshPoint mp3 = patch.BR;
+               MeshPoint mp3 = patch.BR;
                colorNames.append(mp3.colorName);
                colorShades.append(mp3.shade);
                TransVec.append(mp3.transparency);
@@ -7123,7 +7123,7 @@
                                spotColorSet.append(mp3.colorName);
                }
                Gcolors.append(SetGradientColor(mp3.colorName, mp3.shade));
-               meshPoint mp4 = patch.BL;
+               MeshPoint mp4 = patch.BL;
                colorNames.append(mp4.colorName);
                colorShades.append(mp4.shade);
                TransVec.append(mp4.transparency);
@@ -7154,10 +7154,10 @@
                for (int col = 0; col < c->meshGradientPatches.count(); col++)
                {
                        meshGradientPatch patch = c->meshGradientPatches[col];
-                       meshPoint mp1 = patch.TL;
-                       meshPoint mp2 = patch.TR;
-                       meshPoint mp3 = patch.BR;
-                       meshPoint mp4 = patch.BL;
+                       MeshPoint mp1 = patch.TL;
+                       MeshPoint mp2 = patch.TR;
+                       MeshPoint mp3 = patch.BR;
+                       MeshPoint mp4 = patch.BL;
                        int colInd1 = 4 * col;
                        int colInd2 = 4 * col + 1;
                        int colInd3 = 4 * col + 2;
@@ -7279,10 +7279,10 @@
        for (int col = 0; col < c->meshGradientPatches.count(); col++)
        {
                meshGradientPatch patch = c->meshGradientPatches[col];
-               meshPoint mp1 = patch.TL;
-               meshPoint mp2 = patch.TR;
-               meshPoint mp3 = patch.BR;
-               meshPoint mp4 = patch.BL;
+               MeshPoint mp1 = patch.TL;
+               MeshPoint mp2 = patch.TR;
+               MeshPoint mp3 = patch.BR;
+               MeshPoint mp4 = patch.BL;
                int colInd1 = 4 * col;
                int colInd2 = 4 * col + 1;
                int colInd3 = 4 * col + 2;

Modified: 
trunk/Scribus/scribus/plugins/fileloader/scribus12format/scribus12format.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/plugins/fileloader/scribus12format/scribus12format.h
==============================================================================
--- trunk/Scribus/scribus/plugins/fileloader/scribus12format/scribus12format.h  
(original)
+++ trunk/Scribus/scribus/plugins/fileloader/scribus12format/scribus12format.h  
Fri Dec 29 18:04:22 2017
@@ -155,7 +155,7 @@
                        QString GrColorP2;
                        QString GrColorP3;
                        QString GrColorP4;
-                       QList<QList<meshPoint> > meshGradientArray;
+                       QList<QList<MeshPoint> > meshGradientArray;
                        int mGArrayRows;
                        int mGArrayCols;
                        QString TxtStroke;

Modified: 
trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format.cpp
==============================================================================
--- 
trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format.cpp  
    (original)
+++ 
trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format.cpp  
    Fri Dec 29 18:04:22 2017
@@ -3829,7 +3829,7 @@
                }
                if (tName == "MPoint")
                {
-                       meshPoint mp;
+                       MeshPoint mp;
                        mp.colorName     = tAtt.valueAsString("NAME");
                        mp.shade         = tAtt.valueAsInt("SHADE", 100);
                        mp.transparency  = tAtt.valueAsDouble("TRANS", 1.0);
@@ -3851,7 +3851,7 @@
                }
                if (tName == "PMPoint")
                {
-                       meshPoint mp;
+                       MeshPoint mp;
                        mp.colorName     = tAtt.valueAsString("NAME");
                        mp.shade         = tAtt.valueAsInt("SHADE", 100);
                        mp.transparency  = tAtt.valueAsDouble("TRANS", 1.0);
@@ -5473,10 +5473,10 @@
                        int mGArrayCols = attrs.valueAsInt("GMAY", 1);
                        for (int mgr = 0; mgr < mGArrayRows; mgr++)
                        {
-                               QList<meshPoint> ml;
+                               QList<MeshPoint> ml;
                                for (int mgc = 0; mgc < mGArrayCols; mgc++)
                                {
-                                       meshPoint mp;
+                                       MeshPoint mp;
                                        ml.append(mp);
                                }
                                currItem->meshGradientArray.append(ml);

Modified: 
trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format_save.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format_save.cpp
==============================================================================
--- 
trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format_save.cpp
 (original)
+++ 
trunk/Scribus/scribus/plugins/fileloader/scribus150format/scribus150format_save.cpp
 Fri Dec 29 18:04:22 2017
@@ -2111,7 +2111,7 @@
                        {
                                for (int gcol = 0; gcol < 
item->meshGradientArray[grow].count(); gcol++)
                                {
-                                       meshPoint mp = 
item->meshGradientArray[grow][gcol];
+                                       MeshPoint mp = 
item->meshGradientArray[grow][gcol];
                                        docu.writeStartElement("MPoint");
                                        docu.writeAttribute("GX", 
mp.gridPoint.x());
                                        docu.writeAttribute("GY", 
mp.gridPoint.y());
@@ -2139,7 +2139,7 @@
                                meshGradientPatch patch = 
item->meshGradientPatches[grow];
                                for (int gcol = 0; gcol < 4; gcol++)
                                {
-                                       meshPoint mp;
+                                       MeshPoint mp;
                                        docu.writeStartElement("PMPoint");
                                        if (gcol == 0)
                                        {

Modified: trunk/Scribus/scribus/plugins/import/ai/importai.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/plugins/import/ai/importai.cpp
==============================================================================
--- trunk/Scribus/scribus/plugins/import/ai/importai.cpp        (original)
+++ trunk/Scribus/scribus/plugins/import/ai/importai.cpp        Fri Dec 29 
18:04:22 2017
@@ -2087,7 +2087,7 @@
                                        {
                                                for (int gcol = 0; gcol < 
ite->meshGradientArray[grow].count(); gcol++)
                                                {
-                                                       meshPoint mp = 
ite->meshGradientArray[grow][gcol];
+                                                       MeshPoint mp = 
ite->meshGradientArray[grow][gcol];
                                                        
ite->setMeshPointColor(grow, gcol, mp.colorName, mp.shade, mp.transparency);
                                                }
                                        }
@@ -2130,10 +2130,10 @@
                                mVals2 >> meshXSize >> meshYSize;
                                for (int mgr = 0; mgr < meshYSize+1; mgr++)
                                {
-                                       QList<meshPoint> ml;
+                                       QList<MeshPoint> ml;
                                        for (int mgc = 0; mgc < meshXSize+1; 
mgc++)
                                        {
-                                               meshPoint mp;
+                                               MeshPoint mp;
                                                ml.append(mp);
                                        }
                                        meshGradientArray.append(ml);

Modified: trunk/Scribus/scribus/plugins/import/ai/importai.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/plugins/import/ai/importai.h
==============================================================================
--- trunk/Scribus/scribus/plugins/import/ai/importai.h  (original)
+++ trunk/Scribus/scribus/plugins/import/ai/importai.h  Fri Dec 29 18:04:22 2017
@@ -178,7 +178,7 @@
        double meshNode4Control1X, meshNode4Control1Y;
        double meshNode4Control2X, meshNode4Control2Y;
        QString meshColor1, meshColor2, meshColor3, meshColor4;
-       QList<QList<meshPoint> > meshGradientArray;
+       QList<QList<MeshPoint> > meshGradientArray;
        QString docCreator;
        QString docDate;
        QString docTime;

Modified: trunk/Scribus/scribus/plugins/import/emf/importemf.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/plugins/import/emf/importemf.cpp
==============================================================================
--- trunk/Scribus/scribus/plugins/import/emf/importemf.cpp      (original)
+++ trunk/Scribus/scribus/plugins/import/emf/importemf.cpp      Fri Dec 29 
18:04:22 2017
@@ -2140,7 +2140,7 @@
                                if (colorStops.count() == 2)
                                {
                                        int endC = colorStops.count() - 1;
-                                       meshPoint cP;
+                                       MeshPoint cP;
                                        cP.resetTo(center);
                                        cP.transparency = 
colorStops[0]->opacity;
                                        cP.shade = 100;
@@ -2153,14 +2153,14 @@
                                                patch.BR = cP;
                                                if (gpath.isMarker(poi))
                                                        continue;
-                                               meshPoint tL;
+                                               MeshPoint tL;
                                                tL.resetTo(gpath.point(poi));
                                                tL.controlRight = 
gpath.point(poi + 1);
                                                tL.transparency = 
colorStops[endC]->opacity;
                                                tL.shade = 100;
                                                tL.colorName = 
colorStops[endC]->name;
                                                tL.color = 
colorStops[endC]->color;
-                                               meshPoint tR;
+                                               MeshPoint tR;
                                                tR.resetTo(gpath.point(poi + 
2));
                                                tR.controlLeft = 
gpath.point(poi + 3);
                                                tR.transparency = 
colorStops[endC]->opacity;
@@ -2180,7 +2180,7 @@
                                        mm.scale(colorStops[1]->rampPoint, 
colorStops[1]->rampPoint);
                                        mm.translate(-cx.x(), -cx.y());
                                        gpath2.map(mm);
-                                       meshPoint cP;
+                                       MeshPoint cP;
                                        cP.resetTo(center);
                                        cP.transparency = 
colorStops[0]->opacity;
                                        cP.shade = 100;
@@ -2193,14 +2193,14 @@
                                                patch.BR = cP;
                                                if (gpath.isMarker(poi))
                                                        continue;
-                                               meshPoint tL;
+                                               MeshPoint tL;
                                                tL.resetTo(gpath2.point(poi));
                                                tL.controlRight = 
gpath2.point(poi + 1);
                                                tL.transparency = 
colorStops[1]->opacity;
                                                tL.shade = 100;
                                                tL.colorName = 
colorStops[1]->name;
                                                tL.color = colorStops[1]->color;
-                                               meshPoint tR;
+                                               MeshPoint tR;
                                                tR.resetTo(gpath2.point(poi + 
2));
                                                tR.controlLeft = 
gpath2.point(poi + 3);
                                                tR.transparency = 
colorStops[1]->opacity;
@@ -2225,7 +2225,7 @@
                                                        if (gpath.isMarker(poi))
                                                                continue;
                                                        meshGradientPatch patch;
-                                                       meshPoint bL;
+                                                       MeshPoint bL;
                                                        
bL.resetTo(gpath3.point(poi));
                                                        bL.controlRight = 
gpath3.point(poi + 1);
                                                        bL.transparency = 
colorStops[cstp - 1]->opacity;
@@ -2233,7 +2233,7 @@
                                                        bL.colorName = 
colorStops[cstp - 1]->name;
                                                        bL.color = 
colorStops[cstp - 1]->color;
                                                        patch.BL = bL;
-                                                       meshPoint bR;
+                                                       MeshPoint bR;
                                                        
bR.resetTo(gpath3.point(poi + 2));
                                                        bR.controlLeft = 
gpath3.point(poi + 3);
                                                        bR.transparency = 
colorStops[cstp - 1]->opacity;
@@ -2241,14 +2241,14 @@
                                                        bR.colorName = 
colorStops[cstp - 1]->name;
                                                        bR.color = 
colorStops[cstp - 1]->color;
                                                        patch.BR = bR;
-                                                       meshPoint tL;
+                                                       MeshPoint tL;
                                                        
tL.resetTo(gpath2.point(poi));
                                                        tL.controlRight = 
gpath2.point(poi + 1);
                                                        tL.transparency = 
colorStops[cstp]->opacity;
                                                        tL.shade = 100;
                                                        tL.colorName = 
colorStops[cstp]->name;
                                                        tL.color = 
colorStops[cstp]->color;
-                                                       meshPoint tR;
+                                                       MeshPoint tR;
                                                        
tR.resetTo(gpath2.point(poi + 2));
                                                        tR.controlLeft = 
gpath2.point(poi + 3);
                                                        tR.transparency = 
colorStops[cstp]->opacity;

Modified: trunk/Scribus/scribus/plugins/import/revenge/rawpainter.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/plugins/import/revenge/rawpainter.cpp
==============================================================================
--- trunk/Scribus/scribus/plugins/import/revenge/rawpainter.cpp (original)
+++ trunk/Scribus/scribus/plugins/import/revenge/rawpainter.cpp Fri Dec 29 
18:04:22 2017
@@ -1917,7 +1917,7 @@
                        if (colorStops.count() == 2)
                        {
                                int endC = colorStops.count() - 1;
-                               meshPoint cP;
+                               MeshPoint cP;
                                cP.resetTo(center);
                                cP.transparency = colorStops[0]->opacity;
                                cP.shade = 100;
@@ -1930,14 +1930,14 @@
                                        patch.BR = cP;
                                        if (gpath.isMarker(poi))
                                                continue;
-                                       meshPoint tL;
+                                       MeshPoint tL;
                                        tL.resetTo(gpath.point(poi));
                                        tL.controlRight = gpath.point(poi + 1);
                                        tL.transparency = 
colorStops[endC]->opacity;
                                        tL.shade = 100;
                                        tL.colorName = colorStops[endC]->name;
                                        tL.color = colorStops[endC]->color;
-                                       meshPoint tR;
+                                       MeshPoint tR;
                                        tR.resetTo(gpath.point(poi + 2));
                                        tR.controlLeft = gpath.point(poi + 3);
                                        tR.transparency = 
colorStops[endC]->opacity;
@@ -1957,7 +1957,7 @@
                                mm.scale(colorStops[1]->rampPoint, 
colorStops[1]->rampPoint);
                                mm.translate(-center.x(), -center.y());
                                gpath2.map(mm);
-                               meshPoint cP;
+                               MeshPoint cP;
                                cP.resetTo(center);
                                cP.transparency = colorStops[0]->opacity;
                                cP.shade = 100;
@@ -1970,14 +1970,14 @@
                                        patch.BR = cP;
                                        if (gpath.isMarker(poi))
                                                continue;
-                                       meshPoint tL;
+                                       MeshPoint tL;
                                        tL.resetTo(gpath2.point(poi));
                                        tL.controlRight = gpath2.point(poi + 1);
                                        tL.transparency = 
colorStops[1]->opacity;
                                        tL.shade = 100;
                                        tL.colorName = colorStops[1]->name;
                                        tL.color = colorStops[1]->color;
-                                       meshPoint tR;
+                                       MeshPoint tR;
                                        tR.resetTo(gpath2.point(poi + 2));
                                        tR.controlLeft = gpath2.point(poi + 3);
                                        tR.transparency = 
colorStops[1]->opacity;
@@ -2002,7 +2002,7 @@
                                                if (gpath.isMarker(poi))
                                                        continue;
                                                meshGradientPatch patch;
-                                               meshPoint bL;
+                                               MeshPoint bL;
                                                bL.resetTo(gpath3.point(poi));
                                                bL.controlRight = 
gpath3.point(poi + 1);
                                                bL.transparency = 
colorStops[cstp - 1]->opacity;
@@ -2010,7 +2010,7 @@
                                                bL.colorName = colorStops[cstp 
- 1]->name;
                                                bL.color = colorStops[cstp - 
1]->color;
                                                patch.BL = bL;
-                                               meshPoint bR;
+                                               MeshPoint bR;
                                                bR.resetTo(gpath3.point(poi + 
2));
                                                bR.controlLeft = 
gpath3.point(poi + 3);
                                                bR.transparency = 
colorStops[cstp - 1]->opacity;
@@ -2018,14 +2018,14 @@
                                                bR.colorName = colorStops[cstp 
- 1]->name;
                                                bR.color = colorStops[cstp - 
1]->color;
                                                patch.BR = bR;
-                                               meshPoint tL;
+                                               MeshPoint tL;
                                                tL.resetTo(gpath2.point(poi));
                                                tL.controlRight = 
gpath2.point(poi + 1);
                                                tL.transparency = 
colorStops[cstp]->opacity;
                                                tL.shade = 100;
                                                tL.colorName = 
colorStops[cstp]->name;
                                                tL.color = 
colorStops[cstp]->color;
-                                               meshPoint tR;
+                                               MeshPoint tR;
                                                tR.resetTo(gpath2.point(poi + 
2));
                                                tR.controlLeft = 
gpath2.point(poi + 3);
                                                tR.transparency = 
colorStops[cstp]->opacity;
@@ -3271,7 +3271,7 @@
                {
                        ite->meshGradientPatches.clear();
                        FPoint center = FPoint(ite->width() / 2.0, 
ite->height() / 2.0);
-                       meshPoint cP;
+                       MeshPoint cP;
                        cP.resetTo(center);
                        cP.transparency = gradColor2Trans;
                        cP.shade = 100;
@@ -3284,14 +3284,14 @@
                                patch.BR = cP;
                                if (ite->PoLine.isMarker(poi))
                                        continue;
-                               meshPoint tL;
+                               MeshPoint tL;
                                tL.resetTo(ite->PoLine.point(poi));
                                tL.controlRight = ite->PoLine.point(poi + 1);
                                tL.transparency = gradColor1Trans;
                                tL.shade = 100;
                                tL.colorName = gradColor1Str;
                                tL.color = gradColor1;
-                               meshPoint tR;
+                               MeshPoint tR;
                                tR.resetTo(ite->PoLine.point(poi + 2));
                                tR.controlLeft = ite->PoLine.point(poi + 3);
                                tR.transparency = gradColor1Trans;

Modified: trunk/Scribus/scribus/plugins/import/svm/importsvm.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/plugins/import/svm/importsvm.cpp
==============================================================================
--- trunk/Scribus/scribus/plugins/import/svm/importsvm.cpp      (original)
+++ trunk/Scribus/scribus/plugins/import/svm/importsvm.cpp      Fri Dec 29 
18:04:22 2017
@@ -1340,7 +1340,7 @@
                                if (colorStops.count() == 2)
                                {
                                        int endC = colorStops.count() - 1;
-                                       meshPoint cP;
+                                       MeshPoint cP;
                                        cP.resetTo(center);
                                        cP.transparency = 
colorStops[0]->opacity;
                                        cP.shade = 100;
@@ -1353,14 +1353,14 @@
                                                patch.BR = cP;
                                                if (gpath.isMarker(poi))
                                                        continue;
-                                               meshPoint tL;
+                                               MeshPoint tL;
                                                tL.resetTo(gpath.point(poi));
                                                tL.controlRight = 
gpath.point(poi + 1);
                                                tL.transparency = 
colorStops[endC]->opacity;
                                                tL.shade = 100;
                                                tL.colorName = 
colorStops[endC]->name;
                                                tL.color = 
colorStops[endC]->color;
-                                               meshPoint tR;
+                                               MeshPoint tR;
                                                tR.resetTo(gpath.point(poi + 
2));
                                                tR.controlLeft = 
gpath.point(poi + 3);
                                                tR.transparency = 
colorStops[endC]->opacity;
@@ -1380,7 +1380,7 @@
                                        mm.scale(colorStops[1]->rampPoint, 
colorStops[1]->rampPoint);
                                        mm.translate(-cx.x(), -cx.y());
                                        gpath2.map(mm);
-                                       meshPoint cP;
+                                       MeshPoint cP;
                                        cP.resetTo(center);
                                        cP.transparency = 
colorStops[0]->opacity;
                                        cP.shade = 100;
@@ -1393,14 +1393,14 @@
                                                patch.BR = cP;
                                                if (gpath.isMarker(poi))
                                                        continue;
-                                               meshPoint tL;
+                                               MeshPoint tL;
                                                tL.resetTo(gpath2.point(poi));
                                                tL.controlRight = 
gpath2.point(poi + 1);
                                                tL.transparency = 
colorStops[1]->opacity;
                                                tL.shade = 100;
                                                tL.colorName = 
colorStops[1]->name;
                                                tL.color = colorStops[1]->color;
-                                               meshPoint tR;
+                                               MeshPoint tR;
                                                tR.resetTo(gpath2.point(poi + 
2));
                                                tR.controlLeft = 
gpath2.point(poi + 3);
                                                tR.transparency = 
colorStops[1]->opacity;
@@ -1425,7 +1425,7 @@
                                                        if (gpath.isMarker(poi))
                                                                continue;
                                                        meshGradientPatch patch;
-                                                       meshPoint bL;
+                                                       MeshPoint bL;
                                                        
bL.resetTo(gpath3.point(poi));
                                                        bL.controlRight = 
gpath3.point(poi + 1);
                                                        bL.transparency = 
colorStops[cstp - 1]->opacity;
@@ -1433,7 +1433,7 @@
                                                        bL.colorName = 
colorStops[cstp - 1]->name;
                                                        bL.color = 
colorStops[cstp - 1]->color;
                                                        patch.BL = bL;
-                                                       meshPoint bR;
+                                                       MeshPoint bR;
                                                        
bR.resetTo(gpath3.point(poi + 2));
                                                        bR.controlLeft = 
gpath3.point(poi + 3);
                                                        bR.transparency = 
colorStops[cstp - 1]->opacity;
@@ -1441,14 +1441,14 @@
                                                        bR.colorName = 
colorStops[cstp - 1]->name;
                                                        bR.color = 
colorStops[cstp - 1]->color;
                                                        patch.BR = bR;
-                                                       meshPoint tL;
+                                                       MeshPoint tL;
                                                        
tL.resetTo(gpath2.point(poi));
                                                        tL.controlRight = 
gpath2.point(poi + 1);
                                                        tL.transparency = 
colorStops[cstp]->opacity;
                                                        tL.shade = 100;
                                                        tL.colorName = 
colorStops[cstp]->name;
                                                        tL.color = 
colorStops[cstp]->color;
-                                                       meshPoint tR;
+                                                       MeshPoint tR;
                                                        
tR.resetTo(gpath2.point(poi + 2));
                                                        tR.controlLeft = 
gpath2.point(poi + 3);
                                                        tR.transparency = 
colorStops[cstp]->opacity;

Modified: trunk/Scribus/scribus/plugins/import/viva/importviva.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/plugins/import/viva/importviva.cpp
==============================================================================
--- trunk/Scribus/scribus/plugins/import/viva/importviva.cpp    (original)
+++ trunk/Scribus/scribus/plugins/import/viva/importviva.cpp    Fri Dec 29 
18:04:22 2017
@@ -1537,7 +1537,7 @@
                                QColor gradColor1 = colorStops[1]->color;
                                item->meshGradientPatches.clear();
                                FPoint center = FPoint(item->width() / 2.0, 
item->height() / 2.0);
-                               meshPoint cP;
+                               MeshPoint cP;
                                cP.resetTo(center);
                                cP.transparency = 1.0;
                                cP.shade = 100;
@@ -1550,14 +1550,14 @@
                                        patch.BR = cP;
                                        if (item->PoLine.isMarker(poi))
                                                continue;
-                                       meshPoint tL;
+                                       MeshPoint tL;
                                        tL.resetTo(item->PoLine.point(poi));
                                        tL.controlRight = 
item->PoLine.point(poi + 1);
                                        tL.transparency = 1.0;
                                        tL.shade = 100;
                                        tL.colorName = gradColor1Str;
                                        tL.color = gradColor1;
-                                       meshPoint tR;
+                                       MeshPoint tR;
                                        tR.resetTo(item->PoLine.point(poi + 2));
                                        tR.controlLeft = item->PoLine.point(poi 
+ 3);
                                        tR.transparency = 1.0;

Modified: trunk/Scribus/scribus/pslib.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/pslib.cpp
==============================================================================
--- trunk/Scribus/scribus/pslib.cpp     (original)
+++ trunk/Scribus/scribus/pslib.cpp     Fri Dec 29 18:04:22 2017
@@ -3123,7 +3123,7 @@
        {
                for (int gcol = 0; gcol < c->meshGradientArray[grow].count(); 
gcol++)
                {
-                       meshPoint mp1 = c->meshGradientArray[grow][gcol];
+                       MeshPoint mp1 = c->meshGradientArray[grow][gcol];
                        cols.append(mp1.colorName);
                        if (!m_Doc->PageColors.contains(mp1.colorName))
                        {
@@ -3241,10 +3241,10 @@
                quint8 flg = 0;
                for (int gcol = 0; gcol < c->meshGradientArray[grow].count()-1; 
gcol++)
                {
-                       meshPoint mp1 = c->meshGradientArray[grow][gcol];
-                       meshPoint mp2 = c->meshGradientArray[grow][gcol+1];
-                       meshPoint mp3 = c->meshGradientArray[grow+1][gcol+1];
-                       meshPoint mp4 = c->meshGradientArray[grow+1][gcol];
+                       MeshPoint mp1 = c->meshGradientArray[grow][gcol];
+                       MeshPoint mp2 = c->meshGradientArray[grow][gcol+1];
+                       MeshPoint mp3 = c->meshGradientArray[grow+1][gcol+1];
+                       MeshPoint mp4 = c->meshGradientArray[grow+1][gcol];
                        int colInd1 = grow * c->meshGradientArray[grow].count() 
+ gcol;
                        int colInd2 = grow * c->meshGradientArray[grow].count() 
+ gcol + 1;
                        int colInd3 = (grow + 1) * 
c->meshGradientArray[grow].count() + gcol + 1;
@@ -3294,7 +3294,7 @@
        for (int col = 0; col < c->meshGradientPatches.count(); col++)
        {
                meshGradientPatch patch = c->meshGradientPatches[col];
-               meshPoint mp1 = patch.TL;
+               MeshPoint mp1 = patch.TL;
                cols.append(mp1.colorName);
                colsSh.append(mp1.shade);
                if (spotMap.contains(mp1.colorName))
@@ -3302,7 +3302,7 @@
                        if (!spotColorSet.contains(mp1.colorName))
                                spotColorSet.append(mp1.colorName);
                }
-               meshPoint mp2 = patch.TR;
+               MeshPoint mp2 = patch.TR;
                cols.append(mp2.colorName);
                colsSh.append(mp2.shade);
                if (spotMap.contains(mp2.colorName))
@@ -3310,7 +3310,7 @@
                        if (!spotColorSet.contains(mp2.colorName))
                                spotColorSet.append(mp2.colorName);
                }
-               meshPoint mp3 = patch.BR;
+               MeshPoint mp3 = patch.BR;
                cols.append(mp3.colorName);
                colsSh.append(mp3.shade);
                if (spotMap.contains(mp3.colorName))
@@ -3318,7 +3318,7 @@
                        if (!spotColorSet.contains(mp3.colorName))
                                spotColorSet.append(mp3.colorName);
                }
-               meshPoint mp4 = patch.BL;
+               MeshPoint mp4 = patch.BL;
                cols.append(mp4.colorName);
                colsSh.append(mp4.shade);
                if (spotMap.contains(mp4.colorName))
@@ -3425,10 +3425,10 @@
                {
                        col = col2;
                        meshGradientPatch patch = c->meshGradientPatches[col2];
-                       meshPoint mp1 = patch.TL;
-                       meshPoint mp2 = patch.TR;
-                       meshPoint mp3 = patch.BR;
-                       meshPoint mp4 = patch.BL;
+                       MeshPoint mp1 = patch.TL;
+                       MeshPoint mp2 = patch.TR;
+                       MeshPoint mp3 = patch.BR;
+                       MeshPoint mp4 = patch.BL;
                        int colInd1 = 4 * col2;
                        int colInd2 = 4 * col2 + 1;
                        int colInd3 = 4 * col2 + 2;

Modified: trunk/Scribus/scribus/scpainter.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/scpainter.cpp
==============================================================================
--- trunk/Scribus/scribus/scpainter.cpp (original)
+++ trunk/Scribus/scribus/scpainter.cpp Fri Dec 29 18:04:22 2017
@@ -382,7 +382,7 @@
        gradControlP5 = c5;
 }
 
-void ScPainter::setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint p4, 
QList<QList<meshPoint> > meshArray)
+void ScPainter::setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint p4, 
QList<QList<MeshPoint> > meshArray)
 {
        fill_gradient.setType(VGradient::mesh);
        meshGradientArray = meshArray;
@@ -968,10 +968,10 @@
                        {
                                for (int gcol = 0; gcol < 
meshGradientArray[grow].count()-1; gcol++)
                                {
-                                       meshPoint mp1 = 
meshGradientArray[grow][gcol];
-                                       meshPoint mp2 = 
meshGradientArray[grow][gcol+1];
-                                       meshPoint mp3 = 
meshGradientArray[grow+1][gcol+1];
-                                       meshPoint mp4 = 
meshGradientArray[grow+1][gcol];
+                                       MeshPoint mp1 = 
meshGradientArray[grow][gcol];
+                                       MeshPoint mp2 = 
meshGradientArray[grow][gcol+1];
+                                       MeshPoint mp3 = 
meshGradientArray[grow+1][gcol+1];
+                                       MeshPoint mp4 = 
meshGradientArray[grow+1][gcol];
                                        cairo_mesh_pattern_begin_patch(mpat);
                                        cairo_mesh_pattern_move_to(mpat, 
mp1.gridPoint.x(), mp1.gridPoint.y());
                                        cairo_mesh_pattern_curve_to(mpat, 
mp1.controlRight.x(), mp1.controlRight.y(), mp2.controlLeft.x(), 
mp2.controlLeft.y(), mp2.gridPoint.x(), mp2.gridPoint.y());
@@ -1014,10 +1014,10 @@
                        for (int col = 0; col < meshGradientPatches.count(); 
col++)
                        {
                                meshGradientPatch patch = 
meshGradientPatches[col];
-                               meshPoint mp1 = patch.TL;
-                               meshPoint mp2 = patch.TR;
-                               meshPoint mp3 = patch.BR;
-                               meshPoint mp4 = patch.BL;
+                               MeshPoint mp1 = patch.TL;
+                               MeshPoint mp2 = patch.TR;
+                               MeshPoint mp3 = patch.BR;
+                               MeshPoint mp4 = patch.BL;
                                cairo_mesh_pattern_begin_patch(mpat);
                                cairo_mesh_pattern_move_to(mpat, 
mp1.gridPoint.x(), mp1.gridPoint.y());
                                cairo_mesh_pattern_curve_to(mpat, 
mp1.controlRight.x(), mp1.controlRight.y(), mp2.controlLeft.x(), 
mp2.controlLeft.y(), mp2.gridPoint.x(), mp2.gridPoint.y());

Modified: trunk/Scribus/scribus/scpainter.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/scpainter.h
==============================================================================
--- trunk/Scribus/scribus/scpainter.h   (original)
+++ trunk/Scribus/scribus/scpainter.h   Fri Dec 29 18:04:22 2017
@@ -81,7 +81,7 @@
        virtual void set4ColorGeometry(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, FPoint c1, FPoint c2, FPoint c3, FPoint c4);
        virtual void set4ColorColors(QColor col1, QColor col2, QColor col3, 
QColor col4);
        virtual void setDiamondGeometry(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, FPoint c1, FPoint c2, FPoint c3, FPoint c4, FPoint c5);
-       virtual void setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, QList<QList<meshPoint> > meshArray);
+       virtual void setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, QList<QList<MeshPoint> > meshArray);
        virtual void setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, QList<meshGradientPatch> meshPatches);
 
        virtual void setHatchParameters(int mode, double distance, double 
angle, bool useBackground, QColor background, QColor foreground, double width, 
double height);
@@ -216,7 +216,7 @@
        QColor gradPatchColor2;
        QColor gradPatchColor3;
        QColor gradPatchColor4;
-       QList<QList<meshPoint> > meshGradientArray;
+       QList<QList<MeshPoint> > meshGradientArray;
        QList<meshGradientPatch> meshGradientPatches;
        double m_hatchAngle;
        double m_hatchDistance;

Modified: trunk/Scribus/scribus/scpainterex_ps2.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/scpainterex_ps2.h
==============================================================================
--- trunk/Scribus/scribus/scpainterex_ps2.h     (original)
+++ trunk/Scribus/scribus/scpainterex_ps2.h     Fri Dec 29 18:04:22 2017
@@ -118,7 +118,7 @@
        virtual void set4ColorGeometry(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, FPoint c1, FPoint c2, FPoint c3, FPoint c4) {};
        virtual void set4ColorColors(const ScColorShade& col1, const 
ScColorShade& col2, const ScColorShade& col3, const ScColorShade& col4) {};
        virtual void setDiamondGeometry(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, FPoint c1, FPoint c2, FPoint c3, FPoint c4, FPoint c5) {};
-       virtual void setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, QList<QList<meshPoint> > meshArray) {};
+       virtual void setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, QList<QList<MeshPoint> > meshArray) {};
        virtual void setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, QList<meshGradientPatch> meshPatches) {};
 
        virtual void setClipPath();

Modified: trunk/Scribus/scribus/scpainterexbase.h
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/scpainterexbase.h
==============================================================================
--- trunk/Scribus/scribus/scpainterexbase.h     (original)
+++ trunk/Scribus/scribus/scpainterexbase.h     Fri Dec 29 18:04:22 2017
@@ -101,7 +101,7 @@
        virtual void set4ColorGeometry(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, FPoint c1, FPoint c2, FPoint c3, FPoint c4) = 0;
        virtual void set4ColorColors(const ScColorShade& col1, const 
ScColorShade& col2, const ScColorShade& col3, const ScColorShade& col4) = 0;
        virtual void setDiamondGeometry(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, FPoint c1, FPoint c2, FPoint c3, FPoint c4, FPoint c5) = 0;
-       virtual void setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, QList<QList<meshPoint> > meshArray) = 0;
+       virtual void setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, QList<QList<MeshPoint> > meshArray) = 0;
        virtual void setMeshGradient(FPoint p1, FPoint p2, FPoint p3, FPoint 
p4, QList<meshGradientPatch> meshPatches) = 0;
 
        virtual void setClipPath() = 0;

Modified: trunk/Scribus/scribus/scribusdoc.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/scribusdoc.cpp
==============================================================================
--- trunk/Scribus/scribus/scribusdoc.cpp        (original)
+++ trunk/Scribus/scribus/scribusdoc.cpp        Fri Dec 29 18:04:22 2017
@@ -5006,7 +5006,7 @@
                        {
                                for (int gcol = 0; gcol < 
ite->meshGradientArray[grow].count(); gcol++)
                                {
-                                       meshPoint mp = 
ite->meshGradientArray[grow][gcol];
+                                       MeshPoint mp = 
ite->meshGradientArray[grow][gcol];
                                        ite->setMeshPointColor(grow, gcol, 
mp.colorName, mp.shade, mp.transparency);
                                }
                        }
@@ -5051,7 +5051,7 @@
                {
                        for (int gcol = 0; gcol < 
ite->meshGradientArray[grow].count(); gcol++)
                        {
-                               meshPoint mp = 
ite->meshGradientArray[grow][gcol];
+                               MeshPoint mp = 
ite->meshGradientArray[grow][gcol];
                                ite->setMeshPointColor(grow, gcol, 
mp.colorName, mp.shade, mp.transparency);
                        }
                }
@@ -5126,7 +5126,7 @@
                        {
                                for (int gcol = 0; gcol < 
ite->meshGradientArray[grow].count(); gcol++)
                                {
-                                       meshPoint mp = 
ite->meshGradientArray[grow][gcol];
+                                       MeshPoint mp = 
ite->meshGradientArray[grow][gcol];
                                        ite->setMeshPointColor(grow, gcol, 
mp.colorName, mp.shade, mp.transparency);
                                }
                        }
@@ -5176,7 +5176,7 @@
                                {
                                        for (int gcol = 0; gcol < 
ite->meshGradientArray[grow].count(); gcol++)
                                        {
-                                               meshPoint mp = 
ite->meshGradientArray[grow][gcol];
+                                               MeshPoint mp = 
ite->meshGradientArray[grow][gcol];
                                                ite->setMeshPointColor(grow, 
gcol, mp.colorName, mp.shade, mp.transparency);
                                        }
                                }

Modified: trunk/Scribus/scribus/ui/colorsandfills.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/ui/colorsandfills.cpp
==============================================================================
--- trunk/Scribus/scribus/ui/colorsandfills.cpp (original)
+++ trunk/Scribus/scribus/ui/colorsandfills.cpp Fri Dec 29 18:04:22 2017
@@ -1494,7 +1494,7 @@
                        {
                                for (int gcol = 0; gcol < 
ite->meshGradientArray[grow].count(); gcol++)
                                {
-                                       meshPoint mp = 
ite->meshGradientArray[grow][gcol];
+                                       MeshPoint mp = 
ite->meshGradientArray[grow][gcol];
                                        if ((!colorList.contains(mp.colorName)) 
&& (mp.colorName != CommonStrings::None))
                                                colorList.insert(mp.colorName, 
m_colorList[mp.colorName]);
                                }
@@ -1567,7 +1567,7 @@
                        {
                                for (int gcol = 0; gcol < 
ite->meshGradientArray[grow].count(); gcol++)
                                {
-                                       meshPoint mp = 
ite->meshGradientArray[grow][gcol];
+                                       MeshPoint mp = 
ite->meshGradientArray[grow][gcol];
                                        if (mp.colorName == oldName)
                                        {
                                                mp.colorName = newName;

Modified: trunk/Scribus/scribus/ui/cpalette.cpp
URL: 
http://scribus.net/websvn/diff.php?repname=Scribus&rev=22296&path=/trunk/Scribus/scribus/ui/cpalette.cpp
==============================================================================
--- trunk/Scribus/scribus/ui/cpalette.cpp       (original)
+++ trunk/Scribus/scribus/ui/cpalette.cpp       Fri Dec 29 18:04:22 2017
@@ -1036,7 +1036,7 @@
                        stackedWidget_2->setCurrentIndex(2);
                        if ((currentItem->selectedMeshPointX > -1) && 
(currentItem->selectedMeshPointY > -1l))
                        {
-                               meshPoint mp = 
currentItem->meshGradientArray[currentItem->selectedMeshPointX][currentItem->selectedMeshPointY];
+                               MeshPoint mp = 
currentItem->meshGradientArray[currentItem->selectedMeshPointX][currentItem->selectedMeshPointY];
                                setCurrentComboItem(colorMeshPoint, 
mp.colorName);
                                shadeMeshPoint->setValue(mp.shade);
                                transparencyMeshPoint->setValue(mp.transparency 
* 100);
@@ -1193,7 +1193,7 @@
                        stackedWidget_2->setCurrentIndex(2);
                        if ((currentItem->selectedMeshPointX > -1) && 
(currentItem->selectedMeshPointY > -1l))
                        {
-                               meshPoint mp = 
currentItem->meshGradientArray[currentItem->selectedMeshPointX][currentItem->selectedMeshPointY];
+                               MeshPoint mp = 
currentItem->meshGradientArray[currentItem->selectedMeshPointX][currentItem->selectedMeshPointY];
                                setCurrentComboItem(colorMeshPoint, 
mp.colorName);
                                shadeMeshPoint->setValue(mp.shade);
                                transparencyMeshPoint->setValue(mp.transparency 
* 100);
@@ -1288,7 +1288,7 @@
                stackedWidget_2->setCurrentIndex(2);
                if ((currentItem->selectedMeshPointX > -1) && 
(currentItem->selectedMeshPointY > -1l))
                {
-                       meshPoint mp = 
currentItem->meshGradientArray[currentItem->selectedMeshPointX][currentItem->selectedMeshPointY];
+                       MeshPoint mp = 
currentItem->meshGradientArray[currentItem->selectedMeshPointX][currentItem->selectedMeshPointY];
                        setCurrentComboItem(colorMeshPoint, mp.colorName);
                        shadeMeshPoint->setValue(mp.shade);
                        transparencyMeshPoint->setValue(mp.transparency * 100);
@@ -1364,15 +1364,15 @@
        int grow = currentItem->selectedMeshPointX;
        int gcol = currentItem->selectedMeshPointY;
        int cont = currentItem->selectedMeshControlPoint;
-       meshPoint tmp;
+       MeshPoint tmp;
        if (currentItem->gradientType() == 12)
        {
                if ((grow == -1) || (gcol == 0))
                        return;
-               ScItemState<QPair<meshPoint,meshPoint> > *ss = NULL;
+               ScItemState<QPair<MeshPoint,MeshPoint> > *ss = NULL;
                if(UndoManager::undoEnabled())
                {
-                       ss = new ScItemState<QPair<meshPoint,meshPoint> 
>(Um::GradPos);
+                       ss = new ScItemState<QPair<MeshPoint,MeshPoint> 
>(Um::GradPos);
                        ss->set("MOVE_MESH_PATCH");
                        ss->set("ARRAY", false);
                        ss->set("X", grow);
@@ -1441,7 +1441,7 @@
 
                if(UndoManager::undoEnabled())
                {
-                       ScItemState<QPair<meshPoint,meshPoint> > *ss = new 
ScItemState<QPair<meshPoint,meshPoint> >(Um::GradPos);
+                       ScItemState<QPair<MeshPoint,MeshPoint> > *ss = new 
ScItemState<QPair<MeshPoint,MeshPoint> >(Um::GradPos);
                        ss->set("MOVE_MESH_PATCH");
                        ss->set("ARRAY", true);
                        ss->set("X", grow);
@@ -1459,15 +1459,15 @@
 {
        int grow = currentItem->selectedMeshPointX;
        int gcol = currentItem->selectedMeshPointY;
-       meshPoint tmp;
+       MeshPoint tmp;
        if (currentItem->gradientType() == 12)
        {
                if ((grow == -1) || (gcol == 0))
                        return;
-               ScItemState<QPair<meshPoint,meshPoint> > *ss = NULL;
+               ScItemState<QPair<MeshPoint,MeshPoint> > *ss = NULL;
                if(UndoManager::undoEnabled())
                {
-                       ss = new ScItemState<QPair<meshPoint,meshPoint> 
>(Um::GradPos);
+                       ss = new ScItemState<QPair<MeshPoint,MeshPoint> 
>(Um::GradPos);
                        ss->set("MOVE_MESH_PATCH");
                        ss->set("ARRAY", false);
                        ss->set("X", grow);
@@ -1530,7 +1530,7 @@
                tmp.controlBottom = tmp.gridPoint;
                if(UndoManager::undoEnabled())
                {
-                       ScItemState<QPair<meshPoint,meshPoint> > *ss = new 
ScItemState<QPair<meshPoint,meshPoint> >(Um::GradPos);
+                       ScItemState<QPair<MeshPoint,MeshPoint> > *ss = new 
ScItemState<QPair<MeshPoint,MeshPoint> >(Um::GradPos);
                        ss->set("MOVE_MESH_PATCH");
                        ss->set("ARRAY", true);
                        ss->set("X", grow);
@@ -1662,7 +1662,7 @@
                colorMeshPoint->setEnabled(true);
                shadeMeshPoint->setEnabled(true);
                transparencyMeshPoint->setEnabled(true);
-               meshPoint mp = 
currentItem->meshGradientArray[currentItem->selectedMeshPointX][currentItem->selectedMeshPointY];
+               MeshPoint mp = 
currentItem->meshGradientArray[currentItem->selectedMeshPointX][currentItem->selectedMeshPointY];
                setCurrentComboItem(colorMeshPoint, mp.colorName);
                shadeMeshPoint->setValue(mp.shade);
                transparencyMeshPoint->setValue(mp.transparency * 100);
@@ -1725,7 +1725,7 @@
                shadeMeshPoint->setEnabled(true);
                transparencyMeshPoint->setEnabled(true);
                meshGradientPatch patch = 
currentItem->meshGradientPatches[currentItem->selectedMeshPointX];
-               meshPoint mp;
+               MeshPoint mp;
                switch (currentItem->selectedMeshPointY)
                {
                        case 1:


_______________________________________________
scribus-commit mailing list
[email protected]
http://lists.scribus.net/mailman/listinfo/scribus-commit

Reply via email to