TreeDiagram Class Reference

Class representing the tree layout for the built-in class diagram. More...

Public Types
using	Ptr = std::unique_ptr<DiagramRow>
using	Vec = std::vector<Ptr>
using	iterator = typename Vec::iterator

Public Member Functions
	TreeDiagram (const ClassDef *root, bool doBases)
void	computeLayout ()
uint32_t	computeRows ()
void	moveChildren (DiagramItem *root, int dx)
void	computeExtremes (uint32_t *labelWidth, uint32_t *xpos)
void	drawBoxes (TextStream &t, Image *image, bool doBase, bool bitmap, uint32_t baseRows, uint32_t superRows, uint32_t cellWidth, uint32_t cellHeight, QCString relPath="", bool generateMap=TRUE)
void	drawConnectors (TextStream &t, Image *image, bool doBase, bool bitmap, uint32_t baseRows, uint32_t superRows, uint32_t cellWidth, uint32_t cellheight)
DiagramRow *	row (int index)
uint32_t	numRows () const
DiagramRow *	addRow (uint32_t l)
iterator	begin ()
iterator	end ()

Private Member Functions
bool	layoutTree (DiagramItem *root, uint32_t row)

Private Attributes
Vec	m_rows

Detailed Description

Class representing the tree layout for the built-in class diagram.

Definition at line 103 of file diagram.cpp.

Member Typedef Documentation

iterator

using TreeDiagram::iterator = typename Vec::iterator

Definition at line 108 of file diagram.cpp.

Ptr

using TreeDiagram::Ptr = std::unique_ptr<DiagramRow>

Definition at line 106 of file diagram.cpp.

Vec

using TreeDiagram::Vec = std::vector<Ptr>

Definition at line 107 of file diagram.cpp.

Constructor & Destructor Documentation

TreeDiagram()

TreeDiagram::TreeDiagram	(	const ClassDef *	root,
		bool	doBases )

Definition at line 398 of file diagram.cpp.

{
  auto row = std::make_unique<DiagramRow>(this,0);
  DiagramRow *row_ptr = row.get();
  m_rows.push_back(std::move(row));
  row_ptr->insertClass(nullptr,root,doBases,Protection::Public,Specifier::Normal,QCString());
}

References DiagramRow::insertClass(), m_rows, Normal, Public, and row().

Member Function Documentation

addRow()

DiagramRow * TreeDiagram::addRow ( uint32_t l )

inline

Definition at line 126 of file diagram.cpp.

    { m_rows.push_back(std::make_unique<DiagramRow>(this,l)); return m_rows.back().get(); }

References m_rows.

begin()

iterator TreeDiagram::begin ( )

inline

Definition at line 128 of file diagram.cpp.

{ return m_rows.begin();  }

References m_rows.

computeExtremes()

void TreeDiagram::computeExtremes	(	uint32_t *	labelWidth,
		uint32_t *	xpos )

Definition at line 539 of file diagram.cpp.

{
  uint32_t ml=0,mx=0;
  for (const auto &dr : m_rows) // for each row
  {
    bool done=FALSE;
    for (const auto &di : *dr) // for each item in a row
    {
      if (di->isInList()) done=TRUE;
      if (maxXPos) mx=std::max(mx,di->xPos());
      if (maxLabelLen) ml=std::max(ml,Image::stringLength(di->label()));
    }
    if (done) break;
  }
  if (maxLabelLen) *maxLabelLen=ml;
  if (maxXPos)     *maxXPos=mx;
}

References FALSE, m_rows, Image::stringLength, and TRUE.

computeLayout()

void TreeDiagram::computeLayout

(

)

Definition at line 458 of file diagram.cpp.

{
  auto it = m_rows.begin();
  while (it!=m_rows.end() && (*it)->numItems()<maxTreeWidth) ++it;
  if (it!=m_rows.end())
  {
    const auto &row = *it;
    //printf("computeLayout() list row at %d\n",row->number());
    DiagramItem *opi=nullptr;
    int delta=0;
    bool first=TRUE;
    for (const auto &di : *row)
    {
      DiagramItem *pi=di->parentItem();
      if (pi==opi && !first) { delta-=gridWidth; }
      first = pi!=opi;
      opi=pi;
      di->move(delta,0); // collapse all items in the same
                         // list (except the first)
      di->putInList();
    }
  }
 
  // re-organize the diagram items
  DiagramItem *root=m_rows.front()->item(0);
  while (layoutTree(root,0)) { }
 
  // move first items of the lists
  if (it!=m_rows.end())
  {
    const auto &row = *it;
    auto rit = row->begin();
    while (rit!=row->end())
    {
      DiagramItem *pi=(*rit)->parentItem();
      if (pi->numChildren()>1)
      {
        (*rit)->move(gridWidth,0);
        while (rit!=row->end() && (*rit)->parentItem()==pi)
        {
          ++rit;
        }
      }
      else
      {
        ++rit;
      }
    }
  }
}

References gridWidth, layoutTree(), m_rows, maxTreeWidth, DiagramItem::move(), DiagramItem::numChildren(), row(), and TRUE.

computeRows()

uint32_t TreeDiagram::computeRows

(

)

Definition at line 509 of file diagram.cpp.

{
  //printf("TreeDiagram::computeRows()=%d\n",count());
  uint32_t count=0;
  auto it = m_rows.begin();
  while (it!=m_rows.end() && !(*it)->item(0)->isInList())
  {
    ++it;
    ++count;
  }
 
  //printf("count=%d row=%p\n",count,row);
  if (it!=m_rows.end())
  {
    const auto &row = *it;
    uint32_t maxListLen=0;
    uint32_t curListLen=0;
    DiagramItem *opi=nullptr;
    for (const auto &di : *row) // for each item in a row
    {
      if (di->parentItem()!=opi) curListLen=1; else curListLen++;
      if (curListLen>maxListLen) maxListLen=curListLen;
      opi=di->parentItem();
    }
    //printf("maxListLen=%d\n",maxListLen);
    count+=maxListLen;
  }
  return count;
}

References m_rows, DiagramItem::parentItem(), and row().

drawBoxes()

void TreeDiagram::drawBoxes	(	TextStream &	t,
		Image *	image,
		bool	doBase,
		bool	bitmap,
		uint32_t	baseRows,
		uint32_t	superRows,
		uint32_t	cellWidth,
		uint32_t	cellHeight,
		QCString	relPath = "",
		bool	generateMap = TRUE )

Definition at line 592 of file diagram.cpp.

{
  auto it = m_rows.begin();
  if (it!=m_rows.end() && !doBase) ++it;
  bool firstRow = doBase;
  bool done=FALSE;
  float superRowsF = static_cast<float>(superRows);
  for (;it!=m_rows.end() && !done;++it) // for each row
  {
    const auto &dr = *it;
    uint32_t x=0,y=0;
    float xf=0.0f,yf=0.0f;
    DiagramItem *firstDi = dr->item(0);
    if (firstDi->isInList()) // put boxes in a list
    {
      DiagramItem *opi=nullptr;
      DualDirIterator<DiagramRow,const std::unique_ptr<DiagramItem>&> dit(*dr,!doBase);
      while (!dit.atEnd())
      {
        DiagramItem *di = (*dit).get();
        if (di->parentItem()==opi)
        {
          if (bitmap)
          {
            if (doBase) y -= cellHeight+labelVertSpacing;
            else        y += cellHeight+labelVertSpacing;
          }
          else
          {
            if (doBase) yf += 1.0f;
            else        yf -= 1.0f;
          }
        }
        else
        {
          if (bitmap)
          {
            x = di->xPos()*(cellWidth+labelHorSpacing)/gridWidth;
            if (doBase)
            {
              y = image->height()-
                superRows*cellHeight-
                (superRows-1)*labelVertSpacing-
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
            }
            else
            {
              y = (baseRows-1)*(cellHeight+labelVertSpacing)+
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
            }
          }
          else
          {
            xf = di->xfPos()/gridWidth;
            if (doBase)
            {
              yf = di->yfPos()/gridHeight+superRowsF-1.0f;
            }
            else
            {
              yf = superRowsF-1.0f-di->yfPos()/gridHeight;
            }
          }
        }
        opi=di->parentItem();
 
        if (bitmap)
        {
          bool hasDocs=di->getClassDef()->isLinkable();
          writeBitmapBox(di,image,x,y,cellWidth,cellHeight,firstRow,
              hasDocs,di->numChildren()>0);
          if (!firstRow && generateMap)
            writeMapArea(t,di->getClassDef(),relPath,x,y,cellWidth,cellHeight);
        }
        else
        {
          writeVectorBox(t,di,xf,yf,di->numChildren()>0);
        }
 
        ++dit;
      }
      done=TRUE;
    }
    else // draw a tree of boxes
    {
      for (const auto &di : *dr)
      {
        if (bitmap)
        {
          x = di->xPos()*(cellWidth+labelHorSpacing)/gridWidth;
          if (doBase)
          {
            y = image->height()-
              superRows*cellHeight-
              (superRows-1)*labelVertSpacing-
              di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
          }
          else
          {
            y = (baseRows-1)*(cellHeight+labelVertSpacing)+
              di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
          }
          bool hasDocs=di->getClassDef()->isLinkable();
          writeBitmapBox(di.get(),image,x,y,cellWidth,cellHeight,firstRow,hasDocs);
          if (!firstRow && generateMap)
            writeMapArea(t,di->getClassDef(),relPath,x,y,cellWidth,cellHeight);
        }
        else
        {
          xf=di->xfPos()/gridWidth;
          if (doBase)
          {
            yf = di->yfPos()/gridHeight+superRowsF-1.0f;
          }
          else
          {
            yf = superRowsF-1.0f-di->yfPos()/gridHeight;
          }
          writeVectorBox(t,di.get(),xf,yf);
        }
      }
    }
    firstRow=FALSE;
  }
}

References DualDirIterator< C, I >::atEnd(), FALSE, DiagramItem::getClassDef(), gridHeight, gridWidth, Image::height(), DiagramItem::isInList(), Definition::isLinkable(), labelHorSpacing, labelVertSpacing, m_rows, DiagramItem::numChildren(), DiagramItem::parentItem(), TRUE, writeBitmapBox(), writeMapArea(), writeVectorBox(), DiagramItem::xfPos(), DiagramItem::xPos(), DiagramItem::yfPos(), and DiagramItem::yPos().

drawConnectors()

void TreeDiagram::drawConnectors	(	TextStream &	t,
		Image *	image,
		bool	doBase,
		bool	bitmap,
		uint32_t	baseRows,
		uint32_t	superRows,
		uint32_t	cellWidth,
		uint32_t	cellheight )

Definition at line 723 of file diagram.cpp.

{
  bool done=FALSE;
  auto it = m_rows.begin();
  float superRowsF = static_cast<float>(superRows);
  for (;it!=m_rows.end() && !done;++it) // for each row
  {
    const auto &dr = *it;
    DiagramItem *rootDi = dr->item(0);
    if (rootDi->isInList()) // row consists of list connectors
    {
      uint32_t x=0,y=0,ys=0;
      float xf=0.0f,yf=0.0f,ysf=0.0f;
      auto rit = dr->begin();
      while (rit!=dr->end())
      {
        DiagramItem *di=(*rit).get();
        DiagramItem *pi=di->parentItem();
        DiagramItemList dil=pi->getChildren();
        DiagramItem *last=dil.back();
        if (di==last) // single child
        {
          if (bitmap) // draw pixels
          {
            x = di->xPos()*(cellWidth+labelHorSpacing)/gridWidth + cellWidth/2;
            if (doBase) // base classes
            {
              y = image->height()-
                (superRows-1)*(cellHeight+labelVertSpacing)-
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
              image->drawVertArrow(x,y,y+labelVertSpacing/2,
                                   protToColor(di->protection()),
                                   protToMask(di->protection()));
            }
            else // super classes
            {
              y = (baseRows-1)*(cellHeight+labelVertSpacing)-
                labelVertSpacing/2+
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
              image->drawVertLine(x,y,y+labelVertSpacing/2,
                                  protToColor(di->protection()),
                                  protToMask(di->protection()));
            }
          }
          else // draw vectors
          {
            t << protToString(di->protection()) << "\n";
            if (doBase)
            {
              t << "1 " << (di->xfPos()/gridWidth) << " "
                << (di->yfPos()/gridHeight+superRowsF-1.0f) << " in\n";
            }
            else
            {
              t << "0 " << (di->xfPos()/gridWidth) << " "
                << (superRowsF-0.25f-di->yfPos()/gridHeight)
                << " in\n";
            }
          }
        }
        else // multiple children, put them in a vertical list
        {
          if (bitmap)
          {
            x = di->parentItem()->xPos()*
              (cellWidth+labelHorSpacing)/gridWidth+cellWidth/2;
            if (doBase) // base classes
            {
              ys = image->height()-
                (superRows-1)*(cellHeight+labelVertSpacing)-
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
              y = ys - cellHeight/2;
            }
            else // super classes
            {
              ys = (baseRows-1)*(cellHeight+labelVertSpacing)+
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
              y = ys + cellHeight/2;
            }
          }
          else
          {
            xf = di->parentItem()->xfPos()/gridWidth;
            if (doBase)
            {
              ysf = di->yfPos()/gridHeight+superRowsF-1.0f;
              yf = ysf + 0.5f;
            }
            else
            {
              ysf = superRowsF-0.25f-di->yfPos()/gridHeight;
              yf = ysf - 0.25f;
            }
          }
          while (di!=last) // more children to add
          {
            if (bitmap)
            {
              if (doBase) // base classes
              {
                image->drawHorzArrow(y,x,x+cellWidth/2+labelHorSpacing,
                    protToColor(di->protection()),
                    protToMask(di->protection()));
                y -= cellHeight+labelVertSpacing;
              }
              else // super classes
              {
                image->drawHorzLine(y,x,x+cellWidth/2+labelHorSpacing,
                    protToColor(di->protection()),
                    protToMask(di->protection()));
                y += cellHeight+labelVertSpacing;
              }
            }
            else
            {
              t << protToString(di->protection()) << "\n";
              if (doBase)
              {
                t << "1 " << xf << " " << yf << " hedge\n";
                yf += 1.0f;
              }
              else
              {
                t << "0 " << xf << " " << yf << " hedge\n";
                yf -= 1.0f;
              }
            }
            ++rit;
            if (rit!=dr->end()) di = (*rit).get(); else di=nullptr;
          }
          // add last horizontal line and a vertical connection line
          if (bitmap)
          {
            if (doBase) // base classes
            {
              image->drawHorzArrow(y,x,x+cellWidth/2+labelHorSpacing,
                  protToColor(di->protection()),
                  protToMask(di->protection()));
              image->drawVertLine(x,y,ys+labelVertSpacing/2,
                  protToColor(getMinProtectionLevel(dil)),
                  protToMask(getMinProtectionLevel(dil)));
            }
            else // super classes
            {
              image->drawHorzLine(y,x,x+cellWidth/2+labelHorSpacing,
                  protToColor(di->protection()),
                  protToMask(di->protection()));
              image->drawVertLine(x,ys-labelVertSpacing/2,y,
                  protToColor(getMinProtectionLevel(dil)),
                  protToMask(getMinProtectionLevel(dil)));
            }
          }
          else
          {
            t << protToString(di->protection()) << "\n";
            if (doBase)
            {
              t << "1 " << xf << " " << yf << " hedge\n";
            }
            else
            {
              t << "0 " << xf << " " << yf << " hedge\n";
            }
            t << protToString(getMinProtectionLevel(dil)) << "\n";
            if (doBase)
            {
              t << xf << " " << ysf << " " << yf << " vedge\n";
            }
            else
            {
              t << xf << " " << (ysf + 0.25f) << " " << yf << " vedge\n";
            }
          }
        }
        if (rit!=dr->end()) ++rit;
      }
      done=TRUE; // the tree is drawn now
    }
    else // normal tree connector
    {
      for (const auto &di : *dr)
      {
        uint32_t x=0,y=0;
        DiagramItemList dil = di->getChildren();
        DiagramItem *parent  = di->parentItem();
        if (parent) // item has a parent -> connect to it
        {
          if (bitmap) // draw pixels
          {
            x = di->xPos()*(cellWidth+labelHorSpacing)/gridWidth + cellWidth/2;
            if (doBase) // base classes
            {
              y = image->height()-
                (superRows-1)*(cellHeight+labelVertSpacing)-
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
              /* write input line */
              image->drawVertArrow(x,y,y+labelVertSpacing/2,
                  protToColor(di->protection()),
                  protToMask(di->protection()));
            }
            else // super classes
            {
              y = (baseRows-1)*(cellHeight+labelVertSpacing)-
                labelVertSpacing/2+
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
              /* write output line */
              image->drawVertLine(x,y,y+labelVertSpacing/2,
                  protToColor(di->protection()),
                  protToMask(di->protection()));
            }
          }
          else // draw pixels
          {
            t << protToString(di->protection()) << "\n";
            if (doBase)
            {
              t << "1 " << di->xfPos()/gridWidth << " "
                << (di->yfPos()/gridHeight+superRowsF-1.0f) << " in\n";
            }
            else
            {
              t << "0 " << di->xfPos()/gridWidth << " "
                << (superRowsF-0.25f-di->yfPos()/gridHeight)
                << " in\n";
            }
          }
        }
        if (!dil.empty())
        {
          Protection p=getMinProtectionLevel(dil);
          uint32_t mask=protToMask(p);
          uint8_t col=protToColor(p);
          if (bitmap)
          {
            x = di->xPos()*(cellWidth+labelHorSpacing)/gridWidth + cellWidth/2;
            if (doBase) // base classes
            {
              y = image->height()-
                (superRows-1)*(cellHeight+labelVertSpacing)-
                cellHeight-labelVertSpacing/2-
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
              image->drawVertLine(x,y,y+labelVertSpacing/2-1,col,mask);
            }
            else // super classes
            {
              y = (baseRows-1)*(cellHeight+labelVertSpacing)+
                cellHeight+
                di->yPos()*(cellHeight+labelVertSpacing)/gridHeight;
              image->drawVertArrow(x,y,y+labelVertSpacing/2-1,col,mask);
            }
          }
          else
          {
            t << protToString(p) << "\n";
            if (doBase)
            {
              t << "0 " << di->xfPos()/gridWidth  << " "
                << (di->yfPos()/gridHeight+superRowsF-1.0f) << " out\n";
            }
            else
            {
              t << "1 " << di->xfPos()/gridWidth  << " "
                << (superRowsF-1.75f-di->yfPos()/gridHeight)
                << " out\n";
            }
          }
          /* write input line */
          DiagramItem *first = dil.front();
          DiagramItem *last  = dil.back();
          if (first!=last && !first->isInList()) /* connect with all base classes */
          {
            if (bitmap)
            {
              uint32_t xs = first->xPos()*(cellWidth+labelHorSpacing)/gridWidth
                + cellWidth/2;
              uint32_t xe = last->xPos()*(cellWidth+labelHorSpacing)/gridWidth
                + cellWidth/2;
              if (doBase) // base classes
              {
                image->drawHorzLine(y,xs,xe,col,mask);
              }
              else // super classes
              {
                image->drawHorzLine(y+labelVertSpacing/2,xs,xe,col,mask);
              }
            }
            else
            {
              t << protToString(p) << "\n";
              if (doBase)
              {
                t << first->xfPos()/gridWidth << " "
                  << last->xfPos()/gridWidth << " "
                  << (first->yfPos()/gridHeight+superRowsF-1.0f)
                  << " conn\n";
              }
              else
              {
                t << first->xfPos()/gridWidth << " "
                  << last->xfPos()/gridWidth << " "
                  << (superRowsF-first->yfPos()/gridHeight)
                  << " conn\n";
              }
            }
          }
        }
      }
    }
  }
}

References Image::drawHorzArrow(), Image::drawHorzLine(), Image::drawVertArrow(), Image::drawVertLine(), FALSE, DiagramItem::getChildren(), getMinProtectionLevel(), gridHeight, gridWidth, Image::height(), DiagramItem::isInList(), labelHorSpacing, labelVertSpacing, m_rows, parent(), DiagramItem::parentItem(), DiagramItem::protection(), protToColor(), protToMask(), protToString(), TRUE, DiagramItem::xfPos(), DiagramItem::xPos(), DiagramItem::yfPos(), and DiagramItem::yPos().

end()

iterator TreeDiagram::end ( )

inline

Definition at line 129 of file diagram.cpp.

{ return m_rows.end();    }

References m_rows.

layoutTree()

bool TreeDiagram::layoutTree ( DiagramItem * root, uint32_t row )

private

Definition at line 415 of file diagram.cpp.

{
  bool moved=FALSE;
  //printf("layoutTree(%s,%d)\n",qPrint(root->label()),r);
 
  if (root->numChildren()>0)
  {
    auto children = root->getChildren();
    uint32_t pPos=root->xPos();
    uint32_t cPos=root->avgChildPos();
    if (pPos>cPos) // move children
    {
      const auto &row=m_rows.at(r+1);
      //printf("Moving children %d-%d in row %d\n",
      //    dil->getFirst()->number(),row->count()-1,r+1);
      for (uint32_t k=children.front()->number();k<row->numItems();k++)
      {
        row->item(k)->move(static_cast<int>(pPos-cPos),0);
      }
      moved=TRUE;
    }
    else if (pPos<cPos) // move parent
    {
      const auto &row=m_rows.at(r);
      //printf("Moving parents %d-%d in row %d\n",
      //    root->number(),row->count()-1,r);
      for (uint32_t k=root->number();k<row->numItems();k++)
      {
        row->item(k)->move(static_cast<int>(cPos-pPos),0);
      }
      moved=TRUE;
    }
 
    // recurse to children
    auto it = children.begin();
    for (;it!=children.end() && !moved && !(*it)->isInList();++it)
    {
      moved = layoutTree(*it,r+1);
    }
  }
  return moved;
}

References DiagramItem::avgChildPos(), FALSE, DiagramItem::getChildren(), layoutTree(), m_rows, DiagramItem::number(), DiagramItem::numChildren(), row(), TRUE, and DiagramItem::xPos().

Referenced by computeLayout(), and layoutTree().

moveChildren()

void TreeDiagram::moveChildren	(	DiagramItem *	root,
		int	dx )

Definition at line 406 of file diagram.cpp.

{
  for (const auto &di : root->getChildren())
  {
    di->move(dx,0);
    moveChildren(di,dx);
  }
}

References DiagramItem::getChildren(), and moveChildren().

Referenced by moveChildren().

numRows()

uint32_t TreeDiagram::numRows ( ) const

inline

Definition at line 125 of file diagram.cpp.

{ return static_cast<uint32_t>(m_rows.size()); }

References m_rows.

row()

DiagramRow * TreeDiagram::row ( int index )

inline

Definition at line 124 of file diagram.cpp.

{ return m_rows.at(index).get(); }

References m_rows.

Referenced by computeLayout(), computeRows(), layoutTree(), and TreeDiagram().

Member Data Documentation

m_rows

Vec TreeDiagram::m_rows

private

Definition at line 132 of file diagram.cpp.

Referenced by addRow(), begin(), computeExtremes(), computeLayout(), computeRows(), drawBoxes(), drawConnectors(), end(), layoutTree(), numRows(), row(), and TreeDiagram().

---

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

• src/diagram.cpp