dbse::SchemaGraphicsScene Class Reference

#include <SchemaGraphicsScene.hpp>

Inheritance diagram for dbse::SchemaGraphicsScene:

Collaboration diagram for dbse::SchemaGraphicsScene:

Signals
void	sceneModified (bool)
void	saveRequested ()

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	highlight_abstract () const
bool	highlight_active () const
bool	inherited_properties_visible () const
bool	show_defaults () const
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	ToggleHighlightAbstract ()
void	ToggleHighlightActive ()
void	ToggleHighlightClass ()
void	ToggleDefault ()
void	AddDirectSuperClassesSlot ()
void	AddAllSuperClassesSlot ()
void	AddAllSubClassesSlot ()
void	AddDirectRelationshipClassesSlot ()
void	AddAllRelationshipClassesSlot ()
void	RemoveClassSlot ()
void	RemoveArrowSlot ()
void	DrawArrow (QString ClassName, QString RelationshipType, QString RelationshipName)
void	requestSave ()
void	moveScene ()

Private Attributes
QMap< QString, SchemaGraphicObject * >	ItemMap
std::set< SchemaGraphicNote * >	m_notes
QGraphicsLineItem *	m_line
QMenu *	m_context_menu
int	m_seperator_pos
int	m_class_pos
int	m_arrow_pos
int	m_note_pos
int	m_save_pos
QAction *	m_add_class
QAction *	m_edit_class
QAction *	m_toggle_indirect_infos
QAction *	m_toggle_highlight_abstract
QAction *	m_toggle_highlight_active
QAction *	m_toggle_highlight_class
QAction *	m_toggle_default
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
QAction *	m_save
QAction *	m_move
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_abstract
bool	m_highlight_active
bool	m_show_defaults
bool	m_modified

Detailed Description

Definition at line 14 of file SchemaGraphicsScene.hpp.

Constructor & Destructor Documentation

SchemaGraphicsScene()

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

explicit

Definition at line 23 of file SchemaGraphicsScene.cpp.

  : QGraphicsScene(parent)
  , m_line(nullptr)
  , m_context_menu(nullptr)
  , CurrentObject(nullptr)
  , m_current_arrow(nullptr)
  , m_modified(false)
{
  setSceneRect(QRectF(0, 0, 10000, 10000));
 
  QSettings settings;
  settings.beginGroup("view defaults");
 
  m_inherited_properties_visible = settings.value("show_inherited", false).toBool();
  m_highlight_abstract = settings.value("highlight_abstract", false).toBool();
  m_highlight_active = settings.value("highlight_active", false).toBool();
  m_show_defaults = settings.value("show_default", false).toBool();
 
  CreateActions();
}

~SchemaGraphicsScene()

dbse::SchemaGraphicsScene::~SchemaGraphicsScene

(

)

Definition at line 44 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 580 of file SchemaGraphicsScene.cpp.

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

add_note_slot

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

privateslot

Definition at line 555 of file SchemaGraphicsScene.cpp.

{
  m_notes.insert(note);
  addItem(note);
  modified(true);
}

add_notes()

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

Definition at line 360 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));
    m_notes.insert(note);
    addItem(note);
  }
}

AddAllRelationshipClassesSlot

void dbse::SchemaGraphicsScene::AddAllRelationshipClassesSlot ( )

privateslot

Definition at line 732 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 690 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 669 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 711 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 648 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 268 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, this);
      Object->setPos(Positions.at(SchemaClasses.indexOf(ClassName)));
      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 562 of file SchemaGraphicsScene.cpp.

{
  m_notes.erase(note);
  delete note;
}

CleanItemMap()

void dbse::SchemaGraphicsScene::CleanItemMap

(

)

Definition at line 391 of file SchemaGraphicsScene.cpp.

{
  ItemMap.clear();
}

ClearModified()

void dbse::SchemaGraphicsScene::ClearModified

(

)

Definition at line 431 of file SchemaGraphicsScene.cpp.

{
  modified(false);
}

contextMenuEvent()

void dbse::SchemaGraphicsScene::contextMenuEvent

(

QGraphicsSceneContextMenuEvent *

event

)

Definition at line 172 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_abstract);
    m_context_menu->addAction(m_toggle_highlight_active);
    m_context_menu->addAction(m_toggle_default);
 
    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_toggle_highlight_class);
    m_context_menu->addSeparator();
 
    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);
 
    m_context_menu->addSeparator();
    m_save_pos = m_context_menu->actions().size();
    m_context_menu->addAction(m_save);
    m_context_menu->addAction(m_move);
  }
 
  bool active = KernelWrapper::GetInstance().IsActive();
  m_context_menu->actions().at(0)->setVisible(active);
 
  for (int item = 1; item < m_seperator_pos; item++) {
    m_context_menu->actions().at(item)->setVisible(true);
  }
 
  // Set all other items invisible
  const auto nitems = m_context_menu->actions().size();
  for (int item = m_seperator_pos; item < nitems; item++) {
    m_context_menu->actions().at(item)->setVisible(false);
  }
 
  if (ItemMap.size() > 0) {
    m_context_menu->actions().at(m_save_pos - 1)->setVisible(true);
    m_context_menu->actions().at(m_save_pos + 1)->setVisible(true);
  }
  if (m_modified && ItemMap.size() > 0) {
    m_context_menu->actions().at(m_save_pos)->setVisible(true);
  }
 
  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;
      m_toggle_highlight_class->setChecked(CurrentObject->highlighted());
 
      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);
 
      for (int item = m_class_pos + 1; 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 47 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("Show &inherited properties", this);
  m_toggle_indirect_infos->setCheckable(true);
  m_toggle_indirect_infos->setChecked(m_inherited_properties_visible);
  connect(m_toggle_indirect_infos, SIGNAL(triggered()), this, SLOT(ToggleIndirectInfos()));
 
  // Toggle highlighting of all classes in active schema
  m_toggle_highlight_active = new QAction("&Highlight classes in active schema", this);
  m_toggle_highlight_active->setCheckable(true);
  m_toggle_highlight_active->setChecked(m_highlight_active);
  connect(m_toggle_highlight_active, SIGNAL(triggered()), this, SLOT(ToggleHighlightActive()));
 
  // Toggle highlighting of all abstract classes in view
  m_toggle_highlight_abstract = new QAction("&Highlight abstract classes in view", this);
  m_toggle_highlight_abstract->setCheckable(true);
  m_toggle_highlight_abstract->setChecked(m_highlight_abstract);
  connect(m_toggle_highlight_abstract, SIGNAL(triggered()), this, SLOT(ToggleHighlightAbstract()));
 
  // Toggle displaying default values of attributes
  m_toggle_default = new QAction("Show &default values of attributes", this);
  m_toggle_default->setCheckable(true);
  m_toggle_default->setChecked(m_show_defaults);
  connect(m_toggle_default, SIGNAL(triggered()), this, SLOT(ToggleDefault()));
 
  // Toggle highlighting of current class
  m_toggle_highlight_class = new QAction("&Highlight this class", this);
  m_toggle_highlight_class->setCheckable(true);
  connect(m_toggle_highlight_class, SIGNAL(triggered()), this, SLOT(ToggleHighlightClass()));
 
  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 all &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()));
 
  m_save = new QAction("&Save view", this);
  connect(m_save, SIGNAL(triggered()), this, SLOT(requestSave()));
 
  m_move = new QAction("&Move scene", this);
  connect(m_move, SIGNAL(triggered()), this, SLOT(moveScene()));
}

dragEnterEvent()

void dbse::SchemaGraphicsScene::dragEnterEvent

(

QGraphicsSceneDragDropEvent *

event

)

Drag & Drop.

Definition at line 131 of file SchemaGraphicsScene.cpp.

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

dragMoveEvent()

void dbse::SchemaGraphicsScene::dragMoveEvent

(

QGraphicsSceneDragDropEvent *

event

)

Definition at line 139 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 774 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 147 of file SchemaGraphicsScene.cpp.

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

edit_note_slot

void dbse::SchemaGraphicsScene::edit_note_slot ( )

privateslot

Definition at line 543 of file SchemaGraphicsScene.cpp.

{
  m_current_note->open_editor();
}

EditClassSlot

void dbse::SchemaGraphicsScene::EditClassSlot ( )

privateslot

Definition at line 599 of file SchemaGraphicsScene.cpp.

{
  QString class_name = QString::fromStdString(CurrentObject->GetClass()->get_name());
  SchemaClassEditor::launch(class_name);
}

highlight_abstract()

bool dbse::SchemaGraphicsScene::highlight_abstract ( ) const

inlinenodiscard

Definition at line 33 of file SchemaGraphicsScene.hpp.

{ return m_highlight_abstract; }

highlight_active()

bool dbse::SchemaGraphicsScene::highlight_active ( ) const

inlinenodiscard

Definition at line 34 of file SchemaGraphicsScene.hpp.

{ return m_highlight_active; }

inherited_properties_visible()

bool dbse::SchemaGraphicsScene::inherited_properties_visible ( ) const

inlinenodiscard

Definition at line 35 of file SchemaGraphicsScene.hpp.

{ return m_inherited_properties_visible; }

IsModified()

bool dbse::SchemaGraphicsScene::IsModified ( ) const

inlinenodiscard

Definition at line 38 of file SchemaGraphicsScene.hpp.

{ return m_modified; };

modified()

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

protected

Definition at line 437 of file SchemaGraphicsScene.cpp.

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

modified_slot

void dbse::SchemaGraphicsScene::modified_slot ( )

privateslot

Definition at line 478 of file SchemaGraphicsScene.cpp.

{
  modified(true);
}

mouseMoveEvent()

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

protected

Definition at line 420 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 397 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 483 of file SchemaGraphicsScene.cpp.

{
  if (itemAt(mouseEvent->scenePos(), QTransform())) {
    auto item = itemAt(mouseEvent->scenePos(), QTransform());
    if (!m_mouse_item_pos.isNull()) {
      if (m_mouse_item_pos != item->pos()) {
        modified(true);
      }
      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);
}

moveScene

void dbse::SchemaGraphicsScene::moveScene ( )

privateslot

Definition at line 444 of file SchemaGraphicsScene.cpp.

{
  qreal minx = 1e6;
  qreal miny = 1e6;
  for (auto obj : ItemMap) {
    auto pos = obj->pos();
    if (pos.x() < minx) {
      minx = pos.x();
    }
    if (pos.y() < miny) {
      miny = pos.y();
    }
  }
  qreal xoffset = m_current_pos.x() - minx;
  qreal yoffset = m_current_pos.y() - miny;
  for (auto obj : ItemMap) {
    obj->setX(obj->x() + xoffset);
    obj->setY(obj->y() + yoffset);
    obj->update_arrows();
  }
  for (auto obj : m_notes) {
    obj->setX(obj->x() + xoffset);
    obj->setY(obj->y() + yoffset);
  }
  update();
  modified(true);
}

new_class_slot

void dbse::SchemaGraphicsScene::new_class_slot ( )

privateslot

Definition at line 591 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 569 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 370 of file SchemaGraphicsScene.cpp.

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

remove_note_slot

void dbse::SchemaGraphicsScene::remove_note_slot ( )

privateslot

Definition at line 549 of file SchemaGraphicsScene.cpp.

{
  remove_note_object(m_current_note);
}

RemoveArrowSlot

void dbse::SchemaGraphicsScene::RemoveArrowSlot ( )

privateslot

Definition at line 765 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 379 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 753 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 353 of file SchemaGraphicsScene.cpp.

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

requestSave

void dbse::SchemaGraphicsScene::requestSave ( )

privateslot

Definition at line 473 of file SchemaGraphicsScene.cpp.

{
  emit saveRequested();
}

saveRequested

void dbse::SchemaGraphicsScene::saveRequested ( )

signal

sceneModified

void dbse::SchemaGraphicsScene::sceneModified ( bool )

signal

show_defaults()

bool dbse::SchemaGraphicsScene::show_defaults ( ) const

inlinenodiscard

Definition at line 37 of file SchemaGraphicsScene.hpp.

{ return m_show_defaults; };

ToggleDefault

void dbse::SchemaGraphicsScene::ToggleDefault ( )

privateslot

Definition at line 627 of file SchemaGraphicsScene.cpp.

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

ToggleHighlightAbstract

void dbse::SchemaGraphicsScene::ToggleHighlightAbstract ( )

privateslot

Definition at line 620 of file SchemaGraphicsScene.cpp.

{
  m_highlight_abstract = !m_highlight_abstract;
  this->update();
}

ToggleHighlightActive

void dbse::SchemaGraphicsScene::ToggleHighlightActive ( )

privateslot

Definition at line 613 of file SchemaGraphicsScene.cpp.

{
  m_highlight_active = !m_highlight_active;
  this->update();
}

ToggleHighlightClass

void dbse::SchemaGraphicsScene::ToggleHighlightClass ( )

privateslot

Definition at line 606 of file SchemaGraphicsScene.cpp.

{
  CurrentObject->toggle_highlight_class();
  this->update();
}

ToggleIndirectInfos

void dbse::SchemaGraphicsScene::ToggleIndirectInfos ( )

privateslot

Definition at line 637 of file SchemaGraphicsScene.cpp.

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

Member Data Documentation

CurrentObject

SchemaGraphicObject* dbse::SchemaGraphicsScene::CurrentObject

private

Definition at line 107 of file SchemaGraphicsScene.hpp.

ItemMap

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

private

Definition at line 78 of file SchemaGraphicsScene.hpp.

m_add_all_relationship_classes

QAction* dbse::SchemaGraphicsScene::m_add_all_relationship_classes

private

Definition at line 98 of file SchemaGraphicsScene.hpp.

m_add_all_sub_classes

QAction* dbse::SchemaGraphicsScene::m_add_all_sub_classes

private

Definition at line 97 of file SchemaGraphicsScene.hpp.

m_add_all_super_classes

QAction* dbse::SchemaGraphicsScene::m_add_all_super_classes

private

Definition at line 96 of file SchemaGraphicsScene.hpp.

m_add_class

QAction* dbse::SchemaGraphicsScene::m_add_class

private

Definition at line 87 of file SchemaGraphicsScene.hpp.

m_add_direct_relationship_classes

QAction* dbse::SchemaGraphicsScene::m_add_direct_relationship_classes

private

Definition at line 95 of file SchemaGraphicsScene.hpp.

m_add_direct_super_classes

QAction* dbse::SchemaGraphicsScene::m_add_direct_super_classes

private

Definition at line 94 of file SchemaGraphicsScene.hpp.

m_add_note

QAction* dbse::SchemaGraphicsScene::m_add_note

private

Definition at line 99 of file SchemaGraphicsScene.hpp.

m_addclass_connection

QMetaObject::Connection dbse::SchemaGraphicsScene::m_addclass_connection

private

Definition at line 106 of file SchemaGraphicsScene.hpp.

m_arrow_pos

int dbse::SchemaGraphicsScene::m_arrow_pos

private

Definition at line 84 of file SchemaGraphicsScene.hpp.

m_class_pos

int dbse::SchemaGraphicsScene::m_class_pos

private

Definition at line 83 of file SchemaGraphicsScene.hpp.

m_context_menu

QMenu* dbse::SchemaGraphicsScene::m_context_menu

private

Definition at line 81 of file SchemaGraphicsScene.hpp.

m_current_arrow

SchemaGraphicSegmentedArrow* dbse::SchemaGraphicsScene::m_current_arrow

private

Definition at line 108 of file SchemaGraphicsScene.hpp.

m_current_note

SchemaGraphicNote* dbse::SchemaGraphicsScene::m_current_note

private

Definition at line 109 of file SchemaGraphicsScene.hpp.

m_current_pos

QPointF dbse::SchemaGraphicsScene::m_current_pos

private

Definition at line 110 of file SchemaGraphicsScene.hpp.

m_edit_class

QAction* dbse::SchemaGraphicsScene::m_edit_class

private

Definition at line 88 of file SchemaGraphicsScene.hpp.

m_edit_note

QAction* dbse::SchemaGraphicsScene::m_edit_note

private

Definition at line 100 of file SchemaGraphicsScene.hpp.

m_highlight_abstract

bool dbse::SchemaGraphicsScene::m_highlight_abstract

private

Definition at line 114 of file SchemaGraphicsScene.hpp.

m_highlight_active

bool dbse::SchemaGraphicsScene::m_highlight_active

private

Definition at line 115 of file SchemaGraphicsScene.hpp.

m_inherited_properties_visible

bool dbse::SchemaGraphicsScene::m_inherited_properties_visible

private

Definition at line 113 of file SchemaGraphicsScene.hpp.

m_line

QGraphicsLineItem* dbse::SchemaGraphicsScene::m_line

private

Definition at line 80 of file SchemaGraphicsScene.hpp.

m_modified

bool dbse::SchemaGraphicsScene::m_modified

private

Definition at line 117 of file SchemaGraphicsScene.hpp.

m_mouse_item_pos

QPointF dbse::SchemaGraphicsScene::m_mouse_item_pos

private

Definition at line 111 of file SchemaGraphicsScene.hpp.

m_move

QAction* dbse::SchemaGraphicsScene::m_move

private

Definition at line 105 of file SchemaGraphicsScene.hpp.

m_next_note

int dbse::SchemaGraphicsScene::m_next_note { 0 }

private

Definition at line 112 of file SchemaGraphicsScene.hpp.

m_note_pos

int dbse::SchemaGraphicsScene::m_note_pos

private

Definition at line 85 of file SchemaGraphicsScene.hpp.

m_notes

std::set<SchemaGraphicNote*> dbse::SchemaGraphicsScene::m_notes

private

Definition at line 79 of file SchemaGraphicsScene.hpp.

m_remove_arrow

QAction* dbse::SchemaGraphicsScene::m_remove_arrow

private

Definition at line 103 of file SchemaGraphicsScene.hpp.

m_remove_class

QAction* dbse::SchemaGraphicsScene::m_remove_class

private

Definition at line 102 of file SchemaGraphicsScene.hpp.

m_remove_note

QAction* dbse::SchemaGraphicsScene::m_remove_note

private

Definition at line 101 of file SchemaGraphicsScene.hpp.

m_save

QAction* dbse::SchemaGraphicsScene::m_save

private

Definition at line 104 of file SchemaGraphicsScene.hpp.

m_save_pos

int dbse::SchemaGraphicsScene::m_save_pos

private

Definition at line 86 of file SchemaGraphicsScene.hpp.

m_seperator_pos

int dbse::SchemaGraphicsScene::m_seperator_pos

private

Definition at line 82 of file SchemaGraphicsScene.hpp.

m_show_defaults

bool dbse::SchemaGraphicsScene::m_show_defaults

private

Definition at line 116 of file SchemaGraphicsScene.hpp.

m_toggle_default

QAction* dbse::SchemaGraphicsScene::m_toggle_default

private

Definition at line 93 of file SchemaGraphicsScene.hpp.

m_toggle_highlight_abstract

QAction* dbse::SchemaGraphicsScene::m_toggle_highlight_abstract

private

Definition at line 90 of file SchemaGraphicsScene.hpp.

m_toggle_highlight_active

QAction* dbse::SchemaGraphicsScene::m_toggle_highlight_active

private

Definition at line 91 of file SchemaGraphicsScene.hpp.

m_toggle_highlight_class

QAction* dbse::SchemaGraphicsScene::m_toggle_highlight_class

private

Definition at line 92 of file SchemaGraphicsScene.hpp.

m_toggle_indirect_infos

QAction* dbse::SchemaGraphicsScene::m_toggle_indirect_infos

private

Definition at line 89 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