ldforge: comparison src/ldObject.h

-:af81220741d9
+:1a6f1997fcbe
 #include "colors.h"
 #define LDOBJ(T)												\
 public:															\
 	static constexpr LDObjectType SubclassType = OBJ_##T;		\
-	LD##T (LDObjectPtr* selfptr);								\
+	LD##T (LDObject** selfptr);								\
 																\
 	virtual LDObjectType type() const override					\
 	{															\
 		return OBJ_##T;											\
 	}															\
 class QListWidgetItem;
 class LDSubfile;
 class LDDocument;
 class LDBFC;
-using LDBFCPtr = QSharedPointer<LDBFC>;
 //
 // Object type codes.
 //
 enum LDObjectType
 //
 class LDObject
 {
 	PROPERTY (public,		bool,				isHidden,		setHidden,		STOCK_WRITE)
 	PROPERTY (public,		bool,				isSelected,		setSelected,	STOCK_WRITE)
-	PROPERTY (public,		bool,				isDestructed,	setDestructed,	STOCK_WRITE)
 	PROPERTY (public,		LDObject*,			parent,			setParent,		STOCK_WRITE)
 	PROPERTY (public,		LDDocument*,		document,		setDocument,	CUSTOM_WRITE)
 	PROPERTY (private,		int32,				id,				setID,			STOCK_WRITE)
 	PROPERTY (public,		LDColor,			color,			setColor,		CUSTOM_WRITE)
 	PROPERTY (private,		QColor,				randomColor,	setRandomColor,	STOCK_WRITE)
 	PROPERTY (private,		LDObjectWeakPtr,	self,			setSelf,		STOCK_WRITE)
 public:
 	LDObject (LDDocument* document = nullptr);
+	virtual ~LDObject();
 	// This object as LDraw code
 	virtual QString				asText() const = 0;
 	// Makes a copy of this object
-	LDObjectPtr					createCopy() const;
+	LDObject*					createCopy() const;
 	// What color does the object default to?
 	virtual LDColor				defaultColor() const = 0;
 	// Deletes this object
 	// Moves this object using the given vertex as a movement List
 	void						move (Vertex vect);
 	// Object after this in the current file
-	LDObjectPtr					next() const;
+	LDObject*					next() const;
 	// Number of vertices this object has
 	virtual int					numVertices() const = 0;
 	// Object prior to this in the current file
-	LDObjectPtr					previous() const;
+	LDObject*					previous() const;
 	// Is the previous object INVERTNEXT?
 	bool						previousIsInvertnext (LDBFCPtr& ptr);
 	// Replace this LDObject with another LDObject. Object is deleted in the process.
-	void						replace (LDObjectPtr other);
+	void						replace (LDObject* other);
 	// Selects this object.
 	void						select();
 	// Set a vertex to the given value
 	// Set a single coordinate of a vertex
 	void						setVertexCoord (int i, Axis ax, double value);
 	// Swap this object with another.
-	void						swap (LDObjectPtr other);
+	void						swap (LDObject* other);
 	// What object in the current file ultimately references this?
-	LDObjectPtr					topLevelParent();
+	LDObject*					topLevelParent();
 	// Type enumerator of this object
 	virtual LDObjectType		type() const = 0;
 	// Type name of this object
 	// Get type name by enumerator
 	static QString typeName (LDObjectType type);
 	// Returns a default-constructed LDObject by the given type
-	static LDObjectPtr getDefault (const LDObjectType type);
+	static LDObject* getDefault (const LDObjectType type);
 	// TODO: move this to LDDocument?
 	static void moveObjects (LDObjectList objs, const bool up);
 	// Get a description of a list of LDObjects
 	static QString describeObjects (const LDObjectList& objs);
-	static LDObjectPtr fromID (int id);
+	static LDObject* fromID (int id);
 	LDPolygon* getPolygon();
 	// TODO: make this private!
 	QListWidgetItem* qObjListEntry;
-	// This is public because I cannot protect it as the lambda deletor would
-	// have to be the friend. Do not call this! Ever!
-	void finalDelete();
-	// Even though we supply a custom deleter to QSharedPointer, the shared
-	// pointer's base class still calls operator delete directly in one of
-	// its methods. The method should never be called but we need to declare
-	// the class making this delete call a friend anyway.
-	//
-	// Do not directly delete LDObjects. Ever.
-	virtual ~LDObject();
 private:
 	Vertex m_coords[4];
 	void chooseID();
 	}
 	void setPosition (const Vertex& a);
 };
-using LDMatrixObjectPtr = QSharedPointer<LDMatrixObject>;
-using LDMatrixObjectWeakPtr = QWeakPointer<LDMatrixObject>;
 //
 //
 // Represents a line in the LDraw file that could not be properly parsed. It is
 // represented by a (!) ERROR in the code view. It exists for the purpose of
 // allowing garbage lines be debugged and corrected within LDForge.
 		LDObject (document),
 		m_contents (contents),
 		m_reason (reason) {}
 };
-using LDErrorPtr = QSharedPointer<LDError>;
-using LDErrorWeakPtr = QWeakPointer<LDError>;
 //
 //
 // Represents an empty line in the LDraw code file.
 //
 class LDEmpty : public LDObject
 	LDOBJ_VERTICES (0)
 	LDOBJ_UNCOLORED
 	LDOBJ_NON_SCEMANTIC
 	LDOBJ_NO_MATRIX
 };
-using LDEmptyPtr = QSharedPointer<LDEmpty>;
-using LDEmptyWeakPtr = QWeakPointer<LDEmpty>;
 //
 //
 // Represents a code-0 comment in the LDraw code file.
 //
 public:
 	LDComment (QString text, LDDocument* document = nullptr) :
 		LDObject (document),
 		m_text (text) {}
 };
-using LDCommentPtr = QSharedPointer<LDComment>;
-using LDCommentWeakPtr = QWeakPointer<LDComment>;
 //
 //
 // Represents a 0 BFC statement in the LDraw code.
 //
 	// Statement strings
 	static const char* StatementStrings[];
 };
-using LDBFCPtr = QSharedPointer<LDBFC>;
-using LDBFCWeakPtr = QWeakPointer<LDBFC>;
 //
 // LDSubfile
 //
 // Represents a single code-1 subfile reference.
 //
 	QList<LDPolygon> inlinePolygons();
 	virtual void getVertices (QVector<Vertex>& verts) const override;
 };
 Q_DECLARE_OPERATORS_FOR_FLAGS (LDSubfile::InlineFlags)
-using LDSubfilePtr = QSharedPointer<LDSubfile>;
-using LDSubfileWeakPtr = QWeakPointer<LDSubfile>;
 //
 // LDLine
 //
 // Represents a single code-2 line in the LDraw code file.
 public:
 	LDLine (Vertex v1, Vertex v2, LDDocument* document = nullptr);
 };
-using LDLinePtr = QSharedPointer<LDLine>;
-using LDLineWeakPtr = QWeakPointer<LDLine>;
 //
 // LDCondLine
 //
 // Represents a single code-5 conditional line.
 //
 public:
 	LDCondLine (const Vertex& v0, const Vertex& v1, const Vertex& v2, const Vertex& v3, LDDocument* document = nullptr);
 	LDLinePtr toEdgeLine();
 };
-using LDCondLinePtr = QSharedPointer<LDCondLine>;
-using LDCondLineWeakPtr = QWeakPointer<LDCondLine>;
 //
 // LDTriangle
 //
 // Represents a single code-3 triangle in the LDraw code file. Vertices v0, v1
 // and v2 contain the end-points of this triangle. dColor is the color the
 public:
 	LDTriangle (Vertex const& v1, Vertex const& v2, Vertex const& v3, LDDocument* document = nullptr);
 };
-using LDTrianglePtr = QSharedPointer<LDTriangle>;
-using LDTriangleWeakPtr = QWeakPointer<LDTriangle>;
 //
 // LDQuad
 //
 // Represents a single code-4 quadrilateral. v0, v1, v2 and v3 are the end points
 // of the quad, dColor is the color used for the quad.
 	// Split this quad into two triangles
 	QList<LDTrianglePtr> splitToTriangles();
 };
-using LDQuadPtr = QSharedPointer<LDQuad>;
-using LDQuadWeakPtr = QWeakPointer<LDQuad>;
 //
 // LDVertex
 //
 // The vertex is an LDForce-specific extension which represents a single
 // vertex which can be used as a parameter to tools or to store coordinates
 public:
 	Vertex pos;
 	virtual void getVertices (QVector<Vertex>& verts) const override;
 };
-using LDVertexPtr = QSharedPointer<LDVertex>;
-using LDVertexWeakPtr = QWeakPointer<LDVertex>;
 //
 // LDOverlay
 //
 // Overlay image meta, stored in the header of parts so as to preserve overlay
 // information.
 	PROPERTY (public,	int,		width,		setWidth,		STOCK_WRITE)
 	PROPERTY (public,	int,		height,		setHeight,		STOCK_WRITE)
 	PROPERTY (public,	QString,	fileName,	setFileName,	STOCK_WRITE)
 };
-using LDOverlayPtr = QSharedPointer<LDOverlay>;
-using LDOverlayWeakPtr = QWeakPointer<LDOverlay>;
 // Other common LDraw stuff
 static const QString CALicenseText ("!LICENSE Redistributable under CCAL version 2.0 : "
 	"see CAreadme.txt");
 enum
 };
 QString PreferredLicenseText();
 template<typename T>
-inline void DynamicExecute (LDObjectPtr obj, std::function<void (QSharedPointer<T> const&)> func)
+inline void DynamicExecute (LDObject* obj, std::function<void (QSharedPointer<T> const&)> func)
 {
 	static_assert (std::is_base_of<LDObject, T>::value,
 		"DynamicExecute may only be used with LDObject-derivatives");
 	if (obj->type() == T::SubclassType)
-		func (obj.staticCast<T>());
+		func (static_cast<T*> (obj));
 }
 struct LDIterationBreakage {};
 template<typename T>
 	static_assert (std::is_base_of<LDObject, T>::value,
 		"LDIterate may only be used with LDObject-derivatives");
 	try
 	{
-		for (LDObjectPtr const& obj : objs)
+		for (LDObject* const& obj : objs)
 			DynamicExecute<T> (obj, func);
 	}
 	catch (LDIterationBreakage) {}
 }

Mercurial > ldforge / file comparison

comparison: src/ldObject.h

src/ldObject.h