hi squidge....

here is my code please check it......



#include "myGraphicsItemLinear.h"
#include "myGraphicsItemLine.h"
#include "myGraphicsItemPropertyFactory.h"

myGraphicsItemLinear::myGraphicsItemLinear(int nToolID)
{
m_bReshapeable = true;
setItemID(nToolID);

m_Pen1 = NULL;
m_Pen2 = NULL;
m_Pen3 = NULL;
m_Pen4 = NULL;
m_Pen5 = NULL;
}

myGraphicsItem* myGraphicsItemLinear::clone()
{
myGraphicsItem *pItemSelf = new myGraphicsItemLinear(m_nItemID);
pItemSelf->setItemName(m_strItemName);
pItemSelf->loadImage();
pItemSelf->setZValue(this->zValue());
pItemSelf->setMeterPerPixel(m_fMeterPerPixel);
pItemSelf->setPolygon(this->polygon());
pItemSelf->setItemProperty(this->m_pItemProperty->clone());
pItemSelf->setFlags(flags());
//
return pItemSelf;
}

QRectF myGraphicsItemLinear::boundingRect() const
{
QRectF rect(QGraphicsPolygonItem::boundingRect());

if(m_Pen1 != NULL)
{
qreal deviation = m_Pen1->widthF();
rect.adjust(-deviation, -deviation, deviation, deviation);
return rect;
}
else
{
return rect.adjusted(-1,-1,1,1);
}
}

void myGraphicsItemLinear:ropertyChanged(QStandardItem *item)
{
setToolTipFromProperty();
}

void myGraphicsItemLinear:aint(QPainter *painter,
const QStyleOptionGraphicsItem *option,
QWidget *widget)
{
//
painter->setRenderHint(QPainter::Antialiasing);

if(m_Pen1 != NULL)
{
QColor colorPre(m_Pen1->color());
if(isSelected())
{
m_Pen1->setColor(Qt::red);
}
painter->setPen(*m_Pen1);
painter->drawPolyline(m_itemPolygon);
m_Pen1->setColor(colorPre);
}
if(m_Pen2 != NULL)
{
painter->setPen(*m_Pen2);
painter->drawPolyline(m_itemPolygon);
}
if(m_Pen3 != NULL)
{
painter->setPen(*m_Pen3);
painter->drawPolyline(m_itemPolygon);
}
if(m_Pen4 != NULL)
{
painter->setPen(*m_Pen4);
painter->drawPolyline(m_itemPolygon);
}
if(m_Pen5 != NULL)
{
painter->setPen(*m_Pen5);
painter->drawPolyline(m_PolygonInternationalDemarcated);
}
}

QPolygonF myGraphicsItemLinear:olygon() const
{
return m_itemPolygon;
}

void myGraphicsItemLinear::setPolygon(const QPolygonF &polygon)
{
bool rePos = false;
if(m_itemPolygon.count() == polygon.count())
{
rePos = true;
}
m_itemPolygon = polygon;
//
QVector<QPointF> revVect;
QPolygonF tmpPoly(polygon);
QPointF ptNext(0,0);
bool bNextPoint = true;

for(int i=m_itemPolygon.count()-1; i>-1; i--)
{
revVect.append(m_itemPolygon.at(i));

QPointF pt = m_itemPolygon.at(i);
// pt.setY(pt.y()+ 2.5);
// m_PolygonInternationalDemarcated.append(pt);

if (bNextPoint )
{
ptNext = pt;
bNextPoint = false;
QPointF pt = m_itemPolygon.at(i - 1);

int nX = qAbs(pt.x() - ptNext.x());
int nY = qAbs(pt.y() - ptNext.y());

if (nX > nY)
{
ptNext.setY(ptNext.y()+ 2.5);
m_PolygonInternationalDemarcated.append(ptNext);
}
else if (nX < nY)
{
ptNext.setX(ptNext.x() + 2.5);
m_PolygonInternationalDemarcated.append(ptNext);
}
}
else
{
int nX = qAbs(pt.x() - ptNext.x());
int nY = qAbs(pt.y() - ptNext.y());

if (nX > nY)
{
pt.setY(pt.y()+ 2.5);
m_PolygonInternationalDemarcated.append(pt);
}
else if (nX < nY)
{
pt.setX(pt.x() + 2.5);
m_PolygonInternationalDemarcated.append(pt);
}

if (pt.x() != ptNext.x() || pt.y() != ptNext.y())
{
ptNext = pt;
}
} //
}

tmpPoly += revVect;

QGraphicsPolygonItem::setPolygon(tmpPoly);
//
if(rePos)
{
repositionSegmentItem(polygon);
}
else
{
createSegmentItem(polygon);
}
}

void myGraphicsItemLinear::setMeterPerPixel(const float& fMeter)
{
m_fMeterPerPixel = fMeter;
loadImage();
}

void myGraphicsItemLinear::createSegmentItem(const QPolygonF &polygon)
{
qDebug("myGraphicsItemLinear::createSegmentItem");
int nChildID = 1110;


QPolygonF poly;
myGraphicsItemLine *pSegment = NULL;
int i;
for(i = 0; i < polygon.count()-1; i++)
{
poly << polygon.at(i) << polygon.at(i+1);
pSegment = new myGraphicsItemLine(nChildID, this);
pSegment->setPolygon(poly);
//
pSegment->setFlag(ItemIsSelectable, true);
pSegment->setFlag(ItemIsMovable, false);
pSegment->setFlag(ItemIsFocusable, false);
//
poly.clear();
}
}

void myGraphicsItemLinear::repositionSegmentItem(const QPolygonF &polygon)
{
//qDebug("myGraphicsItemLinear::repositionSegmentIte m");
QPolygonF poly;
myGraphicsItemLine *pSegment = NULL;

int i;
for(i = 0; i < polygon.count()-1; i++)
{
poly << polygon.at(i) << polygon.at(i+1);
pSegment = (myGraphicsItemLine*)childItems().at(i);
pSegment->setPolygon(poly);
pSegment->update();
//
poly.clear();
}
}

void myGraphicsItemLinear::setItemProperty(myGraphicsIt emProperty* pProperty)
{
//
myGraphicsItem::setItemProperty(pProperty);

//
myGraphicsItemLine *pSegment = NULL;
myGraphicsItemProperty *pSegmentProperty;
QStandardItemModel *pModel = pProperty->getStandardModel();
int i,j;
for(i = 0; i< childItems().count(); i++)
{
pSegmentProperty = new myGraphicsItemProperty(m_nItemID);
//
for(j = 0; j< pModel->rowCount(); j++)
{
pSegmentProperty->addProperty(pModel->item(j, 0)->text(), pModel->item(j, 1)->text());
}
pSegmentProperty->setSegmentID(i);
//
pSegment = (myGraphicsItemLine*)childItems().at(i);
if(pSegment)
{
pSegment->setItemProperty(pSegmentProperty);
}
}
}


void myGraphicsItemLinear::loadImage()
{

switch(m_nItemID)
{
case ID_TOOL_TERRAIN_RAILWAYS_BROADGAUGE_DOUBLE:
{
m_Pen1 = new QPen();
m_Pen2 = new QPen();

m_Pen1->setStyle(Qt::SolidLine);
m_Pen1->setColor(Qt::black);
m_Pen1->setWidthF(3/m_fMeterPerPixel);
//
QVector<qreal> pattern;
pattern.append(qreal(3));
pattern.append(qreal(11));
m_Pen2->setDashPattern(pattern);
m_Pen2->setDashOffset(4);
m_Pen2->setColor(Qt::white);
m_Pen2->setWidthF(2/m_fMeterPerPixel);
}break;

case ID_TOOL_TERRAIN_RAILWAY_MIXED_GAUGE:
{
m_Pen1 = new QPen();
m_Pen2 = new QPen();

m_Pen1->setStyle(Qt::SolidLine);
m_Pen1->setColor(Qt::black);
m_Pen1->setWidthF(3/m_fMeterPerPixel);
//
QVector<qreal> pattern;
pattern.append(qreal(3));
pattern.append(qreal(11));
m_Pen2->setDashPattern(pattern);
m_Pen2->setDashOffset(4);
m_Pen2->setColor(Qt::white);
m_Pen2->setWidthF(2/m_fMeterPerPixel);

pattern[0] = qreal(10);
pattern[1] = qreal(4);

m_Pen3 = new QPen();

m_Pen3->setStyle(Qt::SolidLine);
m_Pen3->setColor(Qt::black);
m_Pen3->setWidthF(.5/m_fMeterPerPixel);
}break;

default:
{
m_Pen1 = NULL;
m_Pen2 = NULL;
m_Pen3 = NULL;
m_Pen4 = NULL;
m_Pen5 = NULL;
}break;
};
}