CLLayoutRenderer Class Reference

#include <CLLayoutRenderer.h>

Collaboration diagram for CLLayoutRenderer:

Public Member Functions
void	addToSelection (CLGraphicalObject *pObject)
void	analyse_render_information (double lx, double ly, double rx, double ry)
void	change_style (const CLGlobalRenderInformation *pRenderInformation, bool defaultStyle=false)
void	change_style (const CLLocalRenderInformation *pRenderInformation)
void	clearSelection ()
	CLLayoutRenderer (CLayout *pLayout, const CLGlobalRenderInformation *pRenderInformation, const CCopasiVector< CLGlobalRenderInformation > *pGlobalRenderInformationList, const CModel *pModel, const std::string &baseDir)
	CLLayoutRenderer (CLayout *pLayout, const CLLocalRenderInformation *pRenderInformation, const CCopasiVector< CLGlobalRenderInformation > *pGlobalRenderInformationList, const CModel *pModel, const std::string &baseDir)
std::pair< double, double >	convert_to_model_space (double x, double y) const
void	draw_layout ()
double	getAspect () const
const GLfloat *	getFogColor () const
GLfloat	getFogDensity () const
const GLfloat *	getHighlightColor () const
const std::set< const CLGraphicalObject * > &	getHighlightedObjects () const
std::set< const CLGraphicalObject * > &	getHighlightedObjects ()
bool	getHighlightFlag () const
std::multiset < CLGraphicalObject *, compareGraphicalObjectsBySize >	getObjectsAt (double x, double y)
std::multiset < CLGraphicalObject *, compareGraphicalObjectsBySize >	getObjectsAtViewportPosition (unsigned int x, unsigned int y)
std::vector< CLGraphicalObject * >	getObjectsInBoundingBox (double lx, double ly, double rx, double ry, bool partial=true)
std::set< CLGraphicalObject * > &	getSelection ()
const std::set < CLGraphicalObject * > &	getSelection () const
CLBoundingBox *	getSelectionBox ()
const CLBoundingBox *	getSelectionBox () const
double	getZoomFactor () const
bool	isSelected (const CLGraphicalObject *) const
bool	isSetDeduceSpeciesReferenceRoles () const
void	move_curve_object (CLCurve *pCurve, double dx, double dy, bool leaveStartPoint=false, bool leaveEndpoint=false)
void	move_graphical_object (CLGraphicalObject *pObject, double dx, double dy)
void	move_reaction_glyph (CLReactionGlyph *pRG, double dx, double dy, bool moveSelectedAssociation=false)
void	move_selection (double dx, double dy, bool moveAssociated=true)
void	move_species_glyph (CLMetabGlyph *pSG, double dx, double dy, bool moveSelectedAssociations=false)
void	move_species_reference_glyph (CLMetabReferenceGlyph *pSRG, double dx, double dy)
void	move_text_glyph (CLTextGlyph *pTG, double dx, double dy)
void	removeFromSelection (CLGraphicalObject *pObject)
void	resize (GLsizei w, GLsizei h)
void	set_font_renderer (CLFontRendererBase *pFontRenderer)
void	setAspect (double aspect)
void	setDeduceSpeciesReferenceRoles (bool deduce)
void	setFogColor (const GLfloat c[4])
void	setFogDensity (GLfloat dens)
void	setHighlightColor (const GLfloat c[4])
void	setHighlightedObjects (const std::set< const CLGraphicalObject * > &highlightedObjects)
void	setHighlightFlag (bool flag)
void	setImageTexturizer (CLImageTexturizer *pTexturizer)
void	setSelectionBox (const CLBoundingBox *pBox)
void	setX (double x)
void	setY (double y)
void	setZoomFactor (double zoomFactor)
void	toggleHighlightFlag ()
	~CLLayoutRenderer ()

Static Public Member Functions
static double	distance (const CLPoint &p1, const CLPoint &p2)
static CLBoundingBox *	getCurveBoundingBox (const CLCurve *pCurve)
static bool	is_curve_segment_visible (const CLLineSegment &segment, double lx, double ly, double rx, double ry, bool partial)
static bool	is_curve_visible (const CLCurve &curve, double lx, double ly, double rx, double ry, bool partial)
static CLCurve *	revert_curve (const CLCurve *pCurve)

Protected Member Functions
void	clear_cached_data ()
void	create_gradient_texture (unsigned int size, GLubyte *pData, const CLGradientBase *pGradient, double z_value=0.0)
void	create_linear_gradient_texture (unsigned int size, GLubyte *pData, const CLLinearGradient *pGradient, double z_value)
void	create_radial_gradient_texture (unsigned int size, GLubyte *pData, const CLRadialGradient *pGradient, double z_value)
void	draw_cap (double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, double stroke_width)
void	draw_curve (const CLCurve *pCurve, bool drawBasepoints=false)
void	draw_curve (const CLRenderCurve *pCurve, const CLBoundingBox *pBB)
void	draw_datapoints (GLdouble *pData, size_t numPoints, const CLBoundingBox *pBB, bool doTesselation=false, float xOffset=0.0, float yOffset=0.0, float zOffset=0.0)
void	draw_ellipse (const CLEllipse *pEllipse, const CLBoundingBox *pBB)
void	draw_group (const CLGroup *pGroup, const CLBoundingBox *pBB)
void	draw_image (const CLImage *pImage, const CLBoundingBox *pBB)
void	draw_line (size_t numPoints, GLdouble *pData)
void	draw_line_segment (double x1, double y1, double z1, double x2, double y2, double z2, double line_width, bool texture=false, double s1=0.0, double s2=0.0)
void	draw_object (const CLStyle *pStyle, const CLBoundingBox *pBB)
void	draw_polygon (const CLPolygon *pPolygon, const CLBoundingBox *pBB)
void	draw_rectangle (const CLRectangle *pRectangle, const CLBoundingBox *pBB)
void	draw_selection_box () const
void	draw_text (const CLStyle *pStyle, const CLBoundingBox *pBB, const CLTextTextureSpec *pTexture)
void	draw_text (const CLText *pText, const CLBoundingBox *pBB)
void	draw_text (const CLTextTextureSpec *pTexture, double x, double y, double z, const CLBoundingBox *pBB)
void	initialize_gl_extension_functions ()
void	map_arrow_head (const CLPoint &p, const CLPoint &v, const std::string &headId)
void	map_gradient_color (double rel_distance, const CLGradientBase *pGradient, GLubyte *pData)
void	resolve_color (const std::string &color, GLubyte array[4])
void	restore_current_attributes ()
void	save_current_attributes ()
void	segment_data (double length, double ratio, size_t numPoints, GLdouble *pData, std::vector< simple_point > &v)
void	update_associations ()
void	update_colors (const CLGradientBase *pGradient)
void	update_drawables (double lx, double ly, double rx, double ry)
void	update_style_information ()
void	update_textures_and_colors ()
void	update_textures_and_colors (const CLGroup *pGroup, double maxDimension, double height, const std::string &parentFill="", CLFontSpec parentFontSpec=CLFontSpec())

Static Protected Member Functions
static void	calculate_cubicbezier (double sx, double sy, double sz, double p1x, double p1y, double p1z, double p2x, double p2y, double p2z, double ex, double ey, double ez, unsigned int numPoints, GLdouble *pData)
static CLPoint *	calculate_intersection (double p1x, double p1y, double p1z, double sx, double sy, double sz, double p2x, double p2y, double p2z, double tx, double ty, double tz)
static std::pair< double, double >	calculate_intersection_point_2d (double p1x, double p1y, double sx, double sy, double p2x, double p2y, double tx, double ty)
static void	COMBINE_CALLBACK (GLdouble coords[3], GLdouble **, GLfloat *, GLdouble **dataOut)
static void	COMBINE_CALLBACK_GRADIENT (GLdouble coords[3], GLdouble *vertex_data[4], GLfloat weight[4], GLdouble **dataOut)
static const CLPoint	convert_to_absolute (const CLRenderPoint *pRenderPoint, const CLBoundingBox *pBB)
static void	createGLMatrix (const double *const matrix, GLdouble *glMatrix)
static CLLineStippleTexture *	createLineStippleTexture (const std::vector< unsigned int > &dasharray)
static double	distancePointLineSegment (double x, double y, double lx1, double ly1, double lx2, double ly2)
static void	drawSelectionBox (double x, double y, double width, double height, bool drawHandles=false)
static void	extract_1d_attributes (const CLGraphicalPrimitive1D *pObject, CLGroupAttributes *attributes)
static void	extract_2d_attributes (const CLGraphicalPrimitive2D *pObject, CLGroupAttributes *attributes)
template<typename T >
static void	extract_arrowhead_information (const T *pObject, CLGroupAttributes *attributes)
static void	extract_group_attributes (const CLStyle *pStyle, CLGroupAttributes *attributes)
static void	extract_group_attributes (const CLGroup *pGroup, CLGroupAttributes *attributes)
template<typename T >
static void	extract_text_attributes (const T *pObject, CLGroupAttributes *attributes)
static void	extract_transformation_attributes (const CLTransformation *pObject, CLGroupAttributes *attributes)
static CLFontSpec	getFontSpec (const CLGroup *pGroup, double boxHeight, const CLFontSpec &parentFontSpec=CLFontSpec())
static CLFontSpec	getFontSpec (const CLText *pText, double boxHeight, const CLFontSpec &parentFontSpec=CLFontSpec())
static bool	isSegmentHit (const CLLineSegment *pLS, double x, double y, double toleranceRadius)
static const std::string	resolve_text (const CLTextGlyph *pTextGlyph)
static bool	segments_intersect_2d (double p1x1, double p1y1, double p1x2, double p1y2, double p2x1, double p2y1, double p2x2, double p2y2)
static void	TESS_ERROR (GLenum error)
static void	VERTEX_CALLBACK_GRADIENT (GLvoid *vertex)

Protected Attributes
double	mAspect
std::string	mBaseDir
std::map< std::string, CLRGBAColor >	mColorMap
CLGroupAttributes	mCurrentAttributes
bool	mDeduceSpeciesReferenceRoles
std::vector< const CLGraphicalObject * >	mDrawables
GLfloat	mFogColor [4]
GLfloat	mFogDensity
std::map< CLFontSpec, std::map < std::string, CLTextTextureSpec * > >	mFontTextureMap
bool	mGLFunctionsInitialized
std::map< std::string, std::pair< const CLGradientBase *, CLTextureSpec * > >	mGradientMap
std::map< CLGraphicalObject *, std::set< CLTextGlyph * > >	mGraphicalObjectToTextGlyphMap
double	mH
bool	mHighlight
GLfloat	mHighlightColor [4]
std::set< const CLGraphicalObject * >	mHighlightedObjects
std::map< std::string, const CLTextureSpec * >	mImageMap
std::map< std::string, const CLLineEnding * >	mLineEndingMap
std::map< const std::vector < unsigned int >, const CLLineStippleTexture * >	mLinestippleMap
CLFontRendererBase *	mpFontRenderer
void(*	mpGlFogCoordfEXT )(GLfloat)
const CCopasiVector < CLGlobalRenderInformation > *	mpGlobalRenderInfoList
CLImageTexturizer *	mpImageTexturizer
CLayout *	mpLayout
const CModel *	mpModel
CLRenderResolver *	mpResolver
CLBoundingBox *	mpSelectionBox
std::map< CLReactionGlyph *, std::set< std::pair < CLMetabReferenceGlyph *, bool > > >	mReactionToSpeciesReferenceMap
std::set< CLGraphicalObject * >	mSelection
std::map< const CLMetabReferenceGlyph *, std::string >	mSpeciesReferencesWithDeducedRole
std::map < CLMetabReferenceGlyph *, std::pair< CLReactionGlyph *, bool > >	mSpeciesReferenceToReactionMap
std::map < CLMetabReferenceGlyph *, std::pair< CLMetabGlyph *, bool > >	mSpeciesReferenceToSpeciesMap
std::map< CLMetabGlyph *, std::set< std::pair < CLMetabReferenceGlyph *, bool > > >	mSpeciesToSpeciesReferenceMap
std::stack< CLGroupAttributes >	mStateList
std::map< const CLGraphicalObject *, const CLStyle * >	mStyleMap
std::map< const CLTextGlyph *, const CLTextTextureSpec * >	mTextGlyphMap
std::map< CLTextGlyph *, CLGraphicalObject * >	mTextGlyphToGraphicalObjectMap
std::map< const CLText *, const CLTextTextureSpec * >	mTextMap
std::set< GLuint >	mTextureNames
double	mW
double	mX
double	mY
double	mZoomFactor

Static Protected Attributes
static const double	ALMOST_ZERO = 1e-12
static const unsigned int	GRADIENT_TEXTURE_SIZE_LIMIT = 512
static const unsigned int	NUM_BEZIER_POINTS = 20
static const unsigned int	NUM_CIRCLE_SEGMENTS = 60
static const unsigned int	NUM_CORNER_SEGMENTS = 10
static const double	SELECTION_FRAME_WIDTH = 3.0

Detailed Description

Definition at line 61 of file CLLayoutRenderer.h.

Constructor & Destructor Documentation

CLLayoutRenderer::CLLayoutRenderer	(	CLayout *	pLayout,
		const CLGlobalRenderInformation *	pRenderInformation,
		const CCopasiVector< CLGlobalRenderInformation > *	pGlobalRenderInformationList,
		const CModel *	pModel,
		const std::string &	baseDir
	)

constructor for global render information

Definition at line 103 of file CLLayoutRenderer.cpp.

References change_style(), mFogColor, and mHighlightColor.

                                                                                                                                                                                                                                     :
  mStateList(),
  mCurrentAttributes(),
  mpModel(pModel),
  mpLayout(pLayout),
  mpResolver(NULL),
  mBaseDir(baseDir),
  mZoomFactor(1.0),
  mAspect(1.0),
  mX(0.0),
  mY(0.0),
  mW(0.0),
  mH(0.0),
  mpGlobalRenderInfoList(pGlobalRenderInformationList),
  mpFontRenderer(NULL),
  mDeduceSpeciesReferenceRoles(false),
  mpSelectionBox(NULL),
  mpImageTexturizer(NULL)
  , mHighlight(true)
  , mFogDensity(0.8f)
  , mGLFunctionsInitialized(false)
  , mpGlFogCoordfEXT(NULL)
{
  this->mHighlightColor[0] = 0.5;
  this->mHighlightColor[1] = 0.0;
  this->mHighlightColor[2] = 0.0;
  this->mHighlightColor[3] = 1.0;
  this->mFogColor[0] = 0.5;
  this->mFogColor[1] = 0.5;
  this->mFogColor[2] = 0.5;
  this->mFogColor[3] = 1.0;
  this->change_style(pRenderInformation);
}

CLLayoutRenderer::CLLayoutRenderer	(	CLayout *	pLayout,
		const CLLocalRenderInformation *	pRenderInformation,
		const CCopasiVector< CLGlobalRenderInformation > *	pGlobalRenderInformationList,
		const CModel *	pModel,
		const std::string &	baseDir
	)

constructor for local render information

Definition at line 140 of file CLLayoutRenderer.cpp.

References change_style(), initialize_gl_extension_functions(), mFogColor, and mHighlightColor.

                                                                                                                                                                                                                                    :
  mStateList(),
  mCurrentAttributes(),
  mpModel(pModel),
  mpLayout(pLayout),
  mpResolver(NULL),
  mBaseDir(baseDir),
  mZoomFactor(1.0),
  mAspect(1.0),
  mX(0.0),
  mY(0.0),
  mW(0.0),
  mH(0.0),
  mpGlobalRenderInfoList(pGlobalRenderInformationList),
  mpFontRenderer(NULL),
  mDeduceSpeciesReferenceRoles(false),
  mpSelectionBox(NULL)
  , mHighlight(true)
  , mFogDensity(0.8f)
  , mGLFunctionsInitialized(false)
  , mpGlFogCoordfEXT(NULL)
{
  this->mHighlightColor[0] = 0.5;
  this->mHighlightColor[1] = 0.0;
  this->mHighlightColor[2] = 0.0;
  this->mHighlightColor[3] = 1.0;
  this->mFogColor[0] = 0.5;
  this->mFogColor[1] = 0.5;
  this->mFogColor[2] = 0.5;
  this->mFogColor[3] = 1.0;
  this->initialize_gl_extension_functions();
  this->change_style(pRenderInformation);
}

CLLayoutRenderer::~CLLayoutRenderer

(

)

destructor.

Definition at line 234 of file CLLayoutRenderer.cpp.

References clear_cached_data(), mpFontRenderer, mpResolver, and mpSelectionBox.

{
  if (mpResolver != NULL) delete mpResolver;

  // delete the data in all the maps
  this->clear_cached_data();

  if (this->mpFontRenderer)
    {
      delete this->mpFontRenderer;
    }

  if (this->mpSelectionBox != NULL)
    {
      delete this->mpSelectionBox;
    }
}

Member Function Documentation

void CLLayoutRenderer::addToSelection

(

CLGraphicalObject *

pObject

)

This method adds a graphical object to the set of selected objects.

Definition at line 4968 of file CLLayoutRenderer.cpp.

References draw_layout(), and mSelection.

Referenced by CQGLLayoutPainter::mousePressEvent(), and CQGLLayoutPainter::mouseReleaseEvent().

{
  assert(pObject != NULL);

  if (this->mSelection.insert(pObject).second == true)
    {
      this->draw_layout();
    }
}

void CLLayoutRenderer::analyse_render_information	(	double	lx,
		double	ly,
		double	rx,
		double	ry
	)

Analyses the render information and creates some of the textures. First it determines which object are drawn based on the viewport coordinates that are passed in. Next it resolves the styles for all the objects that are to be drawn and it determines the size of the textures. Last it creates all textures.

Definition at line 3310 of file CLLayoutRenderer.cpp.

References ALMOST_ZERO, update_drawables(), update_style_information(), and update_textures_and_colors().

Referenced by change_style(), resize(), and setDeduceSpeciesReferenceRoles().

{
  // go through the complete render information and resolve all colors
  // go through the list of gradients and create CLText*ureSpec objects for each
  // one and put it in a map
  // go through the complete layout and find the largest usage of any
  // gradient
  // Create the gradients
  // go through the layout and find all line stipple patterns and create the
  // textures placeholders for them

  // store the styles that have already been processed so that we process
  // each style only once
  if (rx - lx > ALMOST_ZERO && ry - ly > ALMOST_ZERO)
    {
      this->update_drawables(lx, ly, rx, ry);
      this->update_style_information();
      this->update_textures_and_colors();
    }
}

void CLLayoutRenderer::calculate_cubicbezier ( double  sx, double  sy, double  sz, double  p1x, double  p1y, double  p1z, double  p2x, double  p2y, double  p2z, double  ex, double  ey, double  ez, unsigned int  numPoints, GLdouble *  pData  )

staticprotected

Calculates the points for a cubic bezier curve. The algorithm calculates numPoints and stores them in pData. pData has to be an array with enough space for numPoints*3 GLfloat items.

Definition at line 3036 of file CLLayoutRenderer.cpp.

Referenced by draw_curve(), draw_polygon(), is_curve_segment_visible(), and isSegmentHit().

{
  unsigned int index = 0;
  pData[index++] = sx;
  pData[index++] = sy;
  pData[index++] = sz;
  unsigned int i, iMax = numPoints - 1;
  double stepSize = 1.0 / (float)(iMax);
  double t = 0.0;
  double t_square = 0.0;
  double t_cube = 0.0;
  double oneMinusT = 0.0;
  double oneMinusT_square = 0.0;
  double oneMinusT_cube = 0.0;
  double a, b;

  for (i = 1; i < iMax; ++i)
    {
      t = i * stepSize;
      oneMinusT = 1.0 - t;
      oneMinusT_square = oneMinusT * oneMinusT;
      oneMinusT_cube = oneMinusT * oneMinusT_square;
      t_square = t * t;;
      t_cube = t_square * t;
      a = 3 * t * oneMinusT_square;
      b = 3 * t_square * oneMinusT;
      pData[index++] = sx * oneMinusT_cube + p1x * a + p2x * b + ex * t_cube;
      pData[index++] = sy * oneMinusT_cube + p1y * a + p2y * b + ey * t_cube;
      pData[index++] = sz * oneMinusT_cube + p1z * a + p2z * b + ez * t_cube;
    }

  pData[index++] = ex;
  pData[index++] = ey;
  pData[index++] = ez;
}

CLPoint * CLLayoutRenderer::calculate_intersection ( double  p1x, double  p1y, double  p1z, double  sx, double  sy, double  sz, double  p2x, double  p2y, double  p2z, double  tx, double  ty, double  tz  )

staticprotected

calculates the intersection point of two lines. The caller has to delete the returned point object.

Definition at line 4574 of file CLLayoutRenderer.cpp.

References ALMOST_ZERO, CLPoint::getX(), CLPoint::getY(), and CLPoint::getZ().

Referenced by draw_cap().

{
  CLPoint* pP = NULL;

  if (fabs(sx) > ALMOST_ZERO)
    {
      double m = (p1y - p2y + ((p2x / sx) - (p1x / sx)) * sy) / (ty - tx * sy / sx);
      double n = (p2x + m * tx - p1x) / sx;
      pP = new CLPoint(p2x + m * tx, p2y + m * ty, p2z + m * tz);
      CLPoint* pP2 = new CLPoint(p1x + n * sx, p1y + n * sy, p1z + n * sz);

      if (fabs(pP->getX()) > ALMOST_ZERO)
        {
          assert(fabs((pP->getX() - pP2->getX()) / pP->getX()) < 1e-6);
        }
      else
        {
          assert(fabs(pP2->getX()) < ALMOST_ZERO);
        }

      if (fabs(pP->getY()) > ALMOST_ZERO)
        {
          assert(fabs((pP->getY() - pP2->getY()) / pP->getY()) < 1e-6);
        }
      else
        {
          assert(fabs(pP2->getY()) < ALMOST_ZERO);
        }

      if (fabs(pP->getZ()) > ALMOST_ZERO)
        {
          assert(fabs((pP->getZ() - pP2->getZ()) / pP->getZ()) < 1e-6);
        }
      else
        {
          assert(fabs(pP2->getZ()) < ALMOST_ZERO);
        }

      delete pP2;
    }
  else if (fabs(tx) > ALMOST_ZERO)
    {
      // first line is in the yz plane or a plane parallel to it
      // the intersection must be at p2x=p1x
      double m = (p1x - p2x) / tx;
      pP = new CLPoint(p2x + m * tx, p2y + m * ty, p2z + m * tz);

      if (fabs(sy) > ALMOST_ZERO)
        {
          double n = (pP->getY() - p1y) / sy;
          CLPoint* pP2 = new CLPoint(p1x + n * sx, p1y + n * sy, p1z + n * sz);

          if (fabs(pP->getX()) > ALMOST_ZERO)
            {
              assert(fabs((pP->getX() - pP2->getX()) / pP->getX()) < 1e-6);
            }
          else
            {
              assert(fabs(pP2->getX()) < ALMOST_ZERO);
            }

          if (fabs(pP->getY()) > ALMOST_ZERO)
            {
              assert(fabs((pP->getY() - pP2->getY()) / pP->getY()) < 1e-6);
            }
          else
            {
              assert(fabs(pP2->getY()) < ALMOST_ZERO);
            }

          if (fabs(pP->getZ()) > ALMOST_ZERO)
            {
              assert(fabs((pP->getZ() - pP2->getZ()) / pP->getZ()) < 1e-6);
            }
          else
            {
              assert(fabs(pP2->getZ()) < ALMOST_ZERO);
            }

          delete pP2;
        }
      else if (fabs(sz) > ALMOST_ZERO)
        {
          double n = (pP->getZ() - p1z) / sz;
          CLPoint* pP2 = new CLPoint(p1x + n * sx, p1y + n * sy, p1z + n * sz);

          if (fabs(pP->getX()) > ALMOST_ZERO)
            {
              assert(fabs((pP->getX() - pP2->getX()) / pP->getX()) < 1e-6);
            }
          else
            {
              assert(fabs(pP2->getX()) < ALMOST_ZERO);
            }

          if (fabs(pP->getY()) > ALMOST_ZERO)
            {
              assert(fabs((pP->getY() - pP2->getY()) / pP->getY()) < 1e-6);
            }
          else
            {
              assert(fabs(pP2->getY()) < ALMOST_ZERO);
            }

          if (fabs(pP->getZ()) > ALMOST_ZERO)
            {
              assert(fabs((pP->getZ() - pP2->getZ()) / pP->getZ()) < 1e-6);
            }
          else
            {
              assert(fabs(pP2->getZ()) < ALMOST_ZERO);
            }

          delete pP2;
        }
    }
  else
    {
      // both lines don't have a component in the x direction, so both must
      // lie in the yz plane or a plane parallel to it
      // there can only be an intersection if the x values are the same
      if (fabs(p1x - p2x) < ALMOST_ZERO)
        {
          // they are in the same plane
          if (fabs(sy) > ALMOST_ZERO)
            {
              double m = (p1z - p2z + (p2y / sy) * sz) / (tz - ty / sy * sz);
              double n = (p2y + m * ty) / sy;
              pP = new CLPoint(p2x + m * tx, p2y + m * ty, p2z + m * tz);
              CLPoint* pP2 = new CLPoint(p1x + n * sx, p1y + n * sy, p1z + n * sz);

              if (fabs(pP->getX()) > ALMOST_ZERO)
                {
                  assert(fabs((pP->getX() - pP2->getX()) / pP->getX()) < 1e-6);
                }
              else
                {
                  assert(fabs(pP2->getX()) < ALMOST_ZERO);
                }

              if (fabs(pP->getY()) > ALMOST_ZERO)
                {
                  assert(fabs((pP->getY() - pP2->getY()) / pP->getY()) < 1e-6);
                }
              else
                {
                  assert(fabs(pP2->getY()) < ALMOST_ZERO);
                }

              if (fabs(pP->getZ()) > ALMOST_ZERO)
                {
                  assert(fabs((pP->getZ() - pP2->getZ()) / pP->getZ()) < 1e-6);
                }
              else
                {
                  assert(fabs(pP2->getZ()) < ALMOST_ZERO);
                }

              delete pP2;
            }
          else if (fabs(ty) > ALMOST_ZERO)
            {
              double n = (p2z - p1z + (p2y / ty) * tz) / (sz - sy / ty * tz);
              double m = (p1y + n * sy) / ty;
              pP = new CLPoint(p2x + m * tx, p2y + m * ty, p2z + m * tz);
              CLPoint* pP2 = new CLPoint(p1x + n * sx, p1y + n * sy, p1z + n * sz);

              if (fabs(pP->getX()) > ALMOST_ZERO)
                {
                  assert(fabs((pP->getX() - pP2->getX()) / pP->getX()) < 1e-6);
                }
              else
                {
                  assert(fabs(pP2->getX()) < ALMOST_ZERO);
                }

              if (fabs(pP->getY()) > ALMOST_ZERO)
                {
                  assert(fabs((pP->getY() - pP2->getY()) / pP->getY()) < 1e-6);
                }
              else
                {
                  assert(fabs(pP2->getY()) < ALMOST_ZERO);
                }

              if (fabs(pP->getZ()) > ALMOST_ZERO)
                {
                  assert(fabs((pP->getZ() - pP2->getZ()) / pP->getZ()) < 1e-6);
                }
              else
                {
                  assert(fabs(pP2->getZ()) < ALMOST_ZERO);
                }

              delete pP2;
            }
          else if (fabs(sz) > ALMOST_ZERO)
            {
              double m = (p1y - p2y + (p2z / sz) * sy) / (ty - tz / sz * sy);
              double n = (p2z + m * tz) / sz;
              pP = new CLPoint(p2x + m * tx, p2y + m * ty, p2z + m * tz);
              CLPoint* pP2 = new CLPoint(p1x + n * sx, p1y + n * sy, p1z + n * sz);

              if (fabs(pP->getX()) > ALMOST_ZERO)
                {
                  assert(fabs((pP->getX() - pP2->getX()) / pP->getX()) < 1e-6);
                }
              else
                {
                  assert(fabs(pP2->getX()) < ALMOST_ZERO);
                }

              if (fabs(pP->getY()) > ALMOST_ZERO)
                {
                  assert(fabs((pP->getY() - pP2->getY()) / pP->getY()) < 1e-6);
                }
              else
                {
                  assert(fabs(pP2->getY()) < ALMOST_ZERO);
                }

              if (fabs(pP->getZ()) > ALMOST_ZERO)
                {
                  assert(fabs((pP->getZ() - pP2->getZ()) / pP->getZ()) < 1e-6);
                }
              else
                {
                  assert(fabs(pP2->getZ()) < ALMOST_ZERO);
                }

              delete pP2;
            }
        }
    }

  return pP;
}

std::pair< double, double > CLLayoutRenderer::calculate_intersection_point_2d ( double  p1x, double  p1y, double  sx, double  sy, double  p2x, double  p2y, double  tx, double  ty  )

staticprotected

Calculates the intersection point between two lines in 2D. The intersection point is returned. If the lines are parallel, a point with two NaN values is returned. All numbers <= ALMOST_ZERO are considered to be 0.

Definition at line 4470 of file CLLayoutRenderer.cpp.

References ALMOST_ZERO.

Referenced by segments_intersect_2d().

{
  std::pair<double, double> result = std::pair<double, double>(std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN());

  if (fabs(sx) <= ALMOST_ZERO)
    {
      // two options -> a) tx is also 0.0 -> parallel lines
      //                b) intersection is at  p1x,??
      if (fabs(tx) > ALMOST_ZERO)
        {
          result = std::pair<double, double>(p1x, (p1x - p2x) * (ty / tx) + p2y);
        }
    }
  else if (fabs(sy) <= ALMOST_ZERO)
    {
      // two options a) ty is also 0.0 -> parallel lines
      //             b) intersection at ??,p1y

      if (fabs(tx) > ALMOST_ZERO)
        {
          if (fabs(ty) > ALMOST_ZERO)
            {
              result = std::pair<double, double>((p1y - p2y) * (tx / ty) - p2x, p1y);
            }
        }
      else
        {
          result = std::pair<double, double>(p2x, p1y);
        }
    }
  else if (fabs(tx) <= ALMOST_ZERO)
    {
      // intersection is at p2x,??
      if (fabs(sy) > ALMOST_ZERO)
        {
          result = std::pair<double, double>(p2x, (p2x - p1x) * (sy / sx) + p1y);
        }
    }
  else if (fabs(ty) <= ALMOST_ZERO)
    {
      // intersection at  ??,p2y
      result = std::pair<double, double>((p2y - p1y) * (sx / sy) - p1x, p2y);
    }
  else
    {
      // most general case
      // two options a) lines are parallel
      //             b) intersection at
      //
      //  check if the lines are parallel
      if (fabs(fabs((sx * tx + sy * ty) / (sqrt(sx * sx + sy * sy)*sqrt(tx * tx + ty * ty))) - 1) > ALMOST_ZERO)
        {
          double ss = sy / sx;
          double st = ty / tx;
          double ys = p1y - p1x * ss;
          double yt = p2y - p2x * st;
          // if not, the intersection is at
          double x = (ss - st) / (yt - ys);
          double y = ss * x + ys;
          result = std::pair<double, double>(x, y);
        }
    }

  return result;
}

void CLLayoutRenderer::change_style	(	const CLGlobalRenderInformation *	pRenderInformation,
		bool	defaultStyle = false
	)

This method replaces the current style with the given global render information.

Definition at line 174 of file CLLayoutRenderer.cpp.

References analyse_render_information(), clear_cached_data(), mDeduceSpeciesReferenceRoles, mH, mpFontRenderer, mpGlobalRenderInfoList, mpResolver, mSpeciesReferencesWithDeducedRole, mW, mX, mY, mZoomFactor, CLRenderResolver::setDeducedObjectRoles(), and setDeduceSpeciesReferenceRoles().

Referenced by CQGLLayoutPainter::change_style(), and CLLayoutRenderer().

{
  if (this->mpResolver != NULL)
    {
      delete this->mpResolver;
      this->mpResolver = NULL;
    }

  if (pRenderInformation)
    {
      this->mpResolver = new CLRenderResolver(*pRenderInformation, *this->mpGlobalRenderInfoList);
    }

  if (defaultStyle == true)
    {
      this->setDeduceSpeciesReferenceRoles(true);
    }

  this->clear_cached_data();

  if (this->mpFontRenderer != NULL)
    {
      this->analyse_render_information(mX, mY, mX + mW / this->mZoomFactor, mY + mH / this->mZoomFactor);
    }

  if (this->mDeduceSpeciesReferenceRoles)
    {
      this->mpResolver->setDeducedObjectRoles(this->mSpeciesReferencesWithDeducedRole);
    }
}

void CLLayoutRenderer::change_style

(

const CLLocalRenderInformation *

pRenderInformation

)

This method replaces the current style with the given glocal render information.

Definition at line 205 of file CLLayoutRenderer.cpp.

References analyse_render_information(), clear_cached_data(), CLayout::getListOfLocalRenderInformationObjects(), mDeduceSpeciesReferenceRoles, mH, mpFontRenderer, mpGlobalRenderInfoList, mpLayout, mpResolver, mSpeciesReferencesWithDeducedRole, mW, mX, mY, mZoomFactor, and CLRenderResolver::setDeducedObjectRoles().

{
  if (this->mpResolver != NULL)
    {
      delete this->mpResolver;
      this->mpResolver = NULL;
    }

  if (pRenderInformation)
    {
      this->mpResolver = new CLRenderResolver(*pRenderInformation, this->mpLayout->getListOfLocalRenderInformationObjects(), *this->mpGlobalRenderInfoList);
    }

  this->clear_cached_data();

  if (this->mpFontRenderer != NULL)
    {
      this->analyse_render_information(mX, mY, mX + mW / this->mZoomFactor, mY + mH / this->mZoomFactor);
    }

  if (this->mDeduceSpeciesReferenceRoles)
    {
      this->mpResolver->setDeducedObjectRoles(this->mSpeciesReferencesWithDeducedRole);
    }
}

void CLLayoutRenderer::clear_cached_data ( )

protected

Removes all entries from all cache maps and frees the memory for the textures.

Definition at line 4378 of file CLLayoutRenderer.cpp.

References mColorMap, mDrawables, mFontTextureMap, mGradientMap, mImageMap, mLineEndingMap, mLinestippleMap, mStyleMap, mTextGlyphMap, and mTextMap.

Referenced by change_style(), setDeduceSpeciesReferenceRoles(), and ~CLLayoutRenderer().

{
  std::map<std::string, std::pair<const CLGradientBase*, CLTextureSpec*> >::iterator it1 = this->mGradientMap.begin(), endit1 = this->mGradientMap.end();

  while (it1 != endit1)
    {
      if (it1->second.second != NULL)
        {
          if (it1->second.second->mTextureName != 0)
            {
              glDeleteTextures(1, &it1->second.second->mTextureName);
            }

          delete it1->second.second;
        }

      ++it1;
    }

  this->mGradientMap.clear();
  std::map<CLFontSpec, std::map<std::string, CLTextTextureSpec*> >::iterator it2 = this->mFontTextureMap.begin(), endit2 = this->mFontTextureMap.end();

  while (it2 != endit2)
    {
      std::map<std::string, CLTextTextureSpec*>::const_iterator it3 = it2->second.begin(), endit3 = it2->second.end();

      while (it3 != endit3)
        {
          if (it3->second != NULL)
            {
              if (it3->second->mTextureName != 0)
                {
                  glDeleteTextures(1, &it3->second->mTextureName);
                }

              delete it3->second;
            }

          ++it3;
        }

      it2->second.clear();
      ++it2;
    }

  this->mFontTextureMap.clear();
  std::map<const std::vector<unsigned int>, const CLLineStippleTexture*>::const_iterator it3 = this->mLinestippleMap.begin(), endit3 = this->mLinestippleMap.end();

  while (it3 != endit3)
    {
      if (it3->second != NULL)
        {
          delete it3->second;
        }

      ++it3;
    }

  this->mLinestippleMap.clear();
  // delete all image textures
  std::map<std::string, const CLTextureSpec*>::iterator it4 = this->mImageMap.begin(), endit4 = this->mImageMap.end();

  while (it4 != endit4)
    {
      if (it4->second != NULL)
        {
          if (it4->second->mTextureName != 0)
            {
              glDeleteTextures(1, &it4->second->mTextureName);
            }

          delete it4->second;
        }

      ++it4;
    }

  this->mImageMap.clear();
  this->mColorMap.clear();
  this->mStyleMap.clear();
  this->mDrawables.clear();
  this->mLineEndingMap.clear();
  this->mTextGlyphMap.clear();
  this->mTextMap.clear();
}

void CLLayoutRenderer::clearSelection

(

)

This method clears the selection.

Definition at line 5020 of file CLLayoutRenderer.cpp.

References mSelection.

Referenced by CQGLLayoutPainter::mousePressEvent(), and CQGLLayoutPainter::mouseReleaseEvent().

{
  if (!this->mSelection.empty())
    {
      this->mSelection.clear();
    }
}

void CLLayoutRenderer::COMBINE_CALLBACK ( GLdouble  coords[3], GLdouble **  , GLfloat *  , GLdouble **  dataOut  )

staticprotected

This static method is used as a callback for the GLU tesselator. It is needed for polygons that intersect which itself and the tesselator has to create a new vertex at the intersection.

Definition at line 2983 of file CLLayoutRenderer.cpp.

Referenced by draw_datapoints().

{
  GLdouble* vertex;
  //int i;
  vertex = new GLdouble[3];
  vertex[0] = coords[0];
  vertex[1] = coords[1];
  vertex[2] = coords[2];
  *dataOut = vertex;
}

void CLLayoutRenderer::COMBINE_CALLBACK_GRADIENT ( GLdouble  coords[3], GLdouble *  vertex_data[4], GLfloat  weight[4], GLdouble **  dataOut  )

staticprotected

This static method is used as a callback for the GLU tesselator. It is needed for polygons that intersect which itself and the tesselator has to create a new vertex at the intersection.

Definition at line 2994 of file CLLayoutRenderer.cpp.

Referenced by draw_datapoints().

{
  GLdouble* vertex;
  vertex = new GLdouble[5];
  vertex[0] = coords[0];
  vertex[1] = coords[1];
  vertex[2] = coords[2];
  vertex[3] = weight[0] * vertex_data[0][3]
              + weight[1] * vertex_data[1][3]
              + weight[2] * vertex_data[2][3]
              + weight[3] * vertex_data[3][3];
  vertex[4] = weight[0] * vertex_data[0][4]
              + weight[1] * vertex_data[1][4]
              + weight[2] * vertex_data[2][4]
              + weight[3] * vertex_data[3][4];
  *dataOut = vertex;
}

const CLPoint CLLayoutRenderer::convert_to_absolute ( const CLRenderPoint *  pRenderPoint, const CLBoundingBox *  pBB  )

staticprotected

Converts a given RenderPoint which can have relative values into a layout Point with only absolute values.

Converts a given CLRenderPoint which can have relative values into a layout CLPoint with only absolute values. Even the absolute values of the point which are relative to the bounding box are translated into absolute coordinates.

Definition at line 924 of file CLLayoutRenderer.cpp.

References CLRelAbsVector::getAbsoluteValue(), CLDimensions::getDepth(), CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLPoint::getZ(), CLRenderPoint::x(), CLRenderPoint::y(), and CLRenderPoint::z().

Referenced by draw_curve(), draw_image(), draw_polygon(), and draw_rectangle().

{
  const CLRelAbsVector& x = pRenderPoint->x();
  const CLRelAbsVector& y = pRenderPoint->y();
  const CLRelAbsVector& z = pRenderPoint->z();
  const CLPoint* pPosition = &pBB->getPosition();
  const CLDimensions* pDimensions = &pBB->getDimensions();
  return CLPoint((x.getAbsoluteValue() + pDimensions->getWidth() * x.getRelativeValue() / 100.0) + pPosition->getX(),
                 (y.getAbsoluteValue() + pDimensions->getHeight() * y.getRelativeValue() / 100.0) + pPosition->getY(),
                 (z.getAbsoluteValue() + pDimensions->getDepth() * z.getRelativeValue() / 100.0) + pPosition->getZ());
}

std::pair< double, double > CLLayoutRenderer::convert_to_model_space	(	double	x,
		double	y
	)		const

converts the given coordinates from viewport space into model space.

Definition at line 6575 of file CLLayoutRenderer.cpp.

References mX, mY, and mZoomFactor.

Referenced by getObjectsAtViewportPosition(), CQGLLayoutPainter::mouseMoveEvent(), CQGLLayoutPainter::mouseReleaseEvent(), and CQGLLayoutPainter::update_status_and_cursor().

{
  double modelX = this->mX + (double)x / this->mZoomFactor;
  double modelY = this->mY + (double)y / this->mZoomFactor;
  return std::pair<double, double>(modelX, modelY);
}

void CLLayoutRenderer::create_gradient_texture ( unsigned int  size, GLubyte *  pData, const CLGradientBase *  pGradient, double  z_value = 0.0  )

protected

This method calculates a texture for a given gradient definition and a given size. The data object has to be a vector that can store RGBA values for a rectangle of the given size. The memory has to be allocated before calling the method. The scale specifies by how much the original box has been scaled.

Definition at line 2139 of file CLLayoutRenderer.cpp.

References create_linear_gradient_texture(), and create_radial_gradient_texture().

Referenced by update_textures_and_colors().

{
  if (pGradient)
    {
      const CLLinearGradient* pLG = dynamic_cast<const CLLinearGradient*>(pGradient);

      if (pLG != NULL)
        {
          CLLayoutRenderer::create_linear_gradient_texture(size, pData, pLG, z_value);
        }
      else
        {
          const CLRadialGradient* pRG = dynamic_cast<const CLRadialGradient*>(pGradient);

          if (pRG != NULL)
            {
              CLLayoutRenderer::create_radial_gradient_texture(size, pData, pRG, z_value);
            }
          else
            {
              throw 0;
            }
        }
    }
}

void CLLayoutRenderer::create_linear_gradient_texture ( unsigned int  size, GLubyte *  pData, const CLLinearGradient *  pGradient, double  z_value  )

protected

This method calculates a texture for a given linear gradient definition and a given size. The data object has to be a vector that can store RGBA values for a rectangle of the given size. The memory has to be allocated before calling the method. The scale specifies by how much the original box has been scaled.

Definition at line 2172 of file CLLayoutRenderer.cpp.

References ALMOST_ZERO, CLGradientStops::color(), CLRelAbsVector::getAbsoluteValue(), CLRelAbsVector::getRelativeValue(), CLLinearGradient::getXPoint1(), CLLinearGradient::getXPoint2(), CLLinearGradient::getYPoint1(), CLLinearGradient::getYPoint2(), CLLinearGradient::getZPoint1(), CLLinearGradient::getZPoint2(), CLRGBAColor::mA, CLRGBAColor::mB, mColorMap, CLRGBAColor::mG, CLRGBAColor::mR, mZoomFactor, and CLGradientStops::update_color().

Referenced by create_gradient_texture().

{
  // first calculate the gradient vector
  // we need to consider the scale
  CLGradientStops stops(pGradient, this->mColorMap);
  double x1 = pGradient->getXPoint1().getAbsoluteValue() * this->mZoomFactor + (pGradient->getXPoint1().getRelativeValue() / 100.0 * size);
  double y1 = pGradient->getYPoint1().getAbsoluteValue() * this->mZoomFactor + (pGradient->getYPoint1().getRelativeValue() / 100.0 * size);
  double z1 = pGradient->getZPoint1().getAbsoluteValue() * this->mZoomFactor + (pGradient->getZPoint1().getRelativeValue() / 100.0 * 0.0);
  double x2 = pGradient->getXPoint2().getAbsoluteValue() * this->mZoomFactor + (pGradient->getXPoint2().getRelativeValue() / 100.0 * size);
  double y2 = pGradient->getYPoint2().getAbsoluteValue() * this->mZoomFactor + (pGradient->getYPoint2().getRelativeValue() / 100.0 * size);
  double z2 = pGradient->getZPoint2().getAbsoluteValue() * this->mZoomFactor + (pGradient->getZPoint2().getRelativeValue() / 100.0 * 0.0);
  // for each point we need to calculate the distance from p1 along the
  // vector v(p1,p2)
  // first we need the plane that is perpendicular to the vector v(p1,p2)
  // the we need to calculate the distance of a plane from that range of
  // planes to p1 and normalize it with the length of v(p1,p2)
  // the distance can be positive or negative, this makes a difference for
  // the gradient calculation

  // rel_distance is the distance with respect to the original gradient vector
  // that is, a value of 1.0 means that the point is exactly as far from the
  // plane as the gradient vector is long
  double deltax = x2 - x1;
  double deltay = y2 - y1;
  double deltaz = z2 - z1;
  double length = sqrt(deltax * deltax + deltay * deltay + deltaz * deltaz);

  // line through x1,y1 that is perpendicular to v(p1,p2)
  if (fabs(deltax) < ALMOST_ZERO)
    {
      // the gradient is along the y axis
      unsigned int i, j, iMax = size, jMax = size;
      double rel_distance = 0.0;
      unsigned int index = 0;

      for (i = 0; i < iMax; ++i)
        {
          for (j = 0; j < jMax; ++j)
            {
              rel_distance = (double)(i - y1) / length;
              stops.update_color(rel_distance);
              pData[index] = stops.color().mR;
              pData[++index] = stops.color().mG;
              pData[++index] = stops.color().mB;
              pData[++index] = stops.color().mA;
              ++index;
            }
        }
    }
  else if (fabs(deltay) < ALMOST_ZERO)
    {
      // the gradient is along the x axis
      unsigned int i, j, iMax = size, jMax = size;
      double rel_distance = 0.0;
      unsigned int index = 0;

      for (i = 0; i < iMax; ++i)
        {
          for (j = 0; j < jMax; ++j)
            {
              rel_distance = (double)(j - x1) / length;
              stops.update_color(rel_distance);
              pData[index] = stops.color().mR;
              pData[++index] = stops.color().mG;
              pData[++index] = stops.color().mB;
              pData[++index] = stops.color().mA;
              ++index;
            }
        }
    }
  else
    {
      double slope = deltay / deltax;
      double inv_slope = -deltax / deltay;
      double c_inv = y1 - inv_slope * x1;
      double c;
      // y=s*x+c;
      // intersection of line
      unsigned int i, j, iMax = size, jMax = size;
      double rel_distance = 0.0;
      double px, py;
      double r = inv_slope - slope;
      unsigned int index = 0;

      for (i = 0; i < iMax; ++i)
        {
          for (j = 0; j < jMax; ++j)
            {
              c = i - slope * j;
              // x*slope+c=x*inv_slope+inv_c
              // x*slope-x*inv_slope=inv_c-c
              // x= (inv_c-c)/(slope-inv_slope)
              px = (c - c_inv) / r;
              py = slope * px + c;
              rel_distance = sqrt((j - px) * (j - px) + (i - py) * (i - py)) / length;

              // check if the distance is actually negative
              if ((j - px)*deltax + (i - py)*deltay <= 0)
                {
                  rel_distance = -rel_distance;
                }

              stops.update_color(rel_distance);
              pData[index] = stops.color().mR;
              pData[++index] = stops.color().mG;
              pData[++index] = stops.color().mB;
              pData[++index] = stops.color().mA;
              ++index;
            }
        }
    }
}

void CLLayoutRenderer::create_radial_gradient_texture ( unsigned int  size, GLubyte *  pData, const CLRadialGradient *  pGradient, double  z_value  )

protected

This method calculates a texture for a given radial gradient definition and a given size. The data object has to be a vector that can store RGBA values for a rectangle of the given size. The memory has to be allocated before calling the method. The scale specifies by how much the original box has been scaled.

Definition at line 2292 of file CLLayoutRenderer.cpp.

References ALMOST_ZERO, CLGradientStops::color(), CLRelAbsVector::getAbsoluteValue(), CLRadialGradient::getCenterX(), CLRadialGradient::getCenterY(), CLRadialGradient::getFocalPointX(), CLRadialGradient::getFocalPointY(), CLRadialGradient::getRadius(), CLRelAbsVector::getRelativeValue(), CLRGBAColor::mA, CLRGBAColor::mB, mColorMap, CLRGBAColor::mG, CLRGBAColor::mR, mZoomFactor, and CLGradientStops::update_color().

Referenced by create_gradient_texture().

{
  // experiments with the focal point in firefox
  // - the radius seems to be aplied to the x and the y axis, so if a radius
  // of 50% is used in a rectangle, the circle is not a circle, but an
  // ellipse

  // spreadMethod Pad:
  // if the focal point is on the circle, everything that
  // is outside the circle and on the outside of the tangent with the circle
  // and the focal point is the stop color at 0%, everythin outside the
  // circle on the inside of the tangent is black, the color in the ellipse
  // depends on the distance from the focal point and the circle edge
  // in Inkscape this is different, everything outside the circle is the
  // color of the 100% stop, everything else is patterned
  // if the focal point is within the circle/ellipse, the whole shape has a
  // pattern where everything outside the circle/ellipse has the color of the
  // 100% stop

  // spreadMethod reflect:
  // if the focal point is on the circle, everything has the color at 0% stop
  // in Inkscape this is different, everything outside the tangent is the
  // color of the 100% stop, everything else is patterned
  // if the focal point is within the circle/ellipse, the whole shape has a
  // pattern

  // spreadMethod repeat:
  // if the focal point is on the circle, everything has the color at 0% stop
  // in Inkscape this is different, everything outside the tangent is the
  // color of the 100% stop, everything else is patterned
  // if the focal point is within the circle/ellipse, the whole shape has a
  // pattern

  CLGradientStops stops(pGradient, this->mColorMap);
  double cx = pGradient->getCenterX().getAbsoluteValue() * this->mZoomFactor + pGradient->getCenterX().getRelativeValue() / 100.0 * size;
  double cy = pGradient->getCenterY().getAbsoluteValue() * this->mZoomFactor + pGradient->getCenterY().getRelativeValue() / 100.0 * size;
  double fx = pGradient->getFocalPointX().getAbsoluteValue() * this->mZoomFactor + pGradient->getFocalPointX().getRelativeValue() / 100.0 * size;
  double fy = pGradient->getFocalPointY().getAbsoluteValue() * this->mZoomFactor + pGradient->getFocalPointY().getRelativeValue() / 100.0 * size;
  double rx = pGradient->getRadius().getAbsoluteValue() * this->mZoomFactor + pGradient->getRadius().getRelativeValue() / 100.0 * size;
  double ry = pGradient->getRadius().getAbsoluteValue() * this->mZoomFactor + pGradient->getRadius().getRelativeValue() / 100.0 * size;
  // TODO create an error if the radius is negative

  // TODO correct the focal point if it is outside the circle

  double delta_x, delta_y, slope, A, B, C, a;
  unsigned int i, j;
  // ellipse (x-cx)^2 / rx^2 + (y-cy)^2 / ry^2 = 1
  // -> x=+- sqrt(1-((x-cx)/rx)^2)*ry+cx
  // -> y=+- sqrt(1-((y-cy)/ry)^2)*rx+cy
  // for horizontal and vertical lines through the focal point fx,fy
  // we can already precalculate the value under the square root
  // which determines the number of solutions
  // for vertical lines (x=fx) it is
  const double s = 1 - pow((fx - cx) / rx, 2);
  // for horizontal lines (y=fy) it is
  const double t = 1 - pow((fy - cy) / ry, 2);
  double u = 0.0, solution1x = 0.0, solution1y = 0.0, solution2x = 0.0, solution2y = 0.0;
  unsigned int index = 0;

  for (i = 0; i < size; ++i)
    {
      for (j = 0; j < size; ++j)
        {
          delta_x = j - fx;
          delta_y = i - fy;
          double rel_distance = 1.0;

          if (fabs(delta_x) < ALMOST_ZERO && fabs(delta_y) < ALMOST_ZERO)
            {
              // we are on the focal point, so the rel_distance is 0.0
              rel_distance = 0.0;
            }
          else if (fabs(delta_x) < ALMOST_ZERO)
            {
              // use s
              if (s > 0.0)
                {
                  // there are two crossing points
                  solution1x = fx;
                  // -> y=+- sqrt(s)*ry+cy
                  solution1y = sqrt(s) * ry + cy;
                  solution2x = fx;
                  solution2y = -sqrt(s) * ry + cy;
                  // we have to find out which one is the correct one
                  // the correct one is not necessarily the one that is
                  // closer, but the one that lies on the same side of the
                  // focal point f(fx,fy) as the point we are looking at P(j,i)
                  // so if the dot product is positive, we have the correct
                  // value
                  double dotProduct = ((double)j - fx) * (solution1x - fx) + ((double)i - fy) * (solution1y - fy);

                  if (dotProduct <= 0)
                    {
                      assert(((double)j - fx) * (solution2x - fx) + ((double)i - fy) * (solution2y - fy) > 0);
                      solution1x = solution2x;
                      solution1y = solution2y;
                    }
                }
              else if (fabs(s) < ALMOST_ZERO)
                {
                  // there is only a tangent, so the focal points is directly
                  // on the circle
                  solution1x = fx;
                  // -> y=+- sqrt(s)*rx+cy
                  solution1y = cy;
                }
              else
                {
                  // there is no crossing between the line and the circle,
                  // since the focal points is always within the circle, this
                  // should be impossible
                  throw 0;
                }
            }
          else if (fabs(delta_y) < ALMOST_ZERO)
            {
              // use t
              if (t > 0.0)
                {
                  // there are two crossing points
                  solution1y = fy;
                  // -> x=+- sqrt(t)*rx+cx
                  solution1x = sqrt(t) * rx + cx;
                  solution2y = fy;
                  solution2x = -sqrt(t) * rx + cx;
                  // we have to find out which one is the correct one
                  // the correct one is not necessarily the one that is
                  // closer, but the one that lies on the same side of the
                  // focal point f(fx,fy) as the point we are looking at P(j,i)
                  // so if the dot product is positive, we have the correct
                  // value
                  double dotProduct = ((double)j - fx) * (solution1x - fx) + ((double)i - fy) * (solution1y - fy);

                  if (dotProduct < 0)
                    {
                      assert(((double)j - fx) * (solution2x - fx) + ((double)i - fy) * (solution2y - fy) > 0);
                      solution1x = solution2x;
                      solution1y = solution2y;
                    }
                }
              else if (fabs(t) < ALMOST_ZERO)
                {
                  // there is only a tangent, so the focal points is directly
                  // on the circle
                  solution1y = fy;
                  // -> x=+- sqrt(t)*ry+cx
                  solution1x = cx;
                }
              else
                {
                  // there is no crossing between the line and the circle,
                  // since the focal points is always within the circle, this
                  // should be impossible
                  throw 0;
                }
            }
          else
            {
              slope = delta_y / delta_x;
              // for the general case, we have to calculate the value under
              // the square root for every single point
              // a=fy-slope*fx;
              // u=B^2-4*A*C
              // u=(-2*cx*(ry)^2+2*rx^2*slope*(a-cy))^2-4*(ry^2+rx^2*slope^2)*(ry^2*cx^2+rx^2*(a-cy)^2-rx^2*ry^2)
              // u=(-2*cx*(ry)^2+2*rx^2*slope*(fy-slope*fx-cy))^2-4*(ry^2+rx^2*slope^2)*(ry^2*cx^2+rx^2*(fy-slope*fx-cy)^2-rx^2*ry^2)
              a = fy - slope * fx;
              A = ry * ry + rx * rx * slope * slope;
              B = -2 * cx * ry * ry + 2 * rx * rx * slope * (a - cy);
              C = ry * ry * cx * cx + rx * rx * pow(a - cy, 2) - rx * rx * ry * ry;
              u = B * B - 4 * A * C;

              if (u > 0.0)
                {
                  // two solutions
                  solution1x = (-B + sqrt(u)) / (2 * A);
                  solution2x = (-B - sqrt(u)) / (2 * A);
                  solution1y = solution1x * slope + a;
                  solution2y = solution2x * slope + a;
                  // we have to find out which one is the correct one
                  // the correct one is not necessarily the one that is
                  // closer, but the one that lies on the same side of the
                  // focal point f(fx,fy) as the point we are looking at P(j,i)
                  // so if the dot product is positive, we have the correct
                  // value
                  double dotProduct = ((double)j - fx) * (solution1x - fx) + ((double)i - fy) * (solution1y - fy);

                  if (dotProduct < 0)
                    {
                      assert(((double)j - fx) * (solution2x - fx) + ((double)i - fy) * (solution2y - fy) > 0);
                      solution1x = solution2x;
                      solution1y = solution2y;
                    }
                }
              else if (fabs(u) < ALMOST_ZERO)
                {
                  // one solution, the focal point is on the circle
                  solution1x = (-2 * slope * (fy - slope * fx) + cy) / (2 * (ry * ry + rx * rx * slope * slope));
                  solution1y = solution1x * slope + (fy - slope * fx);
                }
              else
                {
                  // no solution. Since the focal point is always in or on
                  // the circle, this should be impossible
                  throw 0;
                }
            }

          // now we have the correct crosing point in solution1x and
          // solution1y
          // we have to find out if the solution coincides with the focal
          // point
          // TODO, actually this could simplify the code above. If we get
          // only one solution, we actually know that it must be the focal
          // point
          if (fabs(solution1x - fx) >= ALMOST_ZERO || fabs(solution1y - fx) >= ALMOST_ZERO)
            {
              // we calculate the distance from the focal point to the
              // current point
              // and we calculate the distance from the focal point to the
              // crossing point
              // TODO we can save one square root calculation if we only
              // calculate the square root of the rel_distance
              double distance_f_c = sqrt(pow((solution1x - fx), 2) + pow((solution1y - fy), 2));
              double distance_f_p = sqrt(pow((j - fx), 2) + pow((i - fy), 2));
              rel_distance = distance_f_p / distance_f_c;
            }

          stops.update_color(rel_distance);
          pData[index] = stops.color().mR;
          pData[++index] = stops.color().mG;
          pData[++index] = stops.color().mB;
          pData[++index] = stops.color().mA;
          ++index;
        }
    }
}

void CLLayoutRenderer::createGLMatrix ( const double *const  matrix, GLdouble *  glMatrix  )

staticprotected

Definition at line 3185 of file CLLayoutRenderer.cpp.

Referenced by draw_curve(), draw_datapoints(), draw_group(), draw_image(), and draw_text().

{
  glMatrix[0] = matrix[0];
  glMatrix[1] = matrix[1];
  glMatrix[2] = matrix[2];
  glMatrix[3] = 0.0;
  glMatrix[4] = matrix[3];
  glMatrix[5] = matrix[4];
  glMatrix[6] = matrix[5];
  glMatrix[7] = 0.0;
  glMatrix[8] = matrix[6];
  glMatrix[9] = matrix[7];
  glMatrix[10] = matrix[8];
  glMatrix[11] = 0.0;
  glMatrix[12] = matrix[9];
  glMatrix[13] = matrix[10];
  glMatrix[14] = matrix[11];
  glMatrix[15] = 1.0;
}

CLLineStippleTexture * CLLayoutRenderer::createLineStippleTexture ( const std::vector< unsigned int > &  dasharray )

staticprotected

Creates a 1D texture for the line stippling. The caller is responsible for deleting the returned object. If the dasharray does not contain a valid stipple pattern NULL is returned.

Definition at line 3211 of file CLLayoutRenderer.cpp.

Referenced by update_textures_and_colors().

{
  return new CLLineStippleTexture(dasharray);
}

double CLLayoutRenderer::distance ( const CLPoint &  p1, const CLPoint &  p2  )

static

calculates the distance between two layout points.

Definition at line 7136 of file CLLayoutRenderer.cpp.

References CLPoint::getX(), and CLPoint::getY().

Referenced by distancePointLineSegment(), isSegmentHit(), CQGLLayoutPainter::mouseMoveEvent(), update_associations(), and CQGLLayoutPainter::update_status_and_cursor().

{
  return sqrt(pow(p1.getX() - p2.getX(), 2) + pow(p1.getY() - p2.getY(), 2));
}

double CLLayoutRenderer::distancePointLineSegment ( double  x, double  y, double  lx1, double  ly1, double  lx2, double  ly2  )

staticprotected

Calculates the distance between a point and a line segment. It tries to calculate the intersection point of the line and another line perpendicular to the first line through the given point. If this intersection point is on the line segment, the result is the same as the distance between the two lines, otherwise the distance is the distance of the given point to the closest endpoint of the segment.

Definition at line 5418 of file CLLayoutRenderer.cpp.

References distance().

Referenced by isSegmentHit().

{
  double dx = lx2 - lx1;
  double dy = ly2 - ly1;
  double distance = std::numeric_limits<double>::quiet_NaN();

  if (fabs(dx) <= 1e-9)
    {
      if (fabs(dy) > 1e-9)
        {
          if (y >= ((ly1 < ly2) ? ly1 : ly2) && y <= ((ly1 > ly2) ? ly1 : ly2))
            {
              distance = fabs(lx1 - x);
            }
        }
    }
  else if (fabs(dy) <= 1e-9)
    {
      if (x >= ((lx1 < lx2) ? lx1 : lx2) && x <= ((lx1 > lx2) ? lx1 : lx2))
        {
          distance = fabs(ly1 - y);
        }
    }
  else
    {
      double slope = dy / dx;
      double invslope = -1.0 * dx / dy;
      double xCross = (-invslope * x + slope * lx1 + y - ly1) / (slope - invslope);

      if ((xCross >= ((lx1 < lx2) ? lx1 : lx2)) && (xCross <= (((lx1 > lx2) ? lx1 : lx2))))
        {
          double yCross = slope * (xCross - lx1) + ly1;

          if ((yCross >= ((ly1 < ly2) ? ly1 : ly2)) && (yCross <= (((ly1 > ly2) ? ly1 : ly2))))
            {
              distance = sqrt(pow(x - xCross, 2) + pow(y - yCross, 2));
            }
          else
            {
              if (fabs(lx1 - xCross) < fabs(lx2 - xCross))
                {
                  // the distance to lx2.ly2 is smaller
                  distance = sqrt(pow(x - lx2, 2) + pow(y - ly2, 2));
                }
              else
                {
                  distance = sqrt(pow(x - lx1, 2) + pow(y - ly1, 2));
                }
            }
        }
      else
        {
          if (fabs(lx1 - xCross) < fabs(lx2 - xCross))
            {
              // the distance to lx2.ly2 is smaller
              distance = sqrt(pow(x - lx2, 2) + pow(y - ly2, 2));
            }
          else
            {
              distance = sqrt(pow(x - lx1, 2) + pow(y - ly1, 2));
            }
        }
    }

  return distance;
}

void CLLayoutRenderer::draw_cap ( double  x1, double  y1, double  z1, double  x2, double  y2, double  z2, double  x3, double  y3, double  z3, double  stroke_width  )

protected

Routine to draw the caps between two line segments. The method takes the three points that make the two line segments and the width of the line.

Definition at line 4164 of file CLLayoutRenderer.cpp.

References ALMOST_ZERO, calculate_intersection(), CLPoint::getX(), CLPoint::getY(), and CLPoint::getZ().

Referenced by draw_datapoints(), and draw_line().

{
  // calculate the direction vector
  double vx1 = x2 - x1;
  double vy1 = y2 - y1;
  double vz1 = z2 - z1;
  double length = sqrt(vx1 * vx1 + vy1 * vy1 + vz1 * vz1);

  double normLength1, normLength2;

  // calculate the normal to this vector
  double vx2 = 0.0;
  double vy2 = 0.0;
  double vz2 = 0.0;
  double half_width = stroke_width / 2.0;

  if (fabs(vx1) < ALMOST_ZERO && vz1 < ALMOST_ZERO)
    {
      // scale by the stroke_width
      vx2 = -vy1 / length * half_width;
      vy2 = 0.0;
      vz2 = 0.0;
    }
  else
    {
      // scale by the stroke_width
      double normY = vy1 / length;
      vx2 = -normY * vx1 / length * half_width;
      vy2 = (1 - normY * normY) * half_width;
      vz2 = -normY * vz1 / length * half_width;
      normLength1 = half_width / sqrt(vx2 * vx2 + vy2 * vy2 + vz2 * vz2);
      vx2 *= normLength1;
      vy2 *= normLength1;
      vz2 *= normLength1;
    }

  // calculate the direction vector
  double vx3 = x3 - x2;
  double vy3 = y3 - y2;
  double vz3 = z3 - z2;
  double length2 = sqrt(vx3 * vx3 + vy3 * vy3 + vz3 * vz3);

  // calculate the normal to this vector
  double vx4 = 0.0;
  double vy4 = 0.0;
  double vz4 = 0.0;

  if (fabs(vx3) < ALMOST_ZERO && vz3 < ALMOST_ZERO)
    {
      // scale by the stroke_width
      vx4 = -vy3 / length2 * half_width;
      vy4 = 0.0;
      vz4 = 0.0;
    }
  else
    {
      // scale by the stroke_width
      double normY = vy3 / length2;
      vx4 = -normY * vx3 / length2 * half_width;
      vy4 = (1 - normY * normY) * half_width;
      vz4 = -normY * vz3 / length2 * half_width;
      normLength2 = half_width / sqrt(vx4 * vx4 + vy4 * vy4 + vz4 * vz4);
      vx4 *= normLength2;
      vy4 *= normLength2;
      vz4 *= normLength2;
    }

  double length3 = sqrt(pow(x3 - x1, 2) + pow(y3 - y1, 2) + pow(z3 - z1, 2));
  double angle = (vx2 * vx4 + vy2 * vy4 + vz2 * vz4) / (sqrt(vx2 * vx2 + vy2 * vy2 + vz2 * vz2) * sqrt(vx4 * vx4 + vy4 * vy4 + vz4 * vz4));
  angle = acos(angle);

  // if the angle is not +/-0 or +/-180°
  if ((fabs(angle) > ALMOST_ZERO) && (fabs((fabs(angle) - M_PI)) / M_PI > ALMOST_ZERO))
    {
      // if the angle is greater 0, the gap is at the lower edge
      // else the gap is at the upper edge
      // calculate the center of the first line segment box
      // in order to draw the cap, we have to find the box point at the start
      // edge of the second segment that is not inside the box determined by the first segment.
      // This is the point that is further away from the center of the first box.
      double xx = (x2 + x1) / 2.0;
      double yy = (y2 + y1) / 2.0;
      double zz = (z2 + z1) / 2.0;
      double x21 = x2 + vx4;
      double y21 = y2 + vy4;
      double z21 = z2 + vz4;
      double x22 = x2 - vx4;
      double y22 = y2 - vy4;
      double z22 = z2 - vz4;
      double distance1 = sqrt(pow(x21 - xx, 2) + pow(y21 - yy, 2) + pow(z21 - zz, 2));

      if (distance1 > sqrt(pow(x22 - xx, 2) + pow(y22 - yy, 2) + pow(z22 - zz, 2)))
        {
          xx = (x3 + x2) / 2.0;
          yy = (y3 + y2) / 2.0;
          zz = (y3 + y2) / 2.0;
          double x23 = x2 + vx2;
          double y23 = y2 + vy2;
          double z23 = z2 + vz2;
          x22 = x2 - vx2;
          y22 = y2 - vy2;
          z22 = z2 - vz2;
          double distance1 = sqrt(pow(x23 - xx, 2) + pow(y23 - yy, 2) + pow(z23 - zz, 2));

          if (distance1 > sqrt(pow(x22 - xx, 2) + pow(y22 - yy, 2) + pow(z22 - zz, 2)))
            {
              if (angle < M_PI / 2.0 && (length3 > length && length3 > length2))
                {
                  glBegin(GL_TRIANGLES);
                  glVertex3d(x2, y2, z2);
                  glVertex3d(x21, y21, z21);
                  glVertex3d(x23, y23, z23);
                  glEnd();
                }
              else
                {
                  // we need to draw two triangles
                  const CLPoint* pP = CLLayoutRenderer::calculate_intersection(x21, y21, z21, vx3, vy3, vz3, x23, y23, z23, vx1, vy1, vz1);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3d(pP->getX(), pP->getY(), pP->getZ());
                  glVertex3d(x21, y21, z21);
                  glVertex3d(x2, y2, z2);
                  glVertex3d(x23, y23, z23);
                  glEnd();
                  delete pP;
                }
            }
          else
            {
              if (angle < M_PI / 2.0 && (length3 > length && length3 > length2))
                {
                  glBegin(GL_TRIANGLES);
                  glVertex3d(x2, y2, z2);
                  glVertex3d(x21, y21, z21);
                  glVertex3d(x22, y22, z22);
                  glEnd();
                }
              else
                {
                  // we need to draw two triangles
                  const CLPoint* pP = CLLayoutRenderer::calculate_intersection(x21, y21, z21, vx3, vy3, vz3, x22, y22, z22, vx1, vy1, vz1);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3d(pP->getX(), pP->getY(), pP->getZ());
                  glVertex3d(x21, y21, z21);
                  glVertex3d(x2, y2, z2);
                  glVertex3d(x22, y22, z22);
                  glEnd();
                  delete pP;
                }
            }
        }
      else
        {
          xx = (x3 + x2) / 2.0;
          yy = (y3 + y2) / 2.0;
          zz = (y3 + y2) / 2.0;
          double x23 = x2 + vx2;
          double y23 = y2 + vy2;
          double z23 = z2 + vz2;
          x21 = x2 - vx2;
          y21 = y2 - vy2;
          z21 = z2 - vz2;
          double distance1 = sqrt(pow(x23 - xx, 2) + pow(y23 - yy, 2) + pow(z23 - zz, 2));

          if (distance1 > sqrt(pow(x21 - xx, 2) + pow(y21 - yy, 2) + pow(z21 - zz, 2)))
            {
              if (angle < M_PI / 2.0 && length3 > length && length3 > length2)
                {
                  glBegin(GL_TRIANGLES);
                  glVertex3d(x2, y2, z2);
                  glVertex3d(x22, y22, z22);
                  glVertex3d(x23, y23, z23);
                  glEnd();
                }
              else
                {
                  // we need to draw two triangles
                  const CLPoint* pP = CLLayoutRenderer::calculate_intersection(x22, y22, z22, vx3, vy3, vz3, x23, y23, z23, vx1, vy1, vz1);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3d(pP->getX(), pP->getY(), pP->getZ());
                  glVertex3d(x22, y22, z22);
                  glVertex3d(x2, y2, z2);
                  glVertex3d(x23, y23, z23);
                  glEnd();
                  delete pP;
                }
            }
          else
            {
              if (angle < M_PI / 2.0 && length3 > length && length3 > length2)
                {
                  glBegin(GL_TRIANGLES);
                  glVertex3d(x2, y2, z2);
                  glVertex3d(x22, y22, z22);
                  glVertex3d(x21, y21, z21);
                  glEnd();
                }
              else
                {
                  // we need to draw two triangles
                  const CLPoint* pP = CLLayoutRenderer::calculate_intersection(x22, y22, z22, vx3, vy3, vz3, x21, y21, z21, vx1, vy1, vz1);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3d(pP->getX(), pP->getY(), pP->getZ());
                  glVertex3d(x22, y22, z22);
                  glVertex3d(x2, y2, z2);
                  glVertex3d(x21, y21, z21);
                  glEnd();
                  delete pP;
                }
            }
        }
    }
}

void CLLayoutRenderer::draw_curve ( const CLCurve *  pCurve, bool  drawBasepoints = false  )

protected

Method that draws a curve from the layout extension. All the other parameter like color, linewidth etc. have to be set before.

Definition at line 353 of file CLLayoutRenderer.cpp.

References calculate_cubicbezier(), createGLMatrix(), draw_line(), CLLineSegment::getBase1(), CLLineSegment::getBase2(), CLLineSegment::getEnd(), CLTransformation::getIdentityMatrix(), CLCurve::getNumCurveSegments(), CLCurve::getSegmentAt(), CLLineSegment::getStart(), CLPoint::getX(), CLPoint::getY(), CLPoint::getZ(), CLLineSegment::isBezier(), CLRGBAColor::mA, map_arrow_head(), CLRGBAColor::mB, mColorMap, mCurrentAttributes, CLGroupAttributes::mEndHead, CLRGBAColor::mG, CLGroupAttributes::mpTransform, CLRGBAColor::mR, CLGroupAttributes::mStartHead, CLGroupAttributes::mStroke, CLGroupAttributes::mStrokeWidth, simple_point::mX, CLGroupAttributes::mX, simple_point::mY, simple_point::mZ, NUM_BEZIER_POINTS, and NUM_CIRCLE_SEGMENTS.

Referenced by draw_group(), and draw_layout().

{
  // set some attributes from mCurrentAttributes (stroke, stroke_width,
  // stroke_dasharray)
  std::map<std::string, CLRGBAColor>::const_iterator pos = this->mColorMap.find(mCurrentAttributes.mStroke);
  assert(pos != this->mColorMap.end());
  const CLRGBAColor& c = pos->second;
  glColor4ub(c.mR, c.mG, c.mB, c.mA);
  size_t i, iMax = pCurve->getNumCurveSegments();
  const CLLineSegment* pLineSegment = NULL;
  // apply the current transformation
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();

  if (memcmp(mCurrentAttributes.mpTransform, CLTransformation::getIdentityMatrix(), 12 * sizeof(double)))
    {
      // move back to the current offset
      glTranslated(this->mCurrentAttributes.mX, this->mCurrentAttributes.mY, this->mCurrentAttributes.mZ);
      GLdouble* matrix = new GLdouble[16];
      CLLayoutRenderer::createGLMatrix(mCurrentAttributes.mpTransform, matrix);
      glMultMatrixd(matrix);
      delete[] matrix;
      // move to 0.0,0.0,0.0
      glTranslated(-this->mCurrentAttributes.mX, -this->mCurrentAttributes.mY, -this->mCurrentAttributes.mZ);
    }

  // calculate the data points
  std::vector<simple_point> v;
  simple_point p;
  const CLPoint* pP;
  const CLPoint* pP2, *pP3, *pP4;
  GLdouble* pData = NULL;
  CLPoint lastEnd;
  double delta_phi = 2 * M_PI / NUM_CIRCLE_SEGMENTS;
  double phi = 0.0;
  GLdouble* pCircleData = NULL;

  // if we need to draw the basepoints of a curve,
  // we calculate the circle points here.
  // TODO We could actually move this code somewhere else and
  // TODO calculate it only once at startup, but for now this works well enough
  if (drawBasepoints == true)
    {
      pCircleData = new GLdouble[3 * (NUM_CIRCLE_SEGMENTS + 2)];
      pCircleData[0] = 0.0;
      pCircleData[1] = 0.0;
      pCircleData[2] = 0.0;

      for (i = 1; i <= NUM_CIRCLE_SEGMENTS; ++i)
        {
          phi = i * delta_phi;
          pCircleData[i * 3] = cos(phi);
          pCircleData[i * 3 + 1] = sin(phi);
          pCircleData[i * 3 + 2] = 0.0;
        }

      // close the circle
      pCircleData[i * 3] = pCircleData[3];
      pCircleData[i * 3 + 1] = pCircleData[4];
      pCircleData[i * 3 + 2] = pCircleData[5];
    }

  for (i = 0; i < iMax; ++i)
    {
      pLineSegment = pCurve->getSegmentAt(i);

      if (pLineSegment->isBezier())
        {
          pP = &pLineSegment->getStart();

          // check if we have a break in the line
          if (i != 0 && !((*pP) == lastEnd))
            {
              // draw the lines the are currently in v and clear v
              iMax = v.size();

              if (iMax > 1)
                {
                  pData = new GLdouble[3 * iMax];
                  size_t index = 0;
                  const simple_point* pSimple = NULL;

                  for (i = 0; i < iMax; ++i)
                    {
                      pSimple = &v[i];
                      pData[index++] = pSimple->mX;
                      pData[index++] = pSimple->mY;
                      pData[index++] = pSimple->mZ;
                    }

                  // draw the line
                  this->draw_line(iMax, pData);
                  delete[] pData;
                }

              v.clear();
            }

          pP2 = &pLineSegment->getEnd();
          lastEnd = *pP2;
          pP3 = &pLineSegment->getBase1();
          pP4 = &pLineSegment->getBase2();
          pData = new GLdouble[3 * NUM_BEZIER_POINTS];
          CLLayoutRenderer::calculate_cubicbezier(pP->getX(), pP->getY(), pP->getZ(),
                                                  pP3->getX(), pP3->getY(), pP3->getZ(),
                                                  pP4->getX(), pP4->getY(), pP4->getZ(),
                                                  pP2->getX(), pP2->getY(), pP2->getZ(),
                                                  NUM_BEZIER_POINTS, pData);
          size_t j;
          size_t index = 0;

          for (j = 0; j < NUM_BEZIER_POINTS; ++j)
            {
              p.mX = pData[index++];
              p.mY = pData[index++];
              p.mZ = pData[index++];
              v.push_back(p);
            }

          delete[] pData;

          // draw the base points if requested
          if (drawBasepoints == true)
            {
              // we have to draw four circles in the same color as the line,
              // but a little wider
              if (mCurrentAttributes.mStroke != "none" && mCurrentAttributes.mStrokeWidth > 0.0)
                {
                  size_t j;
                  std::map<std::string, CLRGBAColor>::const_iterator pos = this->mColorMap.find(mCurrentAttributes.mStroke);
                  const CLRGBAColor& c = pos->second;
                  glColor4ub(c.mR, c.mG, c.mB, c.mA);
                  glPushMatrix();
                  glTranslated(pP->getX(), pP->getY(), pP->getZ());
                  glScaled(mCurrentAttributes.mStrokeWidth * 2.0, mCurrentAttributes.mStrokeWidth * 2.0, 1.0);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3f(0.0, 0.0, 0.0);

                  for (j = 0; j <= NUM_CIRCLE_SEGMENTS + 1; ++j)
                    {
                      glVertex3d(pCircleData[3 * j], pCircleData[3 * j + 1], pCircleData[3 * j + 2]);
                    }

                  glEnd();
                  glPopMatrix();
                  glPushMatrix();
                  glTranslated(pP2->getX(), pP2->getY(), pP2->getZ());
                  glScaled(mCurrentAttributes.mStrokeWidth * 2.0, mCurrentAttributes.mStrokeWidth * 2.0, 1.0);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3d(0.0, 0.0, 0.0);

                  for (j = 0; j <= NUM_CIRCLE_SEGMENTS + 1; ++j)
                    {
                      glVertex3d(pCircleData[3 * j], pCircleData[3 * j + 1], pCircleData[3 * j + 2]);
                    }

                  glEnd();
                  glPopMatrix();
                  glPushMatrix();
                  glTranslated(pP3->getX(), pP3->getY(), pP3->getZ());
                  glScaled(mCurrentAttributes.mStrokeWidth * 2.0, mCurrentAttributes.mStrokeWidth * 2.0, 1.0);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3d(0.0, 0.0, 0.0);

                  for (j = 0; j <= NUM_CIRCLE_SEGMENTS + 1; ++j)
                    {
                      glVertex3d(pCircleData[3 * j], pCircleData[3 * j + 1], pCircleData[3 * j + 2]);
                    }

                  glEnd();
                  glPopMatrix();
                  glPushMatrix();
                  glTranslated(pP4->getX(), pP4->getY(), pP4->getZ());
                  glScaled(mCurrentAttributes.mStrokeWidth * 2.0, mCurrentAttributes.mStrokeWidth * 2.0, 1.0);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3d(0.0, 0.0, 0.0);

                  for (j = 0; j <= NUM_CIRCLE_SEGMENTS + 1; ++j)
                    {
                      glVertex3d(pCircleData[3 * j], pCircleData[3 * j + 1], pCircleData[3 * j + 2]);
                    }

                  glEnd();
                  glPopMatrix();
                }
            }
        }
      else
        {
          const CLPoint* pP = &pLineSegment->getStart();

          if (i != 0 && !((*pP) == lastEnd))
            {
              // draw the lines that are currently in v and clear v
              iMax = v.size();

              if (iMax > 1)
                {
                  pData = new GLdouble[3 * iMax];
                  size_t index = 0;
                  const simple_point* pSimple = NULL;

                  for (i = 0; i < iMax; ++i)
                    {
                      pSimple = &v[i];
                      pData[index++] = pSimple->mX;
                      pData[index++] = pSimple->mY;
                      pData[index++] = pSimple->mZ;
                    }

                  // draw the line
                  this->draw_line(iMax, pData);
                  delete[] pData;
                }
            }

          p.mX = pP->getX();
          p.mY = pP->getY();
          p.mZ = pP->getZ();
          v.push_back(p);

          if (drawBasepoints == true)
            {
              // we have to draw four circles in the same color as the line,
              // but a little wider
              if (mCurrentAttributes.mStroke != "none" && mCurrentAttributes.mStrokeWidth > 0.0)
                {
                  std::map<std::string, CLRGBAColor>::const_iterator pos = this->mColorMap.find(mCurrentAttributes.mStroke);
                  const CLRGBAColor& c = pos->second;
                  glColor4ub(c.mR, c.mG, c.mB, c.mA);
                  glPushMatrix();
                  glTranslated(pP->getX(), pP->getY(), pP->getZ());
                  glScaled(mCurrentAttributes.mStrokeWidth * 2.0, mCurrentAttributes.mStrokeWidth * 2.0, 1.0);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3d(0.0, 0.0, 0.0);
                  size_t j;

                  for (j = 0; j <= NUM_CIRCLE_SEGMENTS + 1; ++j)
                    {
                      glVertex3d(pCircleData[3 * j], pCircleData[3 * j + 1], pCircleData[3 * j + 2]);
                    }

                  glEnd();
                  glPopMatrix();
                }
            }

          pP = &pLineSegment->getEnd();
          lastEnd = *pP;
          p.mX = pP->getX();
          p.mY = pP->getY();
          p.mZ = pP->getZ();
          v.push_back(p);

          if (drawBasepoints == true)
            {
              // we have to draw four circles in the same color as the line,
              // but a little wider
              if (mCurrentAttributes.mStroke != "none" && mCurrentAttributes.mStrokeWidth > 0.0)
                {
                  std::map<std::string, CLRGBAColor>::const_iterator pos = this->mColorMap.find(mCurrentAttributes.mStroke);
                  const CLRGBAColor& c = pos->second;
                  glColor4ub(c.mR, c.mG, c.mB, c.mA);
                  glPushMatrix();
                  glTranslated(pP->getX(), pP->getY(), pP->getZ());
                  glScaled(mCurrentAttributes.mStrokeWidth * 2.0, mCurrentAttributes.mStrokeWidth * 2.0, 1.0);
                  glBegin(GL_TRIANGLE_FAN);
                  glVertex3d(0.0, 0.0, 0.0);
                  size_t j;

                  for (j = 0; j <= NUM_CIRCLE_SEGMENTS + 1; ++j)
                    {
                      glVertex3d(pCircleData[3 * j], pCircleData[3 * j + 1], pCircleData[3 * j + 2]);
                    }

                  glEnd();
                  glPopMatrix();
                }
            }
        }
    }

  iMax = v.size();

  if (iMax > 1)
    {
      pData = new GLdouble[3 * iMax];
      size_t index = 0;
      const simple_point* pSimple = NULL;

      for (i = 0; i < iMax; ++i)
        {
          pSimple = &v[i];
          pData[index++] = pSimple->mX;
          pData[index++] = pSimple->mY;
          pData[index++] = pSimple->mZ;
        }

      // draw the line
      this->draw_line(iMax, pData);
      delete[] pData;

      if (drawBasepoints == true)
        {
          // we have to draw four circles in the same color as the line,
          // but a little wider
          if (mCurrentAttributes.mStroke != "none" && mCurrentAttributes.mStrokeWidth > 0.0)
            {
              std::map<std::string, CLRGBAColor>::const_iterator pos = this->mColorMap.find(mCurrentAttributes.mStroke);
              const CLRGBAColor& c = pos->second;
              glColor4ub(c.mR, c.mG, c.mB, c.mA);
              glPushMatrix();
              glTranslated(pSimple->mX, pSimple->mY, pSimple->mZ);
              glScaled(mCurrentAttributes.mStrokeWidth, mCurrentAttributes.mStrokeWidth, 1.0);
              glBegin(GL_TRIANGLE_FAN);
              glVertex3d(0.0, 0.0, 0.0);
              size_t j;

              for (j = 0; j <= NUM_CIRCLE_SEGMENTS + 1; ++j)
                {
                  glVertex3d(pCircleData[3 * j], pCircleData[3 * j + 1], pCircleData[3 * j + 2]);
                }

              glEnd();
              glPopMatrix();
            }
        }
    }

  if (pCircleData != NULL) delete[] pCircleData;

  if (!mCurrentAttributes.mStartHead.empty() && mCurrentAttributes.mStartHead != "none")
    {
      const CLLineSegment* pLS = pCurve->getSegmentAt(0);
      const CLPoint* pP = &pLS->getStart();
      CLPoint v;

      if (!pLS->isBezier())
        {
          v = CLPoint(pLS->getStart().getX() - pLS->getEnd().getX(), pLS->getStart().getY() - pLS->getEnd().getY(), pLS->getStart().getZ() - pLS->getEnd().getZ());
        }
      else
        {
          v = CLPoint(pLS->getStart().getX() - pLS->getBase1().getX(), pLS->getStart().getY() - pLS->getBase1().getY(), pLS->getStart().getZ() - pLS->getBase1().getZ());
        }

      this->map_arrow_head(*pP, v, mCurrentAttributes.mStartHead);
    }

  if (!mCurrentAttributes.mEndHead.empty() && mCurrentAttributes.mEndHead != "none")
    {
      const CLLineSegment* pLS = pCurve->getSegmentAt(pCurve->getNumCurveSegments() - 1);
      const CLPoint* pP = &pLS->getEnd();
      CLPoint v;

      if (!pLS->isBezier())
        {
          v = CLPoint(pLS->getEnd().getX() - pLS->getStart().getX(), pLS->getEnd().getY() - pLS->getStart().getY(), pLS->getEnd().getZ() - pLS->getStart().getZ());
        }
      else
        {
          v = CLPoint(pLS->getEnd().getX() - pLS->getBase2().getX(), pLS->getEnd().getY() - pLS->getBase2().getY(), pLS->getEnd().getZ() - pLS->getBase2().getZ());
        }

      this->map_arrow_head(*pP, v, mCurrentAttributes.mEndHead);
    }

  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
}

void CLLayoutRenderer::draw_curve ( const CLRenderCurve *  pCurve, const CLBoundingBox *  pBB  )

protected

Method that draws a curve from the render extension. All the other parameter like color, linewidth etc. have to be set before.

Definition at line 729 of file CLLayoutRenderer.cpp.

References CLRenderCubicBezier::basePoint1_X(), CLRenderCubicBezier::basePoint1_Y(), CLRenderCubicBezier::basePoint1_Z(), CLRenderCubicBezier::basePoint2_X(), CLRenderCubicBezier::basePoint2_Y(), CLRenderCubicBezier::basePoint2_Z(), calculate_cubicbezier(), convert_to_absolute(), createGLMatrix(), draw_line(), extract_1d_attributes(), extract_arrowhead_information(), CLRenderCurve::getCurveElement(), CLTransformation::getIdentityMatrix(), CLRenderCurve::getNumElements(), CLPoint::getX(), CLPoint::getY(), CLPoint::getZ(), map_arrow_head(), mColorMap, mCurrentAttributes, CLGroupAttributes::mEndHead, CLGroupAttributes::mpTransform, CLGroupAttributes::mStartHead, CLGroupAttributes::mStroke, simple_point::mX, CLGroupAttributes::mX, simple_point::mY, simple_point::mZ, NUM_BEZIER_POINTS, restore_current_attributes(), save_current_attributes(), CLRenderPoint::x(), CLRenderPoint::y(), and CLRenderPoint::z().

{
  if (!pBB || !pCurve || pCurve->getNumElements() <= 0) return;

  this->save_current_attributes();
  CLLayoutRenderer::extract_1d_attributes(pCurve, &mCurrentAttributes);
  CLLayoutRenderer::extract_arrowhead_information(pCurve, &mCurrentAttributes);
  // apply the current transformation
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();

  if (memcmp(mCurrentAttributes.mpTransform, CLTransformation::getIdentityMatrix(), 12 * sizeof(double)))
    {
      // move back to the current offset
      glTranslated(this->mCurrentAttributes.mX, this->mCurrentAttributes.mY, this->mCurrentAttributes.mZ);
      GLdouble* matrix = new GLdouble[16];
      CLLayoutRenderer::createGLMatrix(mCurrentAttributes.mpTransform, matrix);
      glMultMatrixd(matrix);
      delete[] matrix;
      // move to 0.0,0.0,0.0
      glTranslated(-this->mCurrentAttributes.mX, -this->mCurrentAttributes.mY, -this->mCurrentAttributes.mZ);
    }

  // set some attributes from mCurrentAttributes (stroke, stroke_width,
  // stroke_dasharray)
  if (this->mCurrentAttributes.mStroke != "none")
    {
      std::map<std::string, CLRGBAColor>::const_iterator pos = this->mColorMap.find(mCurrentAttributes.mStroke);
      assert(pos != this->mColorMap.end());
      const CLRGBAColor& c = pos->second;
      glColor4ub(c.mR, c.mG, c.mB, c.mA);
      size_t i, iMax = pCurve->getNumElements();
      CLRenderPoint start, end, bp1, bp2;
      CLPoint p1, p2, p3, p4;
      const CLRenderPoint* pP = NULL;
      const CLRenderCubicBezier* pCB = NULL;
      // the first one has to be a point
      const CLRenderPoint* pStart = pCurve->getCurveElement(0);
      p1 = convert_to_absolute(pStart, pBB);
      std::vector<simple_point> v;
      // there are going to be at least iMax elements in the vector
      v.reserve(iMax);
      simple_point p;
      p.mX = p1.getX();
      p.mY = p1.getY();
      p.mZ = p1.getZ();
      v.push_back(p);
      GLdouble* pData = NULL;

      for (i = 1; i < iMax; ++i)
        {
          pP = pCurve->getCurveElement(i);
          pCB = dynamic_cast<const CLRenderCubicBezier*>(pP);

          if (pCB != NULL)
            {
              end = CLRenderPoint(pCB->x(), pCB->y(), pCB->z());
              bp1 = CLRenderPoint(pCB->basePoint1_X(), pCB->basePoint1_Y(), pCB->basePoint1_Z());
              bp2 = CLRenderPoint(pCB->basePoint2_X(), pCB->basePoint2_Y(), pCB->basePoint2_Z());
              p2 = convert_to_absolute(&end, pBB);
              p3 = convert_to_absolute(&bp1, pBB);
              p4 = convert_to_absolute(&bp2, pBB);
              pData = new GLdouble[3 * NUM_BEZIER_POINTS];
              CLLayoutRenderer::calculate_cubicbezier(p1.getX(), p1.getY(), p1.getZ(),
                                                      p3.getX(), p3.getY(), p3.getZ(),
                                                      p4.getX(), p4.getY(), p4.getZ(),
                                                      p2.getX(), p2.getY(), p2.getZ(),
                                                      NUM_BEZIER_POINTS, pData);
              size_t j;
              size_t index = 0;

              for (j = 0; j < NUM_BEZIER_POINTS; ++j)
                {
                  p.mX = pData[index++];
                  p.mY = pData[index++];
                  p.mZ = pData[index++];
                  v.push_back(p);
                }

              delete[] pData;
            }
          else
            {
              end = CLRenderPoint(pP->x(), pP->y(), pP->z());
              p2 = convert_to_absolute(&end, pBB);
              p.mX = p2.getX();
              p.mY = p2.getY();
              p.mZ = p2.getZ();
              v.push_back(p);
            }

          // this end is the next start
          p1 = p2;
        }

      iMax = v.size();

      if (iMax > 1)
        {
          pData = new GLdouble[3 * iMax];
          size_t index = 0;
          const simple_point* pSimple = NULL;

          for (i = 0; i < iMax; ++i)
            {
              pSimple = &v[i];
              pData[index++] = pSimple->mX;
              pData[index++] = pSimple->mY;
              pData[index++] = pSimple->mZ;
            }

          // draw the line
          this->draw_line(iMax, pData);
          delete[] pData;
        }

      // map arrow heads
      if (!mCurrentAttributes.mStartHead.empty() && mCurrentAttributes.mStartHead != "none")
        {
          assert(pCurve->getNumElements() > 1);
          const CLRenderPoint* pStart = pCurve->getCurveElement(0);
          const CLPoint start = convert_to_absolute(pStart, pBB);
          CLPoint v;
          const CLRenderPoint* pEnd = pCurve->getCurveElement(1);
          const CLRenderCubicBezier* pCB = dynamic_cast<const CLRenderCubicBezier*>(pEnd);

          if (!pCB)
            {
              const CLPoint end = convert_to_absolute(pEnd, pBB);
              v = CLPoint(start.getX() - end.getX(), start.getY() - end.getY(), start.getZ() - end.getZ());
            }
          else
            {
              const CLRenderPoint* pEnd = new CLRenderPoint(pCB->basePoint1_X(), pCB->basePoint1_Y(), pCB->basePoint1_Z());
              const CLPoint end = convert_to_absolute(pEnd, pBB);
              delete pEnd;
              v = CLPoint(start.getX() - end.getX(), start.getY() - end.getY(), start.getZ() - end.getZ());
            }

          // we have to clear the arrow head attributes before we call the mapping
          // function.
          // If we don't do that and the line ending contains a curve, it will try
          // to map itself to the curve again which is an endless loop.
          this->save_current_attributes();
          std::string headId = mCurrentAttributes.mStartHead;
          this->map_arrow_head(start, v, headId);
          // set the old attributes again
          this->restore_current_attributes();
        }

      if (!mCurrentAttributes.mEndHead.empty() && mCurrentAttributes.mEndHead != "none")
        {
          const CLRenderPoint* pEnd = pCurve->getCurveElement(pCurve->getNumElements() - 1);
          const CLPoint end = convert_to_absolute(pEnd, pBB);

          const CLRenderCubicBezier* pCB = dynamic_cast<const CLRenderCubicBezier*>(pEnd);
          CLPoint v;

          if (!pCB)
            {
              const CLRenderPoint* pStart = pCurve->getCurveElement(pCurve->getNumElements() - 2);
              const CLPoint start = convert_to_absolute(pStart, pBB);
              v = CLPoint(end.getX() - start.getX(), end.getY() - start.getY(), end.getZ() - start.getZ());
            }
          else
            {
              const CLRenderPoint* pStart = new CLRenderPoint(pCB->basePoint2_X(), pCB->basePoint2_Y(), pCB->basePoint2_Z());
              const CLPoint start = convert_to_absolute(pStart, pBB);
              delete pStart;
              v = CLPoint(end.getX() - start.getX(), end.getY() - start.getY(), end.getZ() - start.getZ());
            }

          // we have to clear the arrow head attributes before we call the mapping
          // function.
          // If we don't do that and the line ending contains a curve, it will try
          // to map itself to the curve again which is an endless loop.
          this->save_current_attributes();
          std::string headId = mCurrentAttributes.mEndHead;
          this->map_arrow_head(end, v, headId);
          // set the old attributes again
          this->restore_current_attributes();
        }
    }

  this->restore_current_attributes();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
}

void CLLayoutRenderer::draw_datapoints ( GLdouble *  pData, size_t  numPoints, const CLBoundingBox *  pBB, bool  doTesselation = false, float  xOffset = 0.0, float  yOffset = 0.0, float  zOffset = 0.0  )

protected

Draw a set of datapoints with the current attributes using the given bounding box.

Method to draw a render polygon from a set of datapoints

Definition at line 2693 of file CLLayoutRenderer.cpp.

References COMBINE_CALLBACK(), COMBINE_CALLBACK_GRADIENT(), createGLMatrix(), draw_cap(), draw_line(), CLGraphicalPrimitive2D::EVENODD, CCopasiMessage::EXCEPTION, CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLGraphicalPrimitive2D::INHERIT, CLRGBAColor::mA, CLRGBAColor::mB, mColorMap, mCurrentAttributes, CLGroupAttributes::mFill, CLGroupAttributes::mFillRule, CLRGBAColor::mG, mGradientMap, CLGroupAttributes::mpTransform, CLRGBAColor::mR, CLGroupAttributes::mStroke, CLGroupAttributes::mStrokeWidth, CLGroupAttributes::mX, CLGraphicalPrimitive2D::NONZERO, TESS_ERROR(), CLGraphicalPrimitive2D::UNSET, and VERTEX_CALLBACK_GRADIENT().

Referenced by draw_ellipse(), draw_polygon(), and draw_rectangle().

{
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glTranslatef(xOffset, yOffset, zOffset);

  // apply the current transformation
  if (memcmp(mCurrentAttributes.mpTransform, Transformation::getIdentityMatrix(), 12 * sizeof(double)))
    {
      // move back to the current offset
      glTranslated(this->mCurrentAttributes.mX, this->mCurrentAttributes.mY, this->mCurrentAttributes.mZ);
      GLdouble* matrix = new GLdouble[16];
      CLLayoutRenderer::createGLMatrix(mCurrentAttributes.mpTransform, matrix);
      glMultMatrixd(matrix);
      delete[] matrix;
      // move to 0.0,0.0,0.0
      glTranslated(-this->mCurrentAttributes.mX, -this->mCurrentAttributes.mY, -this->mCurrentAttributes.mZ);
    }

  // draw the rectangle
  // first we draw the filled part
  if (this->mCurrentAttributes.mFillRule != CLGraphicalPrimitive2D::UNSET && this->mCurrentAttributes.mFill != "none")
    {

      // tesselate the polygon to make sure that it is drawn correctly by
      // OpenGL
      GLUtesselator* pTess = NULL;

      if (doTesselation)
        {
          pTess = gluNewTess();
        }

      bool singleColor = true;
      // set the stepsize for the datapoints to 3
      // which means that the data array only contains vertex information
      // if we have a gradient, we have to set it to 5 later on
      // because the data now contains texture coordinates as well
      unsigned int stepsize = 3;
      GLdouble* pOrigData = pData;
      GLdouble* pNewData = NULL;
      std::map<std::string, CLRGBAColor>::const_iterator pos = this->mColorMap.find(mCurrentAttributes.mFill);

      if (pos != this->mColorMap.end())
        {
          const CLRGBAColor& c = pos->second;
          glColor4ub(c.mR, c.mG, c.mB, c.mA);
        }
      else
        {
          singleColor = false;
          // enable tesselation if a gradient is specified
          pTess = gluNewTess();
          // it could be a gradient
          std::map<std::string, std::pair<const CLGradientBase*, CLTextureSpec*> >::const_iterator pos = this->mGradientMap.find(mCurrentAttributes.mFill);
          assert(pos != this->mGradientMap.end());
          const CLTextureSpec* pTexSpec = pos->second.second;
          assert(pTexSpec != NULL);
          unsigned int i;
#ifdef _WIN32
          gluTessCallback(pTess, GLU_TESS_BEGIN, (GLvoid(__stdcall *)())glBegin);
          gluTessCallback(pTess, GLU_TESS_END, glEnd);
          gluTessCallback(pTess, GLU_TESS_VERTEX, (GLvoid(__stdcall *)())CLLayoutRenderer::VERTEX_CALLBACK_GRADIENT);
          gluTessCallback(pTess, GLU_TESS_COMBINE, (GLvoid(__stdcall *)())CLLayoutRenderer::COMBINE_CALLBACK_GRADIENT);
#else
          gluTessCallback(pTess, GLU_TESS_BEGIN, (GLvoid(*)())glBegin);
          gluTessCallback(pTess, GLU_TESS_END, glEnd);
          gluTessCallback(pTess, GLU_TESS_VERTEX, (GLvoid(*)())CLLayoutRenderer::VERTEX_CALLBACK_GRADIENT);
          gluTessCallback(pTess, GLU_TESS_COMBINE, (GLvoid(*)())CLLayoutRenderer::COMBINE_CALLBACK_GRADIENT);
#endif // _WIN32
          stepsize = 5;
          pNewData = new GLdouble[5 * numPoints];
          // assign the texture coordinates
          double width = pBB->getDimensions().getWidth();
          double height = pBB->getDimensions().getHeight();

          for (i = 0; i < numPoints; ++i)
            {
              pNewData[5 * i] = pData[3 * i];
              pNewData[5 * i + 1] = pData[3 * i + 1];
              pNewData[5 * i + 2] = pData[3 * i + 2];
              pNewData[5 * i + 3] = (pData[3 * i] + xOffset - pBB->getPosition().getX()) / width;
              pNewData[5 * i + 4] = (pData[3 * i + 1] + yOffset - pBB->getPosition().getY()) / height;
            }

          pData = pNewData;

          // load the texture
          if (pTexSpec->mTextureName != 0)
            {
              glBindTexture(GL_TEXTURE_2D, pTexSpec->mTextureName);
              // enable 2D texturing
              glEnable(GL_TEXTURE_2D);
            }

          /*
          else
          {
              std::cerr << "Texture not bound." << std::endl;
          }
          */
        }

      if (pTess && singleColor)
        {
          // we don't need to do anythong special during the tesselation since
          // the whole object only has one color
#ifdef _WIN32
          gluTessCallback(pTess, GLU_TESS_BEGIN, (GLvoid(__stdcall *)())glBegin);
          gluTessCallback(pTess, GLU_TESS_END, (GLvoid(__stdcall *)())glEnd);
          gluTessCallback(pTess, GLU_TESS_VERTEX, (GLvoid(__stdcall *)())glVertex3dv);
          gluTessCallback(pTess, GLU_TESS_COMBINE, (GLvoid(__stdcall *)())CLLayoutRenderer::COMBINE_CALLBACK);
#else
          gluTessCallback(pTess, GLU_TESS_BEGIN, (GLvoid(*)())glBegin);
          gluTessCallback(pTess, GLU_TESS_END, (GLvoid(*)())glEnd);
          gluTessCallback(pTess, GLU_TESS_VERTEX, (GLvoid(*)())glVertex3dv);
          gluTessCallback(pTess, GLU_TESS_COMBINE, (GLvoid(*)())CLLayoutRenderer::COMBINE_CALLBACK);
#endif // _WIN32
        }

      if (pTess)
        {
          // specify the fill rule to the tesselator EVENODD, NONZERO
          switch (this->mCurrentAttributes.mFillRule)
            {
              case CLGraphicalPrimitive2D::UNSET:
                // this should not happen
                CCopasiMessage(CCopasiMessage::EXCEPTION, "Invalid Render Information: No fill rule specified");
                break;

              case CLGraphicalPrimitive2D::NONZERO:
                gluTessProperty(pTess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO);
                break;

              case CLGraphicalPrimitive2D::EVENODD:
                gluTessProperty(pTess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
                break;

              case CLGraphicalPrimitive2D::INHERIT:
                // this should not happen
                // inherit has to be replaced by something meaningfull
                CCopasiMessage(CCopasiMessage::EXCEPTION, "Invalid Render Information: fill rule \"INHERIT\" specified");
                break;
            }

#ifdef _WIN32
          gluTessCallback(pTess, GLU_TESS_ERROR, (GLvoid(__stdcall *)())CLLayoutRenderer::TESS_ERROR);
#else
          gluTessCallback(pTess, GLU_TESS_ERROR, (GLvoid(*)())CLLayoutRenderer::TESS_ERROR);
#endif // _WIN32
          gluTessBeginPolygon(pTess, NULL);
          gluTessBeginContour(pTess);
          // specify the actual vertex data
          size_t j = 0, jMax = numPoints - 1;

          while (j < jMax)
            {
              gluTessVertex(pTess, &pData[j * stepsize], &pData[j * stepsize]);
              ++j;
            }

          gluTessEndContour(pTess);
          gluTessEndPolygon(pTess);
          gluDeleteTess(pTess);
          pData = pOrigData;

          if (pNewData)
            {
              delete[] pNewData;
            }
        }
      else
        {
          // it must be a single colored object, so we just draw the vertex array
          glEnableClientState(GL_VERTEX_ARRAY);
          glVertexPointer(3, GL_DOUBLE, 0, pData);
          glDrawArrays(GL_POLYGON, 0, (GLsizei)(numPoints - 1));
          glDisableClientState(GL_VERTEX_ARRAY);
        }

      if (!singleColor)
        {
          // disable texturing again
          glDisable(GL_TEXTURE_2D);
        }
    }

  //
  // next we draw the edge
  //
  if (this->mCurrentAttributes.mStrokeWidth > 0.0 && this->mCurrentAttributes.mStroke != "none")
    {
      std::map<std::string, CLRGBAColor>::const_iterator pos = this->mColorMap.find(mCurrentAttributes.mStroke);
      assert(pos != this->mColorMap.end());
      const CLRGBAColor& c = pos->second;
      glColor4ub(c.mR, c.mG, c.mB, c.mA);
      this->draw_line(numPoints, pData);
      // draw the final cap
      size_t index = (numPoints - 2) * 3;
      draw_cap(pData[index], pData[index + 1], pData[index + 2], pData[0], pData[1], pData[2], pData[3], pData[4], pData[5], mCurrentAttributes.mStrokeWidth);
    }

  glPopMatrix();
}

void CLLayoutRenderer::draw_ellipse ( const CLEllipse *  pEllipse, const CLBoundingBox *  pBB  )

protected

Method to draw a render ellipse object.

Definition at line 1659 of file CLLayoutRenderer.cpp.

References draw_datapoints(), extract_2d_attributes(), CLRelAbsVector::getAbsoluteValue(), CLEllipse::getCX(), CLEllipse::getCY(), CLEllipse::getCZ(), CLDimensions::getDepth(), CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLRelAbsVector::getRelativeValue(), CLEllipse::getRX(), CLEllipse::getRY(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLPoint::getZ(), mCurrentAttributes, NUM_CIRCLE_SEGMENTS, restore_current_attributes(), and save_current_attributes().

Referenced by draw_group().

{
  // store and change the attributes
  this->save_current_attributes();
  CLLayoutRenderer::extract_2d_attributes(pEllipse, &mCurrentAttributes);
  // draw the ellipse
  // first we calculate the data points for the ellipse
  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 z = pBB->getPosition().getZ() + pEllipse->getCZ().getAbsoluteValue() + pEllipse->getCZ().getRelativeValue() / 100.0 * pBB->getDimensions().getDepth();
  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();
  // we add an additional datapoint to close the loop. This way we don't need
  // the draw_loop method, but all is handled in draw_line
  // this also makes line stippling easier for OpenGL < 2.0
  GLdouble* pData = new GLdouble[3 * (NUM_CIRCLE_SEGMENTS + 1)];
  unsigned int i;
  double delta_phi = 2 * M_PI / NUM_CIRCLE_SEGMENTS;
  double phi = 0.0;
  size_t index = 0;

  for (i = 0; i < NUM_CIRCLE_SEGMENTS; ++i)
    {
      // TODO it would be enough to calculate only one quadrant
      phi = i * delta_phi;
      pData[index++] = rx * rx * cos(phi) / sqrt(rx * rx * pow(cos(phi), 2) + ry * ry * pow(sin(phi), 2));
      pData[index++] = ry * ry * sin(phi) / sqrt(rx * rx * pow(cos(phi), 2) + ry * ry * pow(sin(phi), 2));
      pData[index++] = 0.0;
    }

  // close the loop
  pData[index++] = pData[0];
  pData[index++] = pData[1];
  pData[index] = pData[2];
  this->draw_datapoints(pData, NUM_CIRCLE_SEGMENTS + 1, pBB, false, (GLfloat)x, (GLfloat)y, (GLfloat)z);
  delete[] pData;
  // restore the attributes
  this->restore_current_attributes();
}

void CLLayoutRenderer::draw_group ( const CLGroup *  pGroup, const CLBoundingBox *  pBB  )

protected

Method to draw an arbitrary object specified by it's bounding box and the style with which it should be drawn.

Definition at line 1346 of file CLLayoutRenderer.cpp.

References createGLMatrix(), draw_curve(), draw_ellipse(), draw_image(), draw_polygon(), draw_rectangle(), draw_text(), extract_group_attributes(), CLBoundingBox::getDimensions(), CLGroup::getElement(), CLDimensions::getHeight(), CLGroup::getNumElements(), CLBoundingBox::getPosition(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), CLPoint::getZ(), mCurrentAttributes, CLGroupAttributes::mHeight, CLGroupAttributes::mpTransform, CLGroupAttributes::mWidth, CLGroupAttributes::mX, CLGroupAttributes::mY, CLGroupAttributes::mZ, restore_current_attributes(), and save_current_attributes().

Referenced by draw_object(), and map_arrow_head().

{
  // set the group attributes
  this->save_current_attributes();
  CLLayoutRenderer::extract_group_attributes(pGroup, &mCurrentAttributes);
  mCurrentAttributes.mX = pBB->getPosition().getX();
  mCurrentAttributes.mY = pBB->getPosition().getY();
  mCurrentAttributes.mZ = pBB->getPosition().getZ();
  mCurrentAttributes.mWidth = pBB->getDimensions().getWidth();
  mCurrentAttributes.mHeight = pBB->getDimensions().getHeight();
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();

  // apply the current transformation
  if (memcmp(mCurrentAttributes.mpTransform, Transformation::getIdentityMatrix(), 12 * sizeof(double)))
    {
      // move back to the current offset
      glTranslated(this->mCurrentAttributes.mX, this->mCurrentAttributes.mY, this->mCurrentAttributes.mZ);
      GLdouble* matrix = new GLdouble[16];
      CLLayoutRenderer::createGLMatrix(mCurrentAttributes.mpTransform, matrix);
      glMultMatrixd(matrix);
      delete[] matrix;
      // move to 0.0,0.0,0.0
      glTranslated(-this->mCurrentAttributes.mX, -this->mCurrentAttributes.mY, -this->mCurrentAttributes.mZ);
    }

  // draw each element
  const CCopasiObject* pObject = NULL;
  size_t i, iMax = pGroup->getNumElements();

  for (i = 0; i < iMax; ++i)
    {
      pObject = pGroup->getElement(i);
      assert(pObject != NULL);
      // find out what kind of element it is
      const CLEllipse* pEllipse = dynamic_cast<const CLEllipse*>(pObject);

      if (pEllipse != NULL)
        {
          CLLayoutRenderer::draw_ellipse(pEllipse, pBB);
        }
      else
        {
          const CLGroup* pRenderGroup = dynamic_cast<const CLGroup*>(pObject);

          if (pRenderGroup != NULL)
            {
              CLLayoutRenderer::draw_group(pRenderGroup, pBB);
            }
          else
            {
              const CLImage* pImage = dynamic_cast<const CLImage*>(pObject);

              if (pImage != NULL)
                {
                  CLLayoutRenderer::draw_image(pImage, pBB);
                }
              else
                {
                  const CLPolygon* pPolygon = dynamic_cast<const CLPolygon*>(pObject);

                  if (pPolygon != NULL)
                    {
                      CLLayoutRenderer::draw_polygon(pPolygon, pBB);
                    }
                  else
                    {
                      const CLRectangle* pRectangle = dynamic_cast<const CLRectangle*>(pObject);

                      if (pRectangle != NULL)
                        {
                          CLLayoutRenderer::draw_rectangle(pRectangle, pBB);
                        }
                      else
                        {
                          const CLRenderCurve* pCurve = dynamic_cast<const CLRenderCurve*>(pObject);

                          if (pCurve != NULL)
                            {
                              CLLayoutRenderer::draw_curve(pCurve, pBB);
                            }
                          else
                            {
                              const CLText* pText = dynamic_cast<const CLText*>(pObject);

                              if (pText != NULL)
                                {
                                  CLLayoutRenderer::draw_text(pText, pBB);
                                }
                              else
                                {
                                  throw pObject;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

  // restore the attributes
  this->restore_current_attributes();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
}

void CLLayoutRenderer::draw_image ( const CLImage *  pImage, const CLBoundingBox *  pBB  )

protected

Method to draw a render image object.

Definition at line 1702 of file CLLayoutRenderer.cpp.

References convert_to_absolute(), createGLMatrix(), extract_transformation_attributes(), CLRelAbsVector::getAbsoluteValue(), CLBoundingBox::getDimensions(), CLImage::getHeight(), CLDimensions::getHeight(), CLImage::getImageReference(), CLRelAbsVector::getRelativeValue(), CLImage::getWidth(), CLDimensions::getWidth(), CLImage::getX(), CLImage::getY(), CLImage::isSetImageReference(), mBaseDir, mCurrentAttributes, mImageMap, mpImageTexturizer, CLGroupAttributes::mpTransform, CLTextureSpec::mTextureName, CLGroupAttributes::mX, restore_current_attributes(), and save_current_attributes().

Referenced by draw_group().

{
  // the ransformation attributes are the only ones that influence the
  // drawing of an image
  this->save_current_attributes();
  CLLayoutRenderer::extract_transformation_attributes(pImage, &mCurrentAttributes);
  // draw the actual image
  const CLTextureSpec* pTexture = NULL;

  if (pImage->isSetImageReference())
    {
      std::string reference = pImage->getImageReference();
      std::map<std::string, const CLTextureSpec*>::const_iterator pos = this->mImageMap.find(reference);

      if (pos == this->mImageMap.end())
        {
          // we need to create the texture
          if (this->mpImageTexturizer != NULL)
            {
              pTexture = (*this->mpImageTexturizer)(reference, this->mBaseDir);
              this->mImageMap[reference] = pTexture;
              pos = this->mImageMap.find(reference);
              assert(pos != this->mImageMap.end());
            }
        }

      assert(pos != this->mImageMap.end());
      pTexture = pos->second;
      //assert(pTexture);
    }

  if (pTexture)
    {
      // draw the texture in the correct place
      // load the texture
      assert(pTexture->mTextureName != 0);
      glBindTexture(GL_TEXTURE_2D, pTexture->mTextureName);
      const CLDimensions* d = &pBB->getDimensions();
      double width = pImage->getWidth().getAbsoluteValue() + pImage->getWidth().getRelativeValue() / 100.0 * d->getWidth();
      double height = pImage->getHeight().getAbsoluteValue() + pImage->getHeight().getRelativeValue() / 100.0 * d->getHeight();
      CLRenderPoint p(pImage->getX(), pImage->getY());
      CLPoint point = CLLayoutRenderer::convert_to_absolute(&p, pBB);
      // apply the current transformation
      glMatrixMode(GL_MODELVIEW);
      glPushMatrix();

      if (memcmp(mCurrentAttributes.mpTransform, Transformation::getIdentityMatrix(), 12 * sizeof(double)))
        {
          // move back to the current offset
          glTranslated(this->mCurrentAttributes.mX, this->mCurrentAttributes.mY, this->mCurrentAttributes.mZ);
          GLdouble* matrix = new GLdouble[16];
          CLLayoutRenderer::createGLMatrix(mCurrentAttributes.mpTransform, matrix);
          glMultMatrixd(matrix);
          delete[] matrix;
          // move to 0.0,0.0,0.0
          glTranslated(-this->mCurrentAttributes.mX, -this->mCurrentAttributes.mY, -this->mCurrentAttributes.mZ);
        }

      // enable 2D texturing
      glEnable(GL_TEXTURE_2D);
      glMatrixMode(GL_MODELVIEW);
      glPushMatrix();
      glTranslated(point.getX(), point.getY(), point.getZ());
      glBegin(GL_POLYGON);
      glTexCoord2d(0.0, 0.0);
      glVertex3d(0.0, 0.0, 0.0);
      glTexCoord2d(0.0, 1.0);
      glVertex3d(0.0, height, 0.0);
      glTexCoord2d(1.0, 1.0);
      glVertex3d(width, height, 0.0);
      glTexCoord2d(1.0, 0.0);
      glVertex3d(width, 0.0, 0.0);
      glEnd();
      glPopMatrix();
      // disable the 2D texture again
      glDisable(GL_TEXTURE_2D);
    }
  else
    {
      // TODO at least create some kind of error message
    }

  // restore the attributes
  this->restore_current_attributes();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();
}

void CLLayoutRenderer::draw_layout

(

)

Method to draw a given layout with a given render resolver.

Definition at line 939 of file CLLayoutRenderer.cpp.

References draw_curve(), draw_object(), draw_selection_box(), draw_text(), drawSelectionBox(), extract_group_attributes(), CLColorDefinition::getAlpha(), CLRenderResolver::getBackgroundColor(), CLColorDefinition::getBlue(), CLGraphicalObject::getBoundingBox(), CLGlyphWithCurve::getCurve(), getCurveBoundingBox(), CLayout::getDimensions(), CLBoundingBox::getDimensions(), CLColorDefinition::getGreen(), CLDimensions::getHeight(), CLGraphicalObject::getModelObject(), CLCurve::getNumCurveSegments(), CCopasiObject::getObjectParent(), CLBoundingBox::getPosition(), CLColorDefinition::getRed(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), GL_FOG_COORD, GL_FOG_COORD_SRC, initialize_gl_extension_functions(), mCurrentAttributes, mDrawables, mFogColor, mFogDensity, mGLFunctionsInitialized, CLGroupAttributes::mHeight, mHighlight, mHighlightColor, mHighlightedObjects, mpGlFogCoordfEXT, mpLayout, mpResolver, mSelection, CLGroupAttributes::mStroke, CLGroupAttributes::mStrokeWidth, mStyleMap, mTextGlyphMap, CLGroupAttributes::mWidth, CLGroupAttributes::mX, CLGroupAttributes::mY, CLGroupAttributes::mZ, restore_current_attributes(), save_current_attributes(), and CLBoundingBox::setPosition().

Referenced by addToSelection(), CQGLLayoutPainter::draw(), CQGLLayoutPainter::draw_bitmap(), and removeFromSelection().

{
  // first we need to clear the screen
  // with the background color
  glDisable(GL_POLYGON_SMOOTH);

  if (this->mGLFunctionsInitialized == false)
    {
      this->initialize_gl_extension_functions();
    }

  glFogi(GL_FOG_MODE, GL_EXP);

  if (this->mHighlight == true)
    {
      glFogfv(GL_FOG_COLOR, this->mHighlightColor);
    }
  else
    {
      glFogfv(GL_FOG_COLOR, this->mFogColor);
    }

  glFogf(GL_FOG_DENSITY, this->mFogDensity);
  glHint(GL_FOG_HINT, GL_FASTEST);
  glFogi(GL_FOG_COORD_SRC, GL_FOG_COORD);
  glEnable(GL_FOG);
  GLfloat highlight = (GLfloat)this->mHighlight;
  GLfloat notHighlight = (GLfloat)(!this->mHighlight);

  if (this->mpResolver)
    {
      //std::cout << "Drawing layout." << std::endl;
      const CLColorDefinition* pBackgroundColor = this->mpResolver->getBackgroundColor();
      GLfloat red = (GLfloat)(pBackgroundColor->getRed() / 255.0);
      GLfloat green = (GLfloat)(pBackgroundColor->getGreen() / 255.0);
      GLfloat blue = (GLfloat)(pBackgroundColor->getBlue() / 255.0);
      GLfloat alpha = (GLfloat)(pBackgroundColor->getAlpha() / 255.0);

      if (this->mHighlight == false)
        {
          // we have to generate fog on the background ourselfes
          red = (GLfloat)((red + this->mFogColor[0]) * this->mFogDensity);
          green = (GLfloat)((green + this->mFogColor[1]) * this->mFogDensity);
          blue = (GLfloat)((blue + this->mFogColor[2]) * this->mFogDensity);
          alpha = (GLfloat)((alpha + this->mFogColor[3]) * this->mFogDensity);
        }

      glClearColor((GLclampf)red,
                   (GLclampf)green,
                   (GLclampf)blue,
                   (GLclampf)alpha);
      glClear(GL_COLOR_BUFFER_BIT);
      glPushMatrix();
      this->mCurrentAttributes.mX = 0.0;
      this->mCurrentAttributes.mY = 0.0;
      this->mCurrentAttributes.mZ = 0.0;
      this->mCurrentAttributes.mWidth = this->mpLayout->getDimensions().getWidth();
      this->mCurrentAttributes.mHeight = this->mpLayout->getDimensions().getHeight();
      const CLReactionGlyph* pRG = NULL;
      const CLGeneralGlyph* pGG = NULL;
      const CLReferenceGlyph* pRefG = NULL;
      const CLMetabReferenceGlyph* pSRG = NULL;
      const CLTextGlyph* pTG = NULL;
      std::vector<const CLGraphicalObject*>::iterator it = this->mDrawables.begin(), endit = this->mDrawables.end();
      const CLGraphicalObject* pGO = NULL;
// this is needed to highlight or fog certain elements in the diagram
      const CCopasiObject* pModelObject = NULL;
      std::set<const CLGraphicalObject*>::const_iterator end = this->mHighlightedObjects.end();

      while (it != endit)
        {
          pGO = *it;
          pRG = dynamic_cast<const CLReactionGlyph*>(pGO);
          pGG = dynamic_cast<const CLGeneralGlyph*>(pGO);
          pSRG = dynamic_cast<const CLMetabReferenceGlyph*>(pGO);
          pRefG = dynamic_cast<const CLReferenceGlyph*>(pGO);
          pTG = dynamic_cast<const CLTextGlyph*>(pGO);
          std::map<const CLGraphicalObject*, const CLStyle*>::const_iterator styleIt = this->mStyleMap.find(pGO);

          if (styleIt == this->mStyleMap.end() || styleIt->second == NULL)
            {
              ++it;
              continue;
            }

// this is needed to highlight or fog certain elements in the diagram
          const CLGraphicalObject* pGO2 = NULL;

          if (pSRG == NULL)
            {
              pModelObject = (pGO)->getModelObject();
              pGO2 = pGO;
            }
          else if (pRefG == NULL)
            {
              pModelObject = (pGO)->getModelObject();
              pGO2 = pGO;
            }
          else
            {
              // if we have a species reference glyph, we check if the parent reaction glyph is highlighted and if
              // it is we also highlight the species reference glyph
              assert((*it)->getObjectParent() != NULL && (*it)->getObjectParent()->getObjectParent() != NULL);
              assert(dynamic_cast<const CLGraphicalObject*>((*it)->getObjectParent()->getObjectParent()) != NULL);

              if (pGO->getObjectParent() != NULL &&
                  pGO->getObjectParent()->getObjectParent() != NULL
                 )
                {
                  pGO2 = dynamic_cast<const CLGraphicalObject*>(pGO->getObjectParent()->getObjectParent());

                  if (pGO2 != NULL)
                    {
                      pModelObject = pGO2->getModelObject();
                    }
                }
            }

          if (this->mpGlFogCoordfEXT != NULL)
            {
              if (pModelObject != NULL && this->mHighlightedObjects.find(pGO2) != end)
                {
                  (*(this->mpGlFogCoordfEXT))(highlight);
                }
              else
                {
                  (*(this->mpGlFogCoordfEXT))(notHighlight);
                }
            }

          if ((pSRG != NULL && pSRG->getCurve().getNumCurveSegments() != 0))
            {
              // draw the layout curve
              // we need to set the state of the OpenGL state machine
              // save the curent state
              this->save_current_attributes();
              CLLayoutRenderer::extract_group_attributes(styleIt->second, &mCurrentAttributes);

              // only draw the line if the stroke width is a positive value
              // greater zero and if there is a stroke color defined
              if (mCurrentAttributes.mStrokeWidth > 0.0 && mCurrentAttributes.mStroke != "none")
                {
                  bool drawBasepoints = false;

                  if (this->mSelection.size() == 1 && (*this->mSelection.begin()) == pSRG)
                    {
                      drawBasepoints = true;
                    }

                  this->draw_curve(&pSRG->getCurve(), drawBasepoints);
                }

              this->restore_current_attributes();

              // if the curve is the only selected item, we draw the base points,
              // otherwise we only draw the selection frame
              if (this->mSelection.find(const_cast<CLGraphicalObject*>(pGO)) != this->mSelection.end())
                {
                  CLBoundingBox* pBB = getCurveBoundingBox(&pSRG->getCurve());
                  this->drawSelectionBox(pBB->getPosition().getX(), pBB->getPosition().getY(),
                                         pBB->getDimensions().getWidth(), pBB->getDimensions().getHeight(), this->mSelection.size() == 1);
                  delete pBB;
                }
            }
          else  if ((pRefG != NULL && pRefG->getCurve().getNumCurveSegments() != 0))
            {
              // draw the layout curve
              // we need to set the state of the OpenGL state machine
              // save the curent state
              this->save_current_attributes();
              CLLayoutRenderer::extract_group_attributes(styleIt->second, &mCurrentAttributes);

              // only draw the line if the stroke width is a positive value
              // greater zero and if there is a stroke color defined
              if (mCurrentAttributes.mStrokeWidth > 0.0 && mCurrentAttributes.mStroke != "none")
                {
                  bool drawBasepoints = false;

                  if (this->mSelection.size() == 1 && (*this->mSelection.begin()) == pRefG)
                    {
                      drawBasepoints = true;
                    }

                  this->draw_curve(&pRefG->getCurve(), drawBasepoints);
                }

              this->restore_current_attributes();

              // if the curve is the only selected item, we draw the base points,
              // otherwise we only draw the selection frame
              if (this->mSelection.find(const_cast<CLGraphicalObject*>(pGO)) != this->mSelection.end())
                {
                  CLBoundingBox* pBB = getCurveBoundingBox(&pRefG->getCurve());
                  this->drawSelectionBox(pBB->getPosition().getX(), pBB->getPosition().getY(),
                                         pBB->getDimensions().getWidth(), pBB->getDimensions().getHeight(), this->mSelection.size() == 1);
                  delete pBB;
                }
            }
          else if (pRG != NULL && pRG->getCurve().getNumCurveSegments() != 0)
            {
              // draw the layout curve
              // we need to set the state of the OpenGL state machine
              // save the curent state
              this->save_current_attributes();
              CLLayoutRenderer::extract_group_attributes(styleIt->second, &mCurrentAttributes);

              // only do something if the stroke width is a positive value
              // greater 0 and if there is a stroke color defined
              if (mCurrentAttributes.mStrokeWidth > 0.0 && mCurrentAttributes.mStroke != "none")
                {
                  // set the state
                  bool drawBasepoints = false;

                  if (this->mSelection.size() == 1 && (*this->mSelection.begin()) == pRG)
                    {
                      drawBasepoints = true;
                    }

                  this->draw_curve(&pRG->getCurve(), drawBasepoints);
                  // reset the original state
                }

              this->restore_current_attributes();

              // if the curve is the only selected item, we draw the base points,
              // otherwise we only draw the selection frame
              if (this->mSelection.find(const_cast<CLGraphicalObject*>(pGO)) != this->mSelection.end())
                {
                  CLBoundingBox* pBB = getCurveBoundingBox(&pRG->getCurve());
                  this->drawSelectionBox(pBB->getPosition().getX(), pBB->getPosition().getY(),
                                         pBB->getDimensions().getWidth(), pBB->getDimensions().getHeight(), this->mSelection.size() == 1);
                  delete pBB;
                }
            }
          else if (pGG != NULL && pGG->getCurve().getNumCurveSegments() != 0)
            {
              // draw the layout curve
              // we need to set the state of the OpenGL state machine
              // save the curent state
              this->save_current_attributes();
              CLLayoutRenderer::extract_group_attributes(styleIt->second, &mCurrentAttributes);

              // only do something if the stroke width is a positive value
              // greater 0 and if there is a stroke color defined
              if (mCurrentAttributes.mStrokeWidth > 0.0 && mCurrentAttributes.mStroke != "none")
                {
                  // set the state
                  bool drawBasepoints = false;

                  if (this->mSelection.size() == 1 && (*this->mSelection.begin()) == pGG)
                    {
                      drawBasepoints = true;
                    }

                  this->draw_curve(&pGG->getCurve(), drawBasepoints);
                  // reset the original state
                }

              this->restore_current_attributes();

              // if the curve is the only selected item, we draw the base points,
              // otherwise we only draw the selection frame
              if (this->mSelection.find(const_cast<CLGraphicalObject*>(pGO)) != this->mSelection.end())
                {
                  CLBoundingBox* pBB = getCurveBoundingBox(&pGG->getCurve());
                  this->drawSelectionBox(pBB->getPosition().getX(), pBB->getPosition().getY(),
                                         pBB->getDimensions().getWidth(), pBB->getDimensions().getHeight(), this->mSelection.size() == 1);
                  delete pBB;
                }
            }
          else if (pTG != NULL)
            {
              //std::cout << "Drawing CLText*Glyph: " << pTG->getId() << std::endl;
              std::map<const CLTextGlyph*, const CLTextTextureSpec*>::const_iterator pos = this->mTextGlyphMap.find(pTG);
              assert(pos != this->mTextGlyphMap.end());

              if (pos->second != NULL && pos->second->mTextureName != 0)
                {
                  //std::cout <<  "Texture for text glyph found." << std::endl;
                  // in order to position text glyphs corectly, we have to move them up by their mAscent
                  CLBoundingBox bb = pTG->getBoundingBox();
                  CLPoint* pP = &bb.getPosition();
                  bb.setPosition(*pP);
                  this->draw_text(styleIt->second, &bb, pos->second);

                  // draw the selection frame
                  // if it is the only selected element, we also draw the resize handles
                  if (this->mSelection.find(const_cast<CLGraphicalObject*>(pGO)) != this->mSelection.end())
                    {
                      // we need to adjust the bounding box the same way we adjust the text glyphs
                      this->drawSelectionBox(bb.getPosition().getX(), bb.getPosition().getY() + pos->second->mAscent,
                                             bb.getDimensions().getWidth(), bb.getDimensions().getHeight(), this->mSelection.size() == 1);
                    }
                }
            }
          else
            {
              const CLBoundingBox* pBB = &pGO->getBoundingBox();
              this->draw_object(styleIt->second, pBB);

              // draw the selection frame
              // if it is the only selected element, we also draw the resize handles
              if (this->mSelection.find(const_cast<CLGraphicalObject*>(pGO)) != this->mSelection.end())
                {
                  this->drawSelectionBox(pBB->getPosition().getX(), pBB->getPosition().getY(),
                                         pBB->getDimensions().getWidth(), pBB->getDimensions().getHeight(), this->mSelection.size() == 1);
                }
            }

          ++it;
        }

      // flush the GL queue
      glPopMatrix();
      // draw the selection box
      this->draw_selection_box();
      glFlush();
      //std::cout << "Drawing finished." << std::endl << std::endl;
    }

  glDisable(GL_FOG);
}

void CLLayoutRenderer::draw_line ( size_t  numPoints, GLdouble *  pData  )

protected

Method to draw a line made up of a set of points.

Definition at line 3075 of file CLLayoutRenderer.cpp.

References draw_cap(), draw_line_segment(), mCurrentAttributes, mLinestippleMap, CLLineStippleTexture::mPatternLength, CLGroupAttributes::mStrokeDasharray, CLGroupAttributes::mStrokeWidth, CLLineStippleTexture::mTextureLength, CLLineStippleTexture::mTextureName, and segment_data().

Referenced by draw_curve(), and draw_datapoints().

{
  // a line has to have more than one point
  if (numPoints > 1)
    {
      // create the texture for line stippling
      const CLLineStippleTexture* pTexture = NULL;
      std::map<const std::vector<unsigned int>, const CLLineStippleTexture*>::const_iterator pos = this->mLinestippleMap.find(this->mCurrentAttributes.mStrokeDasharray);

      if (pos != this->mLinestippleMap.end())
        {
          pTexture = pos->second;
        }

      GLfloat* pTextureCoordinates = NULL;
      GLdouble* pOrigData = pData;
      size_t iMax = numPoints;

      if (pTexture != NULL)
        {
          // segment the
          // datapoints into pieces that fit the texture pattern
          // and create the texture coordinates
          std::vector<simple_point> v;
          // we need at least numPoints elements in the vector
          v.reserve(numPoints);
          this->segment_data(pTexture->mPatternLength, (double)pTexture->mPatternLength / (double)pTexture->mTextureLength, numPoints, pData, v);

          if (v.size() != numPoints)
            {
              iMax = (unsigned int)v.size();
              // we have to create a new dataset
              pData = new GLdouble[3 * iMax];
              pTextureCoordinates = new GLfloat[iMax];
              std::vector<simple_point>::const_iterator it = v.begin(), endit = v.end();
              unsigned int index = 0;
              unsigned int index2 = 0;

              while (it != endit)
                {
                  pData[index++] = it->mX;
                  pData[index++] = it->mY;
                  pData[index++] = it->mZ;
                  pTextureCoordinates[index2++] = (GLfloat)it->mS;
                  ++it;
                }
            }
          else
            {
              // create an array for the texture coordinates
              pTextureCoordinates = new GLfloat[iMax];
              std::vector<simple_point>::const_iterator it = v.begin(), endit = v.end();
              unsigned int index = 0;

              while (it != endit)
                {
                  pTextureCoordinates[index++] = (GLfloat)it->mS;
                  ++it;
                }
            }

          if (pTexture->mTextureName != 0)
            {
              glBindTexture(GL_TEXTURE_1D, pTexture->mTextureName);
              // enable 1D texturing
              glEnable(GL_TEXTURE_1D);
            }
        }

      unsigned int i;
      // the loop does not go to the very last point, but stops one before that
      --iMax;
      unsigned int index = 0;

      for (i = 0; i < iMax; ++i)
        {
          if (pTextureCoordinates)
            {
              draw_line_segment(pData[index], pData[index + 1], pData[index + 2], pData[index + 3], pData[index + 4], pData[index + 5], mCurrentAttributes.mStrokeWidth, true, 0.0, pTextureCoordinates[i + 1]);
            }
          else
            {
              draw_line_segment(pData[index], pData[index + 1], pData[index + 2], pData[index + 3], pData[index + 4], pData[index + 5], mCurrentAttributes.mStrokeWidth);
            }

          index += 3;

          // don't draw a cap after the last segment
          if (i != iMax - 1)
            {
              draw_cap(pData[index - 3], pData[index - 2], pData[index - 1], pData[index], pData[index + 1], pData[index + 2], pData[index + 3], pData[index + 4], pData[index + 5], mCurrentAttributes.mStrokeWidth);
            }
        }

      // if we created new datapoints, we have to delete them again
      if (pOrigData != pData)
        {
          delete[] pData;
          pData = pOrigData;
        }

      // delete any texture coordinates we have created
      if (pTextureCoordinates != NULL)
        {
          delete[] pTextureCoordinates;
          glDisable(GL_TEXTURE_1D);
        }
    }
}

void CLLayoutRenderer::draw_line_segment ( double  x1, double  y1, double  z1, double  x2, double  y2, double  z2, double  line_width, bool  texture = false, double  s1 = 0.0, double  s2 = 0.0  )

protected

Method that draws a line with the given start and end points. All the other parameter like color, linewidth etc. have to be set before.

Definition at line 265 of file CLLayoutRenderer.cpp.

References ALMOST_ZERO.

Referenced by draw_line().

{
  // calculate the 4 points of the rectangle considering the line width
  // actually the correct thing to do would be to draw a tube, but right now
  // this is takes to many ressources, so we draw a rectangle and use the same
  // mapping as for the line endings.
  // calculate the direction vector
  double vx1 = x2 - x1;
  double vy1 = y2 - y1;
  double vz1 = z2 - z1;
  double length = sqrt(vx1 * vx1 + vy1 * vy1 + vz1 * vz1);

  // calculate the normal to this vector
  double vx2 = 0.0;
  double vy2 = 0.0;
  double vz2 = 0.0;
  double half_width = line_width / 2.0;

  if (fabs(vx1) < ALMOST_ZERO && vz1 < ALMOST_ZERO)
    {
      // scale by the line_width
      vx2 = -vy1 / length * half_width;
      vy2 = 0.0;
      vz2 = 0.0;
    }
  else
    {
      // scale by the line_width
      double normY = vy1 / length;
      vx2 = -normY * vx1 / length * half_width;
      vy2 = (1 - normY * normY) * half_width;
      vz2 = -normY * vz1 / length * half_width;
      double normLength = half_width / sqrt(vx2 * vx2 + vy2 * vy2 + vz2 * vz2);
      vx2 *= normLength;
      vy2 *= normLength;
      vz2 *= normLength;
    }

  // calculate the 4 points
  GLfloat* pDatapoints = new GLfloat[12];
  pDatapoints[0] = (GLfloat)(x1 + vx2);
  pDatapoints[1] = (GLfloat)(y1 + vy2);
  pDatapoints[2] = (GLfloat)(z1 + vz2);
  pDatapoints[3] = (GLfloat)(x1 - vx2);
  pDatapoints[4] = (GLfloat)(y1 - vy2);
  pDatapoints[5] = (GLfloat)(z1 - vz2);
  pDatapoints[6] = (GLfloat)(x2 + vx2);
  pDatapoints[7] = (GLfloat)(y2 + vy2);
  pDatapoints[8] = (GLfloat)(z2 + vz2);
  pDatapoints[9] = (GLfloat)(x2 - vx2);
  pDatapoints[10] = (GLfloat)(y2 - vy2);
  pDatapoints[11] = (GLfloat)(z2 - vz2);
  // enable the line stippling texture if necessary
  GLfloat* pTextureCoordinates = NULL;

  if (texture)
    {
      pTextureCoordinates = new GLfloat[4];
      pTextureCoordinates[0] = (GLfloat)s1;
      pTextureCoordinates[1] = (GLfloat)s1;
      pTextureCoordinates[2] = (GLfloat)s2;
      pTextureCoordinates[3] = (GLfloat)s2;
      // create an array for texture coordinates
      glEnableClientState(GL_TEXTURE_COORD_ARRAY);
      glTexCoordPointer(1, GL_FLOAT, 0, pTextureCoordinates);
    }

  // just draw as a triangle strip
  glEnableClientState(GL_VERTEX_ARRAY);
  glVertexPointer(3, GL_FLOAT, 0, pDatapoints);
  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
  glDisableClientState(GL_VERTEX_ARRAY);

  // disable the line stippleling texture if necessary
  if (texture)
    {
      glDisableClientState(GL_TEXTURE_COORD_ARRAY);
      delete[] pTextureCoordinates;
    }

  delete[] pDatapoints;
}

void CLLayoutRenderer::draw_object ( const CLStyle *  pStyle, const CLBoundingBox *  pBB  )

protected

Method to draw an arbitrary object specified by it's bounding box and the style with which it should be drawn.

Definition at line 1337 of file CLLayoutRenderer.cpp.

References draw_group(), and CLStyle::getGroup().

Referenced by draw_layout().

{
  this->draw_group(pStyle->getGroup(), pBB);
}

void CLLayoutRenderer::draw_polygon ( const CLPolygon *  pPolygon, const CLBoundingBox *  pBB  )

protected

Method to draw a render polygon object.

Definition at line 1793 of file CLLayoutRenderer.cpp.

References CLRenderCubicBezier::basePoint1_X(), CLRenderCubicBezier::basePoint1_Y(), CLRenderCubicBezier::basePoint1_Z(), CLRenderCubicBezier::basePoint2_X(), CLRenderCubicBezier::basePoint2_Y(), CLRenderCubicBezier::basePoint2_Z(), calculate_cubicbezier(), convert_to_absolute(), draw_datapoints(), extract_2d_attributes(), CLPolygon::getElement(), CLPolygon::getNumElements(), CLPoint::getX(), CLPoint::getY(), CLPoint::getZ(), mCurrentAttributes, simple_point::mX, simple_point::mY, simple_point::mZ, NUM_BEZIER_POINTS, restore_current_attributes(), save_current_attributes(), CLRenderPoint::x(), CLRenderPoint::y(), and CLRenderPoint::z().

Referenced by draw_group().

{
  /*
   * Old code to draw the polygon when it consists of only straight lines.
      size_t numPoints=pPolygon->getNumElements()+1;
  if(numPoints>1)
  {
    // store and change the attributes
    this->save_current_attributes();
    CLLayoutRenderer::extract_2d_attributes(pPolygon,&mCurrentAttributes);
    // create the data points
    GLdouble* pData=new GLdouble[3*numPoints];
    size_t i,iMax=numPoints-1;
    CLPoint p;
    const CLRenderPoint* pP;
    size_t index=0;
    for(i=0;i<iMax;++i)
    {
      pP=pPolygon->getElement(i);
      assert(pP);
      p=CLLayoutRenderer::convert_to_absolute(pP,pBB);
      pData[index++]=p.getX();
      pData[index++]=p.getY();
      pData[index++]=p.getZ();
    }
    pData[index++]=pData[0];
    pData[index++]=pData[1];
    pData[index]=pData[2];
    */

  // the first one has to be a point
  // store and change the attributes
  if (pPolygon->getNumElements() > 1)
    {
      this->save_current_attributes();
      CLLayoutRenderer::extract_2d_attributes(pPolygon, &mCurrentAttributes);
      const CLRenderPoint* pStart = pPolygon->getElement(0);
      CLRenderPoint end, bp1, bp2;
      CLPoint p1 = convert_to_absolute(pStart, pBB);
      CLPoint p2, p3, p4;
      std::vector<simple_point> v;
      // there are going to be at least iMax elements in the vector
      size_t i, iMax = pPolygon->getNumElements();
      v.reserve(iMax);
      simple_point p;
      p.mX = p1.getX();
      p.mY = p1.getY();
      p.mZ = p1.getZ();
      v.push_back(p);
      GLdouble* pData = NULL;
      const CLRenderPoint* pP;
      const CLRenderCubicBezier* pCB;

      for (i = 1; i < iMax; ++i)
        {
          pP = pPolygon->getElement(i);
          pCB = dynamic_cast<const CLRenderCubicBezier*>(pP);

          if (pCB != NULL)
            {
              end = CLRenderPoint(pCB->x(), pCB->y(), pCB->z());
              bp1 = CLRenderPoint(pCB->basePoint1_X(), pCB->basePoint1_Y(), pCB->basePoint1_Z());
              bp2 = CLRenderPoint(pCB->basePoint2_X(), pCB->basePoint2_Y(), pCB->basePoint2_Z());
              p2 = convert_to_absolute(&end, pBB);
              p3 = convert_to_absolute(&bp1, pBB);
              p4 = convert_to_absolute(&bp2, pBB);
              pData = new GLdouble[3 * NUM_BEZIER_POINTS];
              CLLayoutRenderer::calculate_cubicbezier(p1.getX(), p1.getY(), p1.getZ(),
                                                      p3.getX(), p3.getY(), p3.getZ(),
                                                      p4.getX(), p4.getY(), p4.getZ(),
                                                      p2.getX(), p2.getY(), p2.getZ(),
                                                      NUM_BEZIER_POINTS, pData);
              size_t j;
              size_t index = 0;

              for (j = 0; j < NUM_BEZIER_POINTS; ++j)
                {
                  p.mX = pData[index++];
                  p.mY = pData[index++];
                  p.mZ = pData[index++];
                  v.push_back(p);
                }

              delete[] pData;
            }
          else
            {
              end = CLRenderPoint(pP->x(), pP->y(), pP->z());
              p2 = convert_to_absolute(&end, pBB);
              p.mX = p2.getX();
              p.mY = p2.getY();
              p.mZ = p2.getZ();
              v.push_back(p);
            }

          // this end is the next start
          p1 = p2;
        }

      iMax = v.size();

      if (iMax > 1)
        {
          pData = new GLdouble[3 * (iMax + 1)];
          size_t index = 0;
          const simple_point* pSimple = NULL;

          for (i = 0; i < iMax; ++i)
            {
              pSimple = &v[i];
              pData[index++] = pSimple->mX;
              pData[index++] = pSimple->mY;
              pData[index++] = pSimple->mZ;
            }

          pData[index++] = pData[0];
          pData[index++] = pData[1];
          pData[index] = pData[2];
          // draw the polygon
          this->draw_datapoints(pData, iMax + 1, pBB, true);
          delete[] pData;
        }

      // restore the attributes
      this->restore_current_attributes();
    }
}

void CLLayoutRenderer::draw_rectangle ( const CLRectangle *  pRectangle, const CLBoundingBox *  pBB  )

protected

Method to draw a render rectangle object.

Definition at line 1924 of file CLLayoutRenderer.cpp.

References convert_to_absolute(), draw_datapoints(), extract_2d_attributes(), CLRelAbsVector::getAbsoluteValue(), CLBoundingBox::getDimensions(), CLRectangle::getHeight(), CLDimensions::getHeight(), CLRectangle::getRadiusX(), CLRectangle::getRadiusY(), CLRelAbsVector::getRelativeValue(), CLRectangle::getWidth(), CLDimensions::getWidth(), CLRectangle::getX(), CLRectangle::getY(), CLRectangle::getZ(), mCurrentAttributes, NUM_CORNER_SEGMENTS, restore_current_attributes(), and save_current_attributes().

Referenced by draw_group().

{
  // store and change the attributes
  this->save_current_attributes();
  CLLayoutRenderer::extract_2d_attributes(pRectangle, &mCurrentAttributes);
  // draw the rectangle
  // first we calculate the points of the rectangle
  CLRenderPoint rp(pRectangle->getX(), pRectangle->getY(), pRectangle->getZ());
  CLPoint p = CLLayoutRenderer::convert_to_absolute(&rp, pBB);
  CLRelAbsVector v = pRectangle->getWidth();
  double width = v.getAbsoluteValue() + (v.getRelativeValue() / 100.0) * pBB->getDimensions().getWidth();
  v = pRectangle->getHeight();
  double height = v.getAbsoluteValue() + (v.getRelativeValue() / 100.0) * pBB->getDimensions().getHeight();
  v = pRectangle->getRadiusX();
  double rx = v.getAbsoluteValue() + (v.getRelativeValue() / 100.0) * width;
  v = pRectangle->getRadiusY();
  double ry = v.getAbsoluteValue() + (v.getRelativeValue() / 100.0) * height;

  // make sure rx and ry are not greater than half the width or height of the
  // rectangle.
  if (rx > width / 2.0) rx = width / 2.0;

  if (ry > height / 2.0) ry = height / 2.0;

  size_t numPoints = 4;

  if (rx > 0.0 && ry > 0.0)
    {
      // we have four corners
      // plus 4 points for the straight lines
      numPoints = 4 * (NUM_CORNER_SEGMENTS + 1);
    }

  // we need to reserve space for all data points and each point has three
  // values
  // we add an additonal data point to close the loop
  GLdouble* pData = new GLdouble[(numPoints + 1) * 3];
  double x = p.getX();
  double y = p.getY();
  double z = p.getZ();
  // now we fill the data array
  size_t index = 0;

  if (rx > 0.0 && ry > 0.0)
    {
      size_t i = 0;
      pData[i++] = 0.0;
      pData[i++] = ry;
      pData[i++] = 0.0;
      pData[i++] = 0.0;
      pData[i++] = height - ry;
      pData[i++] = 0.0;
      i += (NUM_CORNER_SEGMENTS - 1) * 3;
      pData[i++] = rx;
      pData[i++] = height;
      pData[i++] = 0.0;
      pData[i++] = width - rx;
      pData[i++] = height;
      pData[i++] = 0.0;
      i += (NUM_CORNER_SEGMENTS - 1) * 3;
      pData[i++] = width;
      pData[i++] = height - ry;
      pData[i++] = 0.0;
      pData[i++] = width;
      pData[i++] = ry;
      pData[i++] = 0.0;
      i += (NUM_CORNER_SEGMENTS - 1) * 3;
      pData[i++] = width - rx;
      pData[i++] = 0.0;
      pData[i++] = 0.0;
      pData[i++] = rx;
      pData[i++] = 0.0;
      pData[i] = 0.0;
      double delta = M_PI / (2.0 * NUM_CORNER_SEGMENTS);
      double phi = delta;
      double dx, dy, dx_inv, dy_inv;
      index = 0;

      for (i = 0; i < NUM_CORNER_SEGMENTS - 1; ++i)
        {
          index = (2 + i) * 3;
          dx = rx * sin(phi);
          dy = ry * cos(phi);
          dx_inv = rx * sin(M_PI / 2.0 - phi);
          dy_inv = ry * cos(M_PI / 2.0 - phi);
          // the first corner is mirrored, so we switch dx and dy
          pData[index] = rx - dx_inv;
          pData[index + 1] = height - ry + dy_inv;
          pData[index + 2] = 0.0;
          // the second corner is actually the one, we calculate
          index += (NUM_CORNER_SEGMENTS + 1) * 3;
          pData[index] = width - rx + dx;
          pData[index + 1] = height - ry + dy;
          pData[index + 2] = 0.0;
          // third corner is again mirrored
          index += (NUM_CORNER_SEGMENTS + 1) * 3;
          pData[index] = width - rx + dx_inv;
          pData[index + 1] = ry - dy_inv;
          pData[index + 2] = 0.0;
          // the fourth corner
          index += (NUM_CORNER_SEGMENTS + 1) * 3;
          pData[index] = rx - dx;
          pData[index + 1] = ry - dy;
          pData[index + 2] = 0.0;
          phi += delta;
        }
    }
  else
    {
      // first corner
      pData[0] = 0.0;
      pData[1] = 0.0;
      pData[2] = 0.0;
      // second corner
      pData[3] = 0.0;
      pData[4] = height;
      pData[5] = 0.0;
      // third corner
      pData[6] = width;
      pData[7] = height;
      pData[8] = 0.0;
      // fourth corner
      pData[9] = width;
      pData[10] = 0.0;
      pData[11] = 0.0;
    }

  index = 3 * numPoints;
  // we close the loop
  pData[index++] = pData[0];
  pData[index++] = pData[1];
  pData[index] = pData[2];
  this->draw_datapoints(pData, numPoints + 1, pBB, false, (GLfloat)x, (GLfloat)y, (GLfloat)z);
  // delete the data again
  delete[] pData;
  //
  // restore the attributes
  this->restore_current_attributes();
}

void CLLayoutRenderer::draw_selection_box ( ) const

protected

draws the selection box if there is one

Definition at line 6528 of file CLLayoutRenderer.cpp.

References CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLBoundingBox::getPosition(), CLDimensions::getWidth(), CLPoint::getX(), CLPoint::getY(), mH, mpSelectionBox, mW, mX, mY, and mZoomFactor.

Referenced by draw_layout().

{
  if (this->mpSelectionBox != NULL)
    {
      // draw four semi transparent rectangles around the
      // bounding box
      double width = this->mW / this->mZoomFactor;
      double height = this->mH / this->mZoomFactor;
      double lx = this->mpSelectionBox->getPosition().getX();
      double ly = this->mpSelectionBox->getPosition().getY();
      double rx = lx + this->mpSelectionBox->getDimensions().getWidth();
      double ry = ly + this->mpSelectionBox->getDimensions().getHeight();
      glColor4f(0.5, 0.5, 0.5, 0.5);
      // top
      glBegin(GL_POLYGON);
      glVertex3d(this->mX, this->mY, 0.1);
      glVertex3d(this->mX + width, this->mY, 0.1);
      glVertex3d(this->mX + width, ly, 0.1);
      glVertex3d(this->mX, ly, 0.1);
      glEnd();
      // bottom
      glBegin(GL_POLYGON);
      glVertex3d(this->mX, ry, 0.1);
      glVertex3d(this->mX + width, ry, 0.1);
      glVertex3d(this->mX + width, this->mY + height, 0.1);
      glVertex3d(this->mX, this->mY + height, 0.1);
      glEnd();
      // left
      glBegin(GL_POLYGON);
      glVertex3d(this->mX, ly, 0.1);
      glVertex3d(lx, ly, 0.1);
      glVertex3d(lx, ry, 0.1);
      glVertex3d(this->mX, ry, 0.1);
      glEnd();
      // right
      glBegin(GL_POLYGON);
      glVertex3d(rx, ly, 0.1);
      glVertex3d(this->mX + width, ly, 0.1);
      glVertex3d(this->mX + width, ry, 0.1);
      glVertex3d(rx, ry, 0.1);
      glEnd();
    }
}

void CLLayoutRenderer::draw_text ( const CLStyle *  pStyle, const CLBoundingBox *  pBB, const CLTextTextureSpec *  pTexture  )

protected

Method to draw a text object specified by it's bounding box and the style with which it should be drawn as well as the actual string.

Definition at line 1267 of file CLLayoutRenderer.cpp.

References CLText::ANCHOR_BOTTOM, CLText::ANCHOR_END, CLText::ANCHOR_MIDDLE, extract_1d_attributes(), extract_text_attributes(), CLBoundingBox::getDimensions(), CLStyle::getGroup(), CLDimensions::getHeight(), CLDimensions::getWidth(), mCurrentAttributes, CLGroupAttributes::mStroke, CLGroupAttributes::mTextAnchor, CLGroupAttributes::mVTextAnchor, restore_current_attributes(), and save_current_attributes().

Referenced by draw_group(), draw_layout(), and draw_text().

{
  // set the attributes
  this->save_current_attributes();
  // for text elements, only the 1d attributes and the special text
  // attributes are relevant
  CLLayoutRenderer::extract_1d_attributes(pStyle->getGroup(), &mCurrentAttributes);
  CLLayoutRenderer::extract_text_attributes(pStyle->getGroup(), &mCurrentAttributes);

  // we only draw the text if there is a stroke color to draw it with
  if (!mCurrentAttributes.mStroke.empty() && mCurrentAttributes.mStroke != "none")
    {
      // with the new interpretation of the text alignment attributes,
      // we have to specify different offset attributes
      // if the horizontal laignment is middle, we specify the middle of the box
      // as x offset and if the alignment is end, we specify the end as the x offset
      // likewise for the vertical alignment and the y offset
      double xOffset = 0.0;
      double yOffset = 0.0;

      if (this->mCurrentAttributes.mTextAnchor == CLText::ANCHOR_MIDDLE)
        {
          xOffset = pBB->getDimensions().getWidth() * 0.5;;
        }
      else if (this->mCurrentAttributes.mTextAnchor == CLText::ANCHOR_END)
        {
          xOffset = pBB->getDimensions().getWidth();
        }

      if (this->mCurrentAttributes.mVTextAnchor == CLText::ANCHOR_MIDDLE)
        {
          yOffset = pBB->getDimensions().getHeight() * 0.5;
        }
      else if (this->mCurrentAttributes.mVTextAnchor == CLText::ANCHOR_BOTTOM)
        {
          yOffset = pBB->getDimensions().getHeight();
        }

      this->draw_text(pTexture, xOffset, yOffset, 0.0, pBB);
    }

  //restore the attributes
  this->restore_current_attributes();
}

void CLLayoutRenderer::draw_text ( const CLText *  pText, const CLBoundingBox *  pBB  )

protected

Method to draw a render text object.

Definition at line 1520 of file CLLayoutRenderer.cpp.

References draw_text(), extract_1d_attributes(), extract_text_attributes(), CLRelAbsVector::getAbsoluteValue(), CLDimensions::getDepth(), CLBoundingBox::getDimensions(), CLDimensions::getHeight(), CLRelAbsVector::getRelativeValue(), CLDimensions::getWidth(), CLText::getX(), CLText::getY(), CLText::getZ(), CLText::isSetText(), mCurrentAttributes, mTextMap, restore_current_attributes(), and save_current_attributes().

{
  if (pText->isSetText())
    {
      // set the attributes
      this->save_current_attributes();
      // for text elements, only the 1d attributes and the special text
      // attributes are relevant
      CLLayoutRenderer::extract_1d_attributes(pText, &mCurrentAttributes);
      CLLayoutRenderer::extract_text_attributes(pText, &mCurrentAttributes);
      // draw the string
      double x = pText->getX().getAbsoluteValue() + pText->getX().getRelativeValue() / 100.0 * pBB->getDimensions().getWidth();
      double y = pText->getY().getAbsoluteValue() + pText->getY().getRelativeValue() / 100.0 * pBB->getDimensions().getHeight();
      double z = pText->getZ().getAbsoluteValue() + pText->getZ().getRelativeValue() / 100.0 * pBB->getDimensions().getDepth();
      std::map<const CLText*, const CLTextTextureSpec*>::const_iterator pos = this->mTextMap.find(pText);
      assert(pos != this->mTextMap.end());

      if (pos->second != NULL && pos->second->mTextureName != 0)
        {
          //std::cout << "Drawing text \"" << pText->getText() << "\"." << std::endl;
          CLLayoutRenderer::draw_text(pos->second, x, y, z, pBB);
        }

      //restore the attributes
      this->restore_current_attributes();
    }
}

void CLLayoutRenderer::draw_text ( const CLTextTextureSpec *  pTexture, double  x, double  y, double  z, const CLBoundingBox *  pBB  )

protected

Method to draw a string at the given position within the given bounding box.

pTexture->mScale

pTexture->mScale

Definition at line 1551 of file CLLayoutRenderer.cpp.

References CLText::ANCHOR_BOTTOM, CLText::ANCHOR_END, CLText::ANCHOR_MIDDLE, createGLMatrix(), CLBoundingBox::getPosition(), CLPoint::getX(), CLPoint::getY(), CLPoint::getZ(), mColorMap, mCurrentAttributes, CLGroupAttributes::mpTransform, CLTextTextureSpec::mScale, CLGroupAttributes::mStroke, CLGroupAttributes::mTextAnchor, CLTextureSpec::mTextHeight, CLTextureSpec::mTextureHeight, CLTextureSpec::mTextureName, CLTextureSpec::mTextureWidth, CLTextureSpec::mTextWidth, CLGroupAttributes::mVTextAnchor, CLGroupAttributes::mX, and mZoomFactor.

{
  //std::cout << "Drawing text with texture at " << pTexture << std::endl;
  if (pTexture != NULL && pBB != NULL)
    {
      // create a texture for the text.
      // map the origin of the texture to x,y,z
      // map the texture point at textwidth, textheight to x+textwidth,
      // y+textheight
      // This might lead to text that goes beyone the dimensions of the bounding
      // box, but since the user has asked for a text of this size, we just draw
      // it
      std::map<std::string, CLRGBAColor>::const_iterator pos = this->mColorMap.find(mCurrentAttributes.mStroke);
      assert(pos != this->mColorMap.end());
      const CLRGBAColor& c = pos->second;
      glColor4ub(c.mR, c.mG, c.mB, c.mA);
      double xOffset = x + pBB->getPosition().getX();
      double yOffset = y + pBB->getPosition().getY();
      double zOffset = z + pBB->getPosition().getZ();

      // position the text according to how the anchor is set
      if (mCurrentAttributes.mTextAnchor == CLText::ANCHOR_MIDDLE)
        {
          // the new interpretation is that the horizontal center of the text is at xOffset,yOffset
          xOffset -= pTexture->mTextWidth / (2.0 * this->mZoomFactor);
        }
      else if (mCurrentAttributes.mTextAnchor == CLText::ANCHOR_END)
        {
          // the new interpretation is that xOffset specifies the horizontal end of the text, so
          // the start has to be placed at xOffset-pTexture->mTextWidth / this->mZoomFactor
          xOffset -= pTexture->mTextWidth / this->mZoomFactor;
        }

      // do vertical positioning
      if (mCurrentAttributes.mVTextAnchor == CLText::ANCHOR_MIDDLE)
        {
          // the text is vertically centered in the box
          yOffset -= pTexture->mTextHeight / (2.0 * this->mZoomFactor);
        }
      else if (mCurrentAttributes.mVTextAnchor == CLText::ANCHOR_BOTTOM)
        {
          // the lower edge of the text is located at the top edge of the box
          // since heigher y values are downward, this alligns the text at
          // the lower end of the box
          yOffset -= pTexture->mTextHeight / this->mZoomFactor;
        }

      // the yOffset has to consider the mAscent of the text because the
      // placement of the text should be relative to the baseline
      //std::cout << "current bounding box position: " << pBB->getPosition().getX() << "," << pBB->getPosition().getY() << std::endl;
      //std::cout << "texture size: " << pTexture->textureWidth << "x" << pTexture->textureHeight << std::endl;
      //std::cout << "text size: " << pTexture->textWidth << "x" << pTexture->textHeight << std::endl;
      //std::cout << "text mAscent: " << pTexture->mAscent << std::endl;
      //std::cout << "y offset at: " << y << std::endl;
      //std::cout << "placing baseline at: " << yOffset << std::endl;
      //std::cout << "the upper side of the textured box will be located at: " << yOffset << std::endl;

      //
      // we draw a rectangle in the current stroke color. At places where the texture is black, the underlying color should be seen.
      // load the texture
      // enable 2D texturing
      glEnable(GL_TEXTURE_2D);
      glBindTexture(GL_TEXTURE_2D, pTexture->mTextureName);
      glMatrixMode(GL_MODELVIEW);
      glPushMatrix();
      glTranslated(xOffset, yOffset, zOffset);

      // apply the current transformation
      if (memcmp(mCurrentAttributes.mpTransform, Transformation::getIdentityMatrix(), 12 * sizeof(double)))
        {
          // move back to the current offset
          glTranslated(this->mCurrentAttributes.mX, this->mCurrentAttributes.mY, this->mCurrentAttributes.mZ);
          GLdouble* matrix = new GLdouble[16];
          CLLayoutRenderer::createGLMatrix(mCurrentAttributes.mpTransform, matrix);
          glMultMatrixd(matrix);
          delete[] matrix;
          // move to 0.0,0.0,0.0
          glTranslated(-this->mCurrentAttributes.mX, -this->mCurrentAttributes.mY, -this->mCurrentAttributes.mZ);
        }

      //std::cout << "zoom factor: " << this->mZoomFactor << std::endl;
      //std::cout << "Drawing texture " << pTexture->mTextureName << " with:" << std::endl;
      //std::cout << "text height: "  << pTexture->mTextHeight << " text width: " << pTexture->mTextWidth << std::endl;
      //std::cout << "texture height: "  << pTexture->mTextureHeight << " texture width: " << pTexture->mTextureWidth << std::endl;
      //std::cout << "texture scale: " << pTexture->mScale << std::endl;
      double widthRatio = pTexture->mTextWidth /** pTexture->mScale*/ / pTexture->mTextureWidth;
      //std::cout << "width ratio: " << widthRatio << std::endl;
      double heightRatio = pTexture->mTextHeight /** pTexture->mScale*/ / pTexture->mTextureHeight;
      //std::cout << "height ratio: " << heightRatio << std::endl;
      glBegin(GL_POLYGON);
      glTexCoord2f(0.0, 1.0);
      glVertex3f(0.0, 0.0, 0.0);
      glTexCoord2d(0.0, 1.0 - heightRatio);
      glVertex3d(0.0, pTexture->mTextHeight / pTexture->mScale, 0.0);
      glTexCoord2d(widthRatio, 1.0 - heightRatio);
      glVertex3d(pTexture->mTextWidth / pTexture->mScale, pTexture->mTextHeight / pTexture->mScale, 0.0);
      glTexCoord2d(widthRatio, 1.0);
      glVertex3d(pTexture->mTextWidth / pTexture->mScale, 0.0, 0.0);
      glEnd();
      glPopMatrix();
      // disable the 2D texture again
      glDisable(GL_TEXTURE_2D);
    }
}