dbse::SchemaGraphicsScene Class Reference

#include <SchemaGraphicsScene.hpp>

Inheritance diagram for dbse::SchemaGraphicsScene:

Collaboration diagram for dbse::SchemaGraphicsScene:

Signals
void	sceneModified (bool)

Public Member Functions
	SchemaGraphicsScene (QObject *parent=nullptr)
	~SchemaGraphicsScene ()
void	CreateActions ()
void	dragEnterEvent (QGraphicsSceneDragDropEvent *event)
	Drag & Drop.
void	dragMoveEvent (QGraphicsSceneDragDropEvent *event)
void	dropEvent (QGraphicsSceneDragDropEvent *event)
void	contextMenuEvent (QGraphicsSceneContextMenuEvent *event)
QStringList	AddItemsToScene (QStringList SchemaClasses, QList< QPointF > Positions)
void	CleanItemMap ()
void	RemoveClassObject (SchemaGraphicObject *Object)
void	add_notes (QStringList notes, QList< QPointF > positions)
void	remove_note_object (SchemaGraphicNote *obj)
bool	IsModified () const
void	ClearModified ()

Protected Member Functions
void	mousePressEvent (QGraphicsSceneMouseEvent *mouseEvent)
void	mouseMoveEvent (QGraphicsSceneMouseEvent *mouseEvent)
void	mouseReleaseEvent (QGraphicsSceneMouseEvent *mouseEvent)
void	RemoveItemFromScene (QGraphicsItem *item)
void	modified (bool state)

Private Slots
void	new_class_slot ()
void	add_class_slot (QString)
void	new_note_slot ()
void	add_note_slot (SchemaGraphicNote *)
void	cancel_note_slot (SchemaGraphicNote *)
void	edit_note_slot ()
void	remove_note_slot ()
void	modified_slot ()
void	EditClassSlot ()
void	ToggleIndirectInfos ()
void	ToggleHighlightActive ()
void	AddDirectSuperClassesSlot ()
void	AddAllSuperClassesSlot ()
void	AddAllSubClassesSlot ()
void	AddDirectRelationshipClassesSlot ()
void	AddAllRelationshipClassesSlot ()
void	RemoveClassSlot ()
void	RemoveArrowSlot ()
void	DrawArrow (QString ClassName, QString RelationshipType, QString RelationshipName)

Private Attributes
QMap< QString, SchemaGraphicObject * >	ItemMap
QGraphicsLineItem *	m_line
QMenu *	m_context_menu
int	m_seperator_pos
int	m_class_pos
int	m_arrow_pos
int	m_note_pos
QAction *	m_add_class
QAction *	m_edit_class
QAction *	m_toggle_indirect_infos
QAction *	m_toggle_highlight_active
QAction *	m_add_direct_super_classes
QAction *	m_add_direct_relationship_classes
QAction *	m_add_all_super_classes
QAction *	m_add_all_sub_classes
QAction *	m_add_all_relationship_classes
QAction *	m_add_note
QAction *	m_edit_note
QAction *	m_remove_note
QAction *	m_remove_class
QAction *	m_remove_arrow
QMetaObject::Connection	m_addclass_connection
SchemaGraphicObject *	CurrentObject
SchemaGraphicSegmentedArrow *	m_current_arrow
SchemaGraphicNote *	m_current_note
QPointF	m_current_pos
QPointF	m_mouse_item_pos
int	m_next_note {0}
bool	m_inherited_properties_visible
bool	m_highlight_active
bool	m_modified

Detailed Description

Definition at line 15 of file SchemaGraphicsScene.hpp.

Constructor & Destructor Documentation

SchemaGraphicsScene()

dbse::SchemaGraphicsScene::SchemaGraphicsScene ( QObject * parent = nullptr )

explicit

Definition at line 21 of file SchemaGraphicsScene.cpp.

  : QGraphicsScene ( parent ),
    m_line ( nullptr ),
    m_context_menu ( nullptr ),
    CurrentObject ( nullptr ),
    m_current_arrow ( nullptr ),
    m_inherited_properties_visible(false),
    m_highlight_active(false),
    m_modified(false)
{
  CreateActions();
  setSceneRect ( QRectF ( 0, 0, 10000, 10000 ) );
}

~SchemaGraphicsScene()

dbse::SchemaGraphicsScene::~SchemaGraphicsScene

(

)

Definition at line 35 of file SchemaGraphicsScene.cpp.

{
}

Member Function Documentation

add_class_slot

void dbse::SchemaGraphicsScene::add_class_slot ( QString class_name )

privateslot

Updating item list

Definition at line 494 of file SchemaGraphicsScene.cpp.

                                                               {
  disconnect(m_addclass_connection);
 
  auto object = new SchemaGraphicObject(class_name);
  object->setPos(m_current_pos);
  object->set_inherited_properties_visibility(m_inherited_properties_visible);
  object->set_highlight_active(m_highlight_active);
  addItem (object);
  ItemMap.insert(class_name, object);
}

add_note_slot

void dbse::SchemaGraphicsScene::add_note_slot ( SchemaGraphicNote * note )

privateslot

Definition at line 476 of file SchemaGraphicsScene.cpp.

                                                                   {
  addItem(note);
  modified(true);
}

add_notes()

void dbse::SchemaGraphicsScene::add_notes	(	QStringList	notes,
		QList< QPointF >	positions )

Definition at line 315 of file SchemaGraphicsScene.cpp.

                                                                      {
  for ( int index = 0; index<notes.size(); index++) {
    auto note = new SchemaGraphicNote (
      QString("#" + QString::number(m_next_note++)),
      notes.at(index) );
    note->setPos ( positions.at ( index ) );
    addItem(note);
  }
 
}

AddAllRelationshipClassesSlot

void dbse::SchemaGraphicsScene::AddAllRelationshipClassesSlot ( )

privateslot

Definition at line 644 of file SchemaGraphicsScene.cpp.

                                                            {
 
  QString class_name = QString::fromStdString ( CurrentObject->GetClass()->get_name() );
  OksClass * class_info = KernelWrapper::GetInstance().FindClass ( class_name.toStdString() );
  
  QStringList relationship_classes;
  QList<QPointF> positions;
 
  const std::list<OksRelationship *> * all_relationship_list = class_info->all_relationships();
  if ( all_relationship_list != nullptr ) {
      for(const OksRelationship* rl : *all_relationship_list) {
          relationship_classes.push_back(QString::fromStdString(rl->get_type()));
          positions.push_back({0,0});
      }
 
  }
 
  this->AddItemsToScene ( relationship_classes, positions );
}

AddAllSubClassesSlot

void dbse::SchemaGraphicsScene::AddAllSubClassesSlot ( )

privateslot

Definition at line 603 of file SchemaGraphicsScene.cpp.

                                                   {
 
  QString class_name = QString::fromStdString ( CurrentObject->GetClass()->get_name() );
  OksClass * class_info = KernelWrapper::GetInstance().FindClass ( class_name.toStdString() );
  
  QStringList sub_class_list;
  QList<QPointF> positions;
 
  const OksClass::FList* all_classes = class_info->all_sub_classes();
  if(all_classes != nullptr) {
      for(const OksClass* cl : *all_classes) {
          sub_class_list.push_back(QString::fromStdString(cl->get_name()));
          positions.push_back({0,0});
      }
  }
 
  this->AddItemsToScene ( sub_class_list, positions );
 
}

AddAllSuperClassesSlot

void dbse::SchemaGraphicsScene::AddAllSuperClassesSlot ( )

privateslot

Definition at line 582 of file SchemaGraphicsScene.cpp.

                                                     {
 
  QString class_name = QString::fromStdString ( CurrentObject->GetClass()->get_name() );
  OksClass * class_info = KernelWrapper::GetInstance().FindClass ( class_name.toStdString() );
  
  QStringList super_class_list;
  QList<QPointF> positions;
 
  const OksClass::FList* all_classes = class_info->all_super_classes();
  if(all_classes != nullptr) {
      for(const OksClass* cl : *all_classes) {
          super_class_list.push_back(QString::fromStdString(cl->get_name()));
          positions.push_back({0,0});
      }
  }
 
 
  this->AddItemsToScene ( super_class_list, positions );
 
}

AddDirectRelationshipClassesSlot

void dbse::SchemaGraphicsScene::AddDirectRelationshipClassesSlot ( )

privateslot

Definition at line 623 of file SchemaGraphicsScene.cpp.

                                                               {
 
  QString class_name = QString::fromStdString ( CurrentObject->GetClass()->get_name() );
  OksClass * class_info = KernelWrapper::GetInstance().FindClass ( class_name.toStdString() );
  
  QStringList relationship_classes;
  QList<QPointF> positions;
 
  const std::list<OksRelationship *> * direct_relationship_list = class_info->direct_relationships();
  if ( direct_relationship_list != nullptr ) {
      for(const OksRelationship* rl : *direct_relationship_list) {
          relationship_classes.push_back(QString::fromStdString(rl->get_type()));
          positions.push_back({0,0});
      }
 
  }
 
  this->AddItemsToScene ( relationship_classes, positions );
 
}

AddDirectSuperClassesSlot

void dbse::SchemaGraphicsScene::AddDirectSuperClassesSlot ( )

privateslot

Definition at line 562 of file SchemaGraphicsScene.cpp.

                                                        {
 
  QString class_name = QString::fromStdString ( CurrentObject->GetClass()->get_name() );
  OksClass * class_info = KernelWrapper::GetInstance().FindClass ( class_name.toStdString() );
  
  QStringList super_class_list;
  QList<QPointF> positions;
 
  const std::list<std::string *>* direct_classes = class_info->direct_super_classes();
  if(direct_classes != nullptr) {
      for(std::string * cl_name : *direct_classes) {
          super_class_list.push_back(QString::fromStdString(*cl_name));
          positions.push_back({0,0});
      }
  }
 
  this->AddItemsToScene ( super_class_list, positions );
 
}

AddItemsToScene()

QStringList dbse::SchemaGraphicsScene::AddItemsToScene	(	QStringList	SchemaClasses,
		QList< QPointF >	Positions )

Updating item list

Plotting the superclasses

Definition at line 212 of file SchemaGraphicsScene.cpp.

{
  QStringList missingItems{};
 
  for ( QString & ClassName : SchemaClasses )
  {
    if ( !ItemMap.contains ( ClassName ) )
    {
 
      if ( !KernelWrapper::GetInstance().FindClass ( ClassName.toStdString() ) ) {
          std::cout << "ERROR: class " << ClassName.toStdString()  << " not found" << std::endl;
          missingItems.append(ClassName);
          continue;
      }
 
      SchemaGraphicObject * Object = new SchemaGraphicObject ( ClassName );
      Object->setPos ( Positions.at ( SchemaClasses.indexOf ( ClassName ) ) );
      Object->set_inherited_properties_visibility(m_inherited_properties_visible);
      Object->set_highlight_active(m_highlight_active);
      addItem ( Object );
      ItemMap.insert ( ClassName, Object );
    }
  }
 
  for ( QString & ClassName : ItemMap.keys() )
  {
    OksClass * ClassInfo = KernelWrapper::GetInstance().FindClass ( ClassName.toStdString() );
 
    const std::list<OksRelationship *> * DirectRelationshipList =
      ClassInfo->direct_relationships();
    const std::list<std::string *> * DirectSuperClassesList = ClassInfo->direct_super_classes();
 
    std::map<std::string, unsigned int> arrow_count;
 
    if ( DirectRelationshipList != nullptr )
    {
      for ( OksRelationship * ClassRelationship : * ( DirectRelationshipList ) )
      {
        auto rct = ClassRelationship->get_class_type()->get_name();
        QString RelationshipClassType = QString::fromStdString (rct);
 
        if ( ItemMap.contains ( RelationshipClassType ) ) //&& !ItemMap[ClassName]->HasArrow (
          //ItemMap[RelationshipClassType] ) )
        {
          QString SchemaCardinality =
            KernelWrapper::GetInstance().GetCardinalityStringRelationship ( ClassRelationship ) + " ";
          SchemaGraphicSegmentedArrow * NewArrow = new SchemaGraphicSegmentedArrow (
            ItemMap[ClassName], ItemMap[RelationshipClassType],
            arrow_count[rct],
            false,
            ClassRelationship->get_is_composite(),
            QString::fromStdString ( ClassRelationship->get_name() ), SchemaCardinality );
          ItemMap[ClassName]->AddArrow ( NewArrow );
          ItemMap[RelationshipClassType]->AddArrow ( NewArrow );
          addItem ( NewArrow );
          //NewArrow->SetLabelScene(this);
          NewArrow->setZValue ( -1000.0 );
          NewArrow->UpdatePosition();
          arrow_count[rct]++;
        }
      }
    }
 
    if ( DirectSuperClassesList != nullptr )
    {
      for ( std::string * SuperClassNameStd : * ( DirectSuperClassesList ) )
      {
        QString SuperClassName = QString::fromStdString ( *SuperClassNameStd );
 
        if ( ItemMap.contains ( SuperClassName ) ) // && !ItemMap[ClassName]->HasArrow (
          // ItemMap[SuperClassName] ) )
        {
          SchemaGraphicSegmentedArrow * NewArrow = new SchemaGraphicSegmentedArrow (
            ItemMap[ClassName],
            ItemMap[SuperClassName],
            arrow_count[*SuperClassNameStd],
            true,
            false, "", "" );
          ItemMap[ClassName]->AddArrow ( NewArrow );
          ItemMap[SuperClassName]->AddArrow ( NewArrow );
          addItem ( NewArrow );
          //NewArrow->SetLabelScene(this);
          NewArrow->setZValue ( -1000.0 );
          NewArrow->UpdatePosition();
          arrow_count[*SuperClassNameStd]++;
        }
      }
    }
  }
  modified(true);
  return missingItems;
}

cancel_note_slot

void dbse::SchemaGraphicsScene::cancel_note_slot ( SchemaGraphicNote * note )

privateslot

Definition at line 480 of file SchemaGraphicsScene.cpp.

                                                                      {
  delete note;
}

CleanItemMap()

void dbse::SchemaGraphicsScene::CleanItemMap

(

)

Definition at line 345 of file SchemaGraphicsScene.cpp.

{
  ItemMap.clear();
}

ClearModified()

void dbse::SchemaGraphicsScene::ClearModified

(

)

Definition at line 387 of file SchemaGraphicsScene.cpp.

                                            {
  modified(false);
}

contextMenuEvent()

void dbse::SchemaGraphicsScene::contextMenuEvent

(

QGraphicsSceneContextMenuEvent *

event

)

Definition at line 134 of file SchemaGraphicsScene.cpp.

{
  if ( m_context_menu == nullptr ) {
    m_context_menu = new QMenu();
    m_context_menu->addAction ( m_add_class );
    m_context_menu->addAction ( m_add_note );
    m_context_menu->addAction ( m_toggle_indirect_infos );
    m_context_menu->addAction ( m_toggle_highlight_active );
 
    m_seperator_pos = m_context_menu->actions().size();
    m_context_menu->addSeparator();
 
    m_class_pos = m_context_menu->actions().size();
    m_context_menu->addAction ( m_edit_class );
    m_context_menu->addAction ( m_remove_class );
    m_context_menu->addAction ( m_add_direct_super_classes );
    m_context_menu->addAction ( m_add_direct_relationship_classes );
    m_context_menu->addAction ( m_add_all_super_classes );
    m_context_menu->addAction ( m_add_all_sub_classes );
    m_context_menu->addAction ( m_add_all_sub_classes );
    m_context_menu->addAction ( m_add_all_relationship_classes );
 
    m_arrow_pos = m_context_menu->actions().size();
    m_context_menu->addAction ( m_remove_arrow );
 
    m_note_pos = m_context_menu->actions().size();
    m_context_menu->addAction ( m_edit_note );
    m_context_menu->addAction ( m_remove_note );
  }
 
  for (int item=0; item<m_seperator_pos; item++) {
    m_context_menu->actions().at ( item )->setVisible ( true );
  }
 
  // Set all other items invisible
  int nitems = m_context_menu->actions().size();
  for (int item=m_seperator_pos; item<nitems; item++) {
    m_context_menu->actions().at ( item )->setVisible ( false );
  }
 
  if ( itemAt ( event->scenePos(), QTransform() ) ) {
    // Something under mouse pointer, set additional items visible
    // depending on what it is
    m_context_menu->actions().at ( m_seperator_pos )->setVisible ( true );
 
    auto object = dynamic_cast<SchemaGraphicObject *> (
      itemAt ( event->scenePos(), QTransform() ) );
    auto arrow = dynamic_cast<SchemaGraphicSegmentedArrow *> (
      itemAt ( event->scenePos(), QTransform() ) );
    auto note = dynamic_cast<SchemaGraphicNote *> (
      itemAt ( event->scenePos(), QTransform() ) );
 
    if ( object != nullptr) {
      CurrentObject = object;
      auto filename =
        CurrentObject->GetClass()->get_file()->get_full_file_name();
      bool writable = KernelWrapper::GetInstance().IsFileWritable ( filename );
      m_context_menu->actions().at ( m_class_pos )->setVisible ( writable );
      m_context_menu->actions().at ( m_class_pos+1 )->setVisible ( writable );
      for (int item=m_class_pos+2; item<m_arrow_pos; item++) {
        m_context_menu->actions().at ( item )->setVisible ( true );
      }
    }
    else if ( arrow != nullptr ) {
      m_context_menu->actions().at ( m_arrow_pos )->setVisible ( true );
      m_current_arrow = arrow;
    }
    else if ( note != nullptr) {
      for (int item=m_note_pos; item<nitems; item++) {
        m_context_menu->actions().at ( item )->setVisible ( true );
      }
      m_current_note = note;
    }
  }
  m_current_pos = event->scenePos();
  m_context_menu->exec ( event->screenPos() );
}

CreateActions()

void dbse::SchemaGraphicsScene::CreateActions

(

)

Definition at line 39 of file SchemaGraphicsScene.cpp.

{
  // Add new class
  m_add_class = new QAction ( "&Add new class", this );
  connect ( m_add_class, SIGNAL ( triggered() ), this, SLOT ( new_class_slot() ) );
 
  // Edit current class
  m_edit_class = new QAction ( "&Edit class", this );
  connect ( m_edit_class, SIGNAL ( triggered() ), this, SLOT ( EditClassSlot() ) );
 
  // Toggle inherited properties of all classes in view
  m_toggle_indirect_infos = new QAction ( "&Toggle inherited properties", this );
  connect ( m_toggle_indirect_infos, SIGNAL ( triggered() ), this, SLOT ( ToggleIndirectInfos() ) );
 
  // Toggle highlighting of all classes in active schema
  m_toggle_highlight_active = new QAction ( "Toggle &highlighting of classes in active schema", this );
  connect ( m_toggle_highlight_active, SIGNAL ( triggered() ), this, SLOT ( ToggleHighlightActive() ) );
 
  m_add_note = new QAction ( "Add note to view", this );
  connect ( m_add_note, SIGNAL ( triggered() ), this, SLOT ( new_note_slot() ) );
 
  m_edit_note = new QAction ( "Edit note", this );
  connect ( m_edit_note, SIGNAL ( triggered() ), this, SLOT ( edit_note_slot() ) );
 
  m_remove_note = new QAction ( "Remove note", this );
  connect ( m_remove_note, SIGNAL ( triggered() ), this, SLOT ( remove_note_slot() ) );
 
  // Show superclasses of the current class
  m_add_direct_super_classes = new QAction ( "Add direct &superclasses to view", this );
  connect ( m_add_direct_super_classes, SIGNAL ( triggered() ), this, SLOT ( AddDirectSuperClassesSlot() ) );
 
  // Show relationship classes of the current clas
  m_add_direct_relationship_classes = new QAction ( "Add &direct relationship classes to view", this );
  connect ( m_add_direct_relationship_classes, SIGNAL ( triggered() ), this, SLOT ( AddDirectRelationshipClassesSlot() ) );
  
  // Show superclasses of the current class
  m_add_all_super_classes = new QAction ( "Add all &superclasses to view", this );
  connect ( m_add_all_super_classes, SIGNAL ( triggered() ), this, SLOT ( AddAllSuperClassesSlot() ) );
 
  // Show subclasses of the current clas
  m_add_all_sub_classes = new QAction ( "Add all s&ubclasses to view", this );
  connect ( m_add_all_sub_classes, SIGNAL ( triggered() ), this, SLOT ( AddAllSubClassesSlot() ) );
 
  // Show indirect relationship classes of the current class
  m_add_all_relationship_classes = new QAction ( "Add a&ll relationship classes to view", this );
  connect ( m_add_all_relationship_classes, SIGNAL ( triggered() ), this, SLOT ( AddAllRelationshipClassesSlot() ) );
 
  // Remove class
  m_remove_class = new QAction ( "&Remove Class from view", this );
  connect ( m_remove_class, SIGNAL ( triggered() ), this, SLOT ( RemoveClassSlot() ) );
 
  // Remove arrow
  m_remove_arrow = new QAction ( "&Remove Arrow", this );
  connect ( m_remove_arrow, SIGNAL ( triggered() ), this, SLOT ( RemoveArrowSlot() ) );
}

dragEnterEvent()

void dbse::SchemaGraphicsScene::dragEnterEvent

(

QGraphicsSceneDragDropEvent *

event

)

Drag & Drop.

Definition at line 95 of file SchemaGraphicsScene.cpp.

{
  if ( event->mimeData()->hasFormat ( "application/vnd.text.list" ) )
  {
    event->accept();
  }
}

dragMoveEvent()

void dbse::SchemaGraphicsScene::dragMoveEvent

(

QGraphicsSceneDragDropEvent *

event

)

Definition at line 103 of file SchemaGraphicsScene.cpp.

{
  if ( event->mimeData()->hasFormat ( "application/vnd.text.list" ) )
  {
    event->accept();
  }
}

DrawArrow

void dbse::SchemaGraphicsScene::DrawArrow ( QString ClassName, QString RelationshipType, QString RelationshipName )

privateslot

Definition at line 684 of file SchemaGraphicsScene.cpp.

{
  if ( !ItemMap.contains ( ClassName ) || !ItemMap.contains ( RelationshipType ) )
  {
    return;
  }
 
  SchemaGraphicObject * startItem = ItemMap[ClassName];
  SchemaGraphicObject * endItem = ItemMap[RelationshipType];
 
  OksClass * SchemaClass = KernelWrapper::GetInstance().FindClass ( ClassName.toStdString() );
  OksRelationship * SchemaRelationship = SchemaClass->find_direct_relationship (
                                           RelationshipName.toStdString() );
 
  if ( SchemaRelationship != nullptr )
  {
    QString RelationshipCardinality =
      KernelWrapper::GetInstance().GetCardinalityStringRelationship ( SchemaRelationship );
    SchemaGraphicSegmentedArrow * newArrow = new SchemaGraphicSegmentedArrow (
      startItem, endItem,
      0,
      false, SchemaRelationship->get_is_composite(),
      QString::fromStdString ( SchemaRelationship->get_name() ), RelationshipCardinality );
    startItem->AddArrow ( newArrow );
    endItem->AddArrow ( newArrow );
    newArrow->setZValue ( -1000.0 );
    addItem ( newArrow );
    //newArrow->SetLabelScene(this);
    newArrow->UpdatePosition();
  }
}

dropEvent()

void dbse::SchemaGraphicsScene::dropEvent

(

QGraphicsSceneDragDropEvent *

event

)

Definition at line 111 of file SchemaGraphicsScene.cpp.

{
  QByteArray encodedData = event->mimeData()->data ( "application/vnd.text.list" );
  QDataStream stream ( &encodedData, QIODevice::ReadOnly );
  QStringList SchemaClasses;
 
  while ( !stream.atEnd() )
  {
    QString ClassName;
    stream >> ClassName;
    SchemaClasses.append ( ClassName );
  }
 
  QList<QPointF> Positions;
 
  for ( int i = 0; i < SchemaClasses.size(); ++i )
  {
    Positions.push_back ( event->scenePos() );
  }
 
  AddItemsToScene ( SchemaClasses, Positions );
}

edit_note_slot

void dbse::SchemaGraphicsScene::edit_note_slot ( )

privateslot

Definition at line 468 of file SchemaGraphicsScene.cpp.

                                             {
  m_current_note->open_editor();
}

EditClassSlot

void dbse::SchemaGraphicsScene::EditClassSlot ( )

privateslot

Definition at line 512 of file SchemaGraphicsScene.cpp.

{
  bool WidgetFound = false;
  QString ClassName = QString::fromStdString ( CurrentObject->GetClass()->get_name() );
 
  for ( QWidget * Editor : QApplication::allWidgets() )
  {
    SchemaClassEditor * Widget = dynamic_cast<SchemaClassEditor *> ( Editor );
 
    if ( Widget != nullptr )
    {
      if ( ( Widget->objectName() ).compare ( ClassName ) == 0 )
      {
        Widget->raise();
        Widget->setVisible ( true );
        Widget->activateWindow();
        WidgetFound = true;
      }
    }
  }
 
  if ( !WidgetFound )
  {
    SchemaClassEditor * Editor = new SchemaClassEditor ( CurrentObject->GetClass() );
    Editor->show();
  }
}

IsModified()

bool dbse::SchemaGraphicsScene::IsModified ( ) const

inlinenodiscard

Definition at line 34 of file SchemaGraphicsScene.hpp.

{return m_modified;};

modified()

void dbse::SchemaGraphicsScene::modified ( bool state )

protected

Definition at line 391 of file SchemaGraphicsScene.cpp.

                                                 {
  m_modified = state;
  emit sceneModified(state);
}

modified_slot

void dbse::SchemaGraphicsScene::modified_slot ( )

privateslot

Definition at line 396 of file SchemaGraphicsScene.cpp.

                                            {
  modified(true);
}

mouseMoveEvent()

void dbse::SchemaGraphicsScene::mouseMoveEvent ( QGraphicsSceneMouseEvent * mouseEvent )

protected

Definition at line 374 of file SchemaGraphicsScene.cpp.

{
  if ( m_line != nullptr )
  {
    QLineF newLine ( m_line->line().p1(), mouseEvent->scenePos() );
    m_line->setLine ( newLine );
  }
  else
  {
    QGraphicsScene::mouseMoveEvent ( mouseEvent );
  }
}

mousePressEvent()

void dbse::SchemaGraphicsScene::mousePressEvent ( QGraphicsSceneMouseEvent * mouseEvent )

protected

Definition at line 350 of file SchemaGraphicsScene.cpp.

{
  if ( itemAt ( mouseEvent->scenePos(), QTransform() ) ) {
    // Save position of item under mouse so we can see if it has been
    // moved in mouseReleaseEvent
    m_mouse_item_pos = itemAt(mouseEvent->scenePos(), QTransform())->pos();
  }
  if ( mouseEvent->button() != Qt::LeftButton )
  {
    return;
  }
 
  if ( mouseEvent->widget()->cursor().shape() == Qt::CrossCursor )
  {
    m_line = new QGraphicsLineItem ( QLineF ( mouseEvent->scenePos(), mouseEvent->scenePos() ) );
    m_line->setPen ( QPen ( Qt::black, 2 ) );
    addItem ( m_line );
    modified(true);
    return;
  }
 
  QGraphicsScene::mousePressEvent ( mouseEvent );
}

mouseReleaseEvent()

void dbse::SchemaGraphicsScene::mouseReleaseEvent ( QGraphicsSceneMouseEvent * mouseEvent )

protected

Create arrow

Definition at line 399 of file SchemaGraphicsScene.cpp.

{
  if ( itemAt ( mouseEvent->scenePos(), QTransform() ) ) {
    auto item = itemAt(mouseEvent->scenePos(), QTransform() );
    if (!m_mouse_item_pos.isNull()) {
      modified(m_mouse_item_pos != item->pos());
      m_mouse_item_pos = QPointF();
    }
  }
  if ( m_line != nullptr )
  {
    QList<QGraphicsItem *> startItems = items ( m_line->line().p1() );
 
    if ( startItems.count() && startItems.first() == m_line )
    {
      startItems.removeFirst();
    }
 
    QList<QGraphicsItem *> endItems = items ( m_line->line().p2() );
 
    if ( endItems.count() && endItems.first() == m_line )
    {
      endItems.removeFirst();
    }
 
    RemoveItemFromScene ( m_line );
    delete m_line;
 
    if ( startItems.count() > 0 && endItems.count() > 0
         && startItems.first() != endItems.first() )
    {
 
      bool Inheritance = KernelWrapper::GetInstance().GetInheritanceMode();
      SchemaGraphicObject * startItem = qgraphicsitem_cast<SchemaGraphicObject *> (
                                          startItems.first() );
      SchemaGraphicObject * endItem = qgraphicsitem_cast<SchemaGraphicObject *> (
                                        endItems.first() );
 
      if ( Inheritance )
      {
        startItem->GetClass()->add_super_class ( endItem->GetClassName().toStdString() );
        SchemaGraphicSegmentedArrow * newArrow = new SchemaGraphicSegmentedArrow (
          startItem, endItem,
          0,
          Inheritance,
          true, "", "" );
        startItem->AddArrow ( newArrow );
        endItem->AddArrow ( newArrow );
        newArrow->setZValue ( -1000.0 );
        addItem ( newArrow );
        //newArrow->SetLabelScene(this);
        newArrow->UpdatePosition();
      }
      else
      {
        SchemaRelationshipEditor * Editor = new SchemaRelationshipEditor (
          startItem->GetClass(), endItem->GetClassName() );
        connect ( Editor, SIGNAL ( MakeGraphConnection ( QString, QString, QString ) ), this,
                  SLOT ( DrawArrow ( QString, QString, QString ) ) );
        Editor->show();
      }
    }
  }
 
  m_line = nullptr;
  QGraphicsScene::mouseReleaseEvent ( mouseEvent );
}

new_class_slot

void dbse::SchemaGraphicsScene::new_class_slot ( )

privateslot

Definition at line 505 of file SchemaGraphicsScene.cpp.

                                             {
  m_addclass_connection = connect (
    &KernelWrapper::GetInstance(), SIGNAL ( ClassCreated(QString) ),
    this, SLOT ( add_class_slot(QString) ) );
  SchemaClassEditor::createNewClass();
}

new_note_slot

void dbse::SchemaGraphicsScene::new_note_slot ( )

privateslot

Definition at line 484 of file SchemaGraphicsScene.cpp.

                                            {
  auto note = new SchemaGraphicNote (
    QString("#") + QString::number(m_next_note++), QString());
  note->setPos(m_current_pos);
  auto editor = new SchemaNoteEditor(note);
  connect(editor, SIGNAL(note_accepted(SchemaGraphicNote*)), this, SLOT(add_note_slot(SchemaGraphicNote*)));
  connect(editor, SIGNAL(cancelled(SchemaGraphicNote*)), this, SLOT(cancel_note_slot(SchemaGraphicNote*)));
  editor->show();
}

remove_note_object()

void dbse::SchemaGraphicsScene::remove_note_object

(

SchemaGraphicNote *

obj

)

Definition at line 326 of file SchemaGraphicsScene.cpp.

                                                                          {
  if (note == nullptr) {
    return;
  }
  RemoveItemFromScene (note);
}

remove_note_slot

void dbse::SchemaGraphicsScene::remove_note_slot ( )

privateslot

Definition at line 472 of file SchemaGraphicsScene.cpp.

                                               {
  remove_note_object(m_current_note);
}

RemoveArrowSlot

void dbse::SchemaGraphicsScene::RemoveArrowSlot ( )

privateslot

Definition at line 676 of file SchemaGraphicsScene.cpp.

{
  RemoveItemFromScene ( m_current_arrow );
  m_current_arrow->GetStartItem()->RemoveArrow ( m_current_arrow );
  m_current_arrow->GetEndItem()->RemoveArrow ( m_current_arrow );
  m_current_arrow->RemoveArrow();
}

RemoveClassObject()

void dbse::SchemaGraphicsScene::RemoveClassObject

(

SchemaGraphicObject *

Object

)

Definition at line 333 of file SchemaGraphicsScene.cpp.

{
  if ( Object == nullptr )
  {
    return;
  }
 
  Object->RemoveArrows();
  RemoveItemFromScene ( Object );
  ItemMap.remove ( Object->GetClassName() );
}

RemoveClassSlot

void dbse::SchemaGraphicsScene::RemoveClassSlot ( )

privateslot

Definition at line 664 of file SchemaGraphicsScene.cpp.

{
  if ( CurrentObject == nullptr )
  {
    return;
  }
 
  CurrentObject->RemoveArrows();
  RemoveItemFromScene ( CurrentObject );
  ItemMap.remove ( CurrentObject->GetClassName() );
}

RemoveItemFromScene()

void dbse::SchemaGraphicsScene::RemoveItemFromScene ( QGraphicsItem * item )

protected

Definition at line 310 of file SchemaGraphicsScene.cpp.

                                                                        {
  removeItem ( item );
  modified(true);
}

sceneModified

void dbse::SchemaGraphicsScene::sceneModified ( bool )

signal

ToggleHighlightActive

void dbse::SchemaGraphicsScene::ToggleHighlightActive ( )

privateslot

Definition at line 540 of file SchemaGraphicsScene.cpp.

                                                    {
  m_highlight_active = !m_highlight_active;
 
  for ( SchemaGraphicObject * item : ItemMap.values() ) {
    item->set_highlight_active(m_highlight_active);
  }
 
  this->update();
 
}

ToggleIndirectInfos

void dbse::SchemaGraphicsScene::ToggleIndirectInfos ( )

privateslot

Definition at line 551 of file SchemaGraphicsScene.cpp.

                                                  {
  m_inherited_properties_visible = !m_inherited_properties_visible;
 
  for ( SchemaGraphicObject * item : ItemMap.values() ) {
    item->set_inherited_properties_visibility(m_inherited_properties_visible);
  }
 
  this->update();
 
}

Member Data Documentation

CurrentObject

SchemaGraphicObject* dbse::SchemaGraphicsScene::CurrentObject

private

Definition at line 88 of file SchemaGraphicsScene.hpp.

ItemMap

QMap<QString, SchemaGraphicObject *> dbse::SchemaGraphicsScene::ItemMap

private

Definition at line 66 of file SchemaGraphicsScene.hpp.

m_add_all_relationship_classes

QAction* dbse::SchemaGraphicsScene::m_add_all_relationship_classes

private

Definition at line 81 of file SchemaGraphicsScene.hpp.

m_add_all_sub_classes

QAction* dbse::SchemaGraphicsScene::m_add_all_sub_classes

private

Definition at line 80 of file SchemaGraphicsScene.hpp.

m_add_all_super_classes

QAction* dbse::SchemaGraphicsScene::m_add_all_super_classes

private

Definition at line 79 of file SchemaGraphicsScene.hpp.

m_add_class

QAction* dbse::SchemaGraphicsScene::m_add_class

private

Definition at line 73 of file SchemaGraphicsScene.hpp.

m_add_direct_relationship_classes

QAction* dbse::SchemaGraphicsScene::m_add_direct_relationship_classes

private

Definition at line 78 of file SchemaGraphicsScene.hpp.

m_add_direct_super_classes

QAction* dbse::SchemaGraphicsScene::m_add_direct_super_classes

private

Definition at line 77 of file SchemaGraphicsScene.hpp.

m_add_note

QAction* dbse::SchemaGraphicsScene::m_add_note

private

Definition at line 82 of file SchemaGraphicsScene.hpp.

m_addclass_connection

QMetaObject::Connection dbse::SchemaGraphicsScene::m_addclass_connection

private

Definition at line 87 of file SchemaGraphicsScene.hpp.

m_arrow_pos

int dbse::SchemaGraphicsScene::m_arrow_pos

private

Definition at line 71 of file SchemaGraphicsScene.hpp.

m_class_pos

int dbse::SchemaGraphicsScene::m_class_pos

private

Definition at line 70 of file SchemaGraphicsScene.hpp.

m_context_menu

QMenu* dbse::SchemaGraphicsScene::m_context_menu

private

Definition at line 68 of file SchemaGraphicsScene.hpp.

m_current_arrow

SchemaGraphicSegmentedArrow* dbse::SchemaGraphicsScene::m_current_arrow

private

Definition at line 89 of file SchemaGraphicsScene.hpp.

m_current_note

SchemaGraphicNote* dbse::SchemaGraphicsScene::m_current_note

private

Definition at line 90 of file SchemaGraphicsScene.hpp.

m_current_pos

QPointF dbse::SchemaGraphicsScene::m_current_pos

private

Definition at line 91 of file SchemaGraphicsScene.hpp.

m_edit_class

QAction* dbse::SchemaGraphicsScene::m_edit_class

private

Definition at line 74 of file SchemaGraphicsScene.hpp.

m_edit_note

QAction* dbse::SchemaGraphicsScene::m_edit_note

private

Definition at line 83 of file SchemaGraphicsScene.hpp.

m_highlight_active

bool dbse::SchemaGraphicsScene::m_highlight_active

private

Definition at line 95 of file SchemaGraphicsScene.hpp.

m_inherited_properties_visible

bool dbse::SchemaGraphicsScene::m_inherited_properties_visible

private

Definition at line 94 of file SchemaGraphicsScene.hpp.

m_line

QGraphicsLineItem* dbse::SchemaGraphicsScene::m_line

private

Definition at line 67 of file SchemaGraphicsScene.hpp.

m_modified

bool dbse::SchemaGraphicsScene::m_modified

private

Definition at line 96 of file SchemaGraphicsScene.hpp.

m_mouse_item_pos

QPointF dbse::SchemaGraphicsScene::m_mouse_item_pos

private

Definition at line 92 of file SchemaGraphicsScene.hpp.

m_next_note

int dbse::SchemaGraphicsScene::m_next_note {0}

private

Definition at line 93 of file SchemaGraphicsScene.hpp.

{0};

m_note_pos

int dbse::SchemaGraphicsScene::m_note_pos

private

Definition at line 72 of file SchemaGraphicsScene.hpp.

m_remove_arrow

QAction* dbse::SchemaGraphicsScene::m_remove_arrow

private

Definition at line 86 of file SchemaGraphicsScene.hpp.

m_remove_class

QAction* dbse::SchemaGraphicsScene::m_remove_class

private

Definition at line 85 of file SchemaGraphicsScene.hpp.

m_remove_note

QAction* dbse::SchemaGraphicsScene::m_remove_note

private

Definition at line 84 of file SchemaGraphicsScene.hpp.

m_seperator_pos

int dbse::SchemaGraphicsScene::m_seperator_pos

private

Definition at line 69 of file SchemaGraphicsScene.hpp.

m_toggle_highlight_active

QAction* dbse::SchemaGraphicsScene::m_toggle_highlight_active

private

Definition at line 76 of file SchemaGraphicsScene.hpp.

m_toggle_indirect_infos

QAction* dbse::SchemaGraphicsScene::m_toggle_indirect_infos

private

Definition at line 75 of file SchemaGraphicsScene.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/SchemaGraphicsScene.hpp
• /github/workspace/dunedaq/sourcecode/dbe/apps/SchemaEditor/SchemaGraphicsScene.cpp