id
int64 0
755k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
65
| repo_stars
int64 100
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 9
values | repo_extraction_date
stringclasses 92
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
749,876
|
interfacewidget.h
|
KDE_umbrello/umbrello/umlwidgets/interfacewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2019-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef INTERFACEWIDGET_H
#define INTERFACEWIDGET_H
#include "classifierwidget.h"
/**
* Provides an interface widget
*
* The implementation is currently in @ref ClassifierWidget
* and should be moved to this class for easier implementation
*
* @author Ralf Habacker
*/
class InterfaceWidget : public ClassifierWidget
{
public:
InterfaceWidget(UMLScene * scene, UMLClassifier * c);
InterfaceWidget(UMLScene * scene, UMLPackage * p);
};
#endif // INTERFACEWIDGET_H
| 627
|
C++
|
.h
| 22
| 26.272727
| 92
| 0.777038
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,877
|
pinportbase.h
|
KDE_umbrello/umbrello/umlwidgets/pinportbase.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2014-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef PINPORTBASE_H
#define PINPORTBASE_H
#include "umlwidget.h"
#include <QScopedPointer>
class FloatingTextWidget;
class ChildWidgetPlacement;
/**
* @short Abstract base class for PinWidget and PortWidget
* @author Oliver Kellogg
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class PinPortBase : public UMLWidget
{
Q_OBJECT
public:
PinPortBase(UMLScene *scene, WidgetType type, UMLWidget *owner, UMLObject *o);
PinPortBase(UMLScene *scene, WidgetType type, UMLWidget *owner = nullptr, Uml::ID::Type id = Uml::ID::None);
virtual ~PinPortBase();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
virtual QRectF boundingRect() const;
virtual UMLWidget* ownerWidget() const;
void setInitialPosition(const QPointF &scenePos);
qreal getX() const;
qreal getY() const;
QPointF getPos() const;
void updateWidget();
void setName(const QString &strName);
void moveWidgetBy(qreal diffX, qreal diffY);
virtual void notifyParentResize();
UMLWidget* onWidget(const QPointF& p);
UMLWidget* widgetWithID(Uml::ID::Type id);
FloatingTextWidget *floatingTextWidget();
void setFloatingTextWidget(FloatingTextWidget *ft);
void saveToXMI(QXmlStreamWriter& writer);
bool loadFromXMI(QDomElement& qElement);
public Q_SLOTS:
virtual void slotMenuSelection(QAction* action);
protected:
void init(UMLWidget *owner = nullptr);
bool activate(IDChangeLog *changeLog = nullptr);
private:
ChildWidgetPlacement* createPlacement(WidgetBase::WidgetType type);
protected:
FloatingTextWidget *m_pName;
private:
QScopedPointer<ChildWidgetPlacement> m_childPlacement;
};
#endif
| 1,921
|
C++
|
.h
| 53
| 32.584906
| 113
| 0.764069
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,878
|
statewidget.h
|
KDE_umbrello/umbrello/umlwidgets/statewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef STATEWIDGET_H
#define STATEWIDGET_H
#include "umlwidget.h"
#include <QPainter>
#include <QStringList>
#define STATE_MARGIN 5
#define STATE_WIDTH 30
#define STATE_HEIGHT 10
/**
* This class is the graphical version of a UML State.
*
* A StateWidget is created by a @ref UMLView. A StateWidget belongs to
* only one @ref UMLView instance.
* When the @ref UMLView instance that this class belongs to is destroyed,
* it will be automatically deleted.
*
* The StateWidget class inherits from the @ref UMLWidget class
* which adds most of the functionality to this class.
*
* @short A graphical version of a UML State.
* @author Paul Hensgen <phensgen@techie.com>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class StateWidget : public UMLWidget
{
Q_OBJECT
Q_ENUMS(StateType)
public:
/// Enumeration that codes the different types of state.
enum StateType
{
Initial = 0, // Pseudostate
Normal,
End,
Fork, // Pseudostate
Join, // Pseudostate
Junction, // Pseudostate
DeepHistory, // Pseudostate
ShallowHistory, // Pseudostate
Choice, // Pseudostate
//Terminate // Pseudostate
//EntryPoint // Pseudostate
//ExitPoint // Pseudostate
Combined // Pseudostate
};
explicit StateWidget(UMLScene * scene, StateType stateType = Normal, Uml::ID::Type id = Uml::ID::None);
virtual ~StateWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
StateType stateType() const;
QString stateTypeStr() const;
void setStateType(StateType stateType);
bool addActivity(const QString &activity);
bool removeActivity(const QString &activity);
bool renameActivity(const QString &activity, const QString &newName);
QStringList activities() const;
void setActivities(const QStringList &list);
bool drawVertical() const;
void setDrawVertical(bool to = true);
virtual bool showPropertiesDialog();
virtual bool loadFromXMI(QDomElement & qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
protected:
QSizeF minimumSize() const;
QSizeF maximumSize();
void setAspectRatioMode();
virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent *event);
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
public Q_SLOTS:
virtual void slotMenuSelection(QAction* action);
private:
StateType m_stateType; ///< Type of state.
bool m_drawVertical; ///< whether to draw the fork/join horizontally or vertically
QStringList m_Activities; ///< List of activities for the state.
QSizeF m_size; ///< widget size used by combined state
};
#endif
| 3,215
|
C++
|
.h
| 83
| 34.325301
| 109
| 0.716212
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,879
|
objectnodewidget.h
|
KDE_umbrello/umbrello/umlwidgets/objectnodewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef OBJECTNODEWIDGET_H
#define OBJECTNODEWIDGET_H
#include "umlwidget.h"
/**
* This class is the graphical version of a UML Object Node. A ObjectNodeWidget is created
* by a @ref UMLView. An ObjectNodeWidget belongs to only one @ref UMLView instance.
* When the @ref UMLView instance that this class belongs to, it will be automatically deleted.
*
* The ObjectNodeWidget class inherits from the @ref UMLWidget class which adds most of the functionality
* to this class.
*
* @short A graphical version of a UML Activity.
* @author Florence Mattler <florence.mattler@libertysurf.fr>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class ObjectNodeWidget : public UMLWidget
{
Q_OBJECT
public:
enum ObjectNodeType
{
Normal,
Data,
Buffer,
Flow
};
explicit ObjectNodeWidget(UMLScene * scene, ObjectNodeType objectNodeType = Normal, Uml::ID::Type id = Uml::ID::None);
virtual ~ObjectNodeWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
ObjectNodeType objectNodeType() const;
static ObjectNodeType toObjectNodeType(const QString& type);
void setObjectNodeType(ObjectNodeType objectNodeType);
void setObjectNodeType(const QString& type) ;
void setState(const QString& state);
QString state() const;
virtual bool showPropertiesDialog();
void askStateForWidget();
void askForObjectNodeType(UMLWidget* &targetWidget);
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual bool loadFromXMI(QDomElement& qElement);
protected:
QSizeF minimumSize() const;
public Q_SLOTS:
void slotMenuSelection(QAction* action);
void slotOk();
private:
ObjectNodeType m_objectNodeType; ///< type of object node
QString m_state; ///< state of object node when it's an objectFlow
};
#endif
| 2,074
|
C++
|
.h
| 54
| 34.444444
| 122
| 0.74638
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,880
|
pinwidget.h
|
KDE_umbrello/umbrello/umlwidgets/pinwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef PINWIDGET_H
#define PINWIDGET_H
#include "pinportbase.h"
/**
* This class is the graphical version of a UML Pin. A pinWidget is created
* by a @ref UMLView. An pinWidget belongs to only one @ref UMLView instance.
* When the @ref UMLView instance that this class belongs to, it will be automatically deleted.
*
* The pinWidget class inherits from the @ref UMLWidget class which adds most of the functionality
* to this class.
*
* @short A graphical version of a UML pin.
* @author Hassan KOUCH <hkouch@hotmail.com>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class PinWidget : public PinPortBase
{
Q_OBJECT
public:
PinWidget(UMLScene* scene, UMLWidget* owner, Uml::ID::Type id = Uml::ID::None);
virtual ~PinWidget();
public Q_SLOTS:
void slotMenuSelection(QAction* action);
// private:
// int m_nY;
};
#endif
| 1,030
|
C++
|
.h
| 31
| 30.741935
| 98
| 0.742944
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,881
|
categorywidget.h
|
KDE_umbrello/umbrello/umlwidgets/categorywidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CATEGORYWIDGET_H
#define CATEGORYWIDGET_H
#include "umlwidget.h"
#define UC_MARGIN 5
#define UC_RADIUS 30
class UMLCategory;
/**
* This class is the graphical version of a UMLCategory. A CategoryWidget is created
* by a @ref UMLView. An CategoryWidget belongs to only one @ref UMLView instance.
* When the @ref UMLView instance that this class belongs to, it will be automatically deleted.
*
* If the Category class that this CategoryWidget is displaying is deleted, the @ref UMLView will
* make sure that this instance is also deleted.
*
* The CategoryWidget class inherits from the @ref UMLWidget class which adds most of the functionality
* to this class.
*
* @short A graphical version of a UMLCategory.
* @author Sharan Rao
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class CategoryWidget : public UMLWidget
{
Q_OBJECT
public:
CategoryWidget(UMLScene * scene, UMLCategory *o);
virtual ~CategoryWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
void saveToXMI(QXmlStreamWriter& writer);
// For loading we can use the loadFromXMI() inherited from UMLWidget.
protected:
QSizeF minimumSize() const;
public Q_SLOTS:
void slotMenuSelection(QAction* action);
};
#endif
| 1,475
|
C++
|
.h
| 40
| 34.25
| 109
| 0.771067
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,882
|
statusbartoolbutton.h
|
KDE_umbrello/umbrello/umlwidgets/statusbartoolbutton.h
|
// vim: set tabstop=4 shiftwidth=4 noexpandtab:
/*
Gwenview: an image viewer
SPDX-FileCopyrightText: 2007 Aurélien Gâteau <agateau@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#ifndef STATUSBARTOOLBUTTON_H
#define STATUSBARTOOLBUTTON_H
// Qt
#include <QToolButton>
/**
* A thin tool button which can be grouped with another and look like one solid
* bar:
*
* (button1 | button2)
*/
class StatusBarToolButton : public QToolButton
{
Q_OBJECT
public:
enum GroupPosition {
NotGrouped = 0,
GroupLeft = 1,
GroupRight = 2,
GroupCenter = 3
};
explicit StatusBarToolButton(QWidget *parent = nullptr);
virtual QSize minimumSizeHint() const;
virtual QSize sizeHint() const;
void setGroupPosition(StatusBarToolButton::GroupPosition groupPosition);
protected:
virtual void paintEvent(QPaintEvent* event);
private:
GroupPosition mGroupPosition;
};
#endif /* STATUSBARTOOLBUTTON_H */
| 963
|
C++
|
.h
| 36
| 23.388889
| 79
| 0.745355
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,883
|
linkwidget.h
|
KDE_umbrello/umbrello/umlwidgets/linkwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2004-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef LINKWIDGET_H
#define LINKWIDGET_H
#include "basictypes.h"
#include "umlscene.h"
#include <QFont>
// forward declarations
class UMLClassifier;
class UMLOperation;
class FloatingTextWidget;
class QXmlStreamWriter;
/**
* This is an interface realized by AssociationWidget and MessageWidget.
* The design of this interface was driven by the requirements of
* class FloatingTextWidget. As the architecture of Umbrello evolves (for
* example, if the class FloatingTextWidget is redesigned), it can be
* cleaned up.
*
* @short Interface to FloatingTextWidget for AssociationWidget and MessageWidget.
* @author Oliver Kellogg <okellogg@users.sourceforge.net>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class LinkWidget
{
public:
LinkWidget();
virtual ~LinkWidget();
/**
* Sets the font the widget is to use.
* Abstract operation implemented by inheriting classes.
* Motivated by FloatingTextWidget::slotMenuSelection(mt_Operation)
*
* @param font Font to be set.
*/
virtual void lwSetFont(QFont font) = 0;
virtual UMLClassifier *operationOwner();
/**
* Motivated by FloatingTextWidget::slotMenuSelection(mt_Operation)
*/
virtual UMLOperation *operation() = 0;
/**
* Motivated by FloatingTextWidget::slotMenuSelection(mt_Operation)
*/
virtual void setOperation(UMLOperation *op) = 0;
/**
* Motivated by getOperationText()
*/
virtual QString customOpText() = 0;
/**
* Motivated by FloatingTextWidget::slotMenuSelection(mt_Operation)
*/
virtual void setCustomOpText(const QString &opText) = 0;
QString operationText(UMLScene *scene = nullptr);
virtual void resetTextPositions();
/**
* Motivated by FloatingTextWidget::setMessageText()
*/
virtual void setMessageText(FloatingTextWidget *ft) = 0;
/**
* Motivated by FloatingTextWidget::handleRename()
*/
virtual void setText(FloatingTextWidget *ft, const QString &newText) = 0;
virtual bool showPropertiesDialog();
/**
* Motivated by FloatingTextWidget::showOpDialog()
*/
virtual QString lwOperationText() = 0;
/**
* Motivated by FloatingTextWidget::showOpDialog()
*/
virtual UMLClassifier *lwClassifier() = 0;
/**
* Motivated by FloatingTextWidget::showOpDialog()
*/
virtual void setOperationText(const QString &op) = 0;
/**
* Abstract operation implemented by inheriting classes.
* Motivated by FloatingTextWidget::mouseMoveEvent()
*/
virtual void constrainTextPos(qreal &textX, qreal &textY,
qreal textWidth, qreal textHeight,
Uml::TextRole::Enum tr) = 0;
virtual void calculateNameTextSegment();
void setSequenceNumber(const QString &sequenceNumber);
QString sequenceNumber() const;
virtual bool loadFromXMI(QDomElement &qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
protected:
QString m_SequenceNumber;
};
#endif
| 3,241
|
C++
|
.h
| 94
| 29.414894
| 92
| 0.709801
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,884
|
componentwidget.h
|
KDE_umbrello/umbrello/umlwidgets/componentwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef COMPONENTWIDGET_H
#define COMPONENTWIDGET_H
#include "umlwidget.h"
class UMLComponent;
#define COMPONENT_MARGIN 10
/**
* Defines a graphical version of the Component. Most of the functionality
* will come from the @ref UMLComponent class.
*
* @short A graphical version of a Component.
* @author Jonathan Riddell
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class ComponentWidget : public UMLWidget
{
Q_OBJECT
public:
ComponentWidget(UMLScene * scene, UMLComponent *c);
virtual ~ComponentWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
virtual void moveWidgetBy(qreal diffX, qreal diffY);
virtual void adjustAssocs(qreal dx, qreal dy);
virtual void adjustUnselectedAssocs(qreal dx, qreal dy);
virtual void saveToXMI(QXmlStreamWriter& writer);
Q_SIGNALS:
/**
* Emitted when the component widget is moved.
* Provides the delta X and delta Y amount by which the widget was moved
* relative to the previous position.
* Slots into PortWidget::slotCompMoved()
* @param diffX The difference between previous and new X value.
* @param diffY The difference between previous and new Y value.
*/
void sigCompMoved(qreal diffX, qreal diffY);
protected:
QSizeF minimumSize() const;
};
#endif
| 1,545
|
C++
|
.h
| 43
| 32.44186
| 109
| 0.752515
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,885
|
entitywidget.h
|
KDE_umbrello/umbrello/umlwidgets/entitywidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ENTITYWIDGET_H
#define ENTITYWIDGET_H
#include "umlwidget.h"
class UMLScene;
#define ENTITY_MARGIN 5
/**
* Defines a graphical version of the entity. Most of the functionality
* will come from the @ref UMLWidget class from which class inherits from.
*
* @short A graphical version of an entity.
* @author Jonathan Riddell
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class EntityWidget : public UMLWidget
{
Q_OBJECT
public:
explicit EntityWidget(UMLScene *scene, UMLObject* o);
virtual ~EntityWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
virtual bool loadFromXMI(QDomElement &qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
void setShowAttributeSignature(bool flag);
bool showAttributeSignature() const;
public Q_SLOTS:
virtual void slotMenuSelection(QAction* action);
protected:
bool m_showAttributeSignatures{false};
QSizeF minimumSize() const;
QSizeF calculateSize(bool withExtensions=true) const;
};
#endif
| 1,262
|
C++
|
.h
| 37
| 31.054054
| 109
| 0.774114
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,886
|
associationline.h
|
KDE_umbrello/umbrello/umlwidgets/associationline.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ASSOCIATIONLINE_H
#define ASSOCIATIONLINE_H
#include "basictypes.h"
#include <QGraphicsObject>
#include <QList>
#include <QPen>
#include <QPoint>
// forward declarations
class AssociationWidget;
class QDomDocument;
class QDomElement;
class QPainter;
class QXmlStreamWriter;
/**
* This class provides various symbols that can be embedded in AssociationLine.
* It also provides convenience methods to align the symbol to AssociationLine.
*/
class Symbol : public QGraphicsItem
{
public:
typedef QPair<QPointF, QPointF> SymbolEndPoints;
/**
* This enumeration lists all the symbols that can be used as
* embedded on AssociationLine.
*/
enum SymbolType {
None = -1,
OpenArrow,
ClosedArrow,
CrowFeet,
Diamond,
Subset,
Circle,
Count
};
explicit Symbol(SymbolType symbolType, QGraphicsItem *parent = nullptr);
virtual ~Symbol();
SymbolType symbolType() const;
void setSymbolType(SymbolType symbolType);
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
virtual QRectF boundingRect() const;
virtual QPainterPath shape() const;
void alignTo(const QLineF& line);
SymbolEndPoints symbolEndPoints() const;
QPen pen() const;
void setPen(const QPen &pen);
QBrush brush() const;
void setBrush(const QBrush& brush);
private:
QPen m_pen; ///< pen used to draw Symbol
QBrush m_brush; ///< brush used to fill Symbol
SymbolType m_symbolType; ///< current symbol being represented by this item
/// A structure to hold a table of values for all symbols.
struct SymbolProperty {
QRectF boundRect;
QPainterPath shape;
QLineF axisLine;
SymbolEndPoints endPoints;
};
static SymbolProperty *symbolTable; ///< a table which stores all symbol properties
static void setupSymbolTable();
};
/**
* A convenience class that encapsulates geometry management, handles
* mouse and hover events, embeds and aligns symbols and finally draws the
* lines and points.
* Context menu events are handled in AssociationWidget.
*
* This class is infact a draw and event handling proxy for
* AssociationWidget.
*
* @note m_activePointIndex and m_activeSegmentIndex can't be
* active at same time!
*
* @author Gopala Krishna
* @author Andi Fischer
* Bugs and comments to uml-devel@lists.sf.net or https://bugs.kde.org
*/
class AssociationLine : public QGraphicsObject
{
Q_OBJECT
public:
static QString toString(Uml::LayoutType::Enum layout);
static Uml::LayoutType::Enum fromString(const QString& layout);
explicit AssociationLine(AssociationWidget *association);
virtual ~AssociationLine();
QPointF point(int index) const;
bool setPoint(int index, const QPointF& point);
QPointF startPoint() const;
QPointF endPoint() const;
void addPoint(const QPointF& point);
void insertPoint(int index, const QPointF& point);
void removePoint(int index);
int count() const;
void cleanup();
void optimizeLinePoints();
int closestPointIndex(const QPointF& point, qreal delta = Delta) const;
int closestSegmentIndex(const QPointF& point, qreal delta = Delta) const;
bool isEndPointIndex(int index) const;
bool isEndSegmentIndex(int index) const;
bool isAutoLayouted() const;
bool enableAutoLayout();
bool setEndPoints(const QPointF &start, const QPointF &end);
void dumpPoints();
bool loadFromXMI(QDomElement &qElement);
void saveToXMI(QXmlStreamWriter& writer);
QBrush brush() const;
QPen pen() const;
void setPen(const QPen &pen);
void updatePenStyle();
virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget);
QPainterPath path() const;
QRectF boundingRect() const;
QPainterPath shape() const;
Uml::LayoutType::Enum layout() const;
void setLayout(Uml::LayoutType::Enum layout);
void mousePressEvent(QGraphicsSceneMouseEvent *event);
void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
void calculateInitialEndPoints();
void reconstructSymbols();
private:
void setStartSymbol(Symbol::SymbolType symbolType);
void setEndSymbol(Symbol::SymbolType symbolType);
void createSubsetSymbol();
void removeSubsetSymbol();
void createCollaborationLine();
void removeCollaborationLine();
void alignSymbols();
void createSplinePoints();
AssociationWidget *m_associationWidget; ///< association widget which this line represents
QVector<QPointF> m_points; ///< points representing the association line
int m_activePointIndex; ///< index of active point which can be dragged to modify association line
int m_activeSegmentIndex; ///< index of active segment
Symbol *m_startSymbol; ///< symbol drawn at the end of "first" line segment
Symbol *m_endSymbol; ///< symbol drawn at the end of "last" line segment
Symbol *m_subsetSymbol; ///< subset symbol
QGraphicsLineItem *m_collaborationLineItem; ///< parallel arrow line drawn in case of collaboration message
Symbol *m_collaborationLineHead; ///< arrow head drawn at end of m_collaborationLineItem
Uml::LayoutType::Enum m_layout;
QPen m_pen; ///< pen used to draw an association line
bool m_autoLayoutSpline;
static QPainterPath createBezierCurve(QVector<QPointF> points);
static QPainterPath createOrthogonalPath(QVector<QPointF> points);
qreal m_c1dx{0.0}, m_c1dy{0.0}, m_c2dx{0.0}, m_c2dy{0.0};
static const qreal Delta; ///< default delta for fuzzy recognition of points closer to point
static const qreal SelectedPointDiameter; ///< radius of circles drawn to show "selection"
static const qreal SelfAssociationMinimumHeight; ///< minimum height for self association's loop
};
#endif
| 6,692
|
C++
|
.h
| 157
| 36.974522
| 123
| 0.696577
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,887
|
widgetlist_utils.h
|
KDE_umbrello/umbrello/umlwidgets/widgetlist_utils.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2009-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef WIDGETLIST_UTILS_H
#define WIDGETLIST_UTILS_H
#include "umlwidgetlist.h"
/**
* General purpose widget list utilities.
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
namespace WidgetList_Utils
{
qreal getSmallestX(const UMLWidgetList &widgetList);
qreal getSmallestY(const UMLWidgetList &widgetList);
qreal getBiggestX(const UMLWidgetList &widgetList);
qreal getBiggestY(const UMLWidgetList &widgetList);
qreal getHeightsSum(const UMLWidgetList &widgetList);
qreal getWidthsSum(const UMLWidgetList &widgetList);
} // namespace WidgetList_Utils
#endif
| 761
|
C++
|
.h
| 21
| 33.380952
| 92
| 0.788043
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,888
|
activitywidget.h
|
KDE_umbrello/umbrello/umlwidgets/activitywidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ACTIVITYWIDGET_H
#define ACTIVITYWIDGET_H
#include "umlwidget.h"
#include "worktoolbar.h"
#define ACTIVITY_MARGIN 5
#define ACTIVITY_WIDTH 30
#define ACTIVITY_HEIGHT 10
/**
* This class is the graphical version of a UML Activity. A ActivityWidget is created
* by a @ref UMLView. An ActivityWidget belongs to only one @ref UMLView instance.
* When the @ref UMLView instance that this class belongs to, it will be automatically deleted.
*
* The ActivityWidget class inherits from the @ref UMLWidget class which adds most of the functionality
* to this class.
*
* @short A graphical version of a UML Activity.
* @author Paul Hensgen <phensgen@techie.com>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class ActivityWidget : public UMLWidget
{
Q_OBJECT
Q_ENUMS(ActivityType)
public:
enum ActivityType
{
Initial = 0,
Normal,
End,
Final,
Branch,
Invok,
Param
};
explicit ActivityWidget(UMLScene * scene, ActivityType activityType = Normal, Uml::ID::Type id = Uml::ID::None);
virtual ~ActivityWidget();
ActivityType activityType() const;
QString activityTypeStr() const;
void setActivityType(ActivityType activityType);
static bool isActivity(WorkToolBar::ToolBar_Buttons tbb,
ActivityType& resultType);
QString preconditionText() const;
void setPreconditionText(const QString&);
QString postconditionText() const;
void setPostconditionText(const QString&);
virtual bool showPropertiesDialog();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
virtual void moveWidgetBy(qreal diffX, qreal diffY);
virtual bool loadFromXMI(QDomElement & qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
void constrain(qreal& width, qreal& height);
Q_SIGNALS:
/**
* Emitted when the activity widget is moved.
* Provides the delta X and delta Y amount by which the widget was moved
* relative to the previous position.
* Slots into PinWidget::slotActMoved()
* @param diffX The difference between previous and new X value.
* @param diffY The difference between previous and new Y value.
*/
void sigActMoved(qreal diffX, qreal diffY);
public Q_SLOTS:
virtual void slotMenuSelection(QAction* action);
protected:
virtual QSizeF minimumSize() const;
virtual QSizeF maximumSize();
ActivityType m_activityType; ///< Type of activity.
QString m_preconditionText;
QString m_postconditionText;
};
#endif
| 2,783
|
C++
|
.h
| 75
| 32.48
| 116
| 0.733829
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,889
|
actorwidget.h
|
KDE_umbrello/umbrello/umlwidgets/actorwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ACTORWIDGET_H
#define ACTORWIDGET_H
#include "umlwidget.h"
#define A_WIDTH 20
#define A_HEIGHT 40
#define A_MARGIN 5
class UMLActor;
/**
* This class is the graphical version of a UML Actor.
* An ActorWidget is created by a @ref UMLView. An ActorWidget belongs to only
* one @ref UMLView instance.
* When the @ref UMLView instance that this class belongs to is destroyed, the
* ActorWidget will be automatically deleted.
*
* If the UMLActor class that this ActorWidget is displaying is deleted, the
* @ref UMLView will make sure that this instance is also deleted.
*
* The ActorWidget class inherits from the @ref UMLWidget class
* which adds most of the functionality to this class.
*
* @short A graphical version of a UML Actor.
* @author Paul Hensgen <phensgen@techie.com>
* @see UMLWidget
* @see UMLView
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class ActorWidget : public UMLWidget
{
public:
ActorWidget(UMLScene * scene, UMLActor *o);
virtual ~ActorWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
virtual void saveToXMI(QXmlStreamWriter& writer);
protected:
QSizeF minimumSize() const;
};
#endif
| 1,402
|
C++
|
.h
| 41
| 31.853659
| 109
| 0.766272
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,890
|
messagewidget.h
|
KDE_umbrello/umbrello/umlwidgets/messagewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef MESSAGEWIDGET_H
#define MESSAGEWIDGET_H
#include "umlwidget.h"
#include "linkwidget.h"
// forward declarations
class FloatingTextWidget;
class ObjectWidget;
class QResizeEvent;
class UMLOperation;
/**
* Used to display a message on a sequence diagram. The message
* could be between two objects or a message that calls itself on
* an object. This class will only display the line that is
* required and the text will be setup by the @ref FloatingTextWidget
* widget that is passed in the constructor. A message can be
* synchronous (calls a method and gains control back on return,
* as happens in most programming languages) or asynchronous
* (calls a method and gains back control immediately).
*
* @short Displays a message.
* @author Paul Hensgen
* @see UMLWidget
* @see ObjectWidget
* @see FloatingTextWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class MessageWidget : public UMLWidget, public LinkWidget
{
Q_OBJECT
public:
MessageWidget(UMLScene * scene, ObjectWidget* a, ObjectWidget* b,
int y, Uml::SequenceMessage::Enum sequenceMessageType,
Uml::ID::Type id = Uml::ID::None);
MessageWidget(UMLScene * scene, Uml::SequenceMessage::Enum sequenceMessageType,
Uml::ID::Type id = Uml::ID::None);
MessageWidget(UMLScene * scene, ObjectWidget* a, int xclick, int yclick,
Uml::SequenceMessage::Enum sequenceMessageType,
Uml::ID::Type id = Uml::ID::None);
virtual ~MessageWidget();
virtual void setY(qreal y);
//---------- LinkWidget Interface methods implementation from here on.
virtual void lwSetFont (QFont font);
virtual UMLClassifier *operationOwner();
virtual UMLOperation *operation();
virtual void setOperation(UMLOperation *op);
virtual QString customOpText();
virtual void setCustomOpText(const QString &opText);
virtual void setMessageText(FloatingTextWidget *ft);
virtual void setText(FloatingTextWidget *ft, const QString &newText);
virtual QString lwOperationText();
virtual UMLClassifier *lwClassifier();
virtual void setOperationText(const QString &op);
virtual void constrainTextPos(qreal &textX, qreal &textY, qreal textWidth, qreal textHeight,
Uml::TextRole::Enum tr);
//---------- End LinkWidget Interface methods implementation.
/// @return Whether the message is synchronous or asynchronous
Uml::SequenceMessage::Enum sequenceMessageType() const {
return m_sequenceMessageType;
}
bool hasObjectWidget(ObjectWidget * w);
ObjectWidget* objectWidget(Uml::RoleType::Enum role);
void setObjectWidget(ObjectWidget * ow, Uml::RoleType::Enum role);
bool isSelf() const;
/**
* Returns the text widget it is related to.
*
* @return The text widget we are related to.
*/
FloatingTextWidget * floatingTextWidget() {
return m_pFText;
}
/**
* Sets the text widget it is related to.
*
* @param f The text widget we are related to.
*/
void setFloatingTextWidget(FloatingTextWidget * f) {
m_pFText = f;
}
void calculateWidget();
virtual bool activate(IDChangeLog *Log = nullptr);
void resolveObjectWidget(IDChangeLog* log);
void calculateDimensions();
void calculateDimensionsSynchronous();
void calculateDimensionsAsynchronous();
void calculateDimensionsCreation();
void calculateDimensionsDestroy();
void calculateDimensionsLost();
void calculateDimensionsFound();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
void setTextPosition();
void cleanup();
void setSelected(bool _select);
int getMinY();
int getMaxY();
virtual QSizeF minimumSize() const;
UMLWidget* onWidget(const QPointF& p);
virtual void resizeWidget(qreal newW, qreal newH);
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual bool loadFromXMI(QDomElement & qElement);
void setxclicked(int xclick);
void setyclicked(int yclick);
/**
* Return the xclicked
*/
int getxclicked() const {
return m_xclicked;
}
virtual bool showPropertiesDialog();
protected:
virtual void moveWidgetBy(qreal diffX, qreal diffY);
virtual void constrainMovementForAllWidgets(qreal &diffX, qreal &diffY);
virtual bool isInResizeArea(QGraphicsSceneMouseEvent *me);
void setLinkAndTextPos();
int constrainX(int textX, int textWidth, Uml::TextRole::Enum tr);
static void paintArrow(QPainter *p, int x, int y, int w,
Qt::ArrowType direction, bool useDottedLine = false);
static void paintSolidArrowhead(QPainter *p, int x, int y, Qt::ArrowType direction);
void updateResizability();
void paintSynchronous(QPainter *painter, const QStyleOptionGraphicsItem *option);
void paintAsynchronous(QPainter *painter, const QStyleOptionGraphicsItem *option);
void paintCreation(QPainter *painter, const QStyleOptionGraphicsItem *option);
void paintDestroy(QPainter *painter, const QStyleOptionGraphicsItem *option);
void paintLost(QPainter *painter, const QStyleOptionGraphicsItem *option);
void paintFound(QPainter *painter, const QStyleOptionGraphicsItem *option);
// Data loaded/saved
QString m_CustomOp;
/**
* Whether the message is synchronous or asynchronous
*/
Uml::SequenceMessage::Enum m_sequenceMessageType;
private:
void resizeEvent(QResizeEvent *re);
qreal constrainPositionY(qreal diffY);
void init();
QPointer<ObjectWidget> m_pOw[2];
FloatingTextWidget * m_pFText;
int m_xclicked;
int m_yclicked;
/**
* The following variables are used by loadFromXMI() as an intermediate
* store. activate() resolves the IDs, i.e. after activate() the variables
* m_pOw[] and m_pFText can be used.
*/
Uml::ID::Type m_widgetAId, m_widgetBId, m_textId;
public Q_SLOTS:
void slotWidgetMoved(Uml::ID::Type id);
void slotMenuSelection(QAction* action);
Q_SIGNALS:
/**
* emitted when the message widget is moved up or down
* slots into ObjectWidget::slotMessageMoved()
*/
void sigMessageMoved();
};
#endif
| 6,496
|
C++
|
.h
| 160
| 35.11875
| 109
| 0.719014
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,891
|
signalwidget.h
|
KDE_umbrello/umbrello/umlwidgets/signalwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef SIGNALWIDGET_H
#define SIGNALWIDGET_H
#include "floatingtextwidget.h"
#include "linkwidget.h"
#include "umlwidget.h"
#include "worktoolbar.h"
#define SIGNAL_MARGIN 5
#define SIGNAL_WIDTH 45
#define SIGNAL_HEIGHT 15
/**
* Represents a Send signal, Accept signal or Time event on an
* Activity diagram.
*/
class SignalWidget : public UMLWidget
{
Q_OBJECT
Q_ENUMS(SignalType)
public:
/// Enumeration that codes the different types of signal.
enum SignalType
{
Send = 0,
Accept,
Time
};
explicit SignalWidget(UMLScene * scene, SignalType signalType = Send, Uml::ID::Type id = Uml::ID::None);
virtual ~SignalWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
void setX(qreal newX);
void setY(qreal newY);
virtual void setName(const QString &strName);
SignalType signalType() const;
QString signalTypeStr() const;
void setSignalType(SignalType signalType);
virtual bool showPropertiesDialog();
void mouseMoveEvent(QGraphicsSceneMouseEvent *me);
virtual bool loadFromXMI(QDomElement & qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
public Q_SLOTS:
virtual void slotMenuSelection(QAction* action);
protected:
QSizeF minimumSize() const;
/**
* Save the value of the widget to know how to move the floatingtext
*/
int m_oldX;
int m_oldY;
// Only for the time event
/**
* This is a pointer to the Floating Text widget which displays the
* name of the signal widget.
*/
FloatingTextWidget* m_pName;
SignalType m_signalType; ///< Type of signal
protected Q_SLOTS:
void slotTextDestroyed();
};
#endif
| 1,906
|
C++
|
.h
| 62
| 26.596774
| 109
| 0.724932
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,892
|
nodewidget.h
|
KDE_umbrello/umbrello/umlwidgets/nodewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef NODEWIDGET_H
#define NODEWIDGET_H
#include "umlwidget.h"
class UMLNode;
/**
* Defines a graphical version of the Node. Most of the functionality
* will come from the @ref UMLNode class.
*
* @short A graphical version of a Node.
* @author Jonathan Riddell
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class NodeWidget : public UMLWidget
{
public:
NodeWidget(UMLScene * scene, UMLNode *n);
virtual ~NodeWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
void saveToXMI(QXmlStreamWriter& writer);
protected:
QSizeF minimumSize() const;
static const int DEPTH = 30; ///< pixels on Z axis
};
#endif
| 901
|
C++
|
.h
| 29
| 28.344828
| 109
| 0.74826
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,893
|
childwidgetplacementport.h
|
KDE_umbrello/umbrello/umlwidgets/childwidgetplacementport.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2016-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CHILDWIDGETPLACEMENTPORT_H
#define CHILDWIDGETPLACEMENTPORT_H
#include "umlwidgets/childwidgetplacement.h"
/**
* Implementation of child widget placement where child widget is placed onto parent border.
*
* @short Child widget placement on parent border
*/
class ChildWidgetPlacementPort : public ChildWidgetPlacement
{
public:
ChildWidgetPlacementPort(PinPortBase* widget);
virtual ~ChildWidgetPlacementPort();
virtual void detectConnectedSide();
virtual void setInitialPosition(const QPointF &scenePos = QPointF());
virtual void setNewPositionWhenMoved(qreal diffX, qreal diffY);
virtual void setNewPositionOnParentResize();
private:
qreal trimToRange(qreal value, qreal min, qreal max, bool& setToMin, bool& setToMax) const;
qreal minX() const;
qreal maxX() const;
qreal minY() const;
qreal maxY() const;
};
#endif /* ! CHILDWIDGETPLACEMENTPORT_H */
| 1,061
|
C++
|
.h
| 29
| 33.413793
| 95
| 0.778537
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,894
|
toolbarstateonewidget.h
|
KDE_umbrello/umbrello/umlwidgets/toolbarstateonewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2004-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef TOOLBARSTATEONEWIDGET_H
#define TOOLBARSTATEONEWIDGET_H
#include "toolbarstatepool.h"
#include "widgetbase.h"
/**
* Sequence tool to create components linked with one object in sequence diagram
* like precondition.
* With sequence tool, one objects is selected clicking with left button on
* it
*/
class ToolBarStateOneWidget : public ToolBarStatePool
{
Q_OBJECT
public:
explicit ToolBarStateOneWidget(UMLScene *umlScene);
virtual ~ToolBarStateOneWidget();
virtual void cleanBeforeChange();
// FIXME: obsolete
virtual void mouseMove(QGraphicsSceneMouseEvent* ome);
public Q_SLOTS:
virtual void slotWidgetRemoved(UMLWidget* widget);
protected:
virtual void setCurrentElement();
virtual void mouseReleaseWidget();
virtual void mouseReleaseEmpty();
void setWidget(UMLWidget* firstObject);
WidgetBase::WidgetType widgetType();
UMLWidget* m_firstObject; ///< The first object in the message.
/**
* If there is a current widget, it is true if the press event happened on
* the line of an object, or false if it happened on a normal UMLWidget.
*/
bool m_isObjectWidgetLine;
private:
virtual void init();
};
#endif //TOOLBARSTATEONEWIDGET_H
| 1,384
|
C++
|
.h
| 41
| 30.195122
| 92
| 0.760902
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,895
|
regionwidget.h
|
KDE_umbrello/umbrello/umlwidgets/regionwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef REGIONWIDGET_H
#define REGIONWIDGET_H
#include "umlwidget.h"
/**
* Represents a rectangular region on Activity diagram.
*/
class RegionWidget: public UMLWidget
{
Q_OBJECT
public:
explicit RegionWidget(UMLScene* scene, Uml::ID::Type id = Uml::ID::None);
virtual ~RegionWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
void saveToXMI(QXmlStreamWriter& writer);
bool loadFromXMI(QDomElement& qElement);
protected:
QSizeF minimumSize() const;
};
#endif
| 707
|
C++
|
.h
| 23
| 27.73913
| 109
| 0.761834
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,896
|
combinedfragmentwidget.h
|
KDE_umbrello/umbrello/umlwidgets/combinedfragmentwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef COMBINEDFRAGMENTWIDGET_H
#define COMBINEDFRAGMENTWIDGET_H
#include "umlwidget.h"
#include "worktoolbar.h"
#include "floatingdashlinewidget.h"
#include <QList>
/**
* This class is the graphical version of a UML combined fragment. A combinedfragmentWidget is created
* by a @ref UMLView. An combinedfragmentWidget belongs to only one @ref UMLView instance.
* When the @ref UMLView instance that this class belongs to, it will be automatically deleted.
*
* The combinedfragmentWidget class inherits from the @ref UMLWidget class which adds most of the functionality
* to this class.
*
* @short A graphical version of a UML combined fragment.
* @author Hassan KOUCH <hkouch@hotmail.com>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class CombinedFragmentWidget : public UMLWidget
{
Q_OBJECT
public:
enum CombinedFragmentType
{
Ref = 0,
Opt,
Break,
Loop,
Neg,
Crit,
Ass,
Alt,
Par
};
explicit CombinedFragmentWidget(UMLScene * scene,
CombinedFragmentType combinedfragmentType = Ref,
Uml::ID::Type id = Uml::ID::None);
virtual ~CombinedFragmentWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
CombinedFragmentType combinedFragmentType() const;
CombinedFragmentType combinedFragmentType(const QString& combinedfragmentType) const;
void setCombinedFragmentType(CombinedFragmentType combinedfragmentType);
void setCombinedFragmentType(const QString& combinedfragmentType);
void askNameForWidgetType(UMLWidget* &targetWidget, const QString& dialogTitle,
const QString& dialogPrompt, const QString& defaultName);
void saveToXMI(QXmlStreamWriter& writer);
bool loadFromXMI(QDomElement & qElement);
void removeDashLine(FloatingDashLineWidget *line);
virtual void cleanup();
virtual bool activate(IDChangeLog *ChangeLog = nullptr);
virtual QRectF boundingRect() const;
virtual QPainterPath shape() const;
public Q_SLOTS:
void slotMenuSelection(QAction* action);
protected:
QSizeF minimumSize() const;
void toForeground();
/// Type of CombinedFragment.
CombinedFragmentType m_CombinedFragment;
private:
void setDashLineGeometryAndPosition() const;
/// Dash lines of an alternative or parallel combined fragment
QList<FloatingDashLineWidget*> m_dashLines;
qreal m_labelWidth;
};
#endif
| 2,729
|
C++
|
.h
| 70
| 33.457143
| 111
| 0.736643
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,897
|
enumwidget.h
|
KDE_umbrello/umbrello/umlwidgets/enumwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ENUMWIDGET_H
#define ENUMWIDGET_H
#include "umlwidget.h"
#define ENUM_MARGIN 5
/**
* Defines a graphical version of the enum. Most of the functionality
* will come from the @ref UMLWidget class from which class inherits from.
*
* @short A graphical version of an enum.
* @author Jonathan Riddell
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class EnumWidget : public UMLWidget
{
Q_OBJECT
public:
explicit EnumWidget(UMLScene *scene, UMLObject* o);
virtual ~EnumWidget();
bool showPackage() const;
void setShowPackage(bool _status);
void toggleShowPackage();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
virtual bool loadFromXMI(QDomElement& qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
public Q_SLOTS:
virtual void slotMenuSelection(QAction* action);
protected:
QSizeF minimumSize() const;
bool m_showPackage;
};
#endif
| 1,163
|
C++
|
.h
| 36
| 29.222222
| 109
| 0.759857
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,898
|
notewidget.h
|
KDE_umbrello/umbrello/umlwidgets/notewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef NOTEWIDGET_H
#define NOTEWIDGET_H
//app includes
#include "umlwidget.h"
// Qt forward declarations
class QPainter;
/**
* Displays a note box to allow multiple lines of text to be displayed.
* These widgets are diagram specific. They will still need a unique id
* from the @ref UMLDoc class for deletion and other purposes.
*
* @short Displays a note box.
* @author Paul Hensgen <phensgen@techie.com>
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class NoteWidget : public UMLWidget
{
Q_OBJECT
public:
/// This enum type is used to specify the type of note.
enum NoteType
{
Normal,
PreCondition,
PostCondition,
Transformation
};
explicit NoteWidget(UMLScene * scene, NoteWidget::NoteType noteType = Normal,
Uml::ID::Type id = Uml::ID::None);
virtual ~NoteWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
static NoteType stringToNoteType(const QString& noteType);
NoteType noteType() const;
void setNoteType(NoteType noteType);
void setNoteType(const QString& noteType);
Uml::ID::Type diagramLink() const;
void setDiagramLink(Uml::ID::Type viewID);
bool setDiagramLink(const QString &diagramName);
void askForNoteType(UMLWidget* &targetWidget);
virtual bool showPropertiesDialog();
virtual bool loadFromXMI(QDomElement & qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual QSizeF minimumSize() const;
static QPointer<NoteWidget> s_pCurrentNote;
public Q_SLOTS:
void slotMenuSelection(QAction* action);
protected:
virtual QSizeF calculateSize(bool withExtensions = true) const;
void paintText(QPainter *painter);
void paintTextWordWrap(QPainter *painter);
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
private:
Uml::ID::Type m_diagramLink; ///< The diagram/scene this note links to.
NoteType m_noteType; ///< The type of note. @see NoteWidget::NoteType
};
#endif
| 2,270
|
C++
|
.h
| 61
| 32.885246
| 109
| 0.734824
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,899
|
floatingdashlinewidget.h
|
KDE_umbrello/umbrello/umlwidgets/floatingdashlinewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef FLOATINGDASHLINEWIDGET_H
#define FLOATINGDASHLINEWIDGET_H
#include "umlwidget.h"
class CombinedFragmentWidget;
#define FLOATING_DASH_LINE_MARGIN 25
#define FLOATING_DASH_LINE_TEXT_MARGIN 5
/* how many pixels a user could click around a point */
#define POINT_DELTA 5
/**
* This class is used to draw dash lines for UML combined fragments. A FloatingDashLineWidget
* belongs to one @ref CombinedFragmentWidget instance.
*
* The FloatingDashLineWidget class inherits from the @ref UMLWidget class.
*
* @short A dash line for UML combined fragments.
* @author Thomas GALLINARI <tg8187@yahoo.fr>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class FloatingDashLineWidget : public UMLWidget
{
Q_OBJECT
public:
explicit FloatingDashLineWidget(UMLScene *scene, Uml::ID::Type id = Uml::ID::None, CombinedFragmentWidget *parent = nullptr);
~FloatingDashLineWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option = nullptr, QWidget *widget = nullptr);
void slotMenuSelection(QAction* action);
bool onLine(const QPointF& point);
void setText(const QString& text);
void setY(qreal y);
void setYMin(qreal yMin);
void setYMax(qreal yMax);
qreal getYMin() const;
qreal getDiffY() const;
void saveToXMI(QXmlStreamWriter& writer);
bool loadFromXMI(QDomElement & qElement);
private:
/**
* Text associated to the dash line
*/
QString m_text;
/**
* Minimum value of the Y-coordinate of the dash line
* (= y-coordinate of the combined fragment)
*/
qreal m_yMin;
/**
* Maximum value of the Y-coordinate of the dash line
* (= y-coordinate of the combined fragment + height of the combined fragment)
*/
qreal m_yMax;
CombinedFragmentWidget *m_parent;
};
#endif
| 1,999
|
C++
|
.h
| 57
| 31.333333
| 130
| 0.738454
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,900
|
widgetbase.h
|
KDE_umbrello/umbrello/umlwidgets/widgetbase.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2004-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef WIDGETBASE_H
#define WIDGETBASE_H
#include "basictypes.h"
#include "icon_utils.h"
#include <QColor>
#include <QDomDocument>
#include <QFont>
#include <QGraphicsObject>
#include <QObject>
#include <QPainter>
#include <QPointer>
#include <QXmlStreamWriter>
// forward declarations
class QAction;
class ActivityWidget;
class ActorWidget;
class ArtifactWidget;
class AssociationWidget;
class BoxWidget;
class CategoryWidget;
class ClassifierWidget;
class CombinedFragmentWidget;
class ComponentWidget;
class DatatypeWidget;
class EntityWidget;
class EnumWidget;
class FloatingDashLineWidget;
class FloatingTextWidget;
class ForkJoinWidget;
class IDChangeLog;
class InterfaceWidget;
class MessageWidget;
class NodeWidget;
class NoteWidget;
class ObjectNodeWidget;
class ObjectWidget;
class PackageWidget;
class PinWidget;
class PortWidget;
class PinPortBase;
class PreconditionWidget;
class RegionWidget;
class SignalWidget;
class StateWidget;
//class TextWidget;
class UseCaseWidget;
class UMLDoc;
class UMLObject;
class UMLScene;
class UMLWidget; // required by function onWidget()
/**
* Provides a wrapper that bypasses the restriction that
* QGraphicsItem::setSelected() is not virtual
*
* The selection management of umbrello uses a virtual method
* setSelected() for selection to achieve the desired behavior
* in the different derivation levels regarding selection and
* deselection.
*
* Within QGraphicsScene, QGraphicsItem::setSelected() is called
* to manage the selection state, e.g. with clearSelection(), but
* unfortunately cannot be directly overwritten by umbrello because
* this method is not virtual (I consider this a design flaw).
*
* Fortunately there is a workaround for the problem by using
* QGraphicsItem::itemChange(), which is overridden in this class
* and calls the (now) virtual method setSelected() when the selection
* state changes. This calls derived implementations of this method
* and realizes the desired behavior.
*
* Within setSelected() you have to take care that
* QGraphicsObject::setSelected() is not called if the call came
* from itemChange() to avoid an endless loop.
*
* @author Ralf Habacker <ralf.habacker@freenet.de>
*/
class QGraphicsObjectWrapper: public QGraphicsObject
{
public:
virtual void setSelected(bool state);
protected:
bool m_calledFromItemChange{false};
QVariant itemChange(GraphicsItemChange change, const QVariant &value);
};
/**
* @short Common base class for UMLWidget and AssociationWidget
* @author Oliver Kellogg <okellogg@users.sourceforge.net>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class WidgetBase : public QGraphicsObjectWrapper
{
Q_OBJECT
Q_ENUMS(WidgetType)
public:
enum WidgetType
{
wt_Min = 299, // lower bounds check value
wt_UMLWidget, // does not have UMLObject representation
wt_Actor, // has UMLObject representation
wt_UseCase, // has UMLObject representation
wt_Class, // has UMLObject representation
wt_Interface, // has UMLObject representation
wt_Datatype, // has UMLObject representation
wt_Enum, // has UMLObject representation
wt_Entity, // has UMLObject representation
wt_Package, // has UMLObject representation
wt_Object, // has UMLObject representation
wt_Note, // does not have UMLObject representation
wt_Box, // does not have UMLObject representation
wt_Message, // does not have UMLObject representation
wt_Text, // does not have UMLObject representation
wt_State, // does not have UMLObject representation
wt_Activity, // does not have UMLObject representation
wt_Component, // has UMLObject representation
wt_Artifact, // has UMLObject representation
wt_Node, // has UMLObject representation
wt_Association, // has UMLObject representation
wt_ForkJoin, // does not have UMLObject representation
wt_Precondition, // does not have UMLObject representation
wt_CombinedFragment, // does not have UMLObject representation
wt_FloatingDashLine, // does not have UMLObject representation
wt_Signal, // does not have UMLObject representation
wt_Pin,
wt_ObjectNode,
wt_Region,
wt_Category, // has UMLObject representation
wt_Port, // has UMLObject representation
wt_Instance, // has UMLObject representation == wt_Object
wt_Max // upper bounds check value
};
static QString toString(WidgetType wt);
static QString toI18nString(WidgetType wt);
static Icon_Utils::IconType toIcon(WidgetType wt);
explicit WidgetBase(UMLScene * scene, WidgetType type= wt_UMLWidget, Uml::ID::Type id = Uml::ID::None);
virtual ~WidgetBase();
UMLObject* umlObject() const;
virtual void setUMLObject(UMLObject *obj);
Uml::ID::Type id() const;
void setID(Uml::ID::Type id);
void setLocalID(Uml::ID::Type id);
Uml::ID::Type localID() const;
virtual UMLWidget *widgetWithID(Uml::ID::Type id);
WidgetType baseType() const;
void setBaseType(const WidgetType& baseType);
QLatin1String baseTypeStr() const;
QString baseTypeStrWithoutPrefix() const;
virtual void setSelected(bool select);
UMLScene* umlScene() const;
UMLDoc* umlDoc() const;
QString documentation() const;
bool hasDocumentation() const;
virtual void setDocumentation(const QString& doc);
QString name() const;
virtual void setName(const QString &strName);
QColor lineColor() const;
virtual void setLineColor(const QColor& color);
uint lineWidth() const;
virtual void setLineWidth(uint width);
QColor textColor() const;
virtual void setTextColor(const QColor& color);
QColor fillColor() const;
virtual void setFillColor(const QColor& color);
bool usesDiagramLineColor() const;
void setUsesDiagramLineColor(bool state);
bool usesDiagramLineWidth() const;
void setUsesDiagramLineWidth(bool state);
bool useFillColor() const;
virtual void setUseFillColor(bool state);
bool usesDiagramTextColor() const;
void setUsesDiagramTextColor(bool state);
bool usesDiagramFillColor() const;
void setUsesDiagramFillColor(bool state);
bool usesDiagramUseFillColor() const;
void setUsesDiagramUseFillColor(bool state);
virtual QFont font() const;
virtual void setFont(const QFont& font);
bool autoResize() const;
void setAutoResize(bool state);
bool changesShape() const;
void setChangesShape(bool state);
virtual bool showPropertiesDialog();
virtual bool loadFromXMI(QDomElement &qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual void removeAssoc(AssociationWidget* pAssoc);
virtual void addAssoc(AssociationWidget* pAssoc);
WidgetBase& operator=(const WidgetBase& other);
QRectF rect() const;
void setRect(const QRectF& rect);
void setRect(qreal x, qreal y, qreal width, qreal height);
virtual QRectF boundingRect() const;
virtual UMLWidget* onWidget(const QPointF &p);
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
bool isActivityWidget() const { return baseType() == wt_Activity; }
bool isActorWidget() const { return baseType() == wt_Actor; }
bool isArtifactWidget() const { return baseType() == wt_Artifact; }
bool isAssociationWidget() const { return baseType() == wt_Association; }
bool isBoxWidget() const { return baseType() == wt_Box; }
bool isCategoryWidget() const { return baseType() == wt_Category; }
bool isClassWidget() const { return baseType() == wt_Class; }
bool isCombinedFragmentWidget() const { return baseType() == wt_CombinedFragment; }
bool isComponentWidget() const { return baseType() == wt_Component; }
bool isDatatypeWidget() const { return baseType() == wt_Datatype; }
bool isEntityWidget() const { return baseType() == wt_Entity; }
bool isEnumWidget() const { return baseType() == wt_Enum; }
bool isFloatingDashLineWidget() const { return baseType() == wt_FloatingDashLine; }
bool isForkJoinWidget() const { return baseType() == wt_ForkJoin; }
bool isInterfaceWidget() const { return baseType() == wt_Interface; }
bool isMessageWidget() const { return baseType() == wt_Message; }
bool isNodeWidget() const { return baseType() == wt_Node; }
bool isNoteWidget() const { return baseType() == wt_Note; }
bool isObjectNodeWidget() const { return baseType() == wt_ObjectNode; }
bool isObjectWidget() const { return baseType() == wt_Object; }
bool isPackageWidget() const { return baseType() == wt_Package; }
bool isPinWidget() const { return baseType() == wt_Pin; }
bool isPortWidget() const { return baseType() == wt_Port; }
bool isPreconditionWidget() const { return baseType() == wt_Precondition; }
bool isRegionWidget() const { return baseType() == wt_Region; }
bool isSignalWidget() const { return baseType() == wt_Signal; }
bool isStateWidget() const { return baseType() == wt_State; }
bool isTextWidget() const { return baseType() == wt_Text; }
bool isUseCaseWidget() const { return baseType() == wt_UseCase; }
ActivityWidget* asActivityWidget();
ActorWidget* asActorWidget();
ArtifactWidget* asArtifactWidget();
AssociationWidget* asAssociationWidget();
BoxWidget* asBoxWidget();
CategoryWidget* asCategoryWidget();
ClassifierWidget* asClassifierWidget();
CombinedFragmentWidget* asCombinedFragmentWidget();
ComponentWidget* asComponentWidget();
DatatypeWidget* asDatatypeWidget();
EntityWidget* asEntityWidget();
EnumWidget* asEnumWidget();
FloatingDashLineWidget* asFloatingDashLineWidget();
ForkJoinWidget* asForkJoinWidget();
InterfaceWidget* asInterfaceWidget();
MessageWidget* asMessageWidget();
NodeWidget* asNodeWidget();
NoteWidget* asNoteWidget();
ObjectNodeWidget* asObjectNodeWidget();
ObjectWidget* asObjectWidget();
PackageWidget* asPackageWidget();
PinWidget* asPinWidget();
PinPortBase* asPinPortBase();
PortWidget* asPortWidget();
PreconditionWidget* asPreconditionWidget();
RegionWidget* asRegionWidget();
SignalWidget* asSignalWidget();
StateWidget* asStateWidget();
FloatingTextWidget* asFloatingTextWidget();
// TextWidget* asTextWidget();
UseCaseWidget* asUseCaseWidget();
UMLWidget* asUMLWidget();
const ActivityWidget* asActivityWidget() const;
const ActorWidget* asActorWidget() const;
const ArtifactWidget* asArtifactWidget() const;
const AssociationWidget* asAssociationWidget() const;
const BoxWidget* asBoxWidget() const;
const CategoryWidget* asCategoryWidget() const;
const ClassifierWidget* asClassifierWidget() const;
const CombinedFragmentWidget* asCombinedFragmentWidget() const;
const ComponentWidget* asComponentWidget() const;
const DatatypeWidget* asDatatypeWidget() const;
const EntityWidget* asEntityWidget() const;
const EnumWidget* asEnumWidget() const;
const FloatingDashLineWidget* asFloatingDashLineWidget() const;
const ForkJoinWidget* asForkJoinWidget() const;
const InterfaceWidget* asInterfaceWidget() const;
const MessageWidget* asMessageWidget() const;
const NodeWidget* asNodeWidget() const;
const NoteWidget* asNoteWidget() const;
const ObjectNodeWidget* asObjectNodeWidget() const;
const ObjectWidget* asObjectWidget() const;
const PackageWidget* asPackageWidget() const;
const PinWidget* asPinWidget() const;
const PinPortBase* asPinPortBase() const;
const PortWidget* asPortWidget() const;
const PreconditionWidget* asPreconditionWidget() const;
const RegionWidget* asRegionWidget() const;
const SignalWidget* asSignalWidget() const;
const StateWidget* asStateWidget() const;
const FloatingTextWidget* asFloatingTextWidget() const;
// const TextWidget* asTextWidget() const;
const UseCaseWidget* asUseCaseWidget() const;
const UMLWidget* asUMLWidget() const;
static bool widgetHasUMLObject(WidgetBase::WidgetType type);
virtual bool activate(IDChangeLog *changeLog = nullptr);
public Q_SLOTS:
virtual void slotMenuSelection(QAction *trigger);
protected:
virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent *event);
private:
WidgetType m_baseType; ///< Type of widget.
protected:
UMLScene *m_scene;
QPointer<UMLObject> m_umlObject;
QString m_Doc; ///< Only used if m_umlObject is not set.
QString m_Text;
QRectF m_rect; ///< Widget size. In this rectangle, the x and y coordinates are always 0.
/**
* This ID is only used when the widget does not have a
* corresponding UMLObject (i.e. the m_umlObject pointer is nullptr.)
* For UMLObjects, the ID from the UMLObject is used.
*/
Uml::ID::Type m_nId;
/**
* This ID is only used when a widget could be added more than once to a diagram
*/
Uml::ID::Type m_nLocalID;
QColor m_textColor; ///< Color of the text of the widget. Is saved to XMI.
QColor m_lineColor; ///< Color of the lines of the widget. Is saved to XMI.
QColor m_fillColor; ///< color of the background of the widget
QBrush m_brush;
QFont m_font;
uint m_lineWidth; ///< Width of the lines of the widget. Is saved to XMI.
bool m_useFillColor; ///< flag indicates if the UMLWidget uses the Diagram FillColour
/**
* true by default, false if the colors have
* been explicitly set for this widget.
* These are saved to XMI.
*/
bool m_usesDiagramFillColor;
bool m_usesDiagramLineColor;
bool m_usesDiagramLineWidth;
bool m_usesDiagramTextColor;
bool m_usesDiagramUseFillColor;
bool m_autoResize;
bool m_changesShape; ///< The widget changes its shape when the number of connections or their positions are changed
};
#endif
| 15,766
|
C++
|
.h
| 334
| 42.724551
| 120
| 0.663676
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,901
|
packagewidget.h
|
KDE_umbrello/umbrello/umlwidgets/packagewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef PACKAGEWIDGET_H
#define PACKAGEWIDGET_H
#include "umlwidget.h"
class UMLPackage;
class ListPopupMenu;
#define PACKAGE_MARGIN 5
/**
* Defines a graphical version of the Package. Most of the
* functionality will come from the @ref UMLPackage class.
*
* @short A graphical version of a Package.
* @author Jonathan Riddell
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class PackageWidget : public UMLWidget
{
public:
explicit PackageWidget(UMLScene * scene, UMLPackage * o);
virtual ~PackageWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
void saveToXMI(QXmlStreamWriter& writer);
protected:
QSizeF minimumSize() const;
};
#endif
| 930
|
C++
|
.h
| 30
| 28.5
| 109
| 0.771044
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,902
|
layoutgrid.h
|
KDE_umbrello/umbrello/umlwidgets/layoutgrid.h
|
/*
SPDX-FileCopyrightText: 2011 Andi Fischer <andi.fischer@hispeed.ch>
SPDX-FileCopyrightText: 2012 Ralf Habacker <ralf.habacker@freenet.de>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#ifndef LAYOUTGRID_H
#define LAYOUTGRID_H
#include <QColor>
#include <QFont>
class UMLScene;
class QRectF;
/**
* @author Andi Fischer
* This class handles the layout grid, which is drawn in the background
* of the scene. It is used only in UMLScene.
*/
class LayoutGrid
{
public:
explicit LayoutGrid(UMLScene *scene);
~LayoutGrid();
void paint(QPainter *painter, const QRectF &rect);
QRect gridRect() const;
void setGridRect(const QRect& rect);
int gridSpacingX() const;
int gridSpacingY() const;
void setGridSpacing(int sizeX, int sizeY);
const QColor& gridDotColor() const;
void setGridDotColor(const QColor& color);
const QColor& gridCrossColor() const;
void setGridCrossColor(const QColor& color);
const QColor& textColor() const;
void setTextColor(const QColor& color);
QFont textFont() const;
void setTextFont(const QFont& font);
bool isVisible() const;
void setVisible(bool visible);
bool isTextVisible() const;
void setTextVisible(bool visible);
private:
UMLScene *m_scene;
int m_gridSpacingX;
int m_gridSpacingY;
QColor m_gridDotColor;
bool m_isVisible;
};
#endif // LAYOUTGRID_H
| 1,482
|
C++
|
.h
| 47
| 27.638298
| 73
| 0.697527
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,903
|
forkjoinwidget.h
|
KDE_umbrello/umbrello/umlwidgets/forkjoinwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2005-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef FORKJOINWIDGET_H
#define FORKJOINWIDGET_H
//app includes
#include "boxwidget.h"
/**
* @short Displays a fork/join plate in a state diagram.
*
* @author Oliver Kellogg <okellogg@users.sourceforge.net>
*
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class ForkJoinWidget : public BoxWidget
{
Q_OBJECT
Q_PROPERTY(Qt::Orientation orientation READ orientation WRITE setOrientation)
public:
explicit ForkJoinWidget(UMLScene * scene, Qt::Orientation ori = Qt::Horizontal, Uml::ID::Type id = Uml::ID::None);
virtual ~ForkJoinWidget();
Qt::Orientation orientation() const;
void setOrientation(Qt::Orientation ori);
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
virtual bool loadFromXMI(QDomElement & qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual bool showPropertiesDialog();
public Q_SLOTS:
virtual void slotMenuSelection(QAction* action);
protected:
QSizeF minimumSize() const;
virtual void paintSelected(QPainter * p, int offsetX = 0, int offsetY = 0);
void constrain(qreal& width, qreal& height);
private:
Qt::Orientation m_orientation; ///< whether to draw the plate horizontally or vertically
};
#endif
| 1,462
|
C++
|
.h
| 39
| 34.230769
| 118
| 0.756028
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,904
|
boxwidget.h
|
KDE_umbrello/umbrello/umlwidgets/boxwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef BOXWIDGET_H
#define BOXWIDGET_H
//app includes
#include "umlwidget.h"
/**
* Displays a rectangular box.
* These widgets are diagram specific. They will still need a unique id
* from the @ref UMLDoc class for deletion and other purposes.
*
* @short Displays a box.
* @author Jonathan Riddell
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class BoxWidget : public UMLWidget
{
public:
explicit BoxWidget(UMLScene * scene, Uml::ID::Type id = Uml::ID::None, WidgetType type = WidgetBase::wt_Box);
virtual ~BoxWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual bool showPropertiesDialog();
protected:
void toForeground();
};
#endif
| 987
|
C++
|
.h
| 30
| 30.3
| 113
| 0.753684
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,905
|
diagramproxywidget.h
|
KDE_umbrello/umbrello/umlwidgets/diagramproxywidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2019-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef DIAGRAMPROXYWIDGET_H
#define DIAGRAMPROXYWIDGET_H
#include <basictypes.h>
#include <QPointer>
#include <QPointF>
#include <QRectF>
#include <QGraphicsSceneEvent>
class UMLWidget;
class UMLScene;
class IDChangeLog;
class QAction;
class QDomDocument;
class QDomElement;
class QStyleOptionGraphicsItem;
class QXmlStreamWriter;
class DiagramProxyWidget {
public:
DiagramProxyWidget(UMLWidget *widget, qreal borderWidth = 5);
virtual ~DiagramProxyWidget() {}
Uml::ID::Type diagramLink() const;
UMLScene *linkedDiagram() const;
bool setDiagramLink(const Uml::ID::Type &id);
const QRectF &clientRect() const;
const QRectF &sceneRect() const;
void setClientRect(const QRectF &rect);
bool isProxyWidget() const;
UMLWidget *getProxiedWidget(const QPointF &p) const;
QPointF mapFromClient(const QPointF &p) const;
QRectF mapFromClient(const QRectF &r) const;
QPointF mapToClient(const QPointF &pos) const;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
bool showLinkedDiagram() const;
void setShowLinkedDiagram(bool showLinkedDiagram);
QRectF iconRect() const;
void setIconRect(const QRectF &iconRect);
protected:
DiagramProxyWidget& operator=(const DiagramProxyWidget& other);
bool activate(IDChangeLog *changeLog = nullptr);
bool loadFromXMI(QDomElement &qElement);
void saveToXMI(QXmlStreamWriter& writer);
void setupEvent(QGraphicsSceneMouseEvent &e,
const QGraphicsSceneMouseEvent *event, const QPointF &pos) const;
void setupEvent(QGraphicsSceneContextMenuEvent &e,
const QGraphicsSceneContextMenuEvent *event, const QPointF &pos) const;
virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent *event);
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
void slotMenuSelection(QAction *action);
private:
Uml::ID::Type m_diagramLinkId; ///< id of linked diagram
QPointer<UMLScene> m_linkedDiagram; ///< pointer to linked diagram
QRectF m_clientRect; ///< widget area for embedded diagram
QRectF m_sceneRect; ///< scene rectangle used for internal calculations
QRectF m_iconRect; ///< widget area for diagram icon
UMLWidget *m_widget;
qreal m_borderWidth;
bool m_showLinkedDiagram;
};
#endif // DIAGRAMPROXYWIDGET_H
| 2,733
|
C++
|
.h
| 65
| 37.784615
| 102
| 0.769578
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,906
|
widget_factory.h
|
KDE_umbrello/umbrello/umlwidgets/widget_factory.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2006-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef WIDGET_FACTORY_H
#define WIDGET_FACTORY_H
#include <QString>
// forward declarations
class UMLObject;
class UMLScene;
class UMLWidget;
/**
* Widget factory methods.
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
namespace Widget_Factory {
UMLWidget *createWidget(UMLScene *scene, UMLObject *docObj);
UMLWidget* makeWidgetFromXMI(const QString& tag,
const QString& idStr, UMLScene *scene);
} // end namespace Widget_Factory
#endif
| 663
|
C++
|
.h
| 21
| 27.714286
| 92
| 0.735016
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,907
|
artifactwidget.h
|
KDE_umbrello/umbrello/umlwidgets/artifactwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ARTIFACTWIDGET_H
#define ARTIFACTWIDGET_H
#include "umlwidget.h"
class UMLScene;
class UMLArtifact;
#define ARTIFACT_MARGIN 5
/**
* Defines a graphical version of the @ref UMLArtifact.
* Most of the functionality will come from the @ref UMLWidget class.
*
* @short A graphical version of an Artifact.
* @author Jonathan Riddell
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class ArtifactWidget : public UMLWidget
{
public:
ArtifactWidget(UMLScene *scene, UMLArtifact *a);
virtual ~ArtifactWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
// Note: For loading from XMI, the inherited parent method is used.
virtual void saveToXMI(QXmlStreamWriter& writer);
protected:
QSizeF minimumSize() const;
private:
void paintAsFile(QPainter *painter, const QStyleOptionGraphicsItem *option);
void paintAsLibrary(QPainter *painter, const QStyleOptionGraphicsItem *option);
void paintAsTable(QPainter *painter, const QStyleOptionGraphicsItem *option);
void paintAsNormal(QPainter *painter, const QStyleOptionGraphicsItem *option);
QSize calculateIconSize() const;
QSize calculateNormalSize() const;
};
#endif
| 1,429
|
C++
|
.h
| 38
| 34.605263
| 109
| 0.781001
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,908
|
datatypewidget.h
|
KDE_umbrello/umbrello/umlwidgets/datatypewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef DATATYPEWIDGET_H
#define DATATYPEWIDGET_H
#include "umlwidget.h"
class UMLClassifier;
#define DATATYPE_MARGIN 5
/**
* Defines a graphical version of the datatype. Most of the functionality
* will come from the @ref UMLWidget class from which class inherits from.
*
* @short A graphical version of an datatype.
* @author Jonathan Riddell
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class DatatypeWidget : public UMLWidget
{
Q_OBJECT
public:
DatatypeWidget(UMLScene *scene, UMLClassifier *d);
virtual ~DatatypeWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
bool loadFromXMI(QDomElement& qElement);
void saveToXMI(QXmlStreamWriter& writer);
public Q_SLOTS:
protected:
QSizeF minimumSize() const;
};
#endif
| 1,019
|
C++
|
.h
| 32
| 29.125
| 109
| 0.772541
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,909
|
childwidgetplacementpin.h
|
KDE_umbrello/umbrello/umlwidgets/childwidgetplacementpin.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2016-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CHILDWIDGETPLACEMENTPIN_H
#define CHILDWIDGETPLACEMENTPIN_H
#include "umlwidgets/childwidgetplacement.h"
/**
* Implementation of child widget placement where parent and child widget borders are
* always connected.
*
* @short Child widget placement attached to parent
*/
class ChildWidgetPlacementPin : public ChildWidgetPlacement
{
public:
ChildWidgetPlacementPin(PinPortBase* widget);
virtual ~ChildWidgetPlacementPin();
virtual void detectConnectedSide();
virtual void setInitialPosition(const QPointF &scenePos = QPointF());
virtual void setNewPositionWhenMoved(qreal diffX, qreal diffY);
virtual void setNewPositionOnParentResize();
private:
bool isAboveParent() const;
bool isBelowParent() const;
bool isLeftOfParent() const;
bool isRightOfParent() const;
qreal getNewXOnJumpToTopOrBottom() const;
void jumpToTopOfParent();
void jumpToBottomOfParent();
qreal getNewYOnJumpToSide() const;
void jumpToLeftOfParent();
void jumpToRightOfParent();
};
#endif /* ! CHILDWIDGETPLACEMENTPIN_H */
| 1,222
|
C++
|
.h
| 35
| 31.485714
| 92
| 0.782867
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,910
|
childwidgetplacement.h
|
KDE_umbrello/umbrello/umlwidgets/childwidgetplacement.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2016-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CHILDWIDGETPLACEMENT_H
#define CHILDWIDGETPLACEMENT_H
class PinPortBase;
class UMLWidget;
#include <QPointF>
#include <QtGlobal>
/**
* Base class for placing child widgets relative to their parent. Child widget positions
* shall somehow be constrained, e.g. always in contact to the parent widgets border.
*
* @short Base class for child widget placement.
*/
class ChildWidgetPlacement
{
public:
ChildWidgetPlacement(PinPortBase* widget);
virtual ~ChildWidgetPlacement() {}
virtual void detectConnectedSide() = 0;
virtual void setInitialPosition(const QPointF &scenePos = QPointF()) = 0;
virtual void setNewPositionWhenMoved(qreal diffX, qreal diffY) = 0;
virtual void setNewPositionOnParentResize() = 0;
protected:
enum ConnectedSide {
Undefined,
Top,
Right,
Bottom,
Left,
TopLeft,
TopRight,
BottomRight,
BottomLeft
};
void setPos(const QPointF& pos);
void setPos(qreal x, qreal y);
void setX(qreal x);
void setY(qreal y);
qreal x() const;
qreal y() const;
qreal width() const;
qreal height() const;
UMLWidget* ownerWidget() const;
PinPortBase* const m_widget;
ConnectedSide m_connectedSide;
};
#endif /* ! CHILDWIDGETPLACEMENT_H */
| 1,450
|
C++
|
.h
| 50
| 24.58
| 92
| 0.71295
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,911
|
associationwidget.h
|
KDE_umbrello/umbrello/umlwidgets/associationwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ASSOCIATIONWIDGET_H
#define ASSOCIATIONWIDGET_H
#include "associationline.h"
#include "associationwidgetlist.h"
#include "associationwidgetrole.h"
#include "linkwidget.h"
#include "messagewidgetlist.h"
#include "umlwidgetlist.h"
#include "widgetbase.h"
class ClassifierWidget;
class UMLScene;
class UMLAssociation;
class UMLAttribute;
class UMLClassifierListItem;
class UMLOperation;
/**
* This class represents an association inside a diagram.
*
* Constructor is made non accessible:
* Users shall use the static create() methods for constructing AssociationWidgets.
*
* Associations exist not only between UML objects. For example, when a Note is
* attached to a UML object, the Note itself is not a UML object.
* This class supports both kinds of associations. An association where one or
* both roles are not a UML object is called a "pure widget association".
*
* An AssociationWidget where both roles are UML objects has a corresponding
* UMLAssociation. The UMLAssociation can be retrieved using the getAssociation
* method.
* A pure widget association does not have a corresponding UMLAssociation.
* The getAssociation method returns nullptr in this case.
*
* @author Gustavo Madrigal
* @author Gopala Krishna
* @short This class represents an association inside a diagram.
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class AssociationWidget : public WidgetBase, public LinkWidget
{
Q_OBJECT
public:
static AssociationWidget* create(UMLScene *scene);
static AssociationWidget* create
(UMLScene *scene, UMLWidget* WidgetA,
Uml::AssociationType::Enum assocType, UMLWidget* WidgetB,
UMLObject *umlobject = nullptr);
virtual ~AssociationWidget();
virtual void setUMLObject(UMLObject *obj);
//---------- LinkWidget Interface methods implementation from here on.
virtual void lwSetFont(QFont font);
virtual UMLClassifier *operationOwner();
virtual UMLOperation *operation();
virtual void setOperation(UMLOperation *op);
virtual QString customOpText();
virtual void setCustomOpText(const QString &opText);
virtual void resetTextPositions();
virtual void setMessageText(FloatingTextWidget *ft);
virtual void setText(FloatingTextWidget *ft, const QString &newText);
virtual bool showPropertiesDialog();
virtual QString lwOperationText();
virtual UMLClassifier *lwClassifier();
virtual void setOperationText(const QString &op);
virtual void constrainTextPos(qreal &textX, qreal &textY,
qreal textWidth, qreal textHeight,
Uml::TextRole::Enum tr);
virtual void calculateNameTextSegment();
//---------- End LinkWidget Interface methods implementation.
UMLAssociation* association() const;
UMLAttribute* attribute() const;
// AssociationWidget& operator=(const AssociationWidget& other);
bool operator==(const AssociationWidget& other) const;
bool operator!=(AssociationWidget& other) const;
FloatingTextWidget* textWidgetByRole(Uml::TextRole::Enum tr) const;
FloatingTextWidget* nameWidget() const;
QString name() const;
void setName(const QString &strRole);
void setStereotype(const QString &stereo);
FloatingTextWidget* roleWidget(Uml::RoleType::Enum role) const;
QString roleName(Uml::RoleType::Enum role) const;
void setRoleName(const QString &strRole, Uml::RoleType::Enum role);
QString roleDocumentation(Uml::RoleType::Enum role) const;
void setRoleDocumentation(const QString& doc, Uml::RoleType::Enum role);
FloatingTextWidget* multiplicityWidget(Uml::RoleType::Enum role) const;
QString multiplicity(Uml::RoleType::Enum role) const;
void setMultiplicity(const QString& text, Uml::RoleType::Enum role);
Uml::Visibility::Enum visibility(Uml::RoleType::Enum role) const;
void setVisibility(Uml::Visibility::Enum value, Uml::RoleType::Enum role);
FloatingTextWidget* changeabilityWidget(Uml::RoleType::Enum role) const;
Uml::Changeability::Enum changeability(Uml::RoleType::Enum role) const;
void setChangeability(Uml::Changeability::Enum value, Uml::RoleType::Enum role);
Uml::ID::Type widgetIDForRole(Uml::RoleType::Enum role) const;
Uml::ID::Type widgetLocalIDForRole(Uml::RoleType::Enum role) const;
UMLWidget* widgetForRole(Uml::RoleType::Enum role) const;
void setWidgetForRole(UMLWidget* widget, Uml::RoleType::Enum role);
bool containsAsEndpoint(UMLWidget* widget);
Uml::AssociationType::Enum associationType() const;
void setAssociationType(Uml::AssociationType::Enum type);
bool isCollaboration() const;
bool isSelf() const;
QString toString() const;
bool isActivated() const;
void setActivated(bool active);
const AssociationLine& associationLine() const;
AssociationLine& associationLine();
virtual bool activate(IDChangeLog *changeLog = nullptr);
virtual QRectF boundingRect() const;
virtual QPainterPath shape() const;
void widgetMoved(UMLWidget* widget, qreal x, qreal y);
void saveIdealTextPositions();
UMLWidget* onWidget(const QPointF &p);
bool onAssociation(const QPointF& point);
bool onAssocClassLine(const QPointF& point);
void createAssocClassLine();
void createAssocClassLine(ClassifierWidget* classifierWidget,
int linePathSegmentIndex);
void selectAssocClassLine(bool sel = true);
void removeAssocClassLine();
void computeAssocClassLine();
void setXEntireAssoc(qreal x);
void setYEntireAssoc(qreal y);
void moveMidPointsBy(qreal x, qreal y);
void moveEntireAssoc(qreal x, qreal y);
QFont font() const;
virtual void setTextColor(const QColor &color);
virtual void setLineColor(const QColor &color);
virtual void setLineWidth(uint width);
void calculateEndingPoints();
void clipSize();
bool loadFromXMI(QDomElement& qElement, const UMLWidgetList& widgets,
const MessageWidgetList* messages);
virtual bool loadFromXMI(QDomElement& qElement);
virtual void saveToXMI(QXmlStreamWriter& writer);
void cleanup();
bool isPointAddable();
bool isPointRemovable();
bool isAutoLayouted();
bool isLayoutChangeable();
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
virtual void setSelected(bool _select);
public Q_SLOTS: //:TODO: all virtual?
virtual void slotMenuSelection(QAction* action);
void slotClassifierListItemRemoved(UMLClassifierListItem* obj);
void slotAttributeChanged();
void syncToModel();
protected:
virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent *event);
virtual void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
virtual void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
private:
QPointF calculateTextPosition(Uml::TextRole::Enum role);
void setTextPosition(Uml::TextRole::Enum role);
void setTextPositionRelatively(Uml::TextRole::Enum role, const QPointF &oldPosition);
void setFloatingText(Uml::TextRole::Enum role, const QString& text, FloatingTextWidget* &ft);
AssociationWidget(UMLScene *scene);
void setUMLAssociation(UMLAssociation * assoc);
void mergeAssociationDataIntoUMLRepresentation();
static Uml::Region::Enum findPointRegion(const QRectF& rect, const QPointF& pos);
static bool findIntercept(const QRectF& rect, const QPointF& point, QPointF& result);
static QLineF::IntersectType intersect(const QRectF &rect, const QLineF &line,
QPointF* intersectionPoint);
void moveEvent(QGraphicsSceneMouseEvent *me);
Uml::TextRole::Enum calculateNameType(Uml::TextRole::Enum defaultRoleType);
static QPointF swapXY(const QPointF &p);
static QPointF midPoint(const QPointF& p0, const QPointF& p1);
void createPointsSelfAssociation();
void updatePointsSelfAssociation();
void createPointsException();
void updatePointsException();
static bool setStartAndEndPoint(AssociationWidget *assocwidget, UMLWidget *pWidget);
static void updateAssociations(UMLWidget *pWidget, AssociationWidgetList list);
void setChangeWidget(const QString &strChangeWidget, Uml::RoleType::Enum role);
bool checkAddPoint(const QPointF &scenePos);
bool checkRemovePoint(const QPointF &scenePos);
bool checkAutoLayoutSpline();
bool linePathStartsAt(const UMLWidget* widget) const;
bool linePathEndsAt (const UMLWidget* widget) const;
bool m_activated; ///< flag which is true if the activate method has been called for this class instance
/**
* When the association has a Role Floating Text this text should move
* when the AssociationLine moves but only if the closest segment to the
* role text moves.
* This segment is:
* m_associationLine[m_unNameLineSegment] -- m_associationLine[m_unNameLineSegment+1]
*/
int m_unNameLineSegment;
QPointF m_oldNamePoint; ///< Position of name floatingtext saved by saveIdealTextPositions()
QPointF m_oldMultiAPoint; ///< Position of role A multiplicity floatingtext saved by saveIdealTextPositions()
QPointF m_oldMultiBPoint; ///< Position of role B multiplicity floatingtext saved by saveIdealTextPositions()
QPointF m_oldChangeAPoint; ///< Position of role A changeability floatingtext saved by saveIdealTextPositions()
QPointF m_oldChangeBPoint; ///< Position of role B changeability floatingtext saved by saveIdealTextPositions()
QPointF m_oldRoleAPoint; ///< Position of role A name floatingtext saved by saveIdealTextPositions()
QPointF m_oldRoleBPoint; ///< Position of role B name floatingtext saved by saveIdealTextPositions()
int m_nLinePathSegmentIndex; ///< anchor for m_pAssocClassLine
QGraphicsLineItem *m_pAssocClassLine; ///< used for connecting assoc. class
QGraphicsRectItem *m_pAssocClassLineSel0; ///< selection decoration for the start point of the assoc. class line
QGraphicsRectItem *m_pAssocClassLineSel1; ///< selection decoration for the end point of the assoc. class line
AssociationLine m_associationLine; ///< the definition points for the association line
ClassifierWidget *m_associationClass; ///< used if we have an assoc. class
Uml::AssociationType::Enum m_associationType; ///< is only used if m_pObject is not set
AssociationWidgetRole m_role[2];
FloatingTextWidget* m_nameWidget; ///< displays the name of this association
QPointF m_eventScenePos; ///< holds scene pos of contextMenuEvent()
};
#endif
| 11,180
|
C++
|
.h
| 212
| 47.235849
| 117
| 0.751928
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,912
|
floatingtextwidget.h
|
KDE_umbrello/umbrello/umlwidgets/floatingtextwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef FLOATINGTEXTWIDGET_H
#define FLOATINGTEXTWIDGET_H
#include "basictypes.h"
#include "umlwidget.h"
class LinkWidget;
class UMLScene;
/**
* @short Displays a line of text or an operation.
*
* This is a multipurpose class. In its simplest form it will display a
* line of text.
* It can also be setup to be the text for an operation with regard to the
* @ref MessageWidget on the sequence diagram.
* It is also used for the text required for an association.
*
* The differences between all these different uses will be the popup menu
* that is associated with it.
*
* @author Paul Hensgen <phensgen@techie.com>
* @see UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class FloatingTextWidget : public UMLWidget
{
Q_OBJECT
public:
explicit FloatingTextWidget(UMLScene * scene, Uml::TextRole::Enum role = Uml::TextRole::Floating,
const QString& text = QString(), Uml::ID::Type id = Uml::ID::None);
virtual ~FloatingTextWidget();
QString text() const;
void setText(const QString &t);
void setTextcmd(const QString &t);
QString preText() const;
void setPreText(const QString &t);
QString postText() const;
void setPostText(const QString &t);
QString displayText() const;
bool isEmpty();
void showChangeTextDialog();
bool showOperationDialog(bool enableAutoIncrement = true);
virtual bool showPropertiesDialog();
LinkWidget* link() const;
void setLink(LinkWidget * l);
bool activate(IDChangeLog *ChangeLog = nullptr);
Uml::TextRole::Enum textRole() const;
void setTextRole(Uml::TextRole::Enum role);
bool handleRename();
void changeName(const QString& newText);
void setSequenceNumber(const QString &sequenceNumber);
QString sequenceNumber() const;
static bool isTextValid(const QString &text);
UMLWidget* onWidget(const QPointF& p);
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual bool loadFromXMI(QDomElement& qElement);
public Q_SLOTS:
virtual void slotMenuSelection(QAction* action);
void setMessageText();
protected:
QSizeF minimumSize() const;
virtual void moveWidgetBy(qreal diffX, qreal diffY);
virtual void constrainMovementForAllWidgets(qreal &diffX, qreal &diffY);
private:
QPointF constrainPosition(qreal diffX, qreal diffY);
/// The association or message widget we may be linked to.
LinkWidget * m_linkWidget;
//////////////////// Data loaded/saved:
/// Prepended text (such as for scope of association Role or method)
QString m_preText;
/// Ending text (such as bracket on changability notation for association Role)
QString m_postText;
/// The role the text widget will enact.
Uml::TextRole::Enum m_textRole;
////////
/// The horizontal position the widget would have if its move wasn't constrained.
qreal m_unconstrainedPositionX;
/// The vertical position the widget would have if its move wasn't constrained.
qreal m_unconstrainedPositionY;
/// The X direction the widget was moved when the constrain was applied.
/// -1 means left, 1 means right.
int m_movementDirectionX;
/// The Y direction the widget was moved when the constrain was applied.
/// -1 means up, 1 means down.
int m_movementDirectionY;
/// Contains sequence number for sequence or collaboration diagram message.
QString m_SequenceNumber;
};
#endif
| 3,738
|
C++
|
.h
| 92
| 36.184783
| 109
| 0.73062
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,913
|
widget_utils.h
|
KDE_umbrello/umbrello/umlwidgets/widget_utils.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2004-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef WIDGET_UTILS_H
#define WIDGET_UTILS_H
#include "basictypes.h"
#include "messagewidgetlist.h"
#include "umlwidgetlist.h"
#include "widgetbase.h"
#include <QBrush>
#include <QDomDocument>
#include <QPointF>
#include <QLineF>
#include <QPolygonF>
class QGraphicsItem;
class QGraphicsRectItem;
class QXmlStreamWriter;
/**
* General purpose widget utilities.
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
namespace Widget_Utils
{
UMLWidget* findWidget(Uml::ID::Type id,
const UMLWidgetList& widgets,
const MessageWidgetList *messages = nullptr);
QGraphicsRectItem *decoratePoint(const QPointF& p, QGraphicsItem *parent = nullptr);
void drawCrossInEllipse(QPainter *p, const QRectF& ellipse);
void drawTriangledRect(QPainter *painter, const QRectF& rect, const QSizeF& triSize);
// void drawArrowHead(QPainter *painter, const QPointF& arrowPos,
// const QSizeF& arrowSize, Qt::ArrowType arrowType,
// bool solid = false);
// void drawRoundedRect(QPainter *painter, const QRectF& rect, qreal xRadius,
// qreal yRadius, Uml::Corners corners);
QString pointToString(const QPointF& point);
QPointF stringToPoint(const QString& str);
bool loadPixmapFromXMI(QDomElement &qElement, QPixmap &pixmap);
void savePixmapToXMI(QXmlStreamWriter& stream, const QPixmap& pixmap);
bool loadGradientFromXMI(QDomElement &qElement, QGradient *&gradient);
void saveGradientToXMI(QXmlStreamWriter& stream, const QGradient *gradient);
bool loadBrushFromXMI(QDomElement &qElement, QBrush &brush);
void saveBrushToXMI(QXmlStreamWriter& stream, const QBrush& brush);
bool hasSmallerX(const UMLWidget* widget1, const UMLWidget* widget2);
bool hasSmallerY(const UMLWidget* widget1, const UMLWidget* widget2);
QLineF closestPoints(const QPolygonF& self, const QPolygonF& other);
QString defaultWidgetName(WidgetBase::WidgetType type);
QString newTitle(WidgetBase::WidgetType type);
QString newText(WidgetBase::WidgetType type);
QString renameTitle(WidgetBase::WidgetType type);
QString renameText(WidgetBase::WidgetType type);
void ensureNestedVisible(UMLWidget *self, UMLWidgetList widgetList);
QString adornStereo(QString name, bool appendSpace = true);
}
#endif
| 2,531
|
C++
|
.h
| 55
| 41.963636
| 92
| 0.749085
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,914
|
portwidget.h
|
KDE_umbrello/umbrello/umlwidgets/portwidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2014-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef PORTWIDGET_H
#define PORTWIDGET_H
#include "pinportbase.h"
class UMLPort;
/**
* Defines a graphical version of the UML2 port. Most of the functionality
* comes from the @ref PinPortBase class from which this class inherits.
*
* @short A graphical version of a port on a component.
* @author Oliver Kellogg
* @see PinPortBase, UMLWidget
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class PortWidget : public PinPortBase
{
Q_OBJECT
public:
PortWidget(UMLScene *scene, UMLPort *d, UMLWidget *owner = nullptr);
virtual ~PortWidget();
UMLWidget* ownerWidget() const;
public Q_SLOTS:
void slotMenuSelection(QAction* action);
};
#endif
| 848
|
C++
|
.h
| 28
| 27.714286
| 92
| 0.756158
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,915
|
usecasewidget.h
|
KDE_umbrello/umbrello/umlwidgets/usecasewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef USECASEWIDGET_H
#define USECASEWIDGET_H
#include "umlwidget.h"
class UMLUseCase;
#define UC_MARGIN 5
#define UC_WIDTH 60
#define UC_HEIGHT 30
/**
* This class is the graphical version of a UMLUseCase. The
* UseCaseWidget class inherits from the @ref UMLWidget class
* which adds most of the functionality to this class.
* A UseCaseWidget is created by a @ref UMLView. An UseCaseWidget belongs to only one
* @ref UMLView instance. When the @ref UMLView instance that this class belongs to,
* it will be automatically deleted.
*
* If the @ref UMLUseCase class that this UseCaseWidget is displaying is deleted, the @ref UMLView will
* make sure that this instance is also deleted.
*
* The UseCaseWidget class inherits from the @ref UMLWidget class which adds most of the functionality
* to this class.
*
* @short A graphical version of a UMLUseCase.
* @author Paul Hensgen <phensgen@techie.com>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UseCaseWidget : public UMLWidget
{
public:
UseCaseWidget(UMLScene * scene, UMLUseCase *o);
virtual ~UseCaseWidget();
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
// For loading we can use the loadFromXMI() inherited from
// UMLWidget.
virtual void saveToXMI(QXmlStreamWriter& writer);
protected:
QSizeF minimumSize() const;
};
#endif
| 1,582
|
C++
|
.h
| 42
| 35.071429
| 109
| 0.76767
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,916
|
docbook2xhtmlgeneratorjob.h
|
KDE_umbrello/umbrello/docgenerators/docbook2xhtmlgeneratorjob.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2007-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef DOCBOOK2XHTMLGENERATORJOB_H
#define DOCBOOK2XHTMLGENERATORJOB_H
#include <QThread>
#include <QUrl>
/**
* This class is used to generate XHTML from Docbook.
* It emits the name of the temporary file to which it as generated the XHtml as output.
* It runs in a separate thread.
*
* @short Generates XHtml from Docbook
* @author Sharan Rao
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class Docbook2XhtmlGeneratorJob : public QThread
{
Q_OBJECT
public:
Docbook2XhtmlGeneratorJob(QUrl& docBookUrl, QObject* parent);
protected:
void run();
private:
QUrl m_docbookUrl;
Q_SIGNALS:
void xhtmlGenerated(const QString&);
};
#endif
| 848
|
C++
|
.h
| 30
| 25.466667
| 92
| 0.758323
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,917
|
xhtmlgenerator.h
|
KDE_umbrello/umbrello/docgenerators/xhtmlgenerator.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2006 Gael de Chalendar (aka Kleag) kleag@free.fr
SPDX-FileCopyrightText: 2006-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef XHTMLGENERATOR_H
#define XHTMLGENERATOR_H
#include "basictypes.h"
#include <QObject>
#include <QUrl>
class UMLDoc;
class Docbook2XhtmlGeneratorJob;
/**
* class XhtmlGenerator is a documentation generator for UML documents.
* It uses first @ref DocbookGenerator to convert the XMI generated by
* UMLDoc::saveToXMI1 to docbook and next libxslt through
* the XSLT file stored in resources to convert the docbook file to XHTML.
* The latter uses the XSLT available on the Web at
* http://docbook.sourceforge.net/release/xsl/snapshot/html/docbook.xsl
*
* @todo allow to specify the destination and ensure that it works with distant
* ones
*/
class XhtmlGenerator : public QObject
{
Q_OBJECT
public:
XhtmlGenerator();
virtual ~XhtmlGenerator();
bool generateXhtmlForProject();
bool generateXhtmlForProjectInto(const QUrl& destDir);
static QString customXslFile();
Q_SIGNALS:
void finished(bool status);
protected Q_SLOTS:
void slotDocbookToXhtml(bool status);
void slotHtmlGenerated(const QString& tmpFileName);
void threadFinished();
private:
Docbook2XhtmlGeneratorJob* m_d2xg;
bool m_pStatus;
bool m_pThreadFinished;
QUrl m_destDir; ///< Destination directory where the final documentation will be written.
UMLDoc* m_umlDoc;
};
#endif // XHTMLGENERATOR_H
| 1,570
|
C++
|
.h
| 46
| 30.956522
| 94
| 0.774236
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,918
|
docbookgeneratorjob.h
|
KDE_umbrello/umbrello/docgenerators/docbookgeneratorjob.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2007-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef DOCBOOKGENERATORJOB_H
#define DOCBOOKGENERATORJOB_H
#include <QThread>
/**
* This class is used to generate docbook from the document.
* It emits the name of the temporary file to which it as generated the docbook as output.
* It runs in a separate thread.
*
* @short Generates DocBook from the Document
* @author Sharan Rao
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class DocbookGeneratorJob : public QThread
{
Q_OBJECT
public:
explicit DocbookGeneratorJob(QObject* parent);
protected:
void run();
Q_SIGNALS:
void docbookGenerated(const QString& url);
};
#endif
| 786
|
C++
|
.h
| 27
| 26.37037
| 92
| 0.76032
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,919
|
docbookgenerator.h
|
KDE_umbrello/umbrello/docgenerators/docbookgenerator.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2006 Gael de Chalendar (aka Kleag) kleag@free.fr
SPDX-FileCopyrightText: 2006-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef DOCBOOKGENERATOR_H
#define DOCBOOKGENERATOR_H
#include <QtGlobal>
#include <QObject>
#include <QUrl>
class UMLDoc;
class DocbookGeneratorJob;
/**
* class DocbookGenerator is a documentation generator for UML documents.
* It uses libxslt to convert the XMI generated by UMLDoc::saveToXMI1 through
* the XSLT file stored in resources.
*
* @todo Add configure checks for libxml2 and libxslt and use conditional
* compilation of this library and its callers
* @todo allow to specify the destination and ensure that it works with distant
* ones
*/
class DocbookGenerator : public QObject
{
Q_OBJECT
public:
DocbookGenerator();
virtual ~DocbookGenerator();
bool generateDocbookForProject();
void generateDocbookForProjectInto(const QUrl& destDir);
static QString customXslFile();
Q_SIGNALS:
void finished(bool status);
private Q_SLOTS:
void slotDocbookGenerationFinished(const QString&);
void threadFinished();
private:
DocbookGeneratorJob* docbookGeneratorJob;
bool m_pStatus;
bool m_pThreadFinished;
QUrl m_destDir;
UMLDoc* umlDoc;
};
#endif // DOCBOOKGENERATOR_H
| 1,377
|
C++
|
.h
| 44
| 28.045455
| 92
| 0.774487
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,920
|
dialogspopupmenu.h
|
KDE_umbrello/umbrello/menus/dialogspopupmenu.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2018-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef DIALOGSPOPUPMENU_H
#define DIALOGSPOPUPMENU_H
#include "listpopupmenu.h"
class DialogsPopupMenu : public ListPopupMenu
{
Q_OBJECT
Q_ENUMS(TriggerType)
public:
enum TriggerType ///< This type hosts all possible menu types.
{
tt_Min = -1,
tt_Activity_Selected,
tt_Association_Selected,
tt_Attribute_Selected,
tt_EntityAttribute_Selected,
tt_EnumLiteral_Selected,
tt_InstanceAttribute_Selected,
tt_New_Activity,
tt_New_Attribute,
tt_New_EntityAttribute,
tt_New_EnumLiteral,
tt_New_InstanceAttribute,
tt_New_Operation,
tt_New_Parameter,
tt_New_Template,
tt_Operation_Selected,
tt_Parameter_Selected,
tt_Template_Selected,
tt_Undefined,
tt_Max
};
DialogsPopupMenu(QWidget *parent, TriggerType type);
void insertSubMenuNew(TriggerType type);
static QString toString(TriggerType type);
};
QDebug operator<<(QDebug out, DialogsPopupMenu::TriggerType type);
#endif // DIALOGSPOPUPMENU_H
| 1,230
|
C++
|
.h
| 41
| 23.97561
| 92
| 0.691462
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,921
|
associationwidgetpopupmenu.h
|
KDE_umbrello/umbrello/menus/associationwidgetpopupmenu.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2018-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ASSOCIATIONWIDGETPOPUPMENU_H
#define ASSOCIATIONWIDGETPOPUPMENU_H
#include "listpopupmenu.h"
class AssociationLine;
/**
* Constructs the popup menu for an association widget
*/
class AssociationWidgetPopupMenu : public ListPopupMenu
{
public:
AssociationWidgetPopupMenu(QWidget *parent, Uml::AssociationType::Enum type, AssociationWidget *widget);
protected:
void insertSubMenuLayout(const AssociationLine& associationLine);
void insertSubmodelAction();
};
#endif // ASSOCIATIONWIDGETPOPUPMENU_H
| 669
|
C++
|
.h
| 20
| 31.05
| 108
| 0.816485
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,922
|
listpopupmenu.h
|
KDE_umbrello/umbrello/menus/listpopupmenu.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef LISTPOPUPMENU_H
#define LISTPOPUPMENU_H
#include "basictypes.h"
#include "umllistviewitem.h"
#include "umlobject.h"
#include "widgetbase.h"
#include <QMenu>
#include <QHash>
class UMLCategory;
class ListPopupMenuPrivate;
/**
* A popup menu that depending on what type is set to will
* display a different menu.
*
* The data field of actions is used to carry user data
* between objects. Because different types of data are used, a map is loaded
* with an enum as key (see @ref DataType).
*
* @short Displays a popup menu.
* @author Paul Hensgen <phensgen@techie.com>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class ListPopupMenu : public QMenu
{
Q_OBJECT
Q_ENUMS(MenuType)
Q_ENUMS(DataType)
public:
enum MenuType ///< This type hosts all possible menu entry types
{
mt_Model,
// diagrams
mt_Activity_Diagram,
mt_Class_Diagram,
mt_Collaboration_Diagram,
mt_Component_Diagram,
mt_Deployment_Diagram,
mt_EntityRelationship_Diagram,
mt_Sequence_Diagram,
mt_State_Diagram,
mt_UseCase_Diagram,
mt_Logical_Folder,
mt_UseCase_Folder,
mt_Component_Folder,
mt_Deployment_Folder,
mt_EntityRelationship_Folder,
// widgets, uml objects
mt_Accept_Signal,
mt_Accept_Time_Event,
mt_Activity,
mt_Activity_Transition,
mt_Actor,
mt_Artifact,
mt_Attribute,
mt_Branch,
mt_Category,
mt_CheckConstraint,
mt_Choice,
mt_Class,
mt_CombinedState,
mt_Component,
mt_Datatype,
mt_DeepHistory,
mt_DisjointSpecialisation,
mt_EditCombinedState,
mt_End_Activity,
mt_End_State,
mt_Entity,
mt_EntityAttribute,
mt_Enum,
mt_EnumLiteral,
mt_Exception,
mt_FloatText,
mt_Final_Activity,
mt_ForeignKeyConstraint,
mt_Fork,
mt_GoToStateDiagram,
mt_Initial_Activity,
mt_Initial_State,
mt_Invoke_Activity,
mt_Instance,
mt_InstanceAttribute,
mt_Interface,
mt_InterfaceComponent,
mt_InterfaceProvided,
mt_InterfaceRequired,
mt_Junction,
mt_MessageAsynchronous,
mt_MessageCreation,
mt_MessageDestroy,
mt_MessageFound,
mt_MessageLost,
mt_MessageSynchronous,
mt_Node,
mt_Note,
mt_Object,
mt_Object_Node,
mt_Operation,
mt_OverlappingSpecialisation,
mt_Package,
mt_Param_Activity,
mt_Pin,
mt_Port,
mt_PrePostCondition,
mt_PrimaryKeyConstraint,
mt_Region,
mt_SelectStateDiagram,
mt_Send_Signal,
mt_ShallowHistory,
mt_State,
mt_StateFork,
mt_StateJoin,
mt_StateTransition,
mt_Subsystem,
mt_Template,
mt_Union,
mt_UniqueConstraint,
mt_UseCase,
// new from dialogs
mt_New_Activity,
mt_New_Attribute,
mt_New_EntityAttribute,
mt_New_EnumLiteral,
mt_New_InstanceAttribute,
mt_New_Operation,
mt_New_Parameter,
mt_New_Template,
mt_RemoveStateDiagram,
mt_ReturnToClass,
mt_ReturnToCombinedState,
// selection
// visual properties
mt_Hide_Attribute_Signature_Selection,
mt_Hide_Attributes_Selection, // Unset visual property on multiple widgets
mt_Hide_Destruction_Box,
mt_Hide_NonPublic_Selection, // Could be named "show public only"
mt_Hide_Operation_Signature_Selection,
mt_Hide_Operations_Selection, // Hide operations
mt_Hide_Packages_Selection,
mt_Hide_Stereotypes_Selection,
mt_Hide_Visibility_Selection,
mt_Show_Attribute_Signature,
mt_Show_Attribute_Signature_Selection,
mt_Show_Attributes_Selection, // Set visual property on multiple widgets
mt_Show_Attributes, // Toggle visual property on a widget
mt_Show_Destruction_Box,
mt_Show_Documentation,
mt_Show_NonPublic_Selection, // Could be named "hide public only" (crazy!)
mt_Show_Operation_Signature,
mt_Show_Operation_Signature_Selection,
mt_Show_Operations_Selection, // Show operations
mt_Show_Operations, // Toggle 'show operations'
mt_Show_Packages, // etc...
mt_Show_Packages_Selection,
mt_Show_Public_Only,
mt_Show_Stereotypes,
mt_Show_Stereotypes_Selection,
mt_Show_Visibility_Selection,
mt_Visibility,
// other
mt_DrawAsCircle,
mt_ChangeToClass,
mt_ChangeToInterface,
mt_ChangeToPackage,
mt_Open_File,
mt_Rename_Object,
mt_Select_Operation,
mt_Properties,
mt_Rename,
mt_NameAsTooltip,
mt_Show,
mt_Delete,
mt_Export_Image,
mt_Import_Class,
mt_Import_Project,
mt_Cut,
mt_Copy,
mt_Paste,
mt_Clear,
mt_Redo,
mt_Undo,
mt_Reset_Label_Positions,
mt_Line_Color,
mt_Line_Color_Selection,
mt_Fill_Color,
mt_Fill_Color_Selection,
mt_Use_Fill_Color,
mt_Set_Use_Fill_Color_Selection,
mt_Unset_Use_Fill_Color_Selection,
mt_Rename_MultiA,
mt_Rename_MultiB,
mt_Rename_Name,
mt_Rename_RoleAName,
mt_Rename_RoleBName,
mt_Change_Font,
mt_Change_Font_Selection,
mt_SnapToGrid,
mt_SnapComponentSizeToGrid,
mt_ShowDocumentationIndicator,
mt_ShowSnapGrid,
mt_AutoResize,
mt_Resize,
mt_Up,
mt_Down,
mt_FlipHorizontal,
mt_FlipVertical,
mt_Add_Point,
mt_Delete_Point,
mt_Auto_Layout_Spline,
mt_Expand_All, // Expand all items in the list
mt_Collapse_All, // Collapse all items in the list
mt_Refactoring,
mt_ViewCode, // view code document contents
mt_Clone, // Create a deep copy of the object.
mt_Externalize_Folder, // Mark folder for saving as separate submodel
mt_Internalize_Folder, // Reintegrate separate submodel into main model
mt_AddInteractionOperand, // add a dash line to an alternative or a parallel combined fragment
mt_Apply_Layout, // apply automatically created layout
mt_Apply_Layout1, // apply automatically created layout
mt_Apply_Layout2, // apply automatically created layout
mt_Apply_Layout3, // apply automatically created layout
mt_Apply_Layout4, // apply automatically created layout
mt_Apply_Layout5, // apply automatically created layout
mt_Apply_Layout6, // apply automatically created layout
mt_Apply_Layout7, // apply automatically created layout
mt_Apply_Layout8, // apply automatically created layout
mt_Apply_Layout9, // apply automatically created layout
mt_LayoutDirect, // associations with direct lines
mt_LayoutSpline, // associations with slines
mt_LayoutOrthogonal, // associations with orthogonal lines
mt_LayoutPolyline, // associations with polylines
mt_Align_Right,
mt_Align_Left,
mt_Align_Top,
mt_Align_Bottom,
mt_Align_VerticalMiddle,
mt_Align_HorizontalMiddle,
mt_Align_VerticalDistribute,
mt_Align_HorizontalDistribute,
mt_Import_from_File,
mt_Remove,
// add new entries above
mt_Undefined = - 1
};
static QString toString(MenuType menu);
enum DataType ///< Key value of the data map used in actions.
{
dt_MenuPointer,
dt_ApplyLayout
};
static QString toString(DataType data);
static QVariant dataFromAction(DataType key, QAction* action);
ListPopupMenu(QWidget *parent = nullptr);
virtual ~ListPopupMenu();
static UMLObject::ObjectType convert_MT_OT(MenuType mt);
static ListPopupMenu* menuFromAction(QAction *action);
static MenuType typeFromAction(QAction *action);
QAction* getAction(MenuType idx);
void setActionEnabled(MenuType idx, bool value);
MenuType getMenuType(QAction* action);
void dumpActions(const QString &title);
QMenu *newMenu(const QString &title, QWidget *widget);
void addMenu(QMenu *menu);
protected:
void insert(MenuType m);
void insertFromActionKey(const MenuType m, QMenu *menu, const QString &action);
void insert(const MenuType m, QMenu* menu);
void insert(const MenuType m, QMenu* menu, const QIcon & icon, const QString & text);
void insert(const MenuType m, QMenu* menu, const QString & text, const bool checkable = false);
void insert(const MenuType m, const QIcon & icon, const QString & text);
void insert(const MenuType m, const QString & text, const bool checkable = false);
void insertContainerItems(bool folders, bool diagrams, bool packages);
void insertContainerItems(QMenu* menu, bool folders, bool diagrams, bool packages);
void insertAssociationTextItem(const QString &label, MenuType mt);
QMenu *makeNewMenu();
void insertSubMenuCategoryType(UMLCategory *category);
void setActionChecked(MenuType idx, bool value);
void setupActionsData();
QHash<MenuType, QAction*> m_actions;
ListPopupMenuPrivate *d;
};
/// Need this for ability to store ListPopupMenu* in a QVariant
Q_DECLARE_METATYPE(ListPopupMenu*)
#endif
| 10,411
|
C++
|
.h
| 288
| 28.472222
| 117
| 0.615354
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,923
|
umllistviewpopupmenu.h
|
KDE_umbrello/umbrello/menus/umllistviewpopupmenu.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2018-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLLISTVIEWPOPUPMENU_H
#define UMLLISTVIEWPOPUPMENU_H
#include "listpopupmenu.h"
#include "umllistviewitem.h"
class UMLListViewPopupMenu : public ListPopupMenu {
public:
UMLListViewPopupMenu(QWidget *parent, UMLListViewItem *item);
protected:
void insertSubMenuNew(UMLListViewItem::ListViewType type);
void insertStdItems(bool insertLeadingSeparator = true);
void insertSubmodelAction();
};
#endif // UMLLISTVIEWPOPUPMENU_H
| 598
|
C++
|
.h
| 17
| 32.470588
| 92
| 0.807292
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,924
|
umlscenepopupmenu.h
|
KDE_umbrello/umbrello/menus/umlscenepopupmenu.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2018-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLSCENEPOPUPMENU_H
#define UMLSCENEPOPUPMENU_H
#include "listpopupmenu.h"
/**
* @brief The UMLScenePopupMenu class
*/
class UMLScenePopupMenu : public ListPopupMenu
{
public:
UMLScenePopupMenu(QWidget *parent, UMLScene *scene);
protected:
UMLScene *m_scene;
void insertLayoutItems();
void insertSubMenuNew(Uml::DiagramType::Enum type);
};
#endif // UMLSCENEPOPUPMENU_H
| 546
|
C++
|
.h
| 20
| 24.75
| 92
| 0.777351
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,925
|
widgetbasepopupmenu.h
|
KDE_umbrello/umbrello/menus/widgetbasepopupmenu.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2018-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef WIDGETBASEPOPUPMENU_H
#define WIDGETBASEPOPUPMENU_H
#include "listpopupmenu.h"
/**
* Constructs the popup menu for a WidgetBase with customized menu type.
*/
class WidgetBasePopupMenu : public ListPopupMenu
{
public:
WidgetBasePopupMenu(QWidget * parent, WidgetBase * widget, bool multi, WidgetBase::WidgetType uniqueType = WidgetBase::wt_UMLWidget);
protected:
void makeMultiClassifierShowPopup(WidgetBase::WidgetType type);
void makeClassifierShowPopup(ClassifierWidget *c);
void insertSingleSelectionMenu(WidgetBase* widget);
void insertMultiSelectionMenu(WidgetBase::WidgetType uniqueType);
void insertStdItems(bool insertLeadingSeparator = true, WidgetBase::WidgetType type = WidgetBase::wt_UMLWidget);
void insertSubMenuAlign();
void insertSubMenuColor(bool fc);
void insertSubMenuNew(WidgetBase::WidgetType type);
void insertSubMenuShowEntity(EntityWidget *widget);
QMenu *makeCategoryTypeMenu(UMLCategory *category);
};
#endif // WIDGETBASEPOPUPMENU_H
| 1,164
|
C++
|
.h
| 27
| 39.925926
| 137
| 0.80212
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,926
|
umlscenefinder.h
|
KDE_umbrello/umbrello/finder/umlscenefinder.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2014-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLSCENEFINDER_H
#define UMLSCENEFINDER_H
#include "umlfinder.h"
class UMLView;
/**
* UMLListViewFinder provides finding of items in the tree view
*
* @author: Ralf Habacker <ralf.habacker@freenet.de>
*/
class UMLSceneFinder : public UMLFinder
{
public:
explicit UMLSceneFinder(UMLView *view);
virtual ~UMLSceneFinder();
virtual int collect(Category category, const QString &text);
virtual Result displayNext();
virtual Result displayPrevious();
protected:
Uml::ID::Type m_id; ///< id of scene
bool showItem(Uml::ID::Type id);
};
#endif // UMLSCENEFINDER_H
| 753
|
C++
|
.h
| 26
| 26
| 92
| 0.745833
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,927
|
umlfinder.h
|
KDE_umbrello/umbrello/finder/umlfinder.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2014-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLFINDER_H
#define UMLFINDER_H
// app include
#include "basictypes.h"
// qt include
#include <QList>
class UMLObject;
/**
* The UMLFinder class provides the interface for find related classes.
*
* @author: Ralf Habacker <ralf.habacker@freenet.de>
*/
class UMLFinder
{
public:
typedef enum { All, Classes, Packages, Interfaces, Operations, Attributes } Category;
typedef enum { TreeView, CurrentDiagram, AllDiagrams } Filter;
typedef enum { Empty, End, Found, NotFound } Result;
UMLFinder();
virtual ~UMLFinder();
/**
* Collect items limited by a category and a text
*
* @param category Category to search for
* @param text Text to search for
* @return Number of items found
*/
virtual int collect(Category category, const QString &text) = 0;
/**
* Show next item.
*
* @return Result result of the operation
*/
virtual Result displayNext() = 0;
/**
* Show previous item.
*
* @return Result result of the operation
*/
virtual Result displayPrevious() = 0;
protected:
int m_index;
QList<Uml::ID::Type> m_items;
bool includeObject(Category category, UMLObject *o);
};
#endif // UMLFINDER_H
| 1,384
|
C++
|
.h
| 50
| 23.72
| 92
| 0.686556
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,928
|
umllistviewfinder.h
|
KDE_umbrello/umbrello/finder/umllistviewfinder.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2014-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLLISTVIEWFINDER_H
#define UMLLISTVIEWFINDER_H
#include "umlfinder.h"
/**
* UMLListViewFinder provides finding of items in the tree view
*
* @author: Ralf Habacker <ralf.habacker@freenet.de>
*/
class UMLListViewFinder : public UMLFinder
{
public:
UMLListViewFinder();
virtual ~UMLListViewFinder();
virtual int collect(Category category, const QString &text);
virtual Result displayNext();
virtual Result displayPrevious();
protected:
bool showItem(Uml::ID::Type id);
};
#endif // UMLLISTVIEWFINDER_H
| 691
|
C++
|
.h
| 24
| 25.916667
| 92
| 0.759819
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,929
|
umldocfinder.h
|
KDE_umbrello/umbrello/finder/umldocfinder.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2014-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLDOCFINDER_H
#define UMLDOCFINDER_H
#include "umlfinder.h"
#include "umlscene.h"
class UMLSceneFinder;
#include <QList>
/**
* UMLDocFinder provides finding of items for all diagrams in a document
*
* @author: Ralf Habacker <ralf.habacker@freenet.de>
*/
class UMLDocFinder : public UMLFinder
{
public:
UMLDocFinder();
virtual ~UMLDocFinder();
virtual int collect(Category category, const QString &text);
public Q_SLOTS:
virtual Result displayNext();
virtual Result displayPrevious();
protected:
QList<UMLSceneFinder> m_sceneFinder;
};
#endif // UMLDOCFINDER_H
| 754
|
C++
|
.h
| 28
| 24.214286
| 92
| 0.760779
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,930
|
findresults.h
|
KDE_umbrello/umbrello/finder/findresults.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2014-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef FINDRESULTS_H
#define FINDRESULTS_H
#include "umlfinder.h"
#include <QList>
#include <QObject>
class UMLDocFinder;
class UMLListViewFinder;
class UMLSceneFinder;
class QString;
/**
* Class FindResults performs find and provide ui with find results
*
* @author: Ralf Habacker <ralf.habacker@freenet.de>
*/
class FindResults : QObject
{
Q_OBJECT
public:
FindResults();
virtual ~FindResults ();
void clear();
int collect(UMLFinder::Filter filter, UMLFinder::Category category, const QString & text);
public Q_SLOTS:
bool displayNext();
bool displayPrevious();
protected:
QList<UMLSceneFinder> m_sceneFinder;
QList<UMLDocFinder> m_docFinder;
QList<UMLListViewFinder> m_listViewFinder;
};
#endif // FINDRESULTS_H
| 920
|
C++
|
.h
| 35
| 23.371429
| 94
| 0.757714
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,931
|
cmdsetstereotype.h
|
KDE_umbrello/umbrello/cmds/cmdsetstereotype.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDSETSTEREOTYPE_H
#define CMDSETSTEREOTYPE_H
#include "cmdbaseobjectcommand.h"
namespace Uml
{
class CmdSetStereotype : public CmdBaseObjectCommand
{
public:
CmdSetStereotype(UMLObject * obj, const QString& stereo);
~CmdSetStereotype();
void redo();
void undo();
private:
QString m_stereo;
QString m_oldStereo;
};
}
#endif
| 589
|
C++
|
.h
| 22
| 20.590909
| 92
| 0.654189
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,932
|
cmdsetvisibility.h
|
KDE_umbrello/umbrello/cmds/cmdsetvisibility.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDSETVISIBILITY_H
#define CMDSETVISIBILITY_H
#include "cmdbaseobjectcommand.h"
namespace Uml
{
class CmdSetVisibility : public CmdBaseObjectCommand
{
public:
CmdSetVisibility(UMLObject* obj, Uml::Visibility::Enum visibility);
~CmdSetVisibility();
void redo();
void undo();
private:
Uml::Visibility::Enum m_oldVisibility;
Uml::Visibility::Enum m_visibility;
};
}
#endif
| 631
|
C++
|
.h
| 22
| 22.5
| 92
| 0.669983
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,933
|
cmdhandlerename.h
|
KDE_umbrello/umbrello/cmds/cmdhandlerename.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDHANDLERENAME_H
#define CMDHANDLERENAME_H
#include <QUndoCommand>
class FloatingTextWidget;
namespace Uml
{
class CmdHandleRename : public QUndoCommand
{
public:
CmdHandleRename(FloatingTextWidget* ftw, QString& txt);
~CmdHandleRename();
void redo();
void undo();
private:
FloatingTextWidget* m_ftw;
QString m_newstring;
QString m_oldstring;
};
}
#endif
| 601
|
C++
|
.h
| 24
| 20.25
| 92
| 0.691228
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,934
|
cmdbaseobjectcommand.h
|
KDE_umbrello/umbrello/cmds/cmdbaseobjectcommand.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDBASEOBJECTCOMMAND_H
#define CMDBASEOBJECTCOMMAND_H
#include "basictypes.h"
#include <QPointer>
#include <QUndoCommand>
class UMLObject;
namespace Uml
{
class CmdBaseObjectCommand : public QUndoCommand
{
public:
explicit CmdBaseObjectCommand(UMLObject *object);
virtual ~CmdBaseObjectCommand();
protected:
Uml::ID::Type m_objectId;
QPointer<UMLObject> m_object;
void setObject(UMLObject* object);
UMLObject* object();
};
}
#endif // CMDBASEOBJECTCOMMAND_H
| 719
|
C++
|
.h
| 25
| 23.12
| 92
| 0.696793
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,935
|
cmdcreatediagram.h
|
KDE_umbrello/umbrello/cmds/cmdcreatediagram.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2012-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDCREATEDIAGRAM_H
#define CMDCREATEDIAGRAM_H
#include "basictypes.h"
#include <QUndoCommand>
class UMLDoc;
class UMLView;
class UMLFolder;
namespace Uml
{
class CmdCreateDiagram : public QUndoCommand
{
public:
explicit CmdCreateDiagram(UMLDoc *doc, Uml::DiagramType::Enum type, const QString& name, UMLFolder *parent= nullptr);
~CmdCreateDiagram();
void redo();
void undo();
UMLView *view() { return m_pUMLView; }
private:
QString m_name;
Uml::DiagramType::Enum m_type;
UMLDoc* m_pUMLDoc;
UMLView* m_pUMLView;
Uml::ID::Type m_sceneId;
UMLFolder* m_parent;
};
}
#endif
| 909
|
C++
|
.h
| 31
| 24.322581
| 125
| 0.626437
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,936
|
cmdremovediagram.h
|
KDE_umbrello/umbrello/cmds/cmdremovediagram.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2012-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDREMOVEDIAGRAM_H
#define CMDREMOVEDIAGRAM_H
#include "basictypes.h"
#include <QDomElement>
#include <QUndoCommand>
class UMLFolder;
namespace Uml
{
class CmdRemoveDiagram : public QUndoCommand
{
public:
explicit CmdRemoveDiagram(UMLFolder* folder,
Uml::DiagramType::Enum type,
const QString& name,
Uml::ID::Type id);
~CmdRemoveDiagram();
void redo();
void undo();
private:
UMLFolder* m_folder;
Uml::DiagramType::Enum m_type;
QString m_name;
Uml::ID::Type m_sceneId;
QDomElement m_element;
};
}
#endif
| 877
|
C++
|
.h
| 31
| 20.516129
| 92
| 0.594272
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,937
|
cmdremovewidget.h
|
KDE_umbrello/umbrello/cmds/widget/cmdremovewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDREMOVEWIDGET_H
#define CMDREMOVEWIDGET_H
#include "cmdbasewidgetcommand.h"
#include <QDomElement>
class AssociationWidget;
class UMLWidget;
namespace Uml
{
class CmdRemoveWidget : public CmdBaseWidgetCommand
{
public:
explicit CmdRemoveWidget(UMLWidget* widget);
CmdRemoveWidget(AssociationWidget *widget);
~CmdRemoveWidget();
void redo();
void undo();
private:
QDomElement m_element;
QList<QDomElement> m_children;
};
}
#endif
| 668
|
C++
|
.h
| 26
| 21.153846
| 92
| 0.725552
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,938
|
cmdsetname.h
|
KDE_umbrello/umbrello/cmds/widget/cmdsetname.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDSETNAME_H
#define CMDSETNAME_H
#include "cmdbaseobjectcommand.h"
namespace Uml
{
class CmdSetName : public CmdBaseObjectCommand
{
public:
CmdSetName(UMLObject* obj, const QString& name);
~CmdSetName();
void redo();
void undo();
private:
QString m_oldname;
QString m_name;
};
}
#endif
| 546
|
C++
|
.h
| 22
| 18.636364
| 92
| 0.638996
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,939
|
cmdchangetextcolor.h
|
KDE_umbrello/umbrello/cmds/widget/cmdchangetextcolor.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDCHANGETEXTCOLOR_H
#define CMDCHANGETEXTCOLOR_H
#include "cmdbasewidgetcommand.h"
#include <QColor>
class UMLWidget;
namespace Uml
{
class CmdChangeTextColor : public CmdBaseWidgetCommand
{
public:
CmdChangeTextColor(UMLWidget *w, const QColor& col);
~CmdChangeTextColor();
void redo();
void undo();
private:
QColor m_oldColor;
QColor m_newColor;
bool m_oldUsesDiagramValue;
};
}
#endif // CMDCHANGELINECOLOR_H
| 649
|
C++
|
.h
| 25
| 21.32
| 92
| 0.713128
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,940
|
cmdchangevisualproperty.h
|
KDE_umbrello/umbrello/cmds/widget/cmdchangevisualproperty.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDCHANGEVISUALPROPERTY_H
#define CMDCHANGEVISUALPROPERTY_H
#include "classifierwidget.h"
#include "cmdbasewidgetcommand.h"
namespace Uml
{
class CmdChangeVisualProperty : public CmdBaseWidgetCommand
{
public:
CmdChangeVisualProperty(ClassifierWidget* widget, ClassifierWidget::VisualProperty property, bool value);
~CmdChangeVisualProperty();
void redo();
void undo();
private:
ClassifierWidget::VisualProperty m_property;
bool m_newValue;
bool m_oldValue;
};
}
#endif // CMDCHANGEVISUALPROPERTY_H
| 734
|
C++
|
.h
| 24
| 25.833333
| 113
| 0.742898
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,941
|
cmdchangefont.h
|
KDE_umbrello/umbrello/cmds/widget/cmdchangefont.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDCHANGEFONT_H
#define CMDCHANGEFONT_H
#include "cmdbasewidgetcommand.h"
#include <QFont>
class UMLWidget;
namespace Uml
{
class CmdChangeFont : public CmdBaseWidgetCommand
{
public:
CmdChangeFont(UMLWidget* widget, QFont font);
void undo();
void redo();
private:
QFont m_newFont;
QFont m_oldFont;
};
}
#endif // CMDCHANGEFONT_H
| 595
|
C++
|
.h
| 23
| 20.347826
| 92
| 0.652482
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,942
|
cmdmovewidget.h
|
KDE_umbrello/umbrello/cmds/widget/cmdmovewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDMOVEWIDGET_H
#define CMDMOVEWIDGET_H
#include "cmdbasewidgetcommand.h"
#include <QPointF>
class UMLWidget;
namespace Uml
{
class CmdMoveWidget : public CmdBaseWidgetCommand
{
public:
explicit CmdMoveWidget(UMLWidget* widget);
~CmdMoveWidget();
void redo();
void undo();
private:
QPointF m_pos;
QPointF m_posOld;
};
}
#endif
| 565
|
C++
|
.h
| 24
| 19
| 92
| 0.68985
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,943
|
cmdsettxt.h
|
KDE_umbrello/umbrello/cmds/widget/cmdsettxt.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDSETTXT_H
#define CMDSETTXT_H
#include <QUndoCommand>
class FloatingTextWidget;
namespace Uml
{
class CmdSetTxt : public QUndoCommand
{
public:
CmdSetTxt(FloatingTextWidget* ftw, const QString& txt);
~CmdSetTxt();
void redo();
void undo();
private:
FloatingTextWidget* m_ftw;
QString m_newstring;
QString m_oldstring;
};
}
#endif
| 604
|
C++
|
.h
| 24
| 18.875
| 92
| 0.643979
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,944
|
cmdcreatewidget.h
|
KDE_umbrello/umbrello/cmds/widget/cmdcreatewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDCREATEWIDGET_H
#define CMDCREATEWIDGET_H
#include "cmdbasewidgetcommand.h"
#include <QDomElement>
class AssociationWidget;
class UMLWidget;
namespace Uml
{
class CmdCreateWidget : public CmdBaseWidgetCommand
{
public:
explicit CmdCreateWidget(UMLWidget *widget);
CmdCreateWidget(AssociationWidget *widget);
~CmdCreateWidget();
void redo();
void undo();
private:
QDomElement m_element;
};
}
#endif
| 630
|
C++
|
.h
| 25
| 20.84
| 92
| 0.728643
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,945
|
cmdchangelinecolor.h
|
KDE_umbrello/umbrello/cmds/widget/cmdchangelinecolor.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDCHANGELINECOLOR_H
#define CMDCHANGELINECOLOR_H
#include "cmdbasewidgetcommand.h"
#include <QColor>
class UMLWidget;
namespace Uml
{
class CmdChangeLineColor : public CmdBaseWidgetCommand
{
public:
CmdChangeLineColor(UMLWidget *w, const QColor& col);
~CmdChangeLineColor();
void redo();
void undo();
private:
QColor m_oldColor;
QColor m_newColor;
bool m_oldUsesDiagramValue;
};
}
#endif // CMDCHANGELINECOLOR_H
| 672
|
C++
|
.h
| 25
| 22.24
| 92
| 0.6875
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,946
|
cmdresizewidget.h
|
KDE_umbrello/umbrello/cmds/widget/cmdresizewidget.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDRESIZEWIDGET_H
#define CMDRESIZEWIDGET_H
#include "cmdbasewidgetcommand.h"
#include <QSizeF>
class UMLWidget;
namespace Uml
{
class CmdResizeWidget : public CmdBaseWidgetCommand
{
public:
explicit CmdResizeWidget(UMLWidget* widget);
~CmdResizeWidget();
void redo();
void undo();
private:
QSizeF m_size;
QSizeF m_sizeOld;
};
}
#endif
| 575
|
C++
|
.h
| 24
| 19.458333
| 92
| 0.692449
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,947
|
cmdchangemultiplicity.h
|
KDE_umbrello/umbrello/cmds/widget/cmdchangemultiplicity.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
/* Created By Bouchikhi Mohamed-Amine */
#ifndef CMDCHANGEMULTIPLICITY_H
#define CMDCHANGEMULTIPLICITY_H
#include <QUndoCommand>
class UMLRole;
namespace Uml
{
class CmdChangeMultiplicity : public QUndoCommand
{
public:
CmdChangeMultiplicity(UMLRole *role, const QString &multi);
void redo();
void undo();
private:
UMLRole* m_umlRole; ///< Object selected
QString m_oldMulti; ///< Old multiplicity
QString m_newMulti; ///< New multiplicity
};
}
#endif // CMDCHANGEMULTI_H
| 701
|
C++
|
.h
| 24
| 24.625
| 92
| 0.702096
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,948
|
cmdchangeusefillcolor.h
|
KDE_umbrello/umbrello/cmds/widget/cmdchangeusefillcolor.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDCHANGEUSEFILLCOLOR_H
#define CMDCHANGEUSEFILLCOLOR_H
#include "cmdbasewidgetcommand.h"
class UMLWidget;
namespace Uml
{
class CmdChangeUseFillColor : public CmdBaseWidgetCommand
{
public:
CmdChangeUseFillColor(UMLWidget* w, const bool value);
~CmdChangeUseFillColor();
void redo();
void undo();
private:
bool m_oldValue;
bool m_newValue;
};
}
#endif
| 626
|
C++
|
.h
| 23
| 21.173913
| 92
| 0.663866
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,949
|
cmdchangefillcolor.h
|
KDE_umbrello/umbrello/cmds/widget/cmdchangefillcolor.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
/* Created By Krzywda Stanislas and Bouchikhi Mohamed-Amine ;) */
#ifndef CMDCHANGEFILLCOLOR_H
#define CMDCHANGEFILLCOLOR_H
#include "cmdbasewidgetcommand.h"
#include <QColor>
class UMLWidget;
namespace Uml
{
class CmdChangeFillColor : public CmdBaseWidgetCommand
{
public:
CmdChangeFillColor(UMLWidget* w, const QColor& col);
~CmdChangeFillColor();
void redo();
void undo();
private:
QColor m_oldColor; ///< old color
QColor m_color; ///< new color
};
}
#endif /*CMDCHANGEFILLCOLOR_H*/
| 762
|
C++
|
.h
| 25
| 24.72
| 92
| 0.657497
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,950
|
cmdbasewidgetcommand.h
|
KDE_umbrello/umbrello/cmds/widget/cmdbasewidgetcommand.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2020 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDBASEWIDGETCOMMAND_H
#define CMDBASEWIDGETCOMMAND_H
#include "basictypes.h"
#include <QPointer>
#include <QUndoCommand>
class AssociationWidget;
class UMLScene;
class UMLWidget;
namespace Uml
{
class CmdBaseWidgetCommand : public QUndoCommand
{
public:
explicit CmdBaseWidgetCommand(UMLWidget* widget);
CmdBaseWidgetCommand(AssociationWidget* widget);
virtual ~CmdBaseWidgetCommand();
protected:
Uml::ID::Type m_sceneId;
Uml::ID::Type m_widgetId;
QPointer<UMLScene> m_scene;
QPointer<UMLWidget> m_widget;
QPointer<AssociationWidget> m_assocWidget;
bool m_isAssoc;
void setWidget(UMLWidget* widget);
void setWidget(AssociationWidget* widget);
void addWidgetToScene(UMLWidget* widget);
void addWidgetToScene(AssociationWidget* widget);
void removeWidgetFromScene(UMLWidget *widget);
void removeWidgetFromScene(AssociationWidget *widget);
UMLWidget* widget();
AssociationWidget* assocWidget();
UMLScene* scene();
};
}
#endif // CMDBASEWIDGETCOMMAND_H
| 1,355
|
C++
|
.h
| 39
| 27.076923
| 92
| 0.678135
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,951
|
cmdchangelinewidth.h
|
KDE_umbrello/umbrello/cmds/widget/cmdchangelinewidth.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDCHANGELINEWIDTH_H
#define CMDCHANGELINEWIDTH_H
#include "cmdbasewidgetcommand.h"
class UMLWidget;
namespace Uml
{
class CmdChangeLineWidth : public CmdBaseWidgetCommand
{
public:
CmdChangeLineWidth(UMLWidget *w, const uint width);
~CmdChangeLineWidth();
void redo();
void undo();
private:
uint m_oldWidth;
uint m_newWidth;
};
}
#endif // CMDCHANGELINEWIDTH_H
| 607
|
C++
|
.h
| 23
| 21.826087
| 92
| 0.690311
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,952
|
cmdrenameumlobject.h
|
KDE_umbrello/umbrello/cmds/generic/cmdrenameumlobject.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDRENAMEUMLOBJECT_H
#define CMDRENAMEUMLOBJECT_H
#include <QUndoCommand>
class UMLObject;
namespace Uml
{
class CmdRenameUMLObject : public QUndoCommand
{
public:
CmdRenameUMLObject(UMLObject* o, const QString& name);
~CmdRenameUMLObject();
void redo();
void undo();
private:
UMLObject* m_obj;
QString m_name;
QString m_oldname;
};
}
#endif
| 623
|
C++
|
.h
| 24
| 19.666667
| 92
| 0.640203
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,953
|
cmdcreateumlobject.h
|
KDE_umbrello/umbrello/cmds/generic/cmdcreateumlobject.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDCREATEUMLOBJECT_H
#define CMDCREATEUMLOBJECT_H
#include "umlobject.h"
#include <QDomElement>
#include <QUndoCommand>
class UMLPackage;
namespace Uml
{
class CmdCreateUMLObject : public QUndoCommand
{
public:
explicit CmdCreateUMLObject(UMLObject* o);
~CmdCreateUMLObject();
void redo();
void undo();
private:
UMLObject *m_obj;
UMLPackage *m_package;
UMLObject::ObjectType m_type;
QString m_name;
bool m_skipSignal;
};
}
#endif
| 739
|
C++
|
.h
| 28
| 21.571429
| 92
| 0.637784
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,954
|
cmdremoveumlobject.h
|
KDE_umbrello/umbrello/cmds/generic/cmdremoveumlobject.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CMDREMOVEUMLOBJECT_H
#define CMDREMOVEUMLOBJECT_H
#include "umlobject.h"
#include <QUndoCommand>
namespace Uml
{
class CmdRemoveUMLObject : public QUndoCommand
{
public:
explicit CmdRemoveUMLObject(UMLObject* o);
~CmdRemoveUMLObject();
void redo();
void undo();
private:
UMLObject *m_obj;
};
}
#endif
| 532
|
C++
|
.h
| 22
| 19.818182
| 92
| 0.688492
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,955
|
codeimportingwizard.h
|
KDE_umbrello/umbrello/codeimpwizard/codeimportingwizard.h
|
/*
SPDX-FileCopyrightText: 2011 Andi Fischer <andi.fischer@hispeed.ch>
SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/
#ifndef CODEIMPORTINGWIZARD_H
#define CODEIMPORTINGWIZARD_H
// qt includes
#include <QWizard>
class QFileInfo;
class QWizardPage;
class CodeImpSelectPage;
class CodeImpStatusPage;
/**
* @author Andi Fischer
*/
class CodeImportingWizard : public QWizard
{
Q_OBJECT
public:
enum { SelectionPage, StatusPage };
CodeImportingWizard();
~CodeImportingWizard();
void setupPages();
QList<QFileInfo> selectedFiles();
private:
QWizardPage* createSelectionPage();
QWizardPage* createStatusPage();
CodeImpSelectPage *m_SelectionPage;
CodeImpStatusPage *m_StatusPage;
};
#endif
| 787
|
C++
|
.h
| 31
| 22.419355
| 88
| 0.769437
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,956
|
codeimpselectpage.h
|
KDE_umbrello/umbrello/codeimpwizard/codeimpselectpage.h
|
/*
SPDX-FileCopyrightText: 2011 Andi Fischer <andi.fischer@hispeed.ch>
SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/
#ifndef CODEIMPSELECTPAGE_H
#define CODEIMPSELECTPAGE_H
// qt includes
#include <QFileInfo>
#include <QWizardPage>
// app includes
#include "ui_codeimpselectpage.h"
/**
* This class is used in the code importing wizard.
* It represents the first page where files are selected for importing.
* @author Andi Fischer
*/
class CodeImpSelectPage : public QWizardPage, private Ui::CodeImpSelectPage
{
Q_OBJECT
public:
explicit CodeImpSelectPage(QWidget *parent = nullptr);
~CodeImpSelectPage();
QString language();
bool validatePage();
QList<QFileInfo> selectedFiles();
private:
bool matchFilter(const QFileInfo& path);
QList<QFileInfo> m_fileList;
QStringList m_fileExtensions;
static QString s_recentPath;
void setupLanguageBox();
void setupTreeView();
void setupFileExtEdit();
void setupToolTips();
protected Q_SLOTS:
void languageChanged(int id);
void treeClicked(const QModelIndex& index);
void treeEntered(const QModelIndex& index);
private Q_SLOTS:
void changeLanguage();
void subdirStateChanged(int state);
void fileExtChanged();
void selectAll();
void deselectAll();
void updateSelectionCounter();
Q_SIGNALS:
void applyClicked();
void languageChanged();
void syncCodeDocumentsToParent();
void selectionChanged();
};
#endif
| 1,525
|
C++
|
.h
| 52
| 25.75
| 88
| 0.748458
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,957
|
codeimpthread.h
|
KDE_umbrello/umbrello/codeimpwizard/codeimpthread.h
|
/*
SPDX-FileCopyrightText: 2011 Andi Fischer <andi.fischer@hispeed.ch>
SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/
#ifndef CODEIMPTHREAD_H
#define CODEIMPTHREAD_H
#include <QFileInfo>
#include <QMutex>
#include <QThread>
#include <QWaitCondition>
class ClassImport;
/**
* Thread class that does the code import work for one file.
* TODO: For a start it is only a QObject and is used to signals messages.
* @author Andi Fischer
*/
class CodeImpThread : public QObject
{
Q_OBJECT
public:
explicit CodeImpThread(QFileInfo& file, QObject *parent = nullptr);
virtual ~CodeImpThread();
public Q_SLOTS:
virtual void run();
int emitAskQuestion(const QString& question);
void emitMessageToLog(const QString& file, const QString& text);
Q_SIGNALS:
void askQuestion(const QString& question, int& answer);
void messageToWiz(const QString& file, const QString& text);
void messageToLog(const QString& file, const QString& text);
void messageToApp(const QString& text);
void aborted();
void failed();
void finished(bool noError);
private Q_SLOTS:
void questionAsked(const QString& question, int& answer);
private:
QFileInfo& m_file;
//QWaitCondition m_waitCondition;
//QMutex m_mutex;
};
#endif
| 1,336
|
C++
|
.h
| 42
| 28.666667
| 88
| 0.735202
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,958
|
codeimpstatuspage.h
|
KDE_umbrello/umbrello/codeimpwizard/codeimpstatuspage.h
|
/*
SPDX-FileCopyrightText: 2011 Andi Fischer <andi.fischer@hispeed.ch>
SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/
#ifndef CODEIMPSTATUSPAGE_H
#define CODEIMPSTATUSPAGE_H
// app includes
#include "ui_codeimpstatuspage.h"
#include "classifier.h"
//kde includes
#include <kled.h>
// qt includes
#include <QFileInfo>
#include <QHBoxLayout>
#include <QSpacerItem>
#include <QWizardPage>
class QThread;
/**
* This class is used in the code importing wizard.
* It represents the second page where files are listed and imported by parsing.
* The status of the work and a log of actions is shown.
* TODO: Make the LedStatus class more private.
* @author Andi Fischer
*/
class CodeImpStatusPage : public QWizardPage, private Ui::CodeImpStatusPage
{
Q_OBJECT
public:
explicit CodeImpStatusPage(QWidget *parent = nullptr);
~CodeImpStatusPage();
void initializePage();
bool isComplete() const;
private:
QList<QFileInfo> m_files; ///< list of files to import
bool m_workDone;
bool m_savedUndoEnabled; ///< saved undo enabled state
int m_index; ///< index in m_files
QFileInfo m_file; ///< current file
bool m_savedlistViewVisible; ///< indicates previous state of list view
#ifdef ENABLE_IMPORT_THREAD
QThread *m_thread;
#endif
protected Q_SLOTS:
void importCode(); ///< start importing
void importCodeFile(bool noError=true); ///< import single file
void importNextFile(bool noError=true);
void importCodeFinish(); ///< finish importing
void importCodeStop(); ///< cancel importing
void updateStatus(const QString& file, const QString& text);
void messageToLog(const QString& file, const QString& text);
void messageToApp(const QString& text);
void populateStatusList();
void loggerClear();
void loggerExport();
};
namespace CodeImport {
class LedStatus : public QWidget
{
Q_OBJECT
public:
LedStatus(int width, int height) : QWidget() {
setFixedSize(width, height);
QHBoxLayout* layout = new QHBoxLayout();
layout->addItem(new QSpacerItem(20, 20));
m_led = new KLed(QColor(124, 252, 0), KLed::Off, KLed::Sunken, KLed::Circular);
layout->addWidget(m_led);
layout->addItem(new QSpacerItem(20, 20));
setLayout(layout);
}
~LedStatus() {}
void setColor(const QColor& color) { m_led->setColor(color); }
void setOn(bool isOn) { isOn ? m_led->setState(KLed::On) : m_led->setState(KLed::Off); }
private:
KLed* m_led;
};
} // namespace
#endif
| 2,704
|
C++
|
.h
| 77
| 30.571429
| 96
| 0.677752
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,959
|
umlentityattributelist.h
|
KDE_umbrello/umbrello/umlmodel/umlentityattributelist.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2004-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLENTITYATTRIBUTELIST_H
#define UMLENTITYATTRIBUTELIST_H
#include <qlist.h>
#include "entityattribute.h"
//typedef QPtrList<UMLEntityAttribute> UMLEntityAttributeList;
typedef QListIterator<UMLEntityAttribute*> UMLEntityAttributeListIt;
/**
* This sub-class adds copyInto and clone to the QPtrList<UMLEntityAttribute>
* base class.
*/
class UMLEntityAttributeList : public QList<UMLEntityAttribute*>
{
public:
UMLEntityAttributeList();
UMLEntityAttributeList(const UMLEntityAttributeList&);
virtual ~UMLEntityAttributeList();
virtual void copyInto (UMLEntityAttributeList* rhs) const;
virtual UMLEntityAttributeList* clone() const;
};
#endif
| 830
|
C++
|
.h
| 24
| 31.833333
| 92
| 0.811321
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,960
|
umlentityconstraintlist.h
|
KDE_umbrello/umbrello/umlmodel/umlentityconstraintlist.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2004-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLENTITYCONSTRAINTLIST_H
#define UMLENTITYCONSTRAINTLIST_H
#include <qlist.h>
// forward declaration
class UMLEntityConstraint;
typedef QListIterator<UMLEntityConstraint*> UMLEntityConstraintListIt;
/**
* This sub-class adds copyInto and clone to the QPtrList<UMLEntityConstraint>
* base class.
*/
class UMLEntityConstraintList : public QList<UMLEntityConstraint*>
{
public:
UMLEntityConstraintList();
virtual ~UMLEntityConstraintList();
virtual void copyInto (UMLEntityConstraintList* rhs) const;
virtual UMLEntityConstraintList* clone() const;
};
#endif
| 741
|
C++
|
.h
| 23
| 29.521739
| 92
| 0.808782
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,961
|
operation.h
|
KDE_umbrello/umbrello/umlmodel/operation.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef OPERATION_H
#define OPERATION_H
#include "umlattributelist.h"
#include "classifierlistitem.h"
class UMLClassifier;
/**
* This class represents an operation in the UML model.
*
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLOperation : public UMLClassifierListItem
{
Q_OBJECT
public:
UMLOperation(UMLClassifier * parent, const QString& name,
Uml::ID::Type id = Uml::ID::None,
Uml::Visibility::Enum s = Uml::Visibility::Public,
UMLObject *rt = nullptr);
explicit UMLOperation(UMLClassifier * parent);
virtual ~UMLOperation();
bool operator==(const UMLOperation & rhs) const;
virtual void copyInto(UMLObject *lhs) const;
virtual UMLObject* clone() const;
void setType(UMLObject* type);
void moveParmLeft(UMLAttribute *a);
void moveParmRight(UMLAttribute *a);
void removeParm(UMLAttribute *a, bool emitModifiedSignal = true);
UMLAttributeList getParmList() const;
UMLAttribute * findParm(const QString &name) const;
QString toString(Uml::SignatureType::Enum sig = Uml::SignatureType::NoSig,
bool withStereotype=false) const;
void addParm(UMLAttribute *parameter, int position = -1);
bool resolveRef();
QString getUniqueParameterName() const;
virtual bool showPropertiesDialog(QWidget *parent = nullptr);
bool isConstructorOperation() const;
bool isDestructorOperation() const;
bool isLifeOperation() const;
void setConst(bool b);
bool getConst() const;
void setOverride(bool b);
bool getOverride() const;
void setFinal(bool b);
bool getFinal() const;
void setVirtual(bool b);
bool isVirtual() const;
void setInline(bool b);
bool isInline() const;
void setSourceCode(const QString& code);
QString getSourceCode() const;
void saveToXMI(QXmlStreamWriter& writer);
protected:
bool load1(QDomElement & element);
private:
Uml::ID::Type m_returnId; ///< Holds the xmi.id of the <UML:Parameter kind="return">
UMLAttributeList m_args; ///< Parameter list
bool m_bConst; ///< Holds the isQuery attribute of the <UML:Operation>
bool m_bOverride; ///< Holds the override attribute of the <UML:Operation>
bool m_bFinal; ///< Holds the final attribute of the <UML:Operation>
bool m_bVirtual; ///< Holds the virtual attribute of the <UML:Operation>
bool m_bInline; ///< Holds the inline attribute of the <UML:Operation>
QString m_Code; ///< Holds the entered source code
};
#endif
| 2,815
|
C++
|
.h
| 68
| 36.279412
| 92
| 0.689313
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,962
|
entityattribute.h
|
KDE_umbrello/umbrello/umlmodel/entityattribute.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ENTITYATTRIBUTE_H
#define ENTITYATTRIBUTE_H
#include "attribute.h"
#include "basictypes.h"
/**
* This class is used to set up information for an entityattribute. This is a database field
* It has a type, name, index type and default value.
*
* @short Sets up entityattribute information.
* @author Jonathan Riddell <jr@jriddell.org>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLEntityAttribute : public UMLAttribute
{
Q_OBJECT
Q_ENUMS(DBIndex_Type)
public:
enum DBIndex_Type
{
None = 1100,
Primary,
Index,
Unique
};
UMLEntityAttribute(UMLObject* parent, const QString& name,
Uml::ID::Type id = Uml::ID::None,
Uml::Visibility::Enum s = Uml::Visibility::Private,
UMLObject *type = nullptr, const QString& iv = QString());
explicit UMLEntityAttribute(UMLObject* parent);
virtual ~UMLEntityAttribute();
bool operator==(const UMLEntityAttribute& rhs) const;
virtual void copyInto(UMLObject *lhs) const;
virtual UMLObject* clone() const;
void setAttributes(const QString& attributes);
QString getAttributes() const;
void setIndexType(const DBIndex_Type indexType);
DBIndex_Type indexType() const;
void setValues(const QString& values);
QString getValues() const;
void setAutoIncrement(const bool autoIncrement);
bool getAutoIncrement() const;
void setNull(const bool null);
bool getNull() const;
QString toString(Uml::SignatureType::Enum sig = Uml::SignatureType::NoSig,
bool withStereotype=false) const;
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual bool showPropertiesDialog(QWidget *parent = nullptr);
protected:
void init();
bool load1(QDomElement& element);
private:
DBIndex_Type m_indexType;
QString m_values;
QString m_attributes;
bool m_autoIncrement;
bool m_null;
};
#endif
| 2,191
|
C++
|
.h
| 62
| 29.822581
| 93
| 0.690521
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,963
|
actor.h
|
KDE_umbrello/umbrello/umlmodel/actor.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ACTOR_H
#define ACTOR_H
#include "umlcanvasobject.h"
/**
* This class contains the non-graphical information required for a UML Actor.
* This class inherits from @ref UMLCanvasObject which contains most of the
* information.
* The @ref UMLDoc class creates instances of this type.
*
* @short Information for a non-graphical UML Actor.
* @author Paul Hensgen <phensgen@techie.com>
* @see UMLCanvasObject
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLActor : public UMLCanvasObject
{
Q_OBJECT
public:
explicit UMLActor(const QString & name = QString(), Uml::ID::Type id = Uml::ID::None);
virtual ~UMLActor();
virtual void init();
virtual UMLObject* clone() const;
void saveToXMI(QXmlStreamWriter& writer);
protected:
bool load1(QDomElement & element);
};
#endif
| 995
|
C++
|
.h
| 31
| 29.354839
| 92
| 0.747908
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,964
|
attribute.h
|
KDE_umbrello/umbrello/umlmodel/attribute.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ATTRIBUTE_H
#define ATTRIBUTE_H
#include "basictypes.h"
#include "classifierlistitem.h"
#include "umlclassifierlist.h"
/**
* This class is used to set up information for an attribute. This is like
* a programming attribute. It has a type, name, visibility and initial value.
*
* @short Sets up attribute information.
* @author Paul Hensgen <phensgen@techie.com>
* @see UMLObject
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLAttribute : public UMLClassifierListItem
{
Q_OBJECT
public:
UMLAttribute(UMLObject *parent, const QString& name,
Uml::ID::Type id = Uml::ID::None,
Uml::Visibility::Enum s = Uml::Visibility::Private,
UMLObject *type = nullptr, const QString& iv = QString());
explicit UMLAttribute(UMLObject *parent);
bool operator==(const UMLAttribute &rhs) const;
virtual ~UMLAttribute();
virtual void copyInto(UMLObject *lhs) const;
void setName(const QString &name);
void setVisibility(Uml::Visibility::Enum s);
virtual UMLObject* clone() const;
QString getInitialValue() const;
void setInitialValue(const QString &iv);
QString toString(Uml::SignatureType::Enum sig = Uml::SignatureType::NoSig,
bool withStereotype=false) const;
QString getFullyQualifiedName(const QString& separator = QString(),
bool includeRoot = false) const;
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual bool showPropertiesDialog(QWidget *parent = nullptr);
void setParmKind(Uml::ParameterDirection::Enum pk);
Uml::ParameterDirection::Enum getParmKind() const;
virtual UMLClassifierList getTemplateParams();
Q_SIGNALS:
void attributeChanged();
protected:
bool load1(QDomElement & element);
QString m_InitialValue; ///< text for the attribute's initial value.
Uml::ParameterDirection::Enum m_ParmKind;
private:
void setTemplateParams(const QString& templateParam, UMLClassifierList &templateParamList);
};
#endif
| 2,230
|
C++
|
.h
| 54
| 35.851852
| 95
| 0.723721
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,965
|
umlpackagelist.h
|
KDE_umbrello/umbrello/umlmodel/umlpackagelist.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2007 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLPACKAGELIST_H
#define UMLPACKAGELIST_H
#include <qlist.h>
class UMLPackage;
typedef QList<UMLPackage*> UMLPackageList;
typedef QListIterator<UMLPackage*> UMLPackageListIt;
#endif
| 340
|
C++
|
.h
| 11
| 28.727273
| 92
| 0.814815
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,966
|
umlclassifierlist.h
|
KDE_umbrello/umbrello/umlmodel/umlclassifierlist.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2010 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLCLASSIFIERLIST_H
#define UMLCLASSIFIERLIST_H
#include <QList>
// forward declaration
class UMLClassifier;
typedef QList<UMLClassifier*> UMLClassifierList;
typedef QListIterator<UMLClassifier*> UMLClassifierListIt;
#endif
| 382
|
C++
|
.h
| 12
| 29.75
| 92
| 0.827397
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,967
|
association.h
|
KDE_umbrello/umbrello/umlmodel/association.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2022 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ASSOCIATION_H
#define ASSOCIATION_H
#include "basictypes.h"
#include "umlobject.h"
#include <QDomDocument>
#include <QDomElement>
#include <QXmlStreamWriter>
class UMLRole;
/**
* This class contains the non-graphic representation of an association.
* An association can be a generalization, realization, simple association,
* directed association, aggregation, or composition.
*
* @short Sets up association information.
* @author Oliver Kellogg <okellogg@users.sourceforge.net>
* @see UMLObject
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLAssociation : public UMLObject
{
Q_OBJECT
friend class AssociationWidget;
public:
UMLAssociation(Uml::AssociationType::Enum type, UMLObject *roleA, UMLObject *roleB);
explicit UMLAssociation(Uml::AssociationType::Enum type = Uml::AssociationType::Unknown);
virtual ~UMLAssociation();
bool operator==(const UMLAssociation &rhs) const;
QString toString() const;
UMLRole * getUMLRole(Uml::RoleType::Enum role) const;
Uml::ID::Type getObjectId(Uml::RoleType::Enum role) const;
Uml::ID::Type getRoleId(Uml::RoleType::Enum role) const;
void setAssociationType(Uml::AssociationType::Enum assocType);
Uml::AssociationType::Enum getAssocType() const;
void setObject(UMLObject *obj, Uml::RoleType::Enum role);
UMLObject* getObject(Uml::RoleType::Enum role) const;
void setVisibility(Uml::Visibility::Enum value, Uml::RoleType::Enum role);
Uml::Visibility::Enum visibility(Uml::RoleType::Enum role) const;
void setChangeability(Uml::Changeability::Enum value, Uml::RoleType::Enum role);
Uml::Changeability::Enum changeability(Uml::RoleType::Enum role) const;
void setMultiplicity(const QString &multi, Uml::RoleType::Enum role);
QString getMultiplicity(Uml::RoleType::Enum role) const;
void setRoleName(const QString &roleName, Uml::RoleType::Enum role);
QString getRoleName(Uml::RoleType::Enum role) const;
void setRoleDoc(const QString &doc, Uml::RoleType::Enum role);
QString getRoleDoc(Uml::RoleType::Enum role) const;
void setOldLoadMode(bool value = true);
bool getOldLoadMode() const;
virtual UMLObject* clone() const { return nullptr; }
virtual bool resolveRef();
void saveToXMI(QXmlStreamWriter& writer);
virtual bool showPropertiesDialog(QWidget *parent = nullptr);
protected:
bool load1(QDomElement& element);
// keep track of number of parent widgets
// @todo The UMLAssocation should continue to exist when no AssociationWidget exists.
// We do not yet have the means to delete the UMLAssocation because it is not
// represented in the list view. For the time being it is deleted when the last
// AssociationWidget representing it is deleted.
int nrof_parent_widgets;
void init(Uml::AssociationType::Enum type, UMLObject *roleAObj, UMLObject *roleBObj);
UMLRole * m_pRole[2];
Uml::AssociationType::Enum m_AssocType;
QString m_Name;
bool m_bOldLoadMode;
private:
bool isRealization(UMLObject* objA, UMLObject* objB) const;
};
#endif
| 3,360
|
C++
|
.h
| 72
| 42.625
| 93
| 0.735421
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,968
|
umlobjectlist.h
|
KDE_umbrello/umbrello/umlmodel/umlobjectlist.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2001 Gustavo Madrigal gmadrigal @nextphere.com
SPDX-FileCopyrightText: 2002-2014 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLOBJECTLIST_H
#define UMLOBJECTLIST_H
#include <QList>
#include <QPointer>
// forward declarations
class UMLObject;
typedef QListIterator<QPointer<UMLObject> >
UMLObjectListIt;
/**
* This sub-class adds copyInto and clone to the QList<UMLObject*>
* base class.
*/
class UMLObjectList : public QList<QPointer<UMLObject> >
{
public:
UMLObjectList();
virtual ~UMLObjectList();
virtual void copyInto(UMLObjectList *rhs) const;
virtual UMLObjectList* clone() const;
};
#endif
| 730
|
C++
|
.h
| 26
| 25.5
| 92
| 0.778098
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,969
|
datatype.h
|
KDE_umbrello/umbrello/umlmodel/datatype.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef DATATYPE_H
#define DATATYPE_H
#include "classifier.h"
/**
* This class contains the non-graphical information required for a UML Datatype.
* This class inherits from @ref UMLClassifier which contains most
* of the information.
*
* @short Non-graphical information for a Datatype.
* @see UMLClassifier
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLDatatype : public UMLClassifier
{
Q_OBJECT
public:
UMLDatatype(const QString &name=QString(), Uml::ID::Type id=Uml::ID::None);
virtual ~UMLDatatype();
void setOriginType(UMLClassifier *origType);
UMLClassifier * originType() const;
void setIsReference(bool isRef = true);
bool isReference() const;
void setActive(bool active = true);
bool isActive() const;
virtual bool load1(QDomElement & element);
virtual void saveToXMI(QXmlStreamWriter& writer);
protected:
bool m_isRef;
bool m_isActive;
};
#endif
| 1,107
|
C++
|
.h
| 35
| 28.428571
| 92
| 0.746943
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,970
|
umlrole.h
|
KDE_umbrello/umbrello/umlmodel/umlrole.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLROLE_H
#define UMLROLE_H
#include "umlobject.h"
class UMLAssociation;
/**
* This class contains the non-graphic representation of an association role.
*
* @author Brian Thomas <brian.thomas@gsfc.nasa.gov>
* @see UMLObject
*/
class UMLRole : public UMLObject
{
Q_OBJECT
public:
UMLRole(UMLAssociation * parent, UMLObject * parentUMLObject, Uml::RoleType::Enum role);
virtual ~UMLRole();
bool operator==(const UMLRole & rhs) const;
QString toString() const;
void setObject(UMLObject *obj);
UMLObject* object() const;
void setChangeability(Uml::Changeability::Enum value);
Uml::Changeability::Enum changeability() const;
void setMultiplicity(const QString &multi);
QString multiplicity() const;
UMLAssociation * parentAssociation() const;
Uml::RoleType::Enum role() const;
UMLObject* clone() const { return nullptr; }
void saveToXMI(QXmlStreamWriter& writer);
virtual bool showPropertiesDialog(QWidget *parent = nullptr);
protected:
bool load1(QDomElement& element);
private:
UMLAssociation * m_pAssoc;
Uml::RoleType::Enum m_role;
QString m_Multi;
Uml::Changeability::Enum m_Changeability;
};
#endif
| 1,400
|
C++
|
.h
| 42
| 29.547619
| 92
| 0.719731
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,971
|
umlcanvasobject.h
|
KDE_umbrello/umbrello/umlmodel/umlcanvasobject.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CANVASOBJECT_H
#define CANVASOBJECT_H
#include "umlobject.h"
#include "umlobjectlist.h"
#include "umlclassifierlist.h"
#include "umlassociationlist.h"
/**
* This class contains the non-graphical information required for UMLObjects
* which appear as moveable widgets on the scene.
*
* This class inherits from @ref UMLObject which contains most of the
* information.
* It is not instantiated itself, it's just used as a super class for
* actual model objects.
* It adds a member of type UMLObjectList containing subordinate objects.
* The subordinate objects could be associations, attributes, operations,
* or other items depending on the inheriting class.
*
* @short Non-graphical information for a UMLCanvasObject.
* @author Jonathan Riddell
* @see UMLObject
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLCanvasObject : public UMLObject
{
Q_OBJECT
public:
explicit UMLCanvasObject(const QString & name = QString(), Uml::ID::Type id = Uml::ID::None);
virtual ~UMLCanvasObject();
bool operator==(const UMLCanvasObject& rhs) const;
virtual void copyInto(UMLObject *lhs) const;
// The abstract method UMLObject::clone() is implemented
// in the classes inheriting from UMLCanvasObject.
bool addAssociationEnd(UMLAssociation* assoc);
bool hasAssociation(UMLAssociation* assoc) const;
int removeAssociationEnd(UMLAssociation *assoc);
void removeAllAssociationEnds();
int associations() const;
UMLAssociationList getAssociations() const;
UMLAssociationList getSpecificAssocs(Uml::AssociationType::Enum assocType) const;
UMLClassifierList getSuperClasses(bool withRealizations = true) const;
UMLClassifierList getSubClasses() const;
virtual UMLAssociationList getRealizations() const;
UMLAssociationList getAggregations() const;
UMLAssociationList getCompositions() const;
UMLAssociationList getRelationships() const;
virtual UMLObject *findChildObject(const QString &n,
UMLObject::ObjectType t = UMLObject::ot_UMLObject) const;
virtual UMLObject *findChildObjectById(Uml::ID::Type id, bool considerAncestors = false) const;
virtual QString uniqChildName(const UMLObject::ObjectType type,
const QString &prefix = QString()) const;
virtual void removeAllChildObjects();
UMLObjectList &subordinates() const {
m_List.removeAll(nullptr);
return m_List;
}
virtual bool resolveRef();
// The abstract method UMLObject::saveToXMI() is implemented
// in the classes inheriting from UMLCanvasObject.
private:
/**
* List of all the associations in this object.
* Inheriting classes add more types of objects that are possible in this list;
* for example, UMLClassifier adds operations, attributes, and templates.
*
* @todo Only a pointer to the appropriate association end object
* (UMLRole) should be saved here, not the entire UMLAssociation.
*/
mutable UMLObjectList m_List;
Q_SIGNALS:
void sigAssociationEndAdded(UMLAssociation * assoc);
void sigAssociationEndRemoved(UMLAssociation * assoc);
};
#endif
| 3,385
|
C++
|
.h
| 78
| 38.448718
| 99
| 0.747789
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,972
|
classifier.h
|
KDE_umbrello/umbrello/umlmodel/classifier.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CLASSIFIER_H
#define CLASSIFIER_H
#include "package.h"
#include "umlattributelist.h"
#include "umloperationlist.h"
#include "umlclassifierlistitemlist.h"
#include "classifierlistitem.h"
#include "umltemplatelist.h"
#include "model_utils.h"
// forward declarations
class UMLAssociation;
class IDChangeLog;
class UMLClassifierSet;
/**
* This class defines the non-graphical information required for a
* UML Classifier (ie a class or interface).
* This class inherits from @ref UMLPackage which allows classifiers
* to also act as namespaces, i.e. it allows classifiers to nest.
*
* NOTE: There is a unit test available for this class.
* Please, use and adapt it when necessary.
*
* @short Information for a non-graphical Concept/Class.
* @author Paul Hensgen <phensgen@techie.com>
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLClassifier : public UMLPackage
{
Q_OBJECT
public:
/**
* Enumeration identifying the type of classifier.
*/
enum ClassifierType { ALL = 0, CLASS, INTERFACE, DATATYPE };
explicit UMLClassifier(const QString & name = QString(), Uml::ID::Type id = Uml::ID::None);
virtual ~UMLClassifier();
virtual void copyInto(UMLObject *lhs) const;
UMLObject* clone() const;
virtual void setNameCmd(const QString &strName);
virtual UMLAttribute* createAttribute(const QString &name = QString(),
UMLObject *type = nullptr,
Uml::Visibility::Enum vis = Uml::Visibility::Private,
const QString &init = QString());
UMLAttribute* addAttribute(const QString &name, Uml::ID::Type id = Uml::ID::None);
UMLAttribute* addAttribute(const QString &name, UMLObject *type, Uml::Visibility::Enum scope);
bool addAttribute(UMLAttribute *att, IDChangeLog *log = nullptr,
int position = -1);
int removeAttribute(UMLAttribute *att);
UMLAttributeList getAttributeList() const;
UMLAttributeList getAttributeList(Uml::Visibility::Enum scope) const;
UMLAttributeList getAttributeListStatic(Uml::Visibility::Enum scope) const;
UMLOperation* createOperation(const QString &name = QString(),
bool *isExistingOp = nullptr,
Model_Utils::NameAndType_List *params = nullptr);
bool addOperation(UMLOperation* op, int position = -1);
bool addOperation(UMLOperation* op, IDChangeLog* log);
UMLOperation * checkOperationSignature(const QString& name,
UMLAttributeList opParams,
UMLOperation *exemptOp = nullptr) const;
int removeOperation(UMLOperation *op);
int operations() const;
UMLOperationList getOpList(bool includeInherited = false, UMLClassifierSet *alreadyTraversed = nullptr) const;
UMLObject* createTemplate(const QString& name = QString());
UMLTemplate* addTemplate(const QString &name, Uml::ID::Type id = Uml::ID::None);
bool addTemplate(UMLTemplate *newTemplate, IDChangeLog *log = nullptr);
bool addTemplate(UMLTemplate* templt, int position);
int removeTemplate(UMLTemplate* umltemplate);
UMLTemplate *findTemplate(const QString& name) const;
int templates() const;
UMLTemplateList getTemplateList() const;
int takeItem(UMLClassifierListItem* item);
virtual UMLClassifierListItemList getFilteredList(UMLObject::ObjectType ot) const;
virtual bool resolveRef();
UMLOperationList findOperations(const QString &n) const;
virtual UMLObject* findChildObjectById(Uml::ID::Type id,
bool considerAncestors = false) const;
UMLOperation* findOperation(const QString& name,
Model_Utils::NameAndType_List params) const;
UMLClassifierList findSuperClassConcepts(ClassifierType type = ALL) const;
UMLClassifierList findSubClassConcepts(ClassifierType type = ALL) const;
virtual bool acceptAssociationType(Uml::AssociationType::Enum type) const;
void setBaseType(UMLObject::ObjectType ot);
bool isInterface() const;
bool hasAbstractOps() const;
bool hasAssociations() const;
bool hasAttributes() const;
bool hasStaticAttributes() const;
bool hasMethods() const;
bool hasAccessorMethods() const;
bool hasOperationMethods() const;
bool hasVectorFields() const;
/**
* utility functions to allow easy determination of what classifiers
* are "owned" by the current one via named association type (e.g.
* plain, aggregate or compositions).
*/
// UMLClassifierList getPlainAssocChildClassifierList();
// UMLClassifierList getAggregateChildClassifierList();
// UMLClassifierList getCompositionChildClassifierList();
virtual UMLClassifierListItem* makeChildObject(const QString& xmiTag);
void removeObject(UMLObject *pObject);
virtual UMLAssociationList getUniAssociationToBeImplemented() const;
Q_SIGNALS:
void operationAdded(UMLClassifierListItem *);
void operationRemoved(UMLClassifierListItem *);
void templateAdded(UMLClassifierListItem*);
void templateRemoved(UMLClassifierListItem*);
// only applies when (m_Type == ot_Class)
void attributeAdded(UMLClassifierListItem*);
void attributeRemoved(UMLClassifierListItem*);
private:
UMLAssociation *m_pClassAssoc;
/**
* Utility method called by "get*ChildClassfierList()" methods. It basically
* finds all the classifiers named in each association in the given association list
* which aren't the current one. Useful for finding which classifiers are "owned" by the
* current one via declared associations such as in aggregations/compositions.
*/
// UMLClassifierList findAssocClassifierObjsInRoles (UMLAssociationList * list);
protected:
void saveToXMI(QXmlStreamWriter& writer);
virtual bool load1(QDomElement& element);
};
#endif // CLASSIFIER_H
| 6,263
|
C++
|
.h
| 128
| 41.945313
| 115
| 0.714521
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,973
|
umlentitylist.h
|
KDE_umbrello/umbrello/umlmodel/umlentitylist.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2010 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef UMLENTITYLIST_H
#define UMLENTITYLIST_H
#include <QList>
// forward declaration
class UMLEntity;
typedef QList<UMLEntity*> UMLEntityList;
typedef QListIterator<UMLEntity*> UMLEntityListIt;
#endif
| 354
|
C++
|
.h
| 12
| 27.416667
| 92
| 0.813056
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,974
|
checkconstraint.h
|
KDE_umbrello/umbrello/umlmodel/checkconstraint.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2002-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef CHECKCONSTRAINT_H
#define CHECKCONSTRAINT_H
#include "basictypes.h"
#include "entityconstraint.h"
/**
* This class is used to set up information for a unique entity constraint.
*
* @short Sets up Check Constraint information for UMLEntities.
* @author Sharan Rao
* @see UMLObject UMLClassifierListItem UMLEntityConstraint
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLCheckConstraint : public UMLEntityConstraint
{
Q_OBJECT
public:
UMLCheckConstraint(UMLObject *parent, const QString& name,
Uml::ID::Type id = Uml::ID::None);
explicit UMLCheckConstraint(UMLObject *parent);
bool operator==(const UMLCheckConstraint &rhs) const;
virtual ~UMLCheckConstraint();
virtual void copyInto(UMLObject *lhs) const;
virtual UMLObject* clone() const;
QString toString(Uml::SignatureType::Enum sig = Uml::SignatureType::NoSig,
bool withStereotype=false) const;
QString getFullyQualifiedName(const QString& separator = QString(),
bool includeRoot = false) const;
void saveToXMI(QXmlStreamWriter& writer);
virtual bool showPropertiesDialog(QWidget *parent = nullptr);
QString getCheckCondition() const {
return m_CheckCondition;
}
void setCheckCondition(const QString& condition) {
m_CheckCondition = condition.trimmed();
}
protected:
bool load1(QDomElement & element);
private:
void init();
QString m_CheckCondition; ///< the check condition
};
#endif
| 1,723
|
C++
|
.h
| 46
| 32.043478
| 92
| 0.722222
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
749,975
|
enumliteral.h
|
KDE_umbrello/umbrello/umlmodel/enumliteral.h
|
/*
SPDX-License-Identifier: GPL-2.0-or-later
SPDX-FileCopyrightText: 2003-2021 Umbrello UML Modeller Authors <umbrello-devel@kde.org>
*/
#ifndef ENUMLITERAL_H
#define ENUMLITERAL_H
#include "classifierlistitem.h"
/**
* This class is used to set up information for an enum literal. Enum
* literals are the values that enums can be set to.
*
* @short Sets up attribute information.
* @author Paul Hensgen <phensgen@techie.com>
* @see UMLObject
* Bugs and comments to umbrello-devel@kde.org or https://bugs.kde.org
*/
class UMLEnumLiteral : public UMLClassifierListItem
{
public:
UMLEnumLiteral(UMLObject* parent,
const QString& name, Uml::ID::Type id = Uml::ID::None,
const QString& v = QString());
explicit UMLEnumLiteral(UMLObject* parent);
bool operator==(const UMLEnumLiteral &rhs) const;
virtual void copyInto(UMLObject *lhs) const;
virtual UMLObject* clone() const;
virtual ~UMLEnumLiteral();
QString value() const;
void setValue(const QString &v);
QString toString(Uml::SignatureType::Enum sig = Uml::SignatureType::NoSig,
bool withStereotype=false) const;
virtual void saveToXMI(QXmlStreamWriter& writer);
virtual bool showPropertiesDialog(QWidget *parent = nullptr);
protected:
bool load1(QDomElement& element);
/**
* Value is an extension to the UML 2.5 metamodel.
* It manage the internal representation of enumeration value
* in system programming languages.
*/
QString m_Value;
};
#endif
| 1,573
|
C++
|
.h
| 43
| 31.697674
| 92
| 0.712682
|
KDE/umbrello
| 114
| 36
| 0
|
GPL-2.0
|
9/20/2024, 9:41:49 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.