Initial commit

engines/bagel/mfc/afx.h

@@ -0,0 +1,193 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef BAGEL_MFC_AFX_H
+#define BAGEL_MFC_AFX_H
+
+#include "common/stream.h"
+#include "bagel/mfc/minwindef.h"
+
+namespace Bagel {
+namespace MFC {
+
+struct CRuntimeClass;
+class CObject;
+class CException;
+class CFileException;
+
+#define DECLARE_DYNAMIC(class_name) \
+	public: \
+	static const CRuntimeClass class##class_name; \
+	virtual const CRuntimeClass *GetRuntimeClass() const override; \
+
+
+#define RUNTIME_CLASS(class_name) ((const CRuntimeClass *)(&class_name::class##class_name))
+
+#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \
+	const CRuntimeClass class_name::class##class_name = { \
+		#class_name, sizeof(class class_name), wSchema, pfnNew, \
+			RUNTIME_CLASS(base_class_name) }; \
+	const CRuntimeClass* class_name::GetRuntimeClass() const \
+	{ return RUNTIME_CLASS(class_name); }
+
+#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
+	IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, nullptr)
+
+#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \
+	CObject *class_name::CreateObject() \
+	{ return new class_name; } \
+	IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \
+	                       class_name::CreateObject)
+
+#define ASSERT_KINDOF(class_name, object) \
+	assert((object)->IsKindOf(RUNTIME_CLASS(class_name)))
+#define ASSERT_VALID(X) assert((X) != nullptr)
+
+struct CRuntimeClass {
+	const char *m_lpszClassName;
+	int m_nObjectSize;
+	unsigned int m_wSchema;
+	CObject *(*m_pfnCreateObject)();
+	const CRuntimeClass *m_pBaseClass;
+
+	CObject *CreateObject() const;
+	bool IsDerivedFrom(const CRuntimeClass *pBaseClass) const;
+};
+
+class CDumpContext {
+};
+
+class CObject {
+public:
+	static const CRuntimeClass classCObject;
+public:
+	CObject();
+	CObject(const CObject &) = default;
+	CObject &operator=(const CObject &) = default;
+	virtual ~CObject() = 0;
+	virtual const CRuntimeClass *GetRuntimeClass() const;
+
+	virtual void AssertValid() const {}
+	virtual void Dump(CDumpContext &dc) const {}
+
+	bool IsKindOf(const CRuntimeClass *pClass) const;
+};
+
+class CFile : public CObject {
+	DECLARE_DYNAMIC(CFile)
+public:
+	// Flag values
+	enum OpenFlags {
+		modeRead = (int)0x00000,
+		modeWrite = (int)0x00001,
+		modeReadWrite = (int)0x00002,
+		shareCompat = (int)0x00000,
+		shareExclusive = (int)0x00010,
+		shareDenyWrite = (int)0x00020,
+		shareDenyRead = (int)0x00030,
+		shareDenyNone = (int)0x00040,
+		modeNoInherit = (int)0x00080,
+		typeUnicode = (int)0x00400, // used in derived classes (e.g. CStdioFile) only
+		modeCreate = (int)0x01000,
+		modeNoTruncate = (int)0x02000,
+		typeText = (int)0x04000, // used in derived classes (e.g. CStdioFile) only
+		typeBinary = (int)0x08000, // used in derived classes (e.g. CStdioFile) only
+		osNoBuffer = (int)0x10000,
+		osWriteThrough = (int)0x20000,
+		osRandomAccess = (int)0x40000,
+		osSequentialScan = (int)0x80000,
+	};
+
+	enum Attribute {
+		normal = 0x00,                // note: not same as FILE_ATTRIBUTE_NORMAL
+		readOnly = FILE_ATTRIBUTE_READONLY,
+		hidden = FILE_ATTRIBUTE_HIDDEN,
+		system = FILE_ATTRIBUTE_SYSTEM,
+		volume = 0x08,
+		directory = FILE_ATTRIBUTE_DIRECTORY,
+		archive = FILE_ATTRIBUTE_ARCHIVE,
+		device = FILE_ATTRIBUTE_DEVICE,
+		temporary = FILE_ATTRIBUTE_TEMPORARY,
+		sparse = FILE_ATTRIBUTE_SPARSE_FILE,
+		reparsePt = FILE_ATTRIBUTE_REPARSE_POINT,
+		compressed = FILE_ATTRIBUTE_COMPRESSED,
+		offline = FILE_ATTRIBUTE_OFFLINE,
+		notIndexed = FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,
+		encrypted = FILE_ATTRIBUTE_ENCRYPTED
+	};
+
+	enum SeekPosition {
+		begin = 0x0, current = 0x1, end = 0x2
+	};
+
+private:
+	Common::Stream *_stream = nullptr;
+
+	Common::SeekableReadStream *readStream() const;
+	Common::WriteStream *writeStream() const;
+
+public:
+	CFile() {}
+	CFile(const char *lpszFileName, unsigned int nOpenFlags);
+	~CFile() {
+		Close();
+	}
+
+	bool Open(const char *lpszFileName,
+		unsigned int nOpenFlags = CFile::modeRead,
+		CFileException *pError = nullptr);
+	void Close();
+	void Abort();
+	uint64 SeekToEnd();
+	void SeekToBegin();
+	virtual uint64 Seek(int64 lOff, unsigned int nFrom);
+	virtual uint64 GetLength() const;
+	virtual uint64 GetPosition() const;
+
+	virtual unsigned int Read(void *lpBuf, unsigned int nCount);
+	virtual void Write(const void *lpBuf, unsigned int nCount);
+	unsigned int ReadHuge(void *lpBuf, unsigned int nCount) {
+		return Read(lpBuf, nCount);
+	}
+
+	operator Common::SeekableReadStream *() {
+		return readStream();
+	}
+	operator Common::SeekableReadStream &() {
+		return *readStream();
+	}
+
+	/**
+	 * Detaches the stream from the CFile
+	 * without destroying it.
+	 */
+	Common::SeekableReadStream *detach();
+};
+
+/*============================================================================*/
+/* Exceptions - Not supported in ScummVM */
+class CException {};
+class CFileException : public CException {};
+
+} // namespace MFC
+} // namespace Bagel
+
+#endif