Ghosts Class Reference

Class for showing points and lines for all coordinate systems simultaneously, even though the code normally only allows graphical items for once coordinate system to be visible at a time. More...

#include <Ghosts.h>

Collaboration diagram for Ghosts:

Public Member Functions
	Ghosts (unsigned int coordSystemIndexToBeRestored)
	Single constructor. More...
	~Ghosts ()
unsigned int	coordSystemIndexToBeRestored () const
	Coordinate system index that was active before the ghosts. More...
void	captureGraphicsItems (QGraphicsScene &scene)
	Take a snapshot of the graphics items. More...
void	createGhosts (QGraphicsScene &scene)
	Create ghosts from the path/rect/polygon lists. More...
void	destroyGhosts (QGraphicsScene &scene)
	Destory ghosts. Called at end of algorithm. More...

Detailed Description

Class for showing points and lines for all coordinate systems simultaneously, even though the code normally only allows graphical items for once coordinate system to be visible at a time.

QGraphicsLineItems are ignored since those are just used for the AxesChecker, and QGraphicsPixmapItems are ignored since those are just used for the background. The other QGraphicsItem subclasses are captured and converted into ghosts.

Definition at line 25 of file Ghosts.h.

Constructor & Destructor Documentation

Ghosts()

Ghosts::Ghosts

(

unsigned int

coordSystemIndexToBeRestored

)

Single constructor.

Definition at line 17 of file Ghosts.cpp.

                                                         :
  m_coordSystemIndexToBeRestored (coordSystemIndexToBeRestored)
{
}

~Ghosts()

Ghosts::~Ghosts

(

)

Definition at line 22 of file Ghosts.cpp.

{
}

Member Function Documentation

captureGraphicsItems()

void Ghosts::captureGraphicsItems

(

QGraphicsScene &

scene

)

Take a snapshot of the graphics items.

Definition at line 26 of file Ghosts.cpp.

{
  QList<QGraphicsItem*> items = scene.items();
 
  QList<QGraphicsItem*>::iterator itr;
  for (itr = items.begin(); itr != items.end(); itr++) {
 
    QGraphicsItem *item = *itr;
 
    QGraphicsEllipseItem *itemEllipse = dynamic_cast<QGraphicsEllipseItem*> (item);
    if (itemEllipse != nullptr) {
 
      GhostEllipse ghost (itemEllipse->boundingRect(),
                          itemEllipse->pen(),
                          itemEllipse->brush());
      m_ellipses.push_back (ghost);
 
    } else {
 
      QGraphicsPathItem *itemPath = dynamic_cast<QGraphicsPathItem*> (item);
      if (itemPath != nullptr) {
 
        GhostPath ghost (itemPath->path (),
                         itemPath->pen(),
                         itemPath->brush());
        m_paths.push_back (ghost);
 
      } else {
 
        QGraphicsPolygonItem *itemPolygon = dynamic_cast<QGraphicsPolygonItem*> (item);
        if (itemPolygon != nullptr) {
 
          // Polygon is centered at origin so we have to add offset
          QPolygonF polygon = itemPolygon->polygon();
          polygon.translate (itemPolygon->pos ());
 
          GhostPolygon ghost (polygon,
                              itemPolygon->pen(),
                              itemPolygon->brush());
          m_polygons.push_back (ghost);
 
        }
      }
    }
  }
}

coordSystemIndexToBeRestored()

unsigned int Ghosts::coordSystemIndexToBeRestored

(

)

const

Coordinate system index that was active before the ghosts.

Definition at line 73 of file Ghosts.cpp.

{
  return m_coordSystemIndexToBeRestored;
}

createGhosts()

void Ghosts::createGhosts

(

QGraphicsScene &

scene

)

Create ghosts from the path/rect/polygon lists.

Definition at line 78 of file Ghosts.cpp.

{
  int i;
 
  for (i = 0; i < m_ellipses.count(); i++) {
    GhostEllipse ghost = m_ellipses.at(i);
 
    QGraphicsEllipseItem *item = scene.addEllipse (ghost.rect());
 
    item->setData (DATA_KEY_GHOST, QVariant (true));
    item->setPen (ghost.pen());
    item->setBrush (ghost.brush());
    item->setZValue (Z_VALUE);
    item->setVisible (true);
  }
 
  for (i = 0; i < m_paths.count(); i++) {
    GhostPath ghost = m_paths.at(i);
 
    QGraphicsPathItem *item = scene.addPath (ghost.path(),
                                             ghost.pen(),
                                             ghost.brush());
 
    item->setData (DATA_KEY_GHOST, QVariant (true));
    item->setZValue (Z_VALUE);
    item->setVisible (true);
  }
 
  for (i = 0; i < m_polygons.count(); i++) {
    GhostPolygon ghost = m_polygons.at(i);
 
    QGraphicsPolygonItem *item = scene.addPolygon (ghost.polygon(),
                                                   ghost.pen(),
                                                   ghost.brush());
 
    item->setData (DATA_KEY_GHOST, QVariant (true));
    item->setZValue (Z_VALUE);
    item->setVisible (true);
  }
}

destroyGhosts()

void Ghosts::destroyGhosts

(

QGraphicsScene &

scene

)

Destory ghosts. Called at end of algorithm.

Definition at line 119 of file Ghosts.cpp.

{
  QList<QGraphicsItem*> items = scene.items();
  QList<QGraphicsItem*>::iterator itr;
  for (itr = items.begin(); itr != items.end(); itr++) {
 
    QGraphicsItem *item = *itr;
    QVariant data = item->data (DATA_KEY_GHOST);
    if (!data.isNull()) {
      if (data.toBool()) {
        scene.removeItem (item);
      }
    }
  }
}

---

The documentation for this class was generated from the following files:

• Ghosts/Ghosts.h
• Ghosts/Ghosts.cpp