CQRenderConverter.cpp File Reference

#include <QtGui/QGraphicsItem>
#include <QtCore/QSharedPointer>
#include <QtGui/QPen>
#include <QtGui/QFont>
#include <QtGui/QFontMetrics>
#include <QtGui/QPixmap>
#include <QtCore/QFile>
#include <QtGui/QGraphicsScene>
#include <qlayout/CQRenderConverter.h>
#include <qlayout/CQRoundedRect.h>
#include <layout/CLStyle.h>
#include <layout/CLEllipse.h>
#include <layout/CLRectangle.h>
#include <layout/CLImage.h>
#include <layout/CLPolygon.h>
#include <layout/CLText.h>
#include <layout/CLCurve.h>
#include <layout/CLRenderCurve.h>
#include <layout/CLRenderCubicBezier.h>
#include <layout/CLRenderPoint.h>
#include <layout/CLLinearGradient.h>
#include <layout/CLRadialGradient.h>
#include <layout/CLRenderResolver.h>
#include <layout/CLGraphicalPrimitive1D.h>
#include <report/CCopasiRootContainer.h>
#include <CopasiDataModel/CCopasiDataModel.h>
#include <math.h>

Include dependency graph for CQRenderConverter.cpp:

Go to the source code of this file.

Functions
void	addLineEndingToItem (QGraphicsPathItem *item, const CLLineEnding *ending, const CLGroup *group, const CLRenderResolver *resolver, QPointF point, QPointF second, QGraphicsItemGroup *itemGroup)
void	addToPath (QPainterPath &path, const CLRenderCubicBezier *cubic, const CLBoundingBox *pBB)
void	addToPath (QPainterPath &path, const CLRenderPoint *current, const CLBoundingBox *pBB)
void	adjustPosition (QGraphicsTextItem *item, const CLBoundingBox *pBB, const CLText *pText, const CLGroup *group)
void	applyRotationalMapping (QPainterPath &linePath, const CLLineEnding *ending, QPointF point, QPointF second)
void	fillItemFromCurve (QGraphicsItemGroup *item, const CLBoundingBox *pBB, const CLCurve *pCurve, const CLGroup *group, const CLRenderResolver *resolver)
void	fillItemFromEllipse (QGraphicsItemGroup *item, const CLBoundingBox *pBB, const CLEllipse *pEllipse, const CLGroup *group, const CLRenderResolver *resolver)
void	fillItemFromGroup (QGraphicsItemGroup *item, const CLBoundingBox *bounds, const CLGroup *group, const CLRenderResolver *resolver)
void	fillItemFromImage (QGraphicsItemGroup *item, const CLBoundingBox *pBB, const CLImage *pImage, const CLGroup *group, const CLRenderResolver *)
void	fillItemFromPolygon (QGraphicsItemGroup *item, const CLBoundingBox *pBB, const CLPolygon *pPoly, const CLGroup *group, const CLRenderResolver *resolver)
void	fillItemFromRectangle (QGraphicsItemGroup *item, const CLBoundingBox *pBB, const CLRectangle *pRect, const CLGroup *group, const CLRenderResolver *resolver)
void	fillItemFromRenderCurve (QGraphicsItemGroup *item, const CLBoundingBox *pBB, const CLRenderCurve *pCurve, const CLGroup *group, const CLRenderResolver *resolver)
void	fillItemFromText (QGraphicsItemGroup *item, const CLBoundingBox *pBB, const CLText *pText, const CLGroup *group, const CLRenderResolver *resolver)
QSharedPointer< QBrush >	getBrush (const CLGraphicalPrimitive2D *item, const CLGroup *group, const CLRenderResolver *resolver, const CLBoundingBox *pBB)
QColor	getColor (const CLColorDefinition *cd)
QColor	getColor (const std::string &color, const CLRenderResolver *resolver)
QSharedPointer< QFont >	getFont (const CLText *item, const CLGroup *group, const CLRenderResolver *, const CLBoundingBox *pBB)
QSharedPointer< QGradient >	getGradient (const CLGradientBase *base, const CLBoundingBox *bounds, const CLRenderResolver *resolver)
QSharedPointer< QLinearGradient >	getLinearGradient (const CLLinearGradient *linear, const CLBoundingBox *bounds, const CLRenderResolver *resolver)
QSharedPointer< QPainterPath >	getPath (const CLPolygon *pCurve, const CLBoundingBox *pBB)
QSharedPointer< QPainterPath >	getPath (const CLRectangle *pRect, const CLBoundingBox *pBB)
QSharedPointer< QPainterPath >	getPath (const CLEllipse *pEllipse, const CLBoundingBox *pBB)
QSharedPointer< QPainterPath >	getPath (const CLRenderCurve *pCurve, const CLBoundingBox *pBB)
QSharedPointer< QPen >	getPen (const CLGraphicalPrimitive1D *item, const CLGroup *group, const CLRenderResolver *resolver, const CLBoundingBox *)
QSharedPointer< QRadialGradient >	getRadialGradient (const CLRadialGradient *radial, const CLBoundingBox *bounds, const CLRenderResolver *resolver)
void	moveToPoint (QPainterPath &path, const CLRenderPoint *current, const CLBoundingBox *pBB)
QPointF	normalizePoint (const QPointF &vector)
void	transform (QGraphicsItem *item, const CLTransformation2D *trans, const CLGroup *group)

Function Documentation

void addLineEndingToItem	(	QGraphicsPathItem *	item,
		const CLLineEnding *	ending,
		const CLGroup *	group,
		const CLRenderResolver *	resolver,
		QPointF	point,
		QPointF	second,
		QGraphicsItemGroup *	itemGroup
	)

Definition at line 604 of file CQRenderConverter.cpp.

References applyRotationalMapping(), CLGraphicalPrimitive2D::EVENODD, CLLineEnding::getBoundingBox(), getBrush(), CLGroup::getElement(), CLGraphicalPrimitive2D::getFillRule(), CLLineEnding::getGroup(), CLGroup::getNumElements(), getPath(), getPen(), CLGraphicalPrimitive2D::isSetFill(), CLGraphicalPrimitive2D::isSetFillRule(), and CLGraphicalPrimitive2D::NONZERO.

Referenced by CQRenderConverter::applyStyle(), and fillItemFromRenderCurve().

{
  const CLGroup* lineGroup = ending->getGroup();

  for (size_t i = 0; i < lineGroup->getNumElements(); ++i)
    {
      const CLPolygon* poly = dynamic_cast<const CLPolygon*>(lineGroup->getElement(i));
      const CLRenderCurve* rcurve = dynamic_cast<const CLRenderCurve*>(lineGroup->getElement(i));
      const CLEllipse* ellipse = dynamic_cast<const CLEllipse*>(lineGroup->getElement(i));
      const CLRectangle* rect = dynamic_cast<const CLRectangle*>(lineGroup->getElement(i));

      if (rcurve != NULL)
        {
          QPainterPath path = item->path();
          QSharedPointer<QPainterPath> linePath = getPath(rcurve, ending->getBoundingBox());
          applyRotationalMapping(*linePath, ending, point, second);
          linePath->translate(point);
          path.addPath(*linePath.data());
          item->setPath(path);
        }
      else if (poly != NULL)
        {
          QPainterPath path = item->path();
          QSharedPointer<QPainterPath> linePath = getPath(poly, ending->getBoundingBox());
          applyRotationalMapping(*linePath, ending, point, second);
          linePath->translate(point);
          path.addPath(*linePath);
          item->setPath(path);

          if (poly->isSetFill() || group->isSetFill())
            {
              QSharedPointer<QBrush> brush = getBrush(poly, ending->getGroup(), resolver, ending->getBoundingBox());
              QSharedPointer<QPen> pen = getPen(poly, ending->getGroup(), resolver, ending->getBoundingBox());

              linePath->setFillRule(Qt::WindingFill);

              if (poly->isSetFillRule())
                {
                  switch (poly->getFillRule())
                    {
                      case CLGraphicalPrimitive2D::EVENODD:
                        linePath->setFillRule(Qt::OddEvenFill);
                        break;

                      case CLGraphicalPrimitive2D::NONZERO:
                      default:
                        linePath->setFillRule(Qt::WindingFill);
                        break;
                    }
                }

              if (group->isSetFillRule())
                {
                  switch (group->getFillRule())
                    {
                      case CLGraphicalPrimitive2D::EVENODD:
                        linePath->setFillRule(Qt::OddEvenFill);
                        break;

                      case CLGraphicalPrimitive2D::NONZERO:
                      default:
                        linePath->setFillRule(Qt::WindingFill);
                        break;
                    }
                }

              QGraphicsPathItem* outline = new QGraphicsPathItem(*linePath);

              outline->setPen(*pen);
              outline->setBrush(*brush);
              itemGroup->addToGroup(outline);
            }
        }
      else if (ellipse != NULL)
        {
          QPainterPath path = item->path();
          QSharedPointer<QPainterPath> linePath = getPath(ellipse, ending->getBoundingBox());
          applyRotationalMapping(*linePath, ending, point, second);
          linePath->translate(point);
          path.addPath(*linePath);
          item->setPath(path);

          if (ellipse->isSetFill() || group->isSetFill())
            {
              QSharedPointer<QBrush> brush = getBrush(ellipse, ending->getGroup(), resolver, ending->getBoundingBox());
              QSharedPointer<QPen> pen = getPen(ellipse, ending->getGroup(), resolver, ending->getBoundingBox());
              QGraphicsPathItem* outline = new QGraphicsPathItem(*linePath);
              outline->setPen(*pen);
              outline->setBrush(*brush);
              itemGroup->addToGroup(outline);
            }
        }
      else if (rect != NULL)
        {
          QPainterPath path = item->path();
          QSharedPointer<QPainterPath> linePath = getPath(rect, ending->getBoundingBox());
          applyRotationalMapping(*linePath, ending, point, second);
          linePath->translate(point);
          path.addPath(*linePath);
          item->setPath(path);

          if (rect->isSetFill() || group->isSetFill())
            {
              QSharedPointer<QBrush> brush = getBrush(rect, ending->getGroup(), resolver, ending->getBoundingBox());
              QSharedPointer<QPen> pen = getPen(rect, ending->getGroup(), resolver, ending->getBoundingBox());
              QGraphicsPathItem* outline = new QGraphicsPathItem(*linePath);
              outline->setPen(*pen);
              outline->setBrush(*brush);
              itemGroup->addToGroup(outline);
            }
        }
    }
}

void addToPath	(	QPainterPath &	path,
		const CLRenderCubicBezier *	cubic,
		const CLBoundingBox *	pBB
	)

Definition at line 441 of file CQRenderConverter.cpp.

References CLRenderCubicBezier::basePoint1_X(), CLRenderCubicBezier::basePoint1_Y(), CLRenderCubicBezier::basePoint2_X(), CLRenderCubicBezier::basePoint2_Y(), CLRelAbsVector::getAbsoluteValue(), CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLDimensions::getWidth(), CLPoint::getX(), CLRenderPoint::getXOffset(), CLPoint::getY(), and CLRenderPoint::getYOffset().

Referenced by getPath().

{
  path.cubicTo(
    pBB->getPosition().getX() + cubic->basePoint1_X().getAbsoluteValue() + cubic->basePoint1_X().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth(),
    pBB->getPosition().getY() + cubic->basePoint1_Y().getAbsoluteValue() + cubic->basePoint1_Y().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight(),
    pBB->getPosition().getX() + cubic->basePoint2_X().getAbsoluteValue() + cubic->basePoint2_X().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth(),
    pBB->getPosition().getY() + cubic->basePoint2_Y().getAbsoluteValue() + cubic->basePoint2_Y().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight(),
    pBB->getPosition().getX() + cubic->getXOffset().getAbsoluteValue() + cubic->getXOffset().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth(),
    pBB->getPosition().getY() + cubic->getYOffset().getAbsoluteValue() + cubic->getYOffset().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight()
  );
}

void addToPath	(	QPainterPath &	path,
		const CLRenderPoint *	current,
		const CLBoundingBox *	pBB
	)

Definition at line 453 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLDimensions::getWidth(), CLPoint::getX(), CLRenderPoint::getXOffset(), CLPoint::getY(), and CLRenderPoint::getYOffset().

{
  path.lineTo(
    pBB->getPosition().getX() + current->getXOffset().getAbsoluteValue() + current->getXOffset().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth(),
    pBB->getPosition().getY() + current->getYOffset().getAbsoluteValue() + current->getYOffset().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight()
  );
}

void adjustPosition	(	QGraphicsTextItem *	item,
		const CLBoundingBox *	pBB,
		const CLText *	pText,
		const CLGroup *	group
	)

Definition at line 805 of file CQRenderConverter.cpp.

References CLText::ANCHOR_BOTTOM, CLText::ANCHOR_END, CLText::ANCHOR_MIDDLE, CLText::ANCHOR_START, CLText::ANCHOR_TOP, CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLGroup::getTextAnchor(), CLText::getTextAnchor(), CLGroup::getVTextAnchor(), CLText::getVTextAnchor(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLGroup::isSetTextAnchor(), CLText::isSetTextAnchor(), CLGroup::isSetVTextAnchor(), and CLText::isSetVTextAnchor().

Referenced by CQRenderConverter::applyStyle(), and fillItemFromText().

{
  qreal width = item->boundingRect().width();
  qreal height = item->boundingRect().height();
  double bbWidth = pBB->getDimensions().getWidth();
  double bbHeight = pBB->getDimensions().getHeight();

  if (group != NULL && (group->isSetTextAnchor() || group->isSetVTextAnchor()))
    {
      QPointF pos = item->pos();

      if (group->isSetTextAnchor() && width  > 0)
        {
          switch (group->getTextAnchor())
            {
              case CLText::ANCHOR_MIDDLE:
                pos.setX(pBB->getPosition().getX() + (bbWidth - width) / 2.0);
                break;

              case CLText::ANCHOR_END:
                pos.setX(pBB->getPosition().getX() + bbWidth - width);
                break;

              case CLText::ANCHOR_START:
              default:
                break;
            }
        }

      if (group->isSetVTextAnchor() && height > 0)
        {
          switch (group->getVTextAnchor())
            {
              case CLText::ANCHOR_MIDDLE:
                pos.setY(pBB->getPosition().getY() + (bbHeight - height) / 2.0);
                break;

              case CLText::ANCHOR_BOTTOM:
                pos.setY(pBB->getPosition().getY() + (bbHeight - height));
                break;

              case CLText::ANCHOR_TOP:
              default:
                break;
            }
        }

      item->setPos(pos);
    }

  if (pText != NULL && (pText->isSetTextAnchor() || pText->isSetVTextAnchor()))
    {
      QPointF pos = item->pos();

      if (pText->isSetTextAnchor() && width  > 0)
        {
          switch (pText->getTextAnchor())
            {
              case CLText::ANCHOR_MIDDLE:
                pos.setX(pBB->getPosition().getX() + (bbWidth - width) / 2.0);
                break;

              case CLText::ANCHOR_END:
                pos.setX(pBB->getPosition().getX() + bbWidth - width);
                break;

              case CLText::ANCHOR_START:
              default:
                break;
            }
        }

      if (pText->isSetVTextAnchor() && height > 0)
        {
          switch (pText->getVTextAnchor())
            {
              case CLText::ANCHOR_MIDDLE:
                pos.setY(pBB->getPosition().getY() + (bbHeight - height) / 2.0);
                break;

              case CLText::ANCHOR_BOTTOM:
                pos.setY(pBB->getPosition().getY() + bbHeight - height);
                break;

              case CLText::ANCHOR_TOP:
              default:
                break;
            }
        }

      item->setPos(pos);
    }
}

void applyRotationalMapping	(	QPainterPath &	linePath,
		const CLLineEnding *	ending,
		QPointF	point,
		QPointF	second
	)

Definition at line 577 of file CQRenderConverter.cpp.

References CLLineEnding::getIsEnabledRotationalMapping(), and normalizePoint().

Referenced by addLineEndingToItem().

{
  if (!ending->getIsEnabledRotationalMapping())
    return;

  QPointF directionVector(point.x() - second.x(), point.y() - second.y());
  directionVector = normalizePoint(directionVector);

  if (directionVector.x() == 0 && directionVector.y() == 0)
    return;

  QPointF orthogonlVector;

  if (directionVector.x() == 0)
    orthogonlVector = QPointF(directionVector.y(), 0);
  else
    orthogonlVector = QPointF(-directionVector.y() * directionVector.x(),
                              1 - directionVector.y() * directionVector.y());

  orthogonlVector = normalizePoint(orthogonlVector);

  QTransform rotateMatrix(directionVector.x(), directionVector.y(), orthogonlVector.x(),
                          orthogonlVector.y(), 0, 0);

  linePath = rotateMatrix.map(linePath);
}

void fillItemFromCurve	(	QGraphicsItemGroup *	item,
		const CLBoundingBox *	pBB,
		const CLCurve *	pCurve,
		const CLGroup *	group,
		const CLRenderResolver *	resolver
	)

Definition at line 381 of file CQRenderConverter.cpp.

References CLLineSegment::getBase1(), CLLineSegment::getBase2(), CLLineSegment::getEnd(), CLCurve::getListOfPoints(), CLCurve::getNumCurveSegments(), getPen(), CLCurve::getSegmentAt(), CLLineSegment::getStart(), CLPoint::getX(), CLPoint::getY(), CLLineSegment::isBezier(), and CLCurve::isContinuous().

Referenced by fillItemFromGroup().

{
  QPainterPath path;

  if (!pCurve->isContinuous())
    {
      for (size_t i = 0; i < pCurve->getNumCurveSegments(); ++i)
        {
          const CLLineSegment* current = pCurve->getSegmentAt(i);
          path.moveTo(current->getStart().getX(), current->getStart().getY());

          if (current->isBezier())
            {
              path.cubicTo(
                current->getBase1().getX(), current->getBase1().getY(),
                current->getBase2().getX(), current->getBase2().getY(),
                current->getEnd().getX(), current->getEnd().getY());
            }
          else
            {
              path.lineTo(
                current->getEnd().getX(), current->getEnd().getY());
            }
        }
    }
  else if (pCurve->getListOfPoints().size() > 0)
    {
      for (size_t i = 0; i < pCurve->getNumCurveSegments(); ++i)
        {
          const CLLineSegment* current = pCurve->getSegmentAt(i);

          if (i == 0)
            path.moveTo(current->getStart().getX(), current->getStart().getY());

          if (current->isBezier())
            {
              path.cubicTo(
                current->getBase1().getX(), current->getBase1().getY(),
                current->getBase2().getX(), current->getBase2().getY(),
                current->getEnd().getX(), current->getEnd().getY());
            }
          else
            {
              path.lineTo(
                current->getEnd().getX(), current->getEnd().getY());
            }
        }
    }
  else return;

  QGraphicsPathItem *pathItem = new QGraphicsPathItem(path);
  QSharedPointer<QPen> pen = getPen(NULL, group, resolver, pBB);
  pathItem->setPen(*pen);

  //QBrush *brush = getBrush(NULL, group, resolver, pBB);
  //pathItem->setBrush(*brush);
  //delete brush;
  item->addToGroup(pathItem);
}

void fillItemFromEllipse	(	QGraphicsItemGroup *	item,
		const CLBoundingBox *	pBB,
		const CLEllipse *	pEllipse,
		const CLGroup *	group,
		const CLRenderResolver *	resolver
	)

Definition at line 362 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), getBrush(), CLEllipse::getCX(), CLEllipse::getCY(), CLBoundingBox::getDimensions(), CLDimensions::getHeight(), getPen(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLEllipse::getRX(), CLEllipse::getRY(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), and transform().

Referenced by fillItemFromGroup().

{
  double x = pBB->getPosition().getX() + pEllipse->getCX().getAbsoluteValue() + pEllipse->getCX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double y = pBB->getPosition().getY() + pEllipse->getCY().getAbsoluteValue() + pEllipse->getCY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
  double rx = pEllipse->getRX().getAbsoluteValue() + pEllipse->getRX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double ry = pEllipse->getRY().getAbsoluteValue() + pEllipse->getRY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();

  QGraphicsEllipseItem* ellipseItem = new QGraphicsEllipseItem(
    x - rx, y - ry, rx * 2, ry * 2);
  QSharedPointer<QPen> pen = getPen(pEllipse, group, resolver, pBB);
  ellipseItem->setPen(*pen);

  QSharedPointer<QBrush> brush = getBrush(pEllipse, group, resolver, pBB);
  ellipseItem->setBrush(*brush);

  transform(ellipseItem, pEllipse, group);
  item->addToGroup(ellipseItem);
}

void fillItemFromGroup	(	QGraphicsItemGroup *	item,
		const CLBoundingBox *	bounds,
		const CLGroup *	group,
		const CLRenderResolver *	resolver
	)

Definition at line 983 of file CQRenderConverter.cpp.

References fillItemFromCurve(), fillItemFromEllipse(), fillItemFromImage(), fillItemFromPolygon(), fillItemFromRectangle(), fillItemFromRenderCurve(), fillItemFromText(), CLGroup::getElement(), CLGroup::getNumElements(), and transform().

Referenced by CQRenderConverter::fillGroupFromStyle().

{
  if (group == NULL)
    return;

  size_t numElements = group->getNumElements();

  if (numElements == 0)
    {
      return;
    }

  for (size_t i = 0; i < numElements; ++i)
    {
      const CCopasiObject* object = group->getElement(i);
      const CLEllipse* ellipse = dynamic_cast<const CLEllipse*>(object);
      const CLRectangle* rect = dynamic_cast<const CLRectangle*>(object);
      const CLPolygon* poly = dynamic_cast<const CLPolygon*>(object);
      const CLCurve* curve = dynamic_cast<const CLCurve*>(object);
      const CLRenderCurve* rcurve = dynamic_cast<const CLRenderCurve*>(object);
      const CLText* text = dynamic_cast<const CLText*>(object);
      const CLImage* image = dynamic_cast<const CLImage*>(object);
      const CLGroup* childGroup = dynamic_cast<const CLGroup*>(object);

      if (ellipse != NULL)
        {
          fillItemFromEllipse(item, bounds, ellipse, group, resolver);
        }
      else if (rect != NULL)
        {
          fillItemFromRectangle(item, bounds, rect, group, resolver);
        }
      else if (text != NULL)
        {
          fillItemFromText(item, bounds, text, group, resolver);
        }
      else if (curve != NULL)
        {
          fillItemFromCurve(item, bounds, curve, group, resolver);
        }
      else if (rcurve != NULL)
        {
          fillItemFromRenderCurve(item, bounds, rcurve, group, resolver);
        }
      else if (poly != NULL)
        {
          fillItemFromPolygon(item, bounds, poly, group, resolver);
        }
      else if (image != NULL)
        {
          fillItemFromImage(item, bounds, image, group, resolver);
        }
      else if (childGroup != NULL)
        {
          fillItemFromGroup(item, bounds, childGroup, resolver);
        }
    }

  transform(item, group, NULL);
}

void fillItemFromImage	(	QGraphicsItemGroup *	item,
		const CLBoundingBox *	pBB,
		const CLImage *	pImage,
		const CLGroup *	group,
		const CLRenderResolver *
	)

Definition at line 929 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), CCopasiRootContainer::getDatamodelList(), CLBoundingBox::getDimensions(), CLImage::getHeight(), CLDimensions::getHeight(), CLImage::getImageReference(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLImage::getWidth(), CLDimensions::getWidth(), CLPoint::getX(), CLImage::getX(), CLPoint::getY(), CLImage::getY(), and transform().

Referenced by fillItemFromGroup().

{
  double x = pBB->getPosition().getX() + pImage->getX().getAbsoluteValue() + pImage->getX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double y = pBB->getPosition().getY() + pImage->getY().getAbsoluteValue() + pImage->getY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
  double w = pImage->getWidth().getAbsoluteValue() + pImage->getWidth().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double h = pImage->getHeight().getAbsoluteValue() + pImage->getHeight().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();

  QFile *fileName = new QFile(pImage->getImageReference().c_str());

  if (!fileName->exists())
    {
      delete fileName;
      std::string file = ((*CCopasiRootContainer::getDatamodelList())[0])->getReferenceDirectory() + "/" + pImage->getImageReference();
      fileName = new QFile(file.c_str());
    }

  if (!fileName->exists())
    {
      delete fileName;
      return;
    }

  QPixmap pixmap(fileName->fileName());
  pixmap = pixmap.scaled(w, h, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
  delete fileName;
  QGraphicsPixmapItem* result = new QGraphicsPixmapItem(
    pixmap);
  result->setPos(x, y);
  transform(result, pImage, group);

  item->addToGroup(result);
}

void fillItemFromPolygon	(	QGraphicsItemGroup *	item,
		const CLBoundingBox *	pBB,
		const CLPolygon *	pPoly,
		const CLGroup *	group,
		const CLRenderResolver *	resolver
	)

Definition at line 759 of file CQRenderConverter.cpp.

References CLGraphicalPrimitive2D::EVENODD, getBrush(), CLGraphicalPrimitive2D::getFillRule(), getPath(), getPen(), CLGraphicalPrimitive2D::isSetFillRule(), CLGraphicalPrimitive2D::NONZERO, and transform().

Referenced by fillItemFromGroup().

{
  QSharedPointer<QPainterPath> path = getPath(pPoly, pBB);
  path->setFillRule(Qt::WindingFill);

  if (pPoly->isSetFillRule())
    {
      switch (pPoly->getFillRule())
        {
          case CLGraphicalPrimitive2D::EVENODD:
            path->setFillRule(Qt::OddEvenFill);
            break;

          case CLGraphicalPrimitive2D::NONZERO:
          default:
            path->setFillRule(Qt::WindingFill);
            break;
        }
    }

  if (group->isSetFillRule())
    {
      switch (group->getFillRule())
        {
          case CLGraphicalPrimitive2D::EVENODD:
            path->setFillRule(Qt::OddEvenFill);
            break;

          case CLGraphicalPrimitive2D::NONZERO:
          default:
            path->setFillRule(Qt::WindingFill);
            break;
        }
    }

  QGraphicsPathItem *pathItem = new QGraphicsPathItem(*path);
  QSharedPointer<QPen> pen = getPen(pPoly, group, resolver, pBB);
  pathItem->setPen(*pen);
  QSharedPointer<QBrush> brush = getBrush(pPoly, group, resolver, pBB);
  pathItem->setBrush(*brush);

  transform(pathItem, pPoly, group);

  item->addToGroup(pathItem);
}

void fillItemFromRectangle	(	QGraphicsItemGroup *	item,
		const CLBoundingBox *	pBB,
		const CLRectangle *	pRect,
		const CLGroup *	group,
		const CLRenderResolver *	resolver
	)

Definition at line 962 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), getBrush(), CLBoundingBox::getDimensions(), CLRectangle::getHeight(), CLDimensions::getHeight(), getPen(), CLBoundingBox::getPosition(), CLRectangle::getRadiusX(), CLRectangle::getRadiusY(), CLRelAbsVector::getRelativeValue(), CLRectangle::getWidth(), CLDimensions::getWidth(), CLPoint::getX(), CLRectangle::getX(), CLPoint::getY(), CLRectangle::getY(), and transform().

Referenced by fillItemFromGroup().

{
  double x = pBB->getPosition().getX() + pRect->getX().getAbsoluteValue() + pRect->getX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double y = pBB->getPosition().getY() + pRect->getY().getAbsoluteValue() + pRect->getY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
  double w = pRect->getWidth().getAbsoluteValue() + pRect->getWidth().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double h = pRect->getHeight().getAbsoluteValue() + pRect->getHeight().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
  double rx = pRect->getRadiusX().getAbsoluteValue() + pRect->getRadiusX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double ry = pRect->getRadiusY().getAbsoluteValue() + pRect->getRadiusY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();

  QGraphicsRectItem* result = new CQRoundedRect(
    x, y, w, h, rx, ry);
  QSharedPointer<QPen> pen = getPen(pRect, group, resolver, pBB);
  result->setPen(*pen);

  QSharedPointer<QBrush> brush = getBrush(pRect, group, resolver, pBB);
  result->setBrush(*brush);

  transform(result, pRect, group);
  item->addToGroup(result);
}

void fillItemFromRenderCurve	(	QGraphicsItemGroup *	item,
		const CLBoundingBox *	pBB,
		const CLRenderCurve *	pCurve,
		const CLGroup *	group,
		const CLRenderResolver *	resolver
	)

Definition at line 718 of file CQRenderConverter.cpp.

References addLineEndingToItem(), CLRenderCurve::getEndHead(), CLGroup::getEndHead(), CLLineEnding::getGroup(), CLRenderResolver::getLineEnding(), getPath(), getPen(), CLRenderCurve::getStartHead(), CLGroup::getStartHead(), CLRenderCurve::isSetEndHead(), CLGroup::isSetEndHead(), CLRenderCurve::isSetStartHead(), and transform().

Referenced by fillItemFromGroup().

{
  QSharedPointer<QPainterPath> path = getPath(pCurve, pBB);

  QGraphicsPathItem *pathItem = new QGraphicsPathItem(*path);
  QSharedPointer<QPen> pen = getPen(pCurve, group, resolver, pBB);
  pathItem->setPen(*pen);

  item->addToGroup(pathItem);
  //QBrush *brush = getBrush(NULL, group, resolver, pBB);
  //pathItem->setBrush(*brush);
  //delete brush;

  if (path->elementCount() > 1)
    {
      if (group -> isSetStartHead())
        {
          const CLLineEnding *line = resolver->getLineEnding(group->getStartHead());
          addLineEndingToItem(pathItem, line, group, resolver, path->elementAt(0), path->elementAt(1), item);
        }
      else if (pCurve->isSetStartHead())
        {
          const CLLineEnding *line = resolver->getLineEnding(pCurve->getStartHead());
          addLineEndingToItem(pathItem, line, line->getGroup(), resolver, path->elementAt(0), path->elementAt(1), item);
        }

      if (group->isSetEndHead())
        {
          const CLLineEnding *line = resolver->getLineEnding(group->getEndHead());
          addLineEndingToItem(pathItem, line, group, resolver, path->elementAt(path->elementCount() - 1), path->elementAt(path->elementCount() - 2), item);
        }
      else if (pCurve->isSetEndHead())
        {
          const CLLineEnding *line = resolver->getLineEnding(pCurve->getEndHead());
          addLineEndingToItem(pathItem, line, line->getGroup(), resolver, path->elementAt(path->elementCount() - 1), path->elementAt(path->elementCount() - 2), item);
        }
    }

  transform(pathItem, pCurve, group);
}

void fillItemFromText	(	QGraphicsItemGroup *	item,
		const CLBoundingBox *	pBB,
		const CLText *	pText,
		const CLGroup *	group,
		const CLRenderResolver *	resolver
	)

Definition at line 899 of file CQRenderConverter.cpp.

References adjustPosition(), CLRelAbsVector::getAbsoluteValue(), getColor(), CLBoundingBox::getDimensions(), getFont(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLGraphicalPrimitive1D::getStroke(), CLText::getText(), CLDimensions::getWidth(), CLPoint::getX(), CLText::getX(), CLPoint::getY(), CLText::getY(), CLGraphicalPrimitive1D::isSetStroke(), and transform().

Referenced by fillItemFromGroup().

{
  double x = pBB->getPosition().getX() + pText->getX().getAbsoluteValue() + pText->getX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double y = pBB->getPosition().getY() + pText->getY().getAbsoluteValue() + pText->getY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();

  QGraphicsTextItem* result = new QGraphicsTextItem(pText->getText().c_str());
  result ->setPos(x, y);

  if (pText->isSetStroke())
    {
      result->setDefaultTextColor(getColor(pText->getStroke(), resolver));
    }
  else if (group->isSetStroke())
    {
      result->setDefaultTextColor(getColor(group->getStroke(), resolver));
    }

  QSharedPointer<QFont> font = getFont(pText, group, resolver, pBB);

  if (!font.isNull())
    {
      result->setFont(*font);

      adjustPosition(result, pBB, pText, group);
    }

  transform(result, pText, group);
  item->addToGroup(result);
}

QSharedPointer<QBrush> getBrush	(	const CLGraphicalPrimitive2D *	item,
		const CLGroup *	group,
		const CLRenderResolver *	resolver,
		const CLBoundingBox *	pBB
	)

Definition at line 272 of file CQRenderConverter.cpp.

References getColor(), CLGraphicalPrimitive2D::getFillColor(), getGradient(), CLRenderResolver::getGradientBase(), and CLGraphicalPrimitive2D::isSetFill().

Referenced by addLineEndingToItem(), fillItemFromEllipse(), fillItemFromPolygon(), and fillItemFromRectangle().

{
  QColor color;

  if (item != NULL && item->isSetFill())
    {
      const CLGradientBase* base = resolver->getGradientBase(item->getFillColor());

      if (base != NULL)
        {
          return QSharedPointer<QBrush>(new QBrush(*getGradient(base, pBB, resolver)));
        }

      return QSharedPointer<QBrush>(new QBrush(getColor(item->getFillColor(), resolver)));
    }
  else if (group != NULL && group->isSetFill())
    {
      const CLGradientBase* base = resolver->getGradientBase(group->getFillColor());

      if (base != NULL)
        {
          return QSharedPointer<QBrush>(new QBrush(*getGradient(base, pBB, resolver)));
        }

      return QSharedPointer<QBrush>(new QBrush(getColor(group->getFillColor(), resolver)));
    }

  return QSharedPointer<QBrush>(new QBrush());
}

QColor getColor

(

const CLColorDefinition *

cd

)

Definition at line 84 of file CQRenderConverter.cpp.

References CLColorDefinition::getAlpha(), CLColorDefinition::getBlue(), CLColorDefinition::getGreen(), and CLColorDefinition::getRed().

Referenced by CQRenderConverter::applyStyle(), fillItemFromText(), getBrush(), getColor(), getLinearGradient(), getPen(), getRadialGradient(), CQRenderConverter::setBackground(), CQEffectDescriptionEdit::slotSelectColorEnd(), and CQEffectDescriptionEdit::slotSelectColorStart().

{
  if (cd == NULL) return QColor();

  return QColor::fromRgb(cd->getRed(), cd->getGreen(), cd->getBlue(), cd->getAlpha());
}

QColor getColor	(	const std::string &	color,
		const CLRenderResolver *	resolver
	)

Definition at line 91 of file CQRenderConverter.cpp.

References getColor(), CLRenderResolver::getColorDefinition(), CLRenderResolver::getGradientBase(), and CLColorDefinition::setColorValue().

{
  if (color == "none")
    return QColor(Qt::transparent);

  if (resolver->getColorDefinition(color) == NULL && resolver->getGradientBase(color) == NULL)
    {
      CLColorDefinition cd; cd.setColorValue(color);
      return getColor(&cd);
    }

  return getColor(resolver->getColorDefinition(color));
}

QSharedPointer<QFont> getFont	(	const CLText *	item,
		const CLGroup *	group,
		const CLRenderResolver *	,
		const CLBoundingBox *	pBB
	)

Definition at line 193 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), CLBoundingBox::getDimensions(), CLGroup::getFontFamily(), CLText::getFontFamily(), CLGroup::getFontSize(), CLText::getFontSize(), CLGroup::getFontStyle(), CLText::getFontStyle(), CLGroup::getFontWeight(), CLText::getFontWeight(), CLDimensions::getHeight(), CLRelAbsVector::getRelativeValue(), CLText::isSetFontFamily(), CLGroup::isSetFontFamily(), CLText::isSetFontSize(), CLGroup::isSetFontSize(), CLText::isSetFontStyle(), CLGroup::isSetFontStyle(), CLText::isSetFontWeight(), CLGroup::isSetFontWeight(), CLText::STYLE_ITALIC, CLText::WEIGHT_BOLD, and CLText::WEIGHT_NORMAL.

Referenced by CQRenderConverter::applyStyle(), fillItemFromText(), and CopasiUI3Window::slotFontSelection().

{
  QString font("Verdana"); double fontSize = 10, weight = 50; bool italic = false;

  if (item != NULL && item->isSetFontFamily())
    font = item->getFontFamily().c_str();
  else if (group != NULL && group->isSetFontFamily())
    font = group->getFontFamily().c_str();

  if (item != NULL && item->isSetFontSize())
    fontSize = item->getFontSize().getAbsoluteValue() + item->getFontSize().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
  else if (group != NULL && group->isSetFontSize())
    fontSize = group->getFontSize().getAbsoluteValue() + group->getFontSize().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();

  if (item != NULL && item->isSetFontWeight())
    switch (item->getFontWeight())
      {
        case CLText::WEIGHT_BOLD:
          weight = QFont::Bold;
          break;

        case CLText::WEIGHT_NORMAL:
        default:
          weight = QFont::Normal;
          break;
      }
  else if (group != NULL && group->isSetFontWeight())
    switch (group->getFontWeight())
      {
        case CLText::WEIGHT_BOLD:
          weight = QFont::Bold;
          break;

        case CLText::WEIGHT_NORMAL:
        default:
          weight = QFont::Normal;
          break;
      }

  if (item != NULL && item->isSetFontStyle())
    switch (item->getFontStyle())
      {
        case CLText::STYLE_ITALIC:
          italic = true;
          break;

        default:
          break;
      }
  else if (group != NULL && group->isSetFontStyle())
    switch (group->getFontStyle())
      {
        case CLText::STYLE_ITALIC:
          italic = true;
          break;

        default:
          break;
      }

  QSharedPointer<QFont> result = QSharedPointer<QFont>(new QFont(font, -1, weight, italic));
  result->setPixelSize(fontSize);

  if (font == "serif")
    {
      result->setStyleHint(QFont::Serif);
    }
  else if (font == "sans-serif" || font == "sans")
    {
      result->setStyleHint(QFont::SansSerif);
    }
  else if (font == "monospace")
    {
      result->setStyleHint(QFont::Monospace);
    }

  return result;
}

QSharedPointer<QGradient> getGradient	(	const CLGradientBase *	base,
		const CLBoundingBox *	bounds,
		const CLRenderResolver *	resolver
	)

Definition at line 178 of file CQRenderConverter.cpp.

References getLinearGradient(), getRadialGradient(), and linear().

Referenced by getBrush().

{
  const CLLinearGradient* linear = dynamic_cast<const CLLinearGradient*>(base);

  if (linear != NULL)
    return getLinearGradient(linear, bounds, resolver);

  const CLRadialGradient* radial = dynamic_cast<const CLRadialGradient*>(base);

  if (radial != NULL)
    return getRadialGradient(radial, bounds, resolver);

  return QSharedPointer<QGradient>();
}

QSharedPointer<QLinearGradient> getLinearGradient	(	const CLLinearGradient *	linear,
		const CLBoundingBox *	bounds,
		const CLRenderResolver *	resolver
	)

Definition at line 105 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), getColor(), CLBoundingBox::getDimensions(), CLGradientBase::getGradientStop(), CLDimensions::getHeight(), CLGradientBase::getNumGradientStops(), CLGradientStop::getOffset(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLGradientBase::getSpreadMethod(), CLGradientStop::getStopColor(), CLDimensions::getWidth(), CLPoint::getX(), CLLinearGradient::getXPoint1(), CLLinearGradient::getXPoint2(), CLPoint::getY(), CLLinearGradient::getYPoint1(), CLLinearGradient::getYPoint2(), CLGradientBase::PAD, CLGradientBase::REFLECT, and CLGradientBase::REPEAT.

Referenced by getGradient().

{
  double x1 = bounds->getPosition().getX() + linear->getXPoint1().getAbsoluteValue()  + (linear->getXPoint1().getRelativeValue() / 100.0 * bounds->getDimensions().getWidth());
  double y1 = bounds->getPosition().getY() + linear->getYPoint1().getAbsoluteValue()  + (linear->getYPoint1().getRelativeValue() / 100.0 * bounds->getDimensions().getHeight());
  double x2 = bounds->getPosition().getX() + linear->getXPoint2().getAbsoluteValue()  + (linear->getXPoint2().getRelativeValue() / 100.0 * bounds->getDimensions().getWidth());
  double y2 = bounds->getPosition().getY() + linear->getYPoint2().getAbsoluteValue()  + (linear->getYPoint2().getRelativeValue() / 100.0 * bounds->getDimensions().getHeight());

  QSharedPointer<QLinearGradient> result = QSharedPointer<QLinearGradient>(new QLinearGradient(x1, y1, x2, y2));

  switch (linear->getSpreadMethod())
    {
      case CLGradientBase::REFLECT:
        result->setSpread(QGradient::ReflectSpread);
        break;

      case CLGradientBase::REPEAT:
        result->setSpread(QGradient::RepeatSpread);
        break;

      case CLGradientBase::PAD:
        result->setSpread(QGradient::PadSpread);
        break;

      default:
        break;
    }

  for (size_t i = 0; i < linear->getNumGradientStops(); ++i)
    {
      const CLGradientStop* stop = linear->getGradientStop(i);
      result->setColorAt(stop->getOffset().getAbsoluteValue() + stop->getOffset().getRelativeValue() / 100.0, getColor(stop->getStopColor(), resolver));
    }

  return result;
}

QSharedPointer<QPainterPath> getPath	(	const CLPolygon *	pCurve,
		const CLBoundingBox *	pBB
	)

Definition at line 468 of file CQRenderConverter.cpp.

References addToPath(), CLPolygon::getListOfElements(), and moveToPoint().

Referenced by addLineEndingToItem(), fillItemFromPolygon(), and fillItemFromRenderCurve().

{
  QSharedPointer<QPainterPath> path = QSharedPointer<QPainterPath>(new QPainterPath());

  const std::vector<CLRenderPoint*>& elements = *pCurve->getListOfElements();
  std::vector<CLRenderPoint*>::const_iterator it = elements.begin();
  bool first = true;

  for (; it != elements.end(); ++it)
    {
      const CLRenderPoint* current = *it;
      const CLRenderCubicBezier* cubic = dynamic_cast<const CLRenderCubicBezier*>(current);

      if (first)
        {
          moveToPoint(*path, current, pBB);
          first = false;
          continue;
        }

      if (cubic != NULL)
        {
          addToPath(*path, cubic, pBB);
        }
      else
        {
          addToPath(*path, current, pBB);
        }
    }

  path->closeSubpath();

  return path;
}

QSharedPointer<QPainterPath> getPath	(	const CLRectangle *	pRect,
		const CLBoundingBox *	pBB
	)

Definition at line 503 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), CLBoundingBox::getDimensions(), CLRectangle::getHeight(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLRectangle::getRadiusX(), CLRectangle::getRadiusY(), CLRelAbsVector::getRelativeValue(), CLRectangle::getWidth(), CLDimensions::getWidth(), CLPoint::getX(), CLRectangle::getX(), CLPoint::getY(), and CLRectangle::getY().

{

  double x = pBB->getPosition().getX() + pRect->getX().getAbsoluteValue() + pRect->getX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double y = pBB->getPosition().getY() + pRect->getY().getAbsoluteValue() + pRect->getY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
  double w = pRect->getWidth().getAbsoluteValue() + pRect->getWidth().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double h = pRect->getHeight().getAbsoluteValue() + pRect->getHeight().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
  double rx = pRect->getRadiusX().getAbsoluteValue() + pRect->getRadiusX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double ry = pRect->getRadiusY().getAbsoluteValue() + pRect->getRadiusY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();

  QSharedPointer<QPainterPath> path = QSharedPointer<QPainterPath>(new QPainterPath());

  path->addRoundedRect(x, y, w, h, rx, ry);

  return path;
}

QSharedPointer<QPainterPath> getPath	(	const CLEllipse *	pEllipse,
		const CLBoundingBox *	pBB
	)

Definition at line 520 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), CLEllipse::getCX(), CLEllipse::getCY(), CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLEllipse::getRX(), CLEllipse::getRY(), CLDimensions::getWidth(), CLPoint::getX(), and CLPoint::getY().

{

  double x = pBB->getPosition().getX() + pEllipse->getCX().getAbsoluteValue() + pEllipse->getCX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double y = pBB->getPosition().getY() + pEllipse->getCY().getAbsoluteValue() + pEllipse->getCY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
  double rx = pEllipse->getRX().getAbsoluteValue() + pEllipse->getRX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
  double ry = pEllipse->getRY().getAbsoluteValue() + pEllipse->getRY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();

  QSharedPointer<QPainterPath> path = QSharedPointer<QPainterPath>(new QPainterPath());

  path->addEllipse(x - rx, y - ry, 2 * rx, 2 * ry);

  return path;
}

QSharedPointer<QPainterPath> getPath	(	const CLRenderCurve *	pCurve,
		const CLBoundingBox *	pBB
	)

Definition at line 535 of file CQRenderConverter.cpp.

References addToPath(), CLRenderCurve::getListOfCurveElements(), and moveToPoint().

{
  QSharedPointer<QPainterPath> path = QSharedPointer<QPainterPath>(new QPainterPath());

  const std::vector<CLRenderPoint*>& elements = *pCurve->getListOfCurveElements();
  std::vector<CLRenderPoint*>::const_iterator it = elements.begin();
  bool first = true;

  for (; it != elements.end(); ++it)
    {
      const CLRenderPoint* current = *it;
      const CLRenderCubicBezier* cubic = dynamic_cast<const CLRenderCubicBezier*>(current);

      if (first)
        {
          moveToPoint(*path, current, pBB);
          first = false;
          continue;
        }

      if (cubic != NULL)
        {
          addToPath(*path, cubic, pBB);
        }
      else
        {
          addToPath(*path, current, pBB);
        }
    }

  return path;
}

QSharedPointer<QPen> getPen	(	const CLGraphicalPrimitive1D *	item,
		const CLGroup *	group,
		const CLRenderResolver *	resolver,
		const CLBoundingBox *
	)

Definition at line 302 of file CQRenderConverter.cpp.

References getColor(), CLGraphicalPrimitive1D::getDashArray(), CLGraphicalPrimitive1D::getStroke(), CLGraphicalPrimitive1D::getStrokeWidth(), CLGraphicalPrimitive1D::isSetDashArray(), CLGraphicalPrimitive1D::isSetStroke(), and CLGraphicalPrimitive1D::isSetStrokeWidth().

Referenced by addLineEndingToItem(), CQRenderConverter::applyStyle(), fillItemFromCurve(), fillItemFromEllipse(), fillItemFromPolygon(), fillItemFromRectangle(), and fillItemFromRenderCurve().

{
  QColor color; double width;

  if (item != NULL && item->isSetStroke())
    {
      color = getColor(item->getStroke(), resolver);
    }
  else if (group != NULL && group->isSetStroke())
    {
      color = getColor(group->getStroke(), resolver);
    }
  else return QSharedPointer<QPen>(new QPen(Qt::transparent));

  if (item != NULL && item->isSetStrokeWidth())
    {
      width = item->getStrokeWidth();
    }
  else if (group != NULL && group->isSetStrokeWidth())
    {
      width = group->getStrokeWidth();
    }
  else return QSharedPointer<QPen>(new QPen(Qt::transparent));

  QSharedPointer<QPen> result = QSharedPointer<QPen>(new QPen(color, width));
  result->setCapStyle(Qt::RoundCap);
  result->setJoinStyle(Qt::RoundJoin);

  if (item != NULL && item->isSetDashArray())
    {
      const std::vector<unsigned int>& raw = item->getDashArray();
      std::vector<unsigned int>::const_iterator start = raw.begin();
      QVector<qreal> pattern;

      while (start != raw.end())
        {
          pattern << *start;
          ++start;
        }

      result->setDashPattern(pattern);
    }
  else if (group != NULL && group->isSetDashArray())
    {
      const std::vector<unsigned int>& raw = group->getDashArray();
      std::vector<unsigned int>::const_iterator start = raw.begin();
      QVector<qreal> pattern;

      while (start != raw.end())
        {
          pattern << *start;
          ++start;
        }

      result->setDashPattern(pattern);
    }

  return result;
}

QSharedPointer<QRadialGradient> getRadialGradient	(	const CLRadialGradient *	radial,
		const CLBoundingBox *	bounds,
		const CLRenderResolver *	resolver
	)

Definition at line 141 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), CLRadialGradient::getCenterX(), CLRadialGradient::getCenterY(), getColor(), CLBoundingBox::getDimensions(), CLRadialGradient::getFocalPointX(), CLRadialGradient::getFocalPointY(), CLGradientBase::getGradientStop(), CLDimensions::getHeight(), CLGradientBase::getNumGradientStops(), CLGradientStop::getOffset(), CLBoundingBox::getPosition(), CLRadialGradient::getRadius(), CLRelAbsVector::getRelativeValue(), CLGradientBase::getSpreadMethod(), CLGradientStop::getStopColor(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLGradientBase::PAD, CLGradientBase::REFLECT, and CLGradientBase::REPEAT.

Referenced by getGradient().

{
  double cx = bounds->getPosition().getX() + radial->getCenterX().getAbsoluteValue()  + radial->getCenterX().getRelativeValue() / 100.0 * bounds->getDimensions().getWidth();
  double cy = bounds->getPosition().getY() + radial->getCenterY().getAbsoluteValue()  + radial->getCenterY().getRelativeValue() / 100.0 * bounds->getDimensions().getHeight();
  double fx = bounds->getPosition().getX() + radial->getFocalPointX().getAbsoluteValue()  + radial->getFocalPointX().getRelativeValue() / 100.0 * bounds->getDimensions().getWidth();
  double fy = bounds->getPosition().getY() + radial->getFocalPointY().getAbsoluteValue()  + radial->getFocalPointY().getRelativeValue() / 100.0 * bounds->getDimensions().getHeight();
  double r = radial->getRadius().getAbsoluteValue()  + radial->getRadius().getRelativeValue() / 100.0 * bounds->getDimensions().getWidth();

  QSharedPointer<QRadialGradient> result = QSharedPointer<QRadialGradient>(new QRadialGradient(cx, cy, r, fx, fy));

  switch (radial->getSpreadMethod())
    {
      case CLGradientBase::REFLECT:
        result->setSpread(QGradient::ReflectSpread);
        break;

      case CLGradientBase::REPEAT:
        result->setSpread(QGradient::RepeatSpread);
        break;

      case CLGradientBase::PAD:
        result->setSpread(QGradient::PadSpread);
        break;

      default:
        break;
    }

  for (size_t i = 0; i < radial->getNumGradientStops(); ++i)
    {
      const CLGradientStop* stop = radial->getGradientStop(i);
      result->setColorAt(stop->getOffset().getAbsoluteValue() + stop->getOffset().getRelativeValue() / 100.0, getColor(stop->getStopColor(), resolver));
    }

  return result;
}

void moveToPoint	(	QPainterPath &	path,
		const CLRenderPoint *	current,
		const CLBoundingBox *	pBB
	)

Definition at line 460 of file CQRenderConverter.cpp.

References CLRelAbsVector::getAbsoluteValue(), CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLDimensions::getWidth(), CLPoint::getX(), CLRenderPoint::getXOffset(), CLPoint::getY(), and CLRenderPoint::getYOffset().

Referenced by getPath().

{
  path.moveTo(
    pBB->getPosition().getX() + current->getXOffset().getAbsoluteValue() + current->getXOffset().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth(),
    pBB->getPosition().getY() + current->getYOffset().getAbsoluteValue() + current->getYOffset().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight()
  );
}

QPointF normalizePoint

(

const QPointF &

vector

)

Definition at line 568 of file CQRenderConverter.cpp.

Referenced by applyRotationalMapping().

{
  qreal length = (qreal) sqrt(vector.x() * vector.x() + vector.y() * vector.y());

  if (length == 0) length = 1;

  return QPointF(vector.x() / length, vector.y() / length);
}

void transform	(	QGraphicsItem *	item,
		const CLTransformation2D *	trans,
		const CLGroup *	group
	)

Definition at line 36 of file CQRenderConverter.cpp.

References CLTransformation2D::getMatrix2D(), and CLTransformation::isSetMatrix().

Referenced by CCellDesignerImporter::classToEnum(), CCellDesignerImporter::connectionPolicyToEnum(), CLSimpleImageTexturizer::create_texture_for_image(), CCellDesignerImporter::directionToEnum(), fillItemFromEllipse(), fillItemFromGroup(), fillItemFromImage(), fillItemFromPolygon(), fillItemFromRectangle(), fillItemFromRenderCurve(), fillItemFromText(), CCellDesignerImporter::modificationLinkTypeToEnum(), CCellDesignerImporter::modificationTypeToEnum(), CQQtImageTexturizer::operator()(), CCellDesignerImporter::paintSchemeToEnum(), CCellDesignerImporter::parseLine(), CCellDesignerImporter::parsePaint(), CCellDesignerImporter::parseProteins(), CCellDesignerImporter::positionToCompartmentToEnum(), CCellDesignerImporter::positionToEnum(), CCellDesignerImporter::reactionTypeToEnum(), and CCellDesignerImporter::speciesModificationTypeToEnum().

{
  if (trans != NULL && trans->isSetMatrix())
    {
      QRectF pathRect = item->boundingRect();
      QTransform transform(
        trans->getMatrix2D()[0],
        trans->getMatrix2D()[1],
        trans->getMatrix2D()[2],
        trans->getMatrix2D()[3],
        trans->getMatrix2D()[4],
        trans->getMatrix2D()[5]
      );

      QTransform matrix;
      matrix = matrix.translate(pathRect.x(), pathRect.y());
      matrix = matrix.inverted();
      matrix = matrix * transform;

      QTransform translate;
      translate = translate.translate(pathRect.x(), pathRect.y());
      matrix = matrix * translate;
      item->setTransform(matrix, true);
    }
  else if (group != NULL && group->isSetMatrix())
    {
      QRectF pathRect = item->boundingRect();
      QTransform transform(
        group->getMatrix2D()[0],
        group->getMatrix2D()[1],
        group->getMatrix2D()[2],
        group->getMatrix2D()[3],
        group->getMatrix2D()[4],
        group->getMatrix2D()[5]
      );

      QTransform matrix;
      matrix = matrix.translate(pathRect.x(), pathRect.y());
      matrix = matrix.inverted();
      matrix = matrix * transform;

      QTransform translate;
      translate = translate.translate(pathRect.x(), pathRect.y());
      matrix = matrix * translate;
      item->setTransform(matrix, true);
    }
}