Port to CMake from qmake, and split decoder into subdirectory

Qt 5 has had to be dropped as CMakeLists.txt uses qt_* specific commands
which are implemented in Qt 6 onwards.

cmake --install is only working on Linux at the moment; it installs the
executable and the bundled example tti files into /usr/local/share/doc

The teletext decoder with its document storage has been moved to a
subdirectory with the intention of making it possible to use in other
projects, but some further separation of editing stuff will be needed.

src/qteletextdecoder/CMakeLists.txt

@@ -0,0 +1,7 @@
+file (GLOB SOURCES *.cpp)
+
+add_library(qteletextdecoder ${SOURCES} teletextfonts.qrc)
+
+target_include_directories(qteletextdecoder PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_link_libraries(qteletextdecoder Qt::Widgets)

src/qteletextdecoder/decode.h

@@ -0,0 +1,281 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef DECODE_H
+#define DECODE_H
+
+#include <QList>
+#include <QMap>
+#include <QMultiMap>
+
+#include "levelonepage.h"
+
+class TeletextPageDecode : public QObject
+{
+	Q_OBJECT
+
+public:
+	enum CharacterFragment { NormalSize, DoubleHeightTopHalf, DoubleHeightBottomHalf, DoubleWidthLeftHalf, DoubleWidthRightHalf, DoubleSizeTopLeftQuarter, DoubleSizeTopRightQuarter, DoubleSizeBottomLeftQuarter, DoubleSizeBottomRightQuarter };
+	enum RowHeight { NormalHeight, TopHalf, BottomHalf };
+
+	TeletextPageDecode();
+	~TeletextPageDecode();
+	bool refresh(int r, int c) const { return m_refresh[r][c]; }
+	void setRefresh(int r, int c, bool refresh);
+	void decodePage();
+	LevelOnePage *teletextPage() const { return m_levelOnePage; };
+	void setTeletextPage(LevelOnePage *newCurrentPage);
+	void updateSidePanels();
+
+	unsigned char cellCharacterCode(int r, int c) const { return m_cell[r][c].character.code; };
+	int cellCharacterSet(int r, int c) const { return m_cell[r][c].character.set; };
+	int cellCharacterDiacritical(int r, int c) const { return m_cell[r][c].character.diacritical; };
+	int cellG0CharacterSet(int r, int c) const { return m_cell[r][c].g0Set; };
+	int cellG2CharacterSet(int r, int c) const { return m_cell[r][c].g2Set; };
+	int cellForegroundCLUT(int r, int c) const { return m_cell[r][c].attribute.foregroundCLUT; };
+	int cellBackgroundCLUT(int r, int c) const { return m_cell[r][c].attribute.backgroundCLUT; };
+	QColor cellForegroundQColor(int r, int c);
+	QColor cellBackgroundQColor(int r, int c);
+	QColor cellFlashForegroundQColor(int r, int c);
+	int cellFlashMode(int r, int c) const { return m_cell[r][c].attribute.flash.mode; };
+	int cellFlashRatePhase(int r, int c) const { return m_cell[r][c].attribute.flash.ratePhase; };
+	int cellFlash2HzPhaseNumber(int r, int c) const { return m_cell[r][c].attribute.flash.phase2HzShown; };
+	CharacterFragment cellCharacterFragment(int r, int c) const { return m_cell[r][c].fragment; };
+	bool cellBoxed(int r, int c) const { return m_cell[r][c].attribute.display.boxingWindow; };
+	bool cellConceal(int r, int c) const { return m_cell[r][c].attribute.display.conceal; };
+	bool cellUnderlined(int r, int c) const { return cellCharacterSet(r, c) < 24 ? m_cell[r][c].attribute.display.underlineSeparated : false; };
+	bool cellBold(int r, int c) const { return m_cell[r][c].attribute.style.bold; };
+	bool cellItalic(int r, int c) const { return m_cell[r][c].attribute.style.italic; };
+	bool cellProportional(int r, int c) const { return m_cell[r][c].attribute.style.proportional; };
+
+	bool level1MosaicAttr(int r, int c) const { return m_cellLevel1MosaicAttr[r][c]; };
+	bool level1MosaicChar(int r, int c) const { return m_cellLevel1MosaicChar[r][c]; };
+	int level1CharSet(int r, int c) const { return m_cellLevel1CharSet[r][c]; };
+
+	RowHeight rowHeight(int r) const { return m_rowHeight[r]; };
+
+	QColor fullScreenQColor() const { return m_finalFullScreenQColor; };
+	QColor fullRowQColor(int r) const { return m_fullRowQColor[r]; };
+	int leftSidePanelColumns() const { return m_leftSidePanelColumns; };
+	int rightSidePanelColumns() const { return m_rightSidePanelColumns; };
+
+public slots:
+	void setLevel(int level);
+
+signals:
+	void fullScreenColourChanged(QColor newColour);
+	void fullRowColourChanged(int r, QColor newColour);
+	void sidePanelsChanged();
+
+protected:
+	inline void setFullScreenColour(int newColour);
+	inline void setFullRowColour(int row, int newColour);
+
+	int m_finalFullScreenColour, m_level;
+	QColor m_finalFullScreenQColor;
+	int m_leftSidePanelColumns, m_rightSidePanelColumns;
+	const int m_foregroundRemap[8] = { 0,  0,  0,  8,  8, 16, 16, 16 };
+	const int m_backgroundRemap[8] = { 0,  8, 16,  8, 16,  8, 16, 24 };
+
+private:
+	class Invocation;
+
+	enum ColourPart { Foreground, Background, FlashForeground };
+
+	struct textCharacter {
+		unsigned char code=0x20;
+		int set=0;
+		int diacritical=0;
+	};
+
+	friend inline bool operator!=(const textCharacter &lhs, const textCharacter &rhs)
+	{
+		return lhs.code        != rhs.code ||
+	           lhs.set         != rhs.set  ||
+	           lhs.diacritical != rhs.diacritical;
+	}
+
+	struct flashFunctions {
+		int mode=0;
+		int ratePhase=0;
+		int phase2HzShown=0;
+	};
+
+	struct displayAttributes {
+		bool doubleHeight=false;
+		bool doubleWidth=false;
+		bool boxingWindow=false;
+		bool conceal=false;
+		bool invert=false;
+		bool underlineSeparated=false;
+	};
+
+	struct fontStyle {
+		bool proportional=false;
+		bool bold=false;
+		bool italic=false;
+	};
+
+	friend inline bool operator!=(const displayAttributes &lhs, const displayAttributes &rhs)
+	{
+		return lhs.doubleHeight       != rhs.doubleHeight       ||
+		       lhs.doubleWidth        != rhs.doubleWidth        ||
+		       lhs.boxingWindow       != rhs.boxingWindow       ||
+		       lhs.conceal            != rhs.conceal            ||
+		       lhs.invert             != rhs.invert             ||
+		       lhs.underlineSeparated != rhs.underlineSeparated;
+	}
+
+	struct textAttributes {
+		int foregroundCLUT=7;
+		int backgroundCLUT=0;
+		flashFunctions flash;
+		displayAttributes display;
+		fontStyle style;
+	};
+
+	friend inline bool operator!=(const textAttributes &lhs, const textAttributes &rhs)
+	{
+		return lhs.foregroundCLUT      != rhs.foregroundCLUT      ||
+		       lhs.backgroundCLUT      != rhs.backgroundCLUT      ||
+		       lhs.flash.mode          != rhs.flash.mode          ||
+		       lhs.flash.ratePhase     != rhs.flash.ratePhase     ||
+		       lhs.flash.phase2HzShown != rhs.flash.phase2HzShown ||
+		       lhs.display             != rhs.display             ||
+		       lhs.style.proportional  != rhs.style.proportional  ||
+		       lhs.style.bold          != rhs.style.bold          ||
+		       lhs.style.italic        != rhs.style.italic;
+	}
+
+	struct textCell {
+		textCharacter character;
+		textAttributes attribute;
+		CharacterFragment fragment=NormalSize;
+		int g0Set=0;
+		int g2Set=7;
+	};
+
+	friend inline bool operator!=(const textCell &lhs, const textCell &rhs)
+	{
+		return lhs.character != rhs.character ||
+		       lhs.attribute != rhs.attribute ||
+		       lhs.fragment  != rhs.fragment;
+	}
+
+	struct textPainter {
+		textAttributes attribute;
+		textCell result;
+		textCell rightHalfCell;
+		textCell bottomHalfCell[72];
+
+		int styleSpreadRows=0;
+		int setProportionalRows[72], clearProportionalRows[72];
+		int setBoldRows[72], clearBoldRows[72];
+		int setItalicRows[72], clearItalicRows[72];
+	};
+
+	const QMap<int, int> m_level1CharacterMap {
+		{ 0x00, 12 }, { 0x01, 15 }, { 0x02, 22 }, { 0x03, 16 }, { 0x04, 14 }, { 0x05, 19 }, { 0x06, 11 },
+		{ 0x08, 18 }, { 0x09, 15 }, { 0x0a, 22 }, { 0x0b, 16 }, { 0x0c, 14 }, { 0x0e, 11 },
+		{ 0x10, 12 }, { 0x11, 15 }, { 0x12, 22 }, { 0x13, 16 }, { 0x14, 14 }, { 0x15, 19 }, { 0x16, 23 },
+		{ 0x1d, 21 }, { 0x1f, 20 },
+		{ 0x20,  1 }, { 0x21, 15 }, { 0x22, 13 }, { 0x23, 17 }, { 0x24,  2 }, { 0x25,  3 }, { 0x26, 11 },
+		{ 0x36, 23 }, { 0x37,  4 },
+		{ 0x40, 12 }, { 0x44, 14 }, { 0x47,  5 },
+		{ 0x55,  6 }, { 0x57,  5 }
+	};
+	const QMap<int, int> m_g0CharacterMap {
+		{ 0x20,  1 }, { 0x24,  2 }, { 0x25,  3 },
+		{ 0x37,  4 },
+		{ 0x47,  5 },
+		{ 0x55,  6 }, { 0x57,  5 }
+	};
+	const QMap<int, int> m_g2CharacterMap {
+		{ 0x20,  8 }, { 0x24,  8 }, { 0x25,  8 },
+		{ 0x37,  9 },
+		{ 0x40, 10 }, { 0x44, 10 }, { 0x47, 10 },
+		{ 0x55, 10 }, { 0x57, 10 }
+	};
+
+	class Invocation
+	{
+	public:
+		Invocation();
+
+		X26TripletList *tripletList() const { return m_tripletList; };
+		void clear();
+		void setTripletList(X26TripletList *tripletList);
+		int startTripletNumber() const { return m_startTripletNumber; };
+		void setStartTripletNumber(int n);
+		int endTripletNumber() const { return m_endTripletNumber; };
+		void setEndTripletNumber(int n);
+		int originRow() const { return m_originRow; };
+		int originColumn() const { return m_originColumn; };
+		void setOrigin(int row, int column);
+		void buildMap(int level);
+
+		QList<QPair<int, int>> charPositions() const { return m_characterMap.uniqueKeys(); };
+		QList<QPair<int, int>> attrPositions() const { return m_attributeMap.uniqueKeys(); };
+		QList<X26Triplet> charactersMappedAt(int r, int c) const { return m_characterMap.values(qMakePair(r, c)); };
+		QList<X26Triplet> attributesMappedAt(int r, int c) const { return m_attributeMap.values(qMakePair(r, c)); };
+		int rightMostColumn(int r) const { return m_rightMostColumn.value(r, -1); };
+		int fullScreenColour() const { return m_fullScreenCLUT; };
+		QList<X26Triplet> fullRowColoursMappedAt(int r) const { return m_fullRowCLUTMap.values(r); };
+
+	private:
+		X26TripletList *m_tripletList;
+		int m_startTripletNumber, m_endTripletNumber;
+		int m_originRow, m_originColumn;
+		// QPair is row and column
+		QMultiMap<QPair<int, int>, X26Triplet> m_characterMap;
+		QMultiMap<QPair<int, int>, X26Triplet> m_attributeMap;
+		QMap<int, int> m_rightMostColumn;
+		int m_fullScreenCLUT;
+		QMultiMap<int, X26Triplet> m_fullRowCLUTMap;
+	};
+
+	static int s_instances;
+	static textPainter s_blankPainter;
+
+	void decodeRow(int r);
+	QColor cellQColor(int r, int c, ColourPart colourPart);
+	textCell& cellAtCharacterOrigin(int r, int c);
+	void buildInvocationList(Invocation &invocation, int objectType);
+	textCharacter characterFromTriplets(const QList<X26Triplet> triplets);
+	inline void rotateFlashMovement(flashFunctions &flash);
+
+	bool m_refresh[25][72];
+	textCell m_cell[25][72];
+	bool m_cellLevel1MosaicAttr[25][40];
+	bool m_cellLevel1MosaicChar[25][40];
+	int m_cellLevel1CharSet[25][40];
+	LevelOnePage* m_levelOnePage;
+	int m_fullRowColour[25];
+	QColor m_fullRowQColor[25];
+	QList<Invocation> m_invocations[3];
+	Invocation m_localEnhancements;
+	textPainter m_level1ActivePainter;
+	QList<textPainter> m_adapPassPainter[2];
+	int m_level1DefaultCharSet, m_level1SecondCharSet;
+	int m_defaultG0andG2, m_secondG0andG2;
+
+	RowHeight m_rowHeight[25];
+};
+
+#endif

src/qteletextdecoder/document.cpp

@@ -0,0 +1,381 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QAbstractListModel>
+#include <vector>
+
+#include "document.h"
+
+#include "levelonepage.h"
+
+ClutModel::ClutModel(QObject *parent): QAbstractListModel(parent)
+{
+	m_subPage = nullptr;
+}
+
+int ClutModel::rowCount(const QModelIndex & /*parent*/) const
+{
+	return 32;
+}
+
+QVariant ClutModel::data(const QModelIndex &index, int role) const
+{
+	if (!index.isValid())
+		return QVariant();
+
+	if (role == Qt::DisplayRole)
+		return QString("CLUT %1:%2").arg(index.row() >> 3).arg(index.row() & 0x07);
+
+	if (role == Qt::DecorationRole && m_subPage != nullptr)
+		return m_subPage->CLUTtoQColor(index.row());
+
+	return QVariant();
+}
+
+void ClutModel::setSubPage(LevelOnePage *subPage)
+{
+	if (subPage != m_subPage) {
+		m_subPage = subPage;
+		emit dataChanged(createIndex(0, 0), createIndex(31, 0), QVector<int>(Qt::DecorationRole));
+	}
+}
+
+
+TeletextDocument::TeletextDocument()
+{
+	m_pageNumber = 0x199;
+	m_description.clear();
+	m_pageFunction = PFLevelOnePage;
+	m_packetCoding = Coding7bit;
+	m_subPages.push_back(new LevelOnePage);
+	m_currentSubPageIndex = 0;
+	m_undoStack = new QUndoStack(this);
+	m_cursorRow = 1;
+	m_cursorColumn = 0;
+	m_selectionCornerRow = m_selectionCornerColumn = -1;
+	m_selectionSubPage = nullptr;
+
+	m_clutModel = new ClutModel;
+	m_clutModel->setSubPage(m_subPages[0]);
+}
+
+TeletextDocument::~TeletextDocument()
+{
+	delete m_clutModel;
+
+	for (auto &subPage : m_subPages)
+		delete(subPage);
+	for (auto &recycleSubPage : m_recycleSubPages)
+		delete(recycleSubPage);
+}
+
+bool TeletextDocument::isEmpty() const
+{
+	for (auto &subPage : m_subPages)
+		if (!subPage->isEmpty())
+			return false;
+
+	return true;
+}
+
+void TeletextDocument::clear()
+{
+	LevelOnePage *blankSubPage = new LevelOnePage;
+
+	m_subPages.insert(m_subPages.begin(), blankSubPage);
+
+	emit aboutToChangeSubPage();
+	m_currentSubPageIndex = 0;
+	m_clutModel->setSubPage(m_subPages[0]);
+	emit subPageSelected();
+	cancelSelection();
+	m_undoStack->clear();
+
+	for (int i=m_subPages.size()-1; i>0; i--) {
+		delete(m_subPages[i]);
+		m_subPages.erase(m_subPages.begin()+i);
+	}
+}
+
+/*
+void TeletextDocument::setPageFunction(PageFunctionEnum newPageFunction)
+{
+	m_pageFunction = newPageFunction;
+}
+
+void TeletextDocument::setPacketCoding(PacketCodingEnum newPacketEncoding)
+{
+	m_packetCoding = newPacketEncoding;
+}
+*/
+
+void TeletextDocument::selectSubPageIndex(int newSubPageIndex, bool forceRefresh)
+{
+	// forceRefresh overrides "beyond the last subpage" check, so inserting a subpage after the last one still shows - dangerous workaround?
+	if (forceRefresh || (newSubPageIndex != m_currentSubPageIndex && newSubPageIndex < m_subPages.size())) {
+		emit aboutToChangeSubPage();
+
+		m_currentSubPageIndex = newSubPageIndex;
+
+		m_clutModel->setSubPage(m_subPages[m_currentSubPageIndex]);
+		emit subPageSelected();
+		emit selectionMoved();
+		return;
+	}
+}
+
+void TeletextDocument::selectSubPageNext()
+{
+	if (m_currentSubPageIndex < m_subPages.size()-1) {
+		emit aboutToChangeSubPage();
+
+		m_currentSubPageIndex++;
+
+		m_clutModel->setSubPage(m_subPages[m_currentSubPageIndex]);
+		emit subPageSelected();
+		emit selectionMoved();
+	}
+}
+
+void TeletextDocument::selectSubPagePrevious()
+{
+	if (m_currentSubPageIndex > 0) {
+		emit aboutToChangeSubPage();
+
+		m_currentSubPageIndex--;
+
+		m_clutModel->setSubPage(m_subPages[m_currentSubPageIndex]);
+		emit subPageSelected();
+		emit selectionMoved();
+	}
+}
+
+void TeletextDocument::insertSubPage(int beforeSubPageIndex, bool copySubPage)
+{
+	LevelOnePage *insertedSubPage;
+
+	if (copySubPage)
+		insertedSubPage = new LevelOnePage(*m_subPages.at(beforeSubPageIndex));
+	else
+		insertedSubPage = new LevelOnePage;
+
+	if (beforeSubPageIndex == m_subPages.size())
+		m_subPages.push_back(insertedSubPage);
+	else
+		m_subPages.insert(m_subPages.begin()+beforeSubPageIndex, insertedSubPage);
+}
+
+void TeletextDocument::deleteSubPage(int subPageToDelete)
+{
+	m_clutModel->setSubPage(nullptr);
+
+	delete(m_subPages[subPageToDelete]);
+	m_subPages.erase(m_subPages.begin()+subPageToDelete);
+}
+
+void TeletextDocument::deleteSubPageToRecycle(int subPageToRecycle)
+{
+	m_recycleSubPages.push_back(m_subPages[subPageToRecycle]);
+	m_subPages.erase(m_subPages.begin()+subPageToRecycle);
+}
+
+void TeletextDocument::unDeleteSubPageFromRecycle(int subPage)
+{
+	m_subPages.insert(m_subPages.begin()+subPage, m_recycleSubPages.back());
+	m_recycleSubPages.pop_back();
+}
+
+void TeletextDocument::setPageNumber(int pageNumber)
+{
+	// If the magazine number was changed, we need to update the relative magazine numbers in FastText
+	// and page enhancement links
+	int oldMagazine = (m_pageNumber & 0xf00);
+	int newMagazine = (pageNumber & 0xf00);
+	// Fix magazine 0 to 8
+	if (oldMagazine == 0x800)
+		oldMagazine = 0x000;
+	if (newMagazine == 0x800)
+		newMagazine = 0x000;
+	int magazineFlip = oldMagazine ^ newMagazine;
+
+	m_pageNumber = pageNumber;
+
+	for (auto &subPage : m_subPages)
+		if (magazineFlip) {
+			for (int i=0; i<6; i++)
+				subPage->setFastTextLinkPageNumber(i, subPage->fastTextLinkPageNumber(i) ^ magazineFlip);
+			for (int i=0; i<8; i++)
+				subPage->setComposeLinkPageNumber(i, subPage->composeLinkPageNumber(i) ^ magazineFlip);
+	}
+}
+
+void TeletextDocument::setPageNumberFromString(QString pageNumberString)
+{
+	bool pageNumberOk;
+	int pageNumberRead = pageNumberString.toInt(&pageNumberOk, 16);
+
+	if ((!pageNumberOk) || pageNumberRead < 0x100 || pageNumberRead > 0x8ff)
+		return;
+
+	setPageNumber(pageNumberRead);
+}
+
+void TeletextDocument::setDescription(QString newDescription)
+{
+	m_description = newDescription;
+}
+
+void TeletextDocument::setFastTextLinkPageNumberOnAllSubPages(int linkNumber, int pageNumber)
+{
+	for (auto &subPage : m_subPages)
+		subPage->setFastTextLinkPageNumber(linkNumber, pageNumber);
+}
+
+void TeletextDocument::cursorUp(bool shiftKey)
+{
+	if (shiftKey && !selectionActive())
+		setSelectionCorner(m_cursorRow, m_cursorColumn);
+
+	if (--m_cursorRow == 0)
+		m_cursorRow = 24;
+
+	if (shiftKey)
+		emit selectionMoved();
+	else
+		cancelSelection();
+
+	emit cursorMoved();
+}
+
+void TeletextDocument::cursorDown(bool shiftKey)
+{
+	if (shiftKey && !selectionActive())
+		setSelectionCorner(m_cursorRow, m_cursorColumn);
+
+	if (++m_cursorRow == 25)
+		m_cursorRow = 1;
+
+	if (shiftKey)
+		emit selectionMoved();
+	else
+		cancelSelection();
+
+	emit cursorMoved();
+}
+
+void TeletextDocument::cursorLeft(bool shiftKey)
+{
+	if (shiftKey && !selectionActive())
+		setSelectionCorner(m_cursorRow, m_cursorColumn);
+
+	if (--m_cursorColumn == -1) {
+		m_cursorColumn = 39;
+		cursorUp(shiftKey);
+	}
+
+	if (shiftKey)
+		emit selectionMoved();
+	else
+		cancelSelection();
+
+	emit cursorMoved();
+}
+
+void TeletextDocument::cursorRight(bool shiftKey)
+{
+	if (shiftKey && !selectionActive())
+		setSelectionCorner(m_cursorRow, m_cursorColumn);
+
+	if (++m_cursorColumn == 40) {
+		m_cursorColumn = 0;
+		cursorDown(shiftKey);
+	}
+
+	if (shiftKey)
+		emit selectionMoved();
+	else
+		cancelSelection();
+
+	emit cursorMoved();
+}
+
+void TeletextDocument::moveCursor(int cursorRow, int cursorColumn, bool selectionInProgress)
+{
+	if (selectionInProgress && !selectionActive())
+		setSelectionCorner(m_cursorRow, m_cursorColumn);
+
+	if (cursorRow != -1)
+		m_cursorRow = cursorRow;
+	if (cursorColumn != -1)
+		m_cursorColumn = cursorColumn;
+
+	if (selectionInProgress)
+		emit selectionMoved();
+	else
+		cancelSelection();
+
+	emit cursorMoved();
+}
+
+void TeletextDocument::setSelectionCorner(int row, int column)
+{
+	if (m_selectionCornerRow != row || m_selectionCornerColumn != column) {
+		m_selectionSubPage = currentSubPage();
+		m_selectionCornerRow = row;
+		m_selectionCornerColumn = column;
+
+//		emit selectionMoved();
+	}
+}
+
+void TeletextDocument::setSelection(int topRow, int leftColumn, int bottomRow, int rightColumn)
+{
+	if (selectionTopRow() != topRow || selectionBottomRow() != bottomRow || selectionLeftColumn() != leftColumn || selectionRightColumn() != rightColumn) {
+		m_selectionSubPage = currentSubPage();
+		m_selectionCornerRow = topRow;
+		m_cursorRow = bottomRow;
+		m_selectionCornerColumn = leftColumn;
+		m_cursorColumn = rightColumn;
+
+		emit selectionMoved();
+		emit cursorMoved();
+	}
+}
+
+void TeletextDocument::cancelSelection()
+{
+	if (m_selectionSubPage != nullptr) {
+		m_selectionSubPage = nullptr;
+		emit selectionMoved();
+		m_selectionCornerRow = m_selectionCornerColumn = -1;
+	}
+}
+
+int TeletextDocument::levelRequired() const
+{
+	int levelSeen = 0;
+
+	for (auto &subPage : m_subPages) {
+		levelSeen = qMax(levelSeen, subPage->levelRequired());
+		if (levelSeen == 3)
+			break;
+	}
+
+	return levelSeen;
+}

src/qteletextdecoder/document.h

@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef DOCUMENT_H
+#define DOCUMENT_H
+
+#include <QAbstractListModel>
+#include <QObject>
+#include <QUndoStack>
+#include <vector>
+
+#include "levelonepage.h"
+
+class ClutModel : public QAbstractListModel
+{
+	Q_OBJECT
+
+public:
+	ClutModel(QObject *parent = 0);
+
+	int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+	QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+	void setSubPage(LevelOnePage *page);
+
+private:
+	LevelOnePage *m_subPage;
+};
+
+class TeletextDocument : public QObject
+{
+	Q_OBJECT
+
+public:
+	// Available Page Functions according to 9.4.2.1 of the spec
+	enum PageFunctionEnum { PFLevelOnePage, PFDataBroadcasting, PFGlobalPOP, PFNormalPOP, PFGlobalDRCS, PFNormalDRCS, PFMOT, PFMIP, PFBasicTOPTable, PFAdditionalInformationTable, PFMultiPageTable, PFMultiPageExtensionTable, PFTriggerMessages };
+	// Available Page Codings of X/1 to X/25 according to 9.4.2.1 of the spec
+	enum PacketCodingEnum { Coding7bit, Coding8bit, Coding18bit, Coding4bit, Coding4bitThen7bit, CodingPerPacket };
+
+	TeletextDocument();
+	~TeletextDocument();
+
+	bool isEmpty() const;
+	void clear();
+
+	PageFunctionEnum pageFunction() const { return m_pageFunction; }
+//	void setPageFunction(PageFunctionEnum);
+	PacketCodingEnum packetCoding() const { return m_packetCoding; }
+//	void setPacketCoding(PacketCodingEnum);
+
+	int numberOfSubPages() const { return m_subPages.size(); }
+	LevelOnePage* subPage(int p) const { return m_subPages[p]; }
+	LevelOnePage* currentSubPage() const { return m_subPages[m_currentSubPageIndex]; }
+	int currentSubPageIndex() const { return m_currentSubPageIndex; }
+	void selectSubPageIndex(int newSubPageIndex, bool refresh=false);
+	void selectSubPageNext();
+	void selectSubPagePrevious();
+	void insertSubPage(int beforeSubPageIndex, bool copySubPage);
+	void deleteSubPage(int subPageToDelete);
+	void deleteSubPageToRecycle(int subPageToRecycle);
+	void unDeleteSubPageFromRecycle(int subPage);
+	int pageNumber() const { return m_pageNumber; }
+	void setPageNumber(int pageNumber);
+	void setPageNumberFromString(QString pageNumberString);
+	QString description() const { return m_description; }
+	void setDescription(QString newDescription);
+	void setFastTextLinkPageNumberOnAllSubPages(int linkNumber, int pageNumber);
+	QUndoStack *undoStack() const { return m_undoStack; }
+	ClutModel *clutModel() const { return m_clutModel; }
+	int cursorRow() const { return m_cursorRow; }
+	int cursorColumn() const { return m_cursorColumn; }
+	void cursorUp(bool shiftKey=false);
+	void cursorDown(bool shiftKey=false);
+	void cursorLeft(bool shiftKey=false);
+	void cursorRight(bool shiftKey=false);
+	void moveCursor(int cursorRow, int cursorColumn, bool selectionInProgress=false);
+	int selectionTopRow() const { return m_selectionCornerRow == -1 ? m_cursorRow : qMin(m_selectionCornerRow, m_cursorRow); }
+	int selectionBottomRow() const { return qMax(m_selectionCornerRow, m_cursorRow); }
+	int selectionLeftColumn() const { return m_selectionCornerColumn == -1 ? m_cursorColumn : qMin(m_selectionCornerColumn, m_cursorColumn); }
+	int selectionRightColumn() const { return qMax(m_selectionCornerColumn, m_cursorColumn); }
+	int selectionWidth() const { return m_selectionCornerColumn == -1 ? 1 : selectionRightColumn() - selectionLeftColumn() + 1; }
+	int selectionHeight() const { return m_selectionCornerRow == -1 ? 1 : selectionBottomRow() - selectionTopRow() + 1; }
+	bool selectionActive() const { return m_selectionSubPage == currentSubPage(); }
+	int selectionCornerRow() const { return m_selectionCornerRow == -1 ? m_cursorRow : m_selectionCornerRow; }
+	int selectionCornerColumn() const { return m_selectionCornerColumn == -1 ? m_cursorColumn : m_selectionCornerColumn; }
+	void setSelectionCorner(int row, int column);
+	void setSelection(int topRow, int leftColumn, int bottomRow, int rightColumn);
+	void cancelSelection();
+	int levelRequired() const;
+
+signals:
+	void cursorMoved();
+	void selectionMoved();
+	void colourChanged(int i);
+	void pageOptionsChanged();
+	void aboutToChangeSubPage();
+	void subPageSelected();
+	void contentsChanged();
+
+	void tripletCommandHighlight(int tripletNumber);
+
+private:
+	QString m_description;
+	int m_pageNumber, m_currentSubPageIndex;
+	PageFunctionEnum m_pageFunction;
+	PacketCodingEnum m_packetCoding;
+	std::vector<LevelOnePage *> m_subPages;
+	std::vector<LevelOnePage *> m_recycleSubPages;
+	QUndoStack *m_undoStack;
+	int m_cursorRow, m_cursorColumn, m_selectionCornerRow, m_selectionCornerColumn;
+	LevelOnePage *m_selectionSubPage;
+	ClutModel *m_clutModel;
+};
+
+#endif

src/qteletextdecoder/levelonepage.cpp

@@ -0,0 +1,520 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QByteArray>
+#include <QColor>
+#include <QList>
+#include <QString>
+#include <algorithm>
+
+#include "levelonepage.h"
+
+#include "x26triplets.h"
+
+LevelOnePage::LevelOnePage()
+{
+	m_enhancements.reserve(maxEnhancements());
+	clearPage();
+}
+
+LevelOnePage::LevelOnePage(const PageBase &other)
+{
+	m_enhancements.reserve(maxEnhancements());
+	clearPage();
+
+	for (int i=0; i<26; i++)
+		if (other.packetExists(i))
+			setPacket(i, other.packet(i));
+	for (int i=26; i<30; i++)
+		for (int j=0; j<16; j++)
+			if (other.packetExists(i, j))
+				setPacket(i, j, other.packet(i));
+
+	for (int i=PageBase::C4ErasePage; i<=PageBase::C14NOS; i++)
+		setControlBit(i, other.controlBit(i));
+}
+
+// So far we only call clearPage() once, within the constructor
+void LevelOnePage::clearPage()
+{
+	for (int r=0; r<25; r++)
+		for (int c=0; c<40; c++)
+			m_level1Page[r][c] = 0x20;
+	for (int i=C4ErasePage; i<=C14NOS; i++)
+		setControlBit(i, false);
+	for (int i=0; i<8; i++)
+		m_composeLink[i] = { (i<4) ? i : 0, false, i>=4, 0x0ff, 0x0000 };
+	for (int i=0; i<6; i++)
+		m_fastTextLink[i] = { 0x0ff, 0x3f7f };
+
+/*	m_subPageNumber = 0x0000; */
+	m_cycleValue = 20;
+	m_cycleType = CTseconds;
+	m_defaultCharSet = 0;
+	m_defaultNOS = 0;
+	m_secondCharSet = 0xf;
+	m_secondNOS = 0x7;
+
+	m_defaultScreenColour = 0;
+	m_defaultRowColour = 0;
+	m_blackBackgroundSubst = false;
+	m_colourTableRemap = 0;
+	m_leftSidePanelDisplayed = m_rightSidePanelDisplayed = false;
+	m_sidePanelStatusL25 = true;
+	m_sidePanelColumns = 0;
+	std::copy(m_defaultCLUT, m_defaultCLUT+32, m_CLUT);
+//	If clearPage() is called outside constructor, we need to implement m_enhancements.clear();
+}
+
+bool LevelOnePage::isEmpty() const
+{
+	if (!m_enhancements.isEmpty())
+		return false;
+
+	if (!isPaletteDefault(0, 31))
+		return false;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<40; c++)
+			if (m_level1Page[r][c] != 0x20)
+				return false;
+
+	return true;
+}
+
+QByteArray LevelOnePage::packet(int packetNumber) const
+{
+	QByteArray result(40, 0x00);
+
+	if (packetNumber <= 24) {
+		for (int c=0; c<40; c++)
+			result[c] = m_level1Page[packetNumber][c];
+		return result;
+	}
+
+	return PageBase::packet(packetNumber);
+}
+
+QByteArray LevelOnePage::packet(int packetNumber, int designationCode) const
+{
+	QByteArray result(40, 0x00);
+
+	if (packetNumber == 26) {
+		if (!packetFromEnhancementListNeeded(designationCode))
+			return result; // Blank result
+
+		return packetFromEnhancementList(designationCode);
+	}
+
+	if (packetNumber == 27 && designationCode == 0) {
+		for (int i=0; i<6; i++) {
+			result[i*6+1] = m_fastTextLink[i].pageNumber & 0x00f;
+			result[i*6+2] = (m_fastTextLink[i].pageNumber & 0x0f0) >> 4;
+			result[i*6+3] = m_fastTextLink[i].subPageNumber & 0x000f;
+			result[i*6+4] = ((m_fastTextLink[i].subPageNumber & 0x0070) >> 4) | ((m_fastTextLink[i].pageNumber & 0x100) >> 5);
+			result[i*6+5] = (m_fastTextLink[i].subPageNumber & 0x0f00) >> 8;
+			result[i*6+6] = ((m_fastTextLink[i].subPageNumber & 0x3000) >> 12) | ((m_fastTextLink[i].pageNumber & 0x600) >> 7);
+		}
+		result[37] = 0xf;
+		result[38] = result[39] = 0;
+
+		return result;
+	}
+
+	if (packetNumber == 27 && (designationCode == 4 || designationCode == 5)) {
+		for (int i=0; i<(designationCode == 4 ? 6 : 2); i++) {
+			int pageLinkNumber = i+(designationCode == 4 ? 0 : 6);
+
+			result[i*6+1] = (m_composeLink[pageLinkNumber].level3p5 << 3) | (m_composeLink[pageLinkNumber].level2p5 << 2) | m_composeLink[pageLinkNumber].function;
+			result[i*6+2] = ((m_composeLink[pageLinkNumber].pageNumber & 0x100) >> 3) | 0x10 | (m_composeLink[pageLinkNumber].pageNumber & 0x00f);
+			result[i*6+3] = ((m_composeLink[pageLinkNumber].pageNumber & 0x0f0) >> 2) | ((m_composeLink[pageLinkNumber].pageNumber & 0x600) >> 9);
+
+			result[i*6+4] = ((m_composeLink[pageLinkNumber].subPageCodes & 0x000f) << 2);
+			result[i*6+5] = ((m_composeLink[pageLinkNumber].subPageCodes & 0x03f0) >> 4);
+			result[i*6+6] = ((m_composeLink[pageLinkNumber].subPageCodes & 0xfc00) >> 10);
+		}
+
+		return result;
+	}
+
+	if (packetNumber == 28 && (designationCode == 0 || designationCode == 4)) {
+		int CLUToffset = (designationCode == 0) ? 16 : 0;
+
+		result[1] = 0x00;
+		result[2] = ((m_defaultCharSet & 0x3) << 4) | (m_defaultNOS << 1);
+		result[3] = ((m_secondCharSet & 0x1) << 5) | (m_secondNOS << 2) | (m_defaultCharSet >> 2);
+		result[4] = (m_sidePanelStatusL25 << 5) | (m_rightSidePanelDisplayed << 4) | (m_leftSidePanelDisplayed << 3) | (m_secondCharSet >> 1);
+		result[5] = m_sidePanelColumns | ((m_CLUT[CLUToffset] & 0x300) >> 4);
+
+		for (int c=0; c<16; c++) {
+			result[c*2+6] = ((m_CLUT[CLUToffset+c] & 0x0f0) >> 2) | ((m_CLUT[CLUToffset+c] & 0xf00) >> 10);
+			result[c*2+7] = ((m_CLUT[CLUToffset+c+1] & 0x300) >> 4) | (m_CLUT[CLUToffset+c] & 0x00f);
+		}
+
+		result[37] = ((m_defaultScreenColour & 0x03) << 4) | (m_CLUT[CLUToffset+15] & 0x00f);
+		result[38] = ((m_defaultRowColour & 0x07) << 3) | (m_defaultScreenColour >> 2);
+		result[39] = (m_colourTableRemap << 3) | (m_blackBackgroundSubst << 2) | (m_defaultRowColour >> 3);
+
+		return result;
+	}
+
+	return PageBase::packet(packetNumber, designationCode);
+}
+
+bool LevelOnePage::setPacket(int packetNumber, QByteArray packetContents)
+{
+	if (packetNumber <= 24) {
+		for (int c=0; c<40; c++)
+			m_level1Page[packetNumber][c] = packetContents.at(c);
+		return true;
+	}
+
+	qDebug("LevelOnePage unhandled setPacket X/%d", packetNumber);
+	return PageBase::setPacket(packetNumber, packetContents);
+}
+
+bool LevelOnePage::setPacket(int packetNumber, int designationCode, QByteArray packetContents)
+{
+	if (packetNumber == 26) {
+		setEnhancementListFromPacket(designationCode, packetContents);
+		return true;
+	}
+
+	if (packetNumber == 27 && designationCode == 0) {
+		for (int i=0; i<6; i++) {
+			int relativeMagazine = (packetContents.at(i*6+4) >> 3) | ((packetContents.at(i*6+6) & 0xc) >> 1);
+			int pageNumber = (packetContents.at(i*6+2) << 4) | packetContents.at(i*6+1);
+			m_fastTextLink[i].pageNumber = (relativeMagazine << 8) | pageNumber;
+			m_fastTextLink[i].subPageNumber = packetContents.at(i*6+3) | ((packetContents.at(i*6+4) & 0x7) << 4) | (packetContents.at(i*6+5) << 8) | ((packetContents.at(i*6+6) & 0x3) << 12);
+			// TODO remove this warning when we can preserve FastText subpage links
+			if (m_fastTextLink[i].subPageNumber != 0x3f7f)
+				qDebug("FastText link %d has custom subPageNumber %x - will NOT be saved!", i, m_fastTextLink[i].subPageNumber);
+		}
+		return true;
+	}
+
+	if (packetNumber == 27 && (designationCode == 4 || designationCode == 5)) {
+		for (int i=0; i<(designationCode == 4 ? 6 : 2); i++) {
+			int pageLinkNumber = i+(designationCode == 4 ? 0 : 6);
+			int pageFunction = packetContents.at(i*6+1) & 0x03;
+			if (i >= 4)
+				m_composeLink[pageLinkNumber].function = pageFunction;
+			else if (i != pageFunction)
+				qDebug("X/27/4 link number %d fixed at function %d. Attempted to set to %d.", pageLinkNumber, pageLinkNumber, pageFunction);
+
+			m_composeLink[pageLinkNumber].level2p5 = packetContents.at(i*6+1) & 0x04;
+			m_composeLink[pageLinkNumber].level3p5 = packetContents.at(i*6+1) & 0x08;
+
+			m_composeLink[pageLinkNumber].pageNumber = ((packetContents.at(i*6+3) & 0x03) << 9) | ((packetContents.at(i*6+2) & 0x20) << 3) | ((packetContents.at(i*6+3) & 0x3c) << 2) | (packetContents.at(i*6+2) & 0x0f);
+
+			m_composeLink[pageLinkNumber].subPageCodes = (packetContents.at(i*6+4) >> 2) | (packetContents.at(i*6+5) << 4) | (packetContents.at(i*6+6) << 10);
+		}
+		return true;
+	}
+
+	if (packetNumber == 28 && (designationCode == 0 || designationCode == 4)) {
+		int CLUToffset = (designationCode == 0) ? 16 : 0;
+
+		m_defaultCharSet = ((packetContents.at(2) >> 4) & 0x3) | ((packetContents.at(3) << 2) & 0xc);
+		m_defaultNOS = (packetContents.at(2) >> 1) & 0x7;
+		m_secondCharSet = ((packetContents.at(3) >> 5) & 0x1) | ((packetContents.at(4) << 1) & 0xe);
+		m_secondNOS = (packetContents.at(3) >> 2) & 0x7;
+
+		m_leftSidePanelDisplayed = (packetContents.at(4) >> 3) & 1;
+		m_rightSidePanelDisplayed = (packetContents.at(4) >> 4) & 1;
+		m_sidePanelStatusL25 = (packetContents.at(4) >> 5) & 1;
+		m_sidePanelColumns = packetContents.at(5) & 0xf;
+
+		for (int c=0; c<16; c++)
+			m_CLUT[CLUToffset+c] = ((packetContents.at(c*2+5) << 4) & 0x300) | ((packetContents.at(c*2+6) << 10) & 0xc00) | ((packetContents.at(c*2+6) << 2) & 0x0f0) | (packetContents.at(c*2+7) & 0x00f);
+
+		m_defaultScreenColour = (packetContents.at(37) >> 4) | ((packetContents.at(38) << 2) & 0x1c);
+		m_defaultRowColour = ((packetContents.at(38)) >> 3) | ((packetContents.at(39) << 3) & 0x18);
+		m_blackBackgroundSubst = (packetContents.at(39) >> 2) & 1;
+		m_colourTableRemap = (packetContents.at(39) >> 3) & 7;
+
+		return true;
+	}
+
+	qDebug("LevelOnePage unhandled setPacket X/%d/%d", packetNumber, designationCode);
+	return PageBase::setPacket(packetNumber, designationCode, packetContents);
+}
+
+bool LevelOnePage::packetExists(int packetNumber) const
+{
+	if (packetNumber <= 24) {
+		for (int c=0; c<40; c++)
+			if (m_level1Page[packetNumber][c] != 0x20)
+				return true;
+		return false;
+	}
+
+	return PageBase::packetExists(packetNumber);
+}
+
+bool LevelOnePage::packetExists(int packetNumber, int designationCode) const
+{
+	if (packetNumber == 26)
+		return packetFromEnhancementListNeeded(designationCode);
+
+	if (packetNumber == 27 && designationCode == 0) {
+		for (int i=0; i<6; i++)
+			if ((m_fastTextLink[i].pageNumber & 0x0ff) != 0xff)
+				return true;
+
+		return false;
+	}
+
+	if (packetNumber == 27 && (designationCode == 4 || designationCode == 5)) {
+		for (int i=0; i<(designationCode == 4 ? 6 : 2); i++) {
+			int pageLinkNumber = i+(designationCode == 4 ? 0 : 6);
+			if ((m_composeLink[pageLinkNumber].pageNumber & 0x0ff) != 0x0ff)
+				return true;
+		}
+		return false;
+	}
+
+	if (packetNumber == 28) {
+		if (designationCode == 0) {
+			if (m_leftSidePanelDisplayed || m_rightSidePanelDisplayed || m_defaultScreenColour !=0 || m_defaultRowColour !=0 || m_blackBackgroundSubst || m_colourTableRemap !=0 || m_defaultCharSet != 0 || m_secondCharSet != 0xf)
+				return true;
+			return !isPaletteDefault(16, 31);
+		}
+		if (designationCode == 4)
+			return !isPaletteDefault(0, 15);
+	}
+
+	return PageBase::packetExists(packetNumber, designationCode);
+}
+
+bool LevelOnePage::controlBit(int bitNumber) const
+{
+	switch (bitNumber) {
+		case C12NOS:
+			return (m_defaultNOS & 1) == 1;
+		case C13NOS:
+			return (m_defaultNOS & 2) == 2;
+		case C14NOS:
+			return (m_defaultNOS & 4) == 4;
+		default:
+			return PageBase::controlBit(bitNumber);
+	}
+}
+
+bool LevelOnePage::setControlBit(int bitNumber, bool active)
+{
+	switch (bitNumber) {
+		case C12NOS:
+			m_defaultNOS &= 0x06;
+			if (active)
+				m_defaultNOS |= 0x01;
+			return true;
+		case C13NOS:
+			m_defaultNOS &= 0x05;
+			if (active)
+				m_defaultNOS |= 0x02;
+			return true;
+		case C14NOS:
+			m_defaultNOS &= 0x03;
+			if (active)
+				m_defaultNOS |= 0x04;
+			return true;
+		default:
+			return PageBase::setControlBit(bitNumber, active);
+	}
+}
+
+/* void LevelOnePage::setSubPageNumber(int newSubPageNumber) { m_subPageNumber = newSubPageNumber; } */
+void LevelOnePage::setCycleValue(int newValue) { m_cycleValue = newValue; };
+void LevelOnePage::setCycleType(CycleTypeEnum newType) { m_cycleType = newType; }
+void LevelOnePage::setDefaultCharSet(int newDefaultCharSet) { m_defaultCharSet = newDefaultCharSet; }
+
+void LevelOnePage::setDefaultNOS(int defaultNOS)
+{
+	m_defaultNOS = defaultNOS;
+}
+
+void LevelOnePage::setSecondCharSet(int newSecondCharSet)
+{
+	m_secondCharSet = newSecondCharSet;
+	if (m_secondCharSet == 0xf)
+		m_secondNOS = 0x7;
+}
+
+void LevelOnePage::setSecondNOS(int newSecondNOS) { m_secondNOS = newSecondNOS; }
+void LevelOnePage::setCharacter(int row, int column, unsigned char newCharacter) { m_level1Page[row][column] = newCharacter; }
+void LevelOnePage::setDefaultScreenColour(int newDefaultScreenColour) { m_defaultScreenColour = newDefaultScreenColour; }
+void LevelOnePage::setDefaultRowColour(int newDefaultRowColour) { m_defaultRowColour = newDefaultRowColour; }
+void LevelOnePage::setColourTableRemap(int newColourTableRemap) { m_colourTableRemap = newColourTableRemap; }
+void LevelOnePage::setBlackBackgroundSubst(bool newBlackBackgroundSubst) { m_blackBackgroundSubst = newBlackBackgroundSubst; }
+
+int LevelOnePage::CLUT(int index, int renderLevel) const
+{
+	if (renderLevel == 2)
+		return index>=16 ? m_CLUT[index] : m_defaultCLUT[index];
+	else
+		return renderLevel==3 ? m_CLUT[index] : m_defaultCLUT[index];
+}
+
+void LevelOnePage::setCLUT(int index, int newColour)
+{
+	if (index == 8)
+		return;
+	m_CLUT[index] = newColour;
+}
+
+QColor LevelOnePage::CLUTtoQColor(int index, int renderLevel) const
+{
+	int colour12Bit = CLUT(index, renderLevel);
+
+	if (index == 8)
+		return QColor(Qt::transparent);
+
+	return QColor(((colour12Bit & 0xf00) >> 8) * 17, ((colour12Bit & 0x0f0) >> 4) * 17, (colour12Bit & 0x00f) * 17);
+}
+
+bool LevelOnePage::isPaletteDefault(int colour) const
+{
+	return m_CLUT[colour] == m_defaultCLUT[colour];
+}
+
+bool LevelOnePage::isPaletteDefault(int fromColour, int toColour) const
+{
+	for (int i=fromColour; i<=toColour; i++)
+		if (m_CLUT[i] != m_defaultCLUT[i])
+			return false;
+
+	return true;
+}
+
+int LevelOnePage::levelRequired() const
+{
+	// X/28/4 present i.e. CLUTs 0 or 1 redefined - Level 3.5
+	if (!isPaletteDefault(0, 15))
+		return 3;
+
+	// TODO Check for X/28/1 for DCLUT for mode 1-3 DRCS characters - return 3
+
+	// Assume Level 2.5 if any X/28 page enhancements are present, otherwise assume Level 1
+	int levelSeen = (!isPaletteDefault(16, 31) || m_leftSidePanelDisplayed || m_rightSidePanelDisplayed || m_defaultScreenColour !=0 || m_defaultRowColour !=0 || m_blackBackgroundSubst || m_colourTableRemap !=0 || m_defaultCharSet != 0 || m_secondCharSet != 0xf) ? 2 : 0;
+
+	// If there's no X/26 triplets, exit here as Level 1 or 2.5
+	if (m_enhancements.isEmpty())
+		return levelSeen;
+
+	for (int i=0; i<m_enhancements.size(); i++) {
+		// Font style - Level 3.5 only triplet
+		if (m_enhancements.at(i).modeExt() == 0x2e) // Font style
+			return 3;
+
+		if (levelSeen == 0)
+			// Check for Level 1.5 triplets
+			switch (m_enhancements.at(i).modeExt()) {
+				case 0x04: // Set Active Position
+				case 0x07: // Address Row 0
+				case 0x1f: // Termination
+				case 0x22: // G3 character @ Level 1.5
+				case 0x2f: // G2 character
+					levelSeen = 1;
+					break;
+				default:
+					if (m_enhancements.at(i).modeExt() >= 0x30 && m_enhancements.at(i).modeExt() <= 0x3f)
+						// G0 character with diacritical
+						levelSeen = 1;
+			}
+
+		if (levelSeen < 2)
+			switch (m_enhancements.at(i).modeExt()) {
+				// Check for Level 2.5 triplets
+				case 0x00: // Full screen colour
+				case 0x01: // Full row colour
+				case 0x10: // Origin Modifier
+				case 0x11: // Invoke Active Object
+				case 0x12: // Invoke Adaptive Object
+				case 0x13: // Invoke Passive Object
+				case 0x15: // Define Active Object
+				case 0x16: // Define Adaptive Object
+				case 0x17: // Define Passive Object
+				case 0x18: // DRCS Mode
+				case 0x20: // Foreground colour
+				case 0x21: // G1 character
+				case 0x23: // Background colour
+				case 0x27: // Flash functions
+				case 0x28: // G0 and G2 charset designation
+				case 0x29: // G0 character @ Level 2.5
+				case 0x2b: // G3 character @ Level 2.5
+				case 0x2c: // Display attributes
+				case 0x2d: // DRCS character
+					levelSeen = 2;
+					break;
+			}
+
+		if (levelSeen == 2)
+			switch (m_enhancements.at(i).modeExt()) {
+				// Check for triplets with "required at Level 3.5 only" parameters
+				case 0x15: // Define Active Object
+				case 0x16: // Define Adaptive Object
+				case 0x17: // Define Passive Object
+					if ((m_enhancements.at(i).address() & 0x18) == 0x10)
+						return 3;
+					break;
+				case 0x18: // DRCS Mode
+					if ((m_enhancements.at(i).data() & 0x30) == 0x20)
+						return 3;
+					break;
+			}
+	}
+
+	return levelSeen;
+}
+
+void LevelOnePage::setLeftSidePanelDisplayed(bool newLeftSidePanelDisplayed) { m_leftSidePanelDisplayed = newLeftSidePanelDisplayed; }
+void LevelOnePage::setRightSidePanelDisplayed(bool newRightSidePanelDisplayed) { m_rightSidePanelDisplayed = newRightSidePanelDisplayed; }
+void LevelOnePage::setSidePanelColumns(int newSidePanelColumns) { m_sidePanelColumns = newSidePanelColumns; }
+void LevelOnePage::setSidePanelStatusL25(bool newSidePanelStatusL25) { m_sidePanelStatusL25 = newSidePanelStatusL25; }
+
+void LevelOnePage::setFastTextLinkPageNumber(int linkNumber, int pageNumber)
+{
+	m_fastTextLink[linkNumber].pageNumber = pageNumber;
+}
+
+void LevelOnePage::setComposeLinkFunction(int linkNumber, int newFunction)
+{
+	m_composeLink[linkNumber].function = newFunction;
+}
+
+void LevelOnePage::setComposeLinkLevel2p5(int linkNumber, bool newRequired)
+{
+	m_composeLink[linkNumber].level2p5 = newRequired;
+}
+
+void LevelOnePage::setComposeLinkLevel3p5(int linkNumber, bool newRequired)
+{
+	m_composeLink[linkNumber].level3p5 = newRequired;
+}
+
+void LevelOnePage::setComposeLinkPageNumber(int linkNumber, int newPageNumber)
+{
+	m_composeLink[linkNumber].pageNumber = newPageNumber;
+}
+
+void LevelOnePage::setComposeLinkSubPageCodes(int linkNumber, int newSubPageCodes)
+{
+	m_composeLink[linkNumber].subPageCodes = newSubPageCodes;
+}

src/qteletextdecoder/levelonepage.h

@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef LEVELONEPAGE_H
+#define LEVELONEPAGE_H
+
+#include <QByteArray>
+#include <QColor>
+#include <QObject>
+#include <QString>
+
+#include "pagex26base.h"
+#include "x26triplets.h"
+
+class LevelOnePage : public PageX26Base //: public QObject
+{
+	//Q_OBJECT
+
+public:
+	enum CycleTypeEnum { CTcycles, CTseconds };
+
+	LevelOnePage();
+	LevelOnePage(const PageBase &other);
+
+	bool isEmpty() const override;
+
+	QByteArray packet(int packetNumber) const override;
+	QByteArray packet(int packetNumber, int designationCode) const override;
+	bool packetExists(int packetNumber) const override;
+	bool packetExists(int packetNumber, int designationCode) const override;
+	bool setPacket(int packetNumber, QByteArray packetContents) override;
+	bool setPacket(int packetNumber, int designationCode, QByteArray packetContents) override;
+
+	bool controlBit(int bitNumber) const override;
+	bool setControlBit(int bitNumber, bool active) override;
+
+	void clearPage();
+
+	int maxEnhancements() const { return 208; };
+
+/*	void setSubPageNumber(int); */
+	int cycleValue() const { return m_cycleValue; };
+	void setCycleValue(int newValue);
+	CycleTypeEnum cycleType() const { return m_cycleType; };
+	void setCycleType(CycleTypeEnum newType);
+	int defaultCharSet() const { return m_defaultCharSet; }
+	void setDefaultCharSet(int newDefaultCharSet);
+	int defaultNOS() const { return m_defaultNOS; }
+	void setDefaultNOS(int defaultNOS);
+	int secondCharSet() const { return m_secondCharSet; }
+	void setSecondCharSet(int newSecondCharSet);
+	int secondNOS() const { return m_secondNOS; }
+	void setSecondNOS(int newSecondNOS);
+	unsigned char character(int row, int column) const { return m_level1Page[row][column]; }
+	void setCharacter(int row, int column, unsigned char newCharacter);
+	int defaultScreenColour() const { return m_defaultScreenColour; }
+	void setDefaultScreenColour(int newDefaultScreenColour);
+	int defaultRowColour() const { return m_defaultRowColour; }
+	void setDefaultRowColour(int newDefaultRowColour);
+	int colourTableRemap() const { return m_colourTableRemap; }
+	void setColourTableRemap(int newColourTableRemap);
+	bool blackBackgroundSubst() const { return m_blackBackgroundSubst; }
+	void setBlackBackgroundSubst(bool newBlackBackgroundSubst);
+	int CLUT(int index, int renderLevel=3) const;
+	void setCLUT(int index, int newColour);
+	QColor CLUTtoQColor(int index, int renderlevel=3) const;
+	bool isPaletteDefault(int colour) const;
+	bool isPaletteDefault(int fromColour, int toColour) const;
+	int levelRequired() const;
+	bool leftSidePanelDisplayed() const { return m_leftSidePanelDisplayed; }
+	void setLeftSidePanelDisplayed(bool newLeftSidePanelDisplayed);
+	bool rightSidePanelDisplayed() const { return m_rightSidePanelDisplayed; }
+	void setRightSidePanelDisplayed(bool newRightSidePanelDisplayed);
+	int sidePanelColumns() const { return m_sidePanelColumns; }
+	void setSidePanelColumns(int newSidePanelColumns);
+	bool sidePanelStatusL25() const { return m_sidePanelStatusL25; }
+	void setSidePanelStatusL25(bool newSidePanelStatusL25);
+	int fastTextLinkPageNumber(int linkNumber) const { return m_fastTextLink[linkNumber].pageNumber; }
+	void setFastTextLinkPageNumber(int linkNumber, int pageNumber);
+	int composeLinkFunction(int linkNumber) const { return m_composeLink[linkNumber].function; }
+	void setComposeLinkFunction(int linkNumber, int newFunction);
+	bool composeLinkLevel2p5(int linkNumber) const { return m_composeLink[linkNumber].level2p5; }
+	void setComposeLinkLevel2p5(int linkNumber, bool newRequired);
+	bool composeLinkLevel3p5(int linkNumber) const { return m_composeLink[linkNumber].level3p5; }
+	void setComposeLinkLevel3p5(int linkNumber, bool newRequired);
+	int composeLinkPageNumber(int linkNumber) const { return m_composeLink[linkNumber].pageNumber; }
+	void setComposeLinkPageNumber(int linkNumber, int newPageNumber);
+	int composeLinkSubPageCodes(int linkNumber) const { return m_composeLink[linkNumber].subPageCodes; }
+	void setComposeLinkSubPageCodes(int linkNumber, int newSubPageCodes);
+
+private:
+	unsigned char m_level1Page[25][40];
+/*	int m_subPageNumber; */
+	int m_cycleValue;
+	CycleTypeEnum m_cycleType;
+	int m_defaultCharSet, m_defaultNOS, m_secondCharSet, m_secondNOS;
+	int m_defaultScreenColour, m_defaultRowColour, m_colourTableRemap, m_sidePanelColumns;
+	bool m_blackBackgroundSubst, m_leftSidePanelDisplayed, m_rightSidePanelDisplayed, m_sidePanelStatusL25;
+	int m_CLUT[32];
+	struct fastTextLink {
+		int pageNumber;
+		int subPageNumber;
+	} m_fastTextLink[6];
+	struct composeLink {
+		int function;
+		bool level2p5, level3p5;
+		int pageNumber, subPageCodes;
+	} m_composeLink[8];
+
+	const int m_defaultCLUT[32] = {
+		0x000, 0xf00, 0x0f0, 0xff0, 0x00f, 0xf0f, 0x0ff, 0xfff,
+		0x000, 0x700, 0x070, 0x770, 0x007, 0x707, 0x077, 0x777,
+		0xf05, 0xf70, 0x0f7, 0xffb, 0x0ca, 0x500, 0x652, 0xc77,
+		0x333, 0xf77, 0x7f7, 0xff7, 0x77f, 0xf7f, 0x7ff, 0xddd
+	};
+};
+
+#endif

src/qteletextdecoder/pagebase.cpp

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QByteArray>
+
+#include "pagebase.h"
+
+PageBase::PageBase()
+{
+	// We use nullptrs to keep track of allocated packets, so initialise them this way
+	for (int i=0; i<26; i++)
+		m_displayPackets[i] = nullptr;
+	for (int i=0; i<4; i++)
+		for (int j=0; j<16; j++)
+			m_designationPackets[i][j] = nullptr;
+
+	for (int i=PageBase::C4ErasePage; i<=PageBase::C14NOS; i++)
+		m_controlBits[i] = false;
+}
+
+PageBase::~PageBase()
+{
+	for (int i=0; i<26; i++)
+		if (m_displayPackets[i] != nullptr)
+			delete m_displayPackets[i];
+	for (int i=0; i<4; i++)
+		for (int j=0; j<16; j++)
+			if (m_designationPackets[i][j] != nullptr)
+				delete m_designationPackets[i][j];
+}
+
+bool PageBase::isEmpty() const
+{
+	for (int i=0; i<26; i++)
+		if (m_displayPackets[i] != nullptr)
+			return false;
+	for (int i=0; i<4; i++)
+		for (int j=0; j<16; j++)
+			if (m_designationPackets[i][j] != nullptr)
+				return false;
+
+	return true;
+}
+
+QByteArray PageBase::packet(int i) const
+{
+	if (m_displayPackets[i] == nullptr)
+		return QByteArray(); // Blank result
+
+	return *m_displayPackets[i];
+}
+
+QByteArray PageBase::packet(int i, int j) const
+{
+	if (m_designationPackets[i-26][j] == nullptr)
+		return QByteArray(); // Blank result
+
+	return *m_designationPackets[i-26][j];
+}
+
+
+bool PageBase::setPacket(int i, QByteArray packetContents)
+{
+	if (m_displayPackets[i] == nullptr)
+		m_displayPackets[i] = new QByteArray(40, 0x00);
+	*m_displayPackets[i] = packetContents;
+
+	return true;
+}
+
+bool PageBase::setPacket(int i, int j, QByteArray packetContents)
+{
+	if (m_designationPackets[i-26][j] == nullptr)
+		m_designationPackets[i-26][j] = new QByteArray(40, 0x00);
+	*m_designationPackets[i-26][j] = packetContents;
+
+	return true;
+}
+
+/*
+bool PageBase::deletePacket(int i)
+{
+	if (m_displayPackets[i] != nullptr) {
+		delete m_displayPackets[i];
+		m_displayPackets[i] = nullptr;
+	}
+
+	return true;
+}
+
+bool PageBase::deletePacket(int i)
+{
+	if (m_designationPackets[i-26][j] != nullptr) {
+		delete m_designationPackets[i-26][j];
+		m_designationPackets[i-26][j] = nullptr;
+	}
+
+	return true;
+}
+*/
+
+bool PageBase::setControlBit(int bitNumber, bool active)
+{
+	m_controlBits[bitNumber] = active;
+	return true;
+}

src/qteletextdecoder/pagebase.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PAGEBASE_H
+#define PAGEBASE_H
+
+#include <QByteArray>
+
+// If we inherit from QObject then we can't copy construct, so "make a new subpage that's a copy of this one" wouldn't work
+class PageBase //: public QObject
+{
+	//Q_OBJECT
+
+public:
+	enum ControlBitsEnum { C4ErasePage, C5Newsflash, C6Subtitle, C7SuppressHeader, C8Update, C9InterruptedSequence, C10InhibitDisplay, C11SerialMagazine, C12NOS, C13NOS, C14NOS };
+
+	PageBase();
+	virtual ~PageBase();
+
+	virtual bool isEmpty() const;
+
+	virtual QByteArray packet(int i) const;
+	virtual QByteArray packet(int i, int j) const;
+	virtual bool packetExists(int i) const { return m_displayPackets[i] != nullptr; }
+	virtual bool packetExists(int i, int j) const { return m_designationPackets[i-26][j] != nullptr; }
+	virtual bool setPacket(int i, QByteArray packetContents);
+	virtual bool setPacket(int i, int j, QByteArray packetContents);
+//	bool deletePacket(int);
+//	bool deletePacket(int, int);
+
+	virtual bool controlBit(int bitNumber) const { return m_controlBits[bitNumber]; }
+	virtual bool setControlBit(int bitNumber, bool active);
+
+private:
+	bool m_controlBits[11];
+	QByteArray *m_displayPackets[26], *m_designationPackets[4][16];
+};
+
+#endif

src/qteletextdecoder/pagex26base.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QByteArray>
+
+#include "pagex26base.h"
+
+QByteArray PageX26Base::packetFromEnhancementList(int packetNumber) const
+{
+	QByteArray result(40, 0x00);
+
+	int enhanceListPointer;
+	X26Triplet lastTriplet;
+
+	for (int i=0; i<13; i++) {
+		enhanceListPointer = packetNumber*13+i;
+
+		if (enhanceListPointer < m_enhancements.size()) {
+			result[i*3+1] = m_enhancements.at(enhanceListPointer).address();
+			result[i*3+2] = m_enhancements.at(enhanceListPointer).mode() | ((m_enhancements.at(enhanceListPointer).data() & 1) << 5);
+			result[i*3+3] = m_enhancements.at(enhanceListPointer).data() >> 1;
+
+			// If this is the last triplet, get a copy to repeat to the end of the packet
+			if (enhanceListPointer == m_enhancements.size()-1) {
+				lastTriplet = m_enhancements.at(enhanceListPointer);
+				// If the last triplet was NOT a Termination Marker, make up one
+				if (lastTriplet.mode() != 0x1f || lastTriplet.address() != 0x3f) {
+					lastTriplet.setAddress(0x3f);
+					lastTriplet.setMode(0x1f);
+					lastTriplet.setData(0x07);
+				}
+			}
+		} else {
+			// We've gone past the end of the triplet list, so repeat the Termination Marker to the end
+			result[i*3+1] = lastTriplet.address();
+			result[i*3+2] = lastTriplet.mode() | ((lastTriplet.data() & 1) << 5);
+			result[i*3+3] = lastTriplet.data() >> 1;
+		}
+	}
+
+	return result;
+}
+
+void PageX26Base::setEnhancementListFromPacket(int packetNumber, QByteArray packetContents)
+{
+	// Preallocate entries in the m_enhancements list to hold our incoming triplets.
+	// We write "dummy" reserved 11110 Row Triplets in the allocated entries which then get overwritten by the packet contents.
+	// This is in case of missing packets so we can keep Local Object pointers valid.
+	while (m_enhancements.size() < (packetNumber+1)*13)
+		m_enhancements.append(m_paddingX26Triplet);
+
+	int enhanceListPointer;
+	X26Triplet newX26Triplet;
+
+	for (int i=0; i<13; i++) {
+		enhanceListPointer = packetNumber*13+i;
+
+		newX26Triplet.setAddress(packetContents.at(i*3+1) & 0x3f);
+		newX26Triplet.setMode(packetContents.at(i*3+2) & 0x1f);
+		newX26Triplet.setData(((packetContents.at(i*3+3) & 0x3f) << 1) | ((packetContents.at(i*3+2) & 0x20) >> 5));
+		m_enhancements.replace(enhanceListPointer, newX26Triplet);
+	}
+	if (newX26Triplet.mode() == 0x1f && newX26Triplet.address() == 0x3f && newX26Triplet.data() & 0x01)
+		// Last triplet was a Termination Marker (without ..follows) so clean up the repeated ones
+		while (m_enhancements.size()>1 && m_enhancements.at(m_enhancements.size()-2).mode() == 0x1f && m_enhancements.at(m_enhancements.size()-2).address() == 0x3f && m_enhancements.at(m_enhancements.size()-2).data() == newX26Triplet.data())
+			m_enhancements.removeLast();
+}

src/qteletextdecoder/pagex26base.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PAGEX26BASE_H
+#define PAGEX26BASE_H
+
+#include <QByteArray>
+#include <QList>
+
+#include "pagebase.h"
+#include "x26triplets.h"
+
+class PageX26Base : public PageBase //: public QObject
+{
+	//Q_OBJECT
+
+public:
+	X26TripletList *enhancements() { return &m_enhancements; };
+	virtual int maxEnhancements() const =0;
+
+protected:
+	QByteArray packetFromEnhancementList(int packetNumber) const;
+	void setEnhancementListFromPacket(int packetNumber, QByteArray packetContents);
+	bool packetFromEnhancementListNeeded(int n) const { return ((m_enhancements.size()+12) / 13) > n; };
+
+	X26TripletList m_enhancements;
+	const X26Triplet m_paddingX26Triplet { 41, 0x1e, 0 };
+};
+
+#endif

src/qteletextdecoder/render.cpp

@@ -0,0 +1,467 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QBitmap>
+#include <QColor>
+#include <QDir>
+#include <QImage>
+#include <QPainter>
+#include <QPixmap>
+
+#include "render.h"
+
+#include "decode.h"
+
+int TeletextFontBitmap::s_instances = 0;
+
+QBitmap *TeletextFontBitmap::s_fontBitmap = nullptr;
+QImage *TeletextFontBitmap::s_fontImage = nullptr;
+
+TeletextFontBitmap::TeletextFontBitmap()
+{
+	Q_INIT_RESOURCE(teletextfonts);
+
+	if (s_instances == 0) {
+		s_fontBitmap = new QBitmap(":/fontimages/teletextfont.png");
+		s_fontImage = new QImage(s_fontBitmap->toImage());
+	}
+	s_instances++;
+}
+
+TeletextFontBitmap::~TeletextFontBitmap()
+{
+	s_instances--;
+	if (s_instances == 0) {
+		delete s_fontImage;
+		delete s_fontBitmap;
+	}
+}
+
+
+TeletextPageRender::TeletextPageRender()
+{
+	for (int i=0; i<6; i++)
+		m_pageImage[i] = new QImage(864, 250, QImage::Format_ARGB32_Premultiplied);
+
+	m_reveal = false;
+	m_mix = false;
+	m_showControlCodes = false;
+	m_flashBuffersHz = 0;
+
+	for (int r=0; r<25; r++) {
+		m_flashingRow[r] = 0;
+		for (int c=0; c<40; c++)
+			m_controlCodeCache[r][c] = 0x7f;
+	}
+}
+
+TeletextPageRender::~TeletextPageRender()
+{
+	for (int i=0; i<6; i++)
+		delete m_pageImage[i];
+}
+
+void TeletextPageRender::setDecoder(TeletextPageDecode *decoder)
+{
+	m_decoder = decoder;
+}
+
+inline void TeletextPageRender::drawFromBitmap(QPainter &painter, int r, int c, const QImage image, TeletextPageDecode::CharacterFragment characterFragment)
+{
+	switch (characterFragment) {
+		case TeletextPageDecode::NormalSize:
+			painter.drawImage(c*12, r*10, image);
+			break;
+		case TeletextPageDecode::DoubleHeightTopHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 0, 12, 5));
+			break;
+		case TeletextPageDecode::DoubleHeightBottomHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 5, 12, 5));
+			break;
+		case TeletextPageDecode::DoubleWidthLeftHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 0, 6, 10));
+			break;
+		case TeletextPageDecode::DoubleWidthRightHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(6, 0, 6, 10));
+			break;
+		case TeletextPageDecode::DoubleSizeTopLeftQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 0, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeTopRightQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(6, 0, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 5, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeBottomRightQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(6, 5, 6, 5));
+			break;
+	}
+}
+
+inline void TeletextPageRender::drawFromFontBitmap(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment)
+{
+	switch (characterFragment) {
+		case TeletextPageDecode::NormalSize:
+			painter.drawImage(c*12, r*10, *m_fontBitmap.image(), (characterCode-32)*12, characterSet*10, 12, 10);
+			break;
+		case TeletextPageDecode::DoubleHeightTopHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10, 12, 5));
+			break;
+		case TeletextPageDecode::DoubleHeightBottomHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10+5, 12, 5));
+			break;
+		case TeletextPageDecode::DoubleWidthLeftHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10, 6, 10));
+			break;
+		case TeletextPageDecode::DoubleWidthRightHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12+6, characterSet*10, 6, 10));
+			break;
+		case TeletextPageDecode::DoubleSizeTopLeftQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeTopRightQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12+6, characterSet*10, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10+5, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeBottomRightQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12+6, characterSet*10+5, 6, 5));
+			break;
+	}
+}
+
+inline void TeletextPageRender::drawCharacter(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, int characterDiacritical, TeletextPageDecode::CharacterFragment characterFragment)
+{
+	const bool dontUnderline = characterCode == 0x00;
+	if (dontUnderline)
+		characterCode = 0x20;
+
+	if (characterCode == 0x20 && characterSet < 25 && characterDiacritical == 0)
+		painter.fillRect(c*12, r*10, 12, 10, m_backgroundQColor);
+	else if (characterCode == 0x7f && characterSet == 24)
+		painter.fillRect(c*12, r*10, 12, 10, m_foregroundQColor);
+	else if ((m_decoder->cellBold(r, c) || m_decoder->cellItalic(r, c)) && characterSet < 24)
+		drawBoldOrItalicCharacter(painter, r, c, characterCode, characterSet, characterFragment);
+	else {
+		m_fontBitmap.image()->setColorTable(QVector<QRgb>{m_backgroundQColor.rgba(), m_foregroundQColor.rgba()});
+		drawFromFontBitmap(painter, r, c, characterCode, characterSet, characterFragment);
+	}
+
+	if (m_decoder->cellUnderlined(r, c) && !dontUnderline) {
+		painter.setPen(m_foregroundQColor);
+		switch (characterFragment) {
+			case TeletextPageDecode::NormalSize:
+			case TeletextPageDecode::DoubleWidthLeftHalf:
+			case TeletextPageDecode::DoubleWidthRightHalf:
+				painter.drawLine(c*12, r*10+9, c*12+11, r*10+9);
+				break;
+			case TeletextPageDecode::DoubleHeightBottomHalf:
+			case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
+			case TeletextPageDecode::DoubleSizeBottomRightQuarter:
+				painter.drawRect(c*12, r*10+8, 11, 1);
+				break;
+			default:
+				break;
+		}
+	}
+
+	if (characterDiacritical != 0) {
+		painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+		m_fontBitmap.image()->setColorTable(QVector<QRgb>{0x00000000, m_foregroundQColor.rgba()});
+		drawFromFontBitmap(painter, r, c, characterDiacritical+64, 7, characterFragment);
+		painter.setCompositionMode(QPainter::CompositionMode_Source);
+	}
+}
+
+inline void TeletextPageRender::drawBoldOrItalicCharacter(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment)
+{
+	QImage styledImage = QImage(12, 10, QImage::Format_Mono);
+	QPainter styledPainter;
+
+	m_fontBitmap.image()->setColorTable(QVector<QRgb>{m_backgroundQColor.rgba(), m_foregroundQColor.rgba()});
+	styledImage.setColorTable(QVector<QRgb>{m_backgroundQColor.rgba(), m_foregroundQColor.rgba()});
+
+	if (m_decoder->cellItalic(r, c)) {
+		styledImage.fill(0);
+
+		styledPainter.begin(&styledImage);
+		styledPainter.setCompositionMode(QPainter::CompositionMode_Source);
+		styledPainter.drawImage(1, 0, *m_fontBitmap.image(), (characterCode-32)*12, characterSet*10, 11, 3);
+		styledPainter.drawImage(0, 3, *m_fontBitmap.image(), (characterCode-32)*12, characterSet*10+3, 12, 3);
+		styledPainter.drawImage(0, 6, *m_fontBitmap.image(), (characterCode-32)*12+1, characterSet*10+6, 11, 4);
+		styledPainter.end();
+	} else
+		styledImage = m_fontBitmap.image()->copy((characterCode-32)*12, characterSet*10, 12, 10);
+
+	if (m_decoder->cellBold(r, c)) {
+		QImage boldeningImage;
+
+		boldeningImage = styledImage.copy();
+		styledPainter.begin(&styledImage);
+		styledPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+		boldeningImage.setColorTable(QVector<QRgb>{0x00000000, m_foregroundQColor.rgba()});
+		styledPainter.drawImage(1, 0, boldeningImage);
+		styledPainter.end();
+	}
+	drawFromBitmap(painter, r, c, styledImage, characterFragment);
+}
+
+void TeletextPageRender::renderPage(bool force)
+{
+	for (int r=0; r<25; r++)
+		renderRow(r, 0, force);
+}
+
+void TeletextPageRender::renderRow(int r, int ph, bool force)
+{
+	QPainter painter;
+	int flashingRow = 0;
+	bool rowRefreshed = false;
+
+	painter.begin(m_pageImage[ph]);
+	painter.setCompositionMode(QPainter::CompositionMode_Source);
+
+	for (int c=0; c<72; c++) {
+		bool controlCodeChanged = false;
+
+		// Ensure that shown control codes are refreshed
+		if (ph == 0 && m_showControlCodes && c < 40 && (m_controlCodeCache[r][c] != 0x7f || m_decoder->teletextPage()->character(r, c) < 0x20)) {
+			controlCodeChanged = m_controlCodeCache[r][c] != m_decoder->teletextPage()->character(r, c);
+			if (controlCodeChanged) {
+				if (m_decoder->teletextPage()->character(r, c) < 0x20)
+					m_controlCodeCache[r][c] = m_decoder->teletextPage()->character(r, c);
+				else
+					m_controlCodeCache[r][c] = 0x7f;
+			}
+		}
+
+		if (ph == 0) {
+			if (m_decoder->cellFlashMode(r, c) != 0)
+				flashingRow = qMax(flashingRow, (m_decoder->cellFlashRatePhase(r, c) == 0) ? 1 : 2);
+		} else
+			force = m_decoder->cellFlashMode(r, c) != 0;
+
+		// If drawing into a flash pixmap buffer, "force" is set on a flashing cell only
+		// and since the refresh and controlCodeChanged variables will be false at this point
+		// only flashing cells will be drawn
+		if (m_decoder->refresh(r, c) || force || controlCodeChanged) {
+			unsigned char characterCode;
+			int characterSet, characterDiacritical;
+
+			rowRefreshed = true;
+
+			if (!m_reveal && m_decoder->cellConceal(r, c)) {
+				characterCode = 0x20;
+				characterSet = 0;
+				characterDiacritical = 0;
+			} else {
+				characterCode = m_decoder->cellCharacterCode(r, c);
+				characterSet = m_decoder->cellCharacterSet(r, c);
+				characterDiacritical = m_decoder->cellCharacterDiacritical(r, c);
+			}
+
+			if (m_decoder->cellFlashMode(r, c) == 0)
+				m_foregroundQColor = m_decoder->cellForegroundQColor(r, c);
+			else {
+				// Flashing cell, decide if phase in this cycle is on or off
+				bool phaseOn;
+
+				if (m_decoder->cellFlashRatePhase(r, c) == 0)
+					phaseOn = (ph < 3) ^ (m_decoder->cellFlashMode(r, c) == 2);
+				else
+					phaseOn = ((ph == m_decoder->cellFlash2HzPhaseNumber(r, c)-1) || (ph == m_decoder->cellFlash2HzPhaseNumber(r, c)+2)) ^ (m_decoder->cellFlashMode(r, c) == 2);
+
+				// If flashing to adjacent CLUT select the appropriate foreground colour
+				if (m_decoder->cellFlashMode(r, c) == 3 && !phaseOn)
+					m_foregroundQColor = m_decoder->cellFlashForegroundQColor(r, c);
+				else
+					m_foregroundQColor = m_decoder->cellForegroundQColor(r, c);
+
+				// If flashing mode is Normal or Invert, draw a space instead of a character on phase
+				if ((m_decoder->cellFlashMode(r, c) == 1 || m_decoder->cellFlashMode(r, c) == 2) && !phaseOn) {
+					// Character 0x00 draws space without underline
+					characterCode = 0x00;
+					characterSet = 0;
+					characterDiacritical = 0;
+				}
+			}
+
+			if (!m_mix || m_decoder->cellBoxed(r, c))
+				m_backgroundQColor = m_decoder->cellBackgroundQColor(r, c);
+			else
+				m_backgroundQColor = Qt::transparent;
+
+			drawCharacter(painter, r, c, characterCode, characterSet, characterDiacritical, m_decoder->cellCharacterFragment(r, c));
+
+			if (m_showControlCodes && c < 40 && m_decoder->teletextPage()->character(r, c) < 0x20) {
+				painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+				m_fontBitmap.image()->setColorTable(QVector<QRgb>{0x7f000000, 0xe0ffffff});
+				painter.drawImage(c*12, r*10, *m_fontBitmap.image(), (m_decoder->teletextPage()->character(r, c)+32)*12, 250, 12, 10);
+				painter.setCompositionMode(QPainter::CompositionMode_Source);
+			}
+		}
+	}
+
+	painter.end();
+
+	if (ph != 0)
+		return;
+
+	if (flashingRow == 3)
+		flashingRow = 2;
+	if (flashingRow != m_flashingRow[r])
+		setRowFlashStatus(r, flashingRow);
+
+	for (int c=0; c<72; c++)
+		m_decoder->setRefresh(r, c, false);
+
+	// If row had changes rendered and flashing is present anywhere on the screen,
+	// copy this rendered line into the other flash pixmap buffers and then re-render
+	// the flashing cells in those buffers
+	if (rowRefreshed && m_flashBuffersHz > 0) {
+		painter.begin(m_pageImage[3]);
+		painter.setCompositionMode(QPainter::CompositionMode_Source);
+		painter.drawImage(0, r*10, *m_pageImage[0], 0, r*10, 864, 10);
+		painter.end();
+
+		renderRow(r, 3);
+
+		if (m_flashBuffersHz == 2) {
+			painter.begin(m_pageImage[1]);
+			painter.setCompositionMode(QPainter::CompositionMode_Source);
+			painter.drawImage(0, r*10, *m_pageImage[0], 0, r*10, 864, 10);
+			painter.end();
+			painter.begin(m_pageImage[2]);
+			painter.setCompositionMode(QPainter::CompositionMode_Source);
+			painter.drawImage(0, r*10, *m_pageImage[0], 0, r*10, 864, 10);
+			painter.end();
+			painter.begin(m_pageImage[4]);
+			painter.setCompositionMode(QPainter::CompositionMode_Source);
+			painter.drawImage(0, r*10, *m_pageImage[3], 0, r*10, 864, 10);
+			painter.end();
+			painter.begin(m_pageImage[5]);
+			painter.setCompositionMode(QPainter::CompositionMode_Source);
+			painter.drawImage(0, r*10, *m_pageImage[3], 0, r*10, 864, 10);
+			painter.end();
+
+			renderRow(r, 1);
+			renderRow(r, 2);
+			renderRow(r, 4);
+			renderRow(r, 5);
+		}
+	}
+}
+
+void TeletextPageRender::setRowFlashStatus(int r, int rowFlashHz)
+{
+	m_flashingRow[r] = rowFlashHz;
+
+	if (rowFlashHz == m_flashBuffersHz)
+		return;
+
+	if (rowFlashHz < m_flashBuffersHz) {
+		// New flash Hz for this row is lower than the entire screen flash Hz
+		// Check the other rows if they still need flashing at the current flash Hz
+		// If not, reduce the screen flash Hz
+		int highestRowFlashHz = rowFlashHz;
+
+		for (int ri=0; ri<25; ri++)
+			if (m_flashingRow[ri] > highestRowFlashHz) {
+				highestRowFlashHz = m_flashingRow[ri];
+				if (highestRowFlashHz == 2)
+					break;
+			}
+
+		if (highestRowFlashHz > rowFlashHz)
+			rowFlashHz = highestRowFlashHz;
+		if (rowFlashHz == m_flashBuffersHz)
+			return;
+
+		m_flashBuffersHz = rowFlashHz;
+		emit flashChanged(m_flashBuffersHz);
+		return;
+	}
+
+	// If we get here, new flash Hz for this row is higher than the entire flash Hz
+	// so prepare the pixmap flash buffers
+	if (m_flashBuffersHz == 0)
+		*m_pageImage[3] = m_pageImage[0]->copy();
+	if (rowFlashHz == 2) {
+		*m_pageImage[1] = m_pageImage[0]->copy();
+		*m_pageImage[2] = m_pageImage[0]->copy();
+		*m_pageImage[4] = m_pageImage[3]->copy();
+		*m_pageImage[5] = m_pageImage[3]->copy();
+	}
+
+	m_flashBuffersHz = rowFlashHz;
+	emit flashChanged(m_flashBuffersHz);
+}
+
+void TeletextPageRender::colourChanged(int index)
+{
+	for (int r=0; r<25; r++)
+		for (int c=0; c<72; c++) {
+			if (m_decoder->cellForegroundCLUT(r, c) == index || m_decoder->cellBackgroundCLUT(r, c) == index || m_decoder->cellForegroundCLUT(r, c) == 8 || m_decoder->cellBackgroundCLUT(r, c) == 8)
+				m_decoder->setRefresh(r, c, true);
+			if (m_decoder->cellFlashMode(r, c) == 3 && ((m_decoder->cellForegroundCLUT(r, c) ^ 8) == index || (m_decoder->cellForegroundCLUT(r, c) ^ 8) == 8))
+				m_decoder->setRefresh(r, c, true);
+		}
+}
+
+void TeletextPageRender::setReveal(bool reveal)
+{
+	if (reveal == m_reveal)
+		return;
+
+	m_reveal = reveal;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<72; c++)
+			if (m_decoder->cellConceal(r, c))
+				m_decoder->setRefresh(r, c, true);
+}
+
+void TeletextPageRender::setMix(bool mix)
+{
+	if (mix  == m_mix)
+		return;
+
+	m_mix = mix;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<72; c++)
+			if (!m_decoder->cellBoxed(r, c))
+				m_decoder->setRefresh(r, c, true);
+}
+
+
+void TeletextPageRender::setShowControlCodes(bool showControlCodes)
+{
+	if (showControlCodes == m_showControlCodes)
+		return;
+
+	m_showControlCodes = showControlCodes;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<40; c++)
+			if (m_decoder->teletextPage()->character(r, c) < 0x20)
+				m_decoder->setRefresh(r, c, true);
+}

src/qteletextdecoder/render.h

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef RENDER_H
+#define RENDER_H
+
+#include <QBitmap>
+#include <QColor>
+#include <QIcon>
+#include <QImage>
+#include <QPixmap>
+
+#include "decode.h"
+
+class TeletextFontBitmap
+{
+public:
+	TeletextFontBitmap();
+	~TeletextFontBitmap();
+
+	QImage *image() const { return s_fontImage; }
+	QPixmap charBitmap(int c, int s) const { return s_fontBitmap->copy((c-32)*12, s*10, 12, 10); }
+	QIcon charIcon(int c, int s) const { return QIcon(charBitmap(c, s)); }
+
+private:
+	static int s_instances;
+	static QBitmap* s_fontBitmap;
+	static QImage* s_fontImage;
+};
+
+class TeletextPageRender : public QObject
+{
+	Q_OBJECT
+
+public:
+	TeletextPageRender();
+	~TeletextPageRender();
+
+	QImage* image(int i) const { return m_pageImage[i]; };
+	bool mix() const { return m_mix; };
+	void setDecoder(TeletextPageDecode *decoder);
+	void renderPage(bool force=false);
+	bool showControlCodes() const { return m_showControlCodes; };
+
+public slots:
+	void colourChanged(int index);
+	void setReveal(bool reveal);
+	void setMix(bool mix);
+	void setShowControlCodes(bool showControlCodes);
+
+signals:
+	void flashChanged(int newFlashHz);
+
+protected:
+	TeletextFontBitmap m_fontBitmap;
+	QImage* m_pageImage[6];
+	unsigned char m_controlCodeCache[25][40];
+	bool m_reveal, m_mix, m_showControlCodes;
+	int m_flashBuffersHz;
+	int m_flashingRow[25];
+
+private:
+	inline void drawFromBitmap(QPainter &, int, int, const QImage, TeletextPageDecode::CharacterFragment);
+	inline void drawFromFontBitmap(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment);
+	inline void drawCharacter(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, int characterDiacritical, TeletextPageDecode::CharacterFragment characterFragment);
+	inline void drawBoldOrItalicCharacter(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment);
+	void renderRow(int r, int ph, bool force=false);
+	void setRowFlashStatus(int r, int rowFlashHz);
+
+	QColor m_foregroundQColor, m_backgroundQColor;
+	TeletextPageDecode *m_decoder;
+};
+
+#endif

src/qteletextdecoder/teletextfonts.qrc

@@ -0,0 +1,5 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+	<file>fontimages/teletextfont.png</file>
+</qresource>
+</RCC>

src/qteletextdecoder/x26triplets.cpp

@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "x26triplets.h"
+
+X26Triplet::X26Triplet(int address, int mode, int data)
+{
+	m_address = address;
+	m_mode = mode;
+	m_data = data;
+}
+
+void X26Triplet::setAddress(int address)
+{
+	m_address = address;
+}
+
+void X26Triplet::setMode(int mode)
+{
+	m_mode = mode;
+}
+
+void X26Triplet::setData(int data)
+{
+	m_data = data;
+}
+
+void X26Triplet::setAddressRow(int addressRow)
+{
+	m_address = (addressRow == 24) ? 40 : addressRow+40;
+}
+
+void X26Triplet::setAddressColumn(int addressColumn)
+{
+	m_address = addressColumn;
+}
+
+void X26Triplet::setObjectLocalDesignationCode(int i)
+{
+	m_address = (m_address & 0x38) | (i >> 3);
+	m_data = (m_data & 0x0f) | ((i & 0x07) << 4);
+}
+
+void X26Triplet::setObjectLocalTripletNumber(int i)
+{
+	m_data = (m_data & 0x70) | i;
+}
+
+void X26Triplet::setObjectLocalIndex(int i)
+{
+	m_address = (m_address & 0x38) + (i >= 104); // Set bit 0 of address if triplet >= 8
+	m_data = (((i / 13) & 0x07) << 4) | (i % 13);
+}
+
+
+void X26TripletList::updateInternalData()
+{
+	ActivePosition activePosition;
+	X26Triplet *triplet;
+
+	m_objects[0].clear();
+	m_objects[1].clear();
+	m_objects[2].clear();
+
+	// Check for errors, and fill in where the Active Position goes for Level 2.5 and above
+	for (int i=0; i < m_list.size(); i++) {
+		triplet = &m_list[i];
+		triplet->m_error = X26Triplet::NoError;
+		triplet->m_reservedMode = false;
+		triplet->m_reservedData = false;
+
+		if (triplet->isRowTriplet()) {
+			switch (triplet->modeExt()) {
+				case 0x00: // Full screen colour
+					if (activePosition.isDeployed())
+						// TODO more specific error needed
+						triplet->m_error = X26Triplet::ActivePositionMovedUp;
+					if (triplet->m_data & 0x60)
+						triplet->m_reservedData = true;
+					break;
+				case 0x01: // Full row colour
+					if (!activePosition.setRow(triplet->addressRow()))
+						triplet->m_error = X26Triplet::ActivePositionMovedUp;
+					if ((triplet->m_data & 0x60) != 0x00 && (triplet->m_data & 0x60) != 0x60)
+						triplet->m_reservedData = true;
+					break;
+				case 0x04: // Set Active Position;
+					if (!activePosition.setRow(triplet->addressRow()))
+						triplet->m_error = X26Triplet::ActivePositionMovedUp;
+					else if (triplet->data() >= 40)
+						// FIXME data column highlighted?
+						triplet->m_reservedData = true;
+					else if (!activePosition.setColumn(triplet->data()))
+						triplet->m_error = X26Triplet::ActivePositionMovedLeft;
+					break;
+				case 0x07: // Address row 0
+					if (triplet->m_address != 63)
+						// FIXME data column highlighted?
+						triplet->m_reservedData = true;
+					else if (activePosition.isDeployed())
+						triplet->m_error = X26Triplet::ActivePositionMovedUp;
+					else {
+						activePosition.setRow(0);
+						activePosition.setColumn(8);
+					}
+					if ((triplet->m_data & 0x60) != 0x00 && (triplet->m_data & 0x60) != 0x60)
+						triplet->m_reservedData = true;
+					break;
+				case 0x10: // Origin Modifier
+					if (i == m_list.size()-1 ||
+					    m_list.at(i+1).modeExt() < 0x11 ||
+					    m_list.at(i+1).modeExt() > 0x13)
+						triplet->m_error = X26Triplet::OriginModifierAlone;
+					break;
+				case 0x11: // Invoke Active Object
+				case 0x12: // Invoke Adaptive Object
+				case 0x13: // Invoke Passive Object
+					if (triplet->objectSource() == X26Triplet::LocalObject) {
+						if (triplet->objectLocalTripletNumber() > 12 ||
+							triplet->objectLocalIndex() > (m_list.size()-1) ||
+							m_list.at(triplet->objectLocalIndex()).modeExt() < 0x15 ||
+							m_list.at(triplet->objectLocalIndex()).modeExt() > 0x17)
+							triplet->m_error = X26Triplet::InvokePointerInvalid;
+						else if ((triplet->modeExt() | 0x04) != m_list.at(triplet->objectLocalIndex()).modeExt())
+							triplet->m_error = X26Triplet::InvokeTypeMismatch;
+					}
+					break;
+				case 0x15: // Define Active Object
+				case 0x16: // Define Adaptive Object
+				case 0x17: // Define Passive Object
+					m_objects[triplet->modeExt() - 0x15].append(i);
+					activePosition.reset();
+					// Make sure data field holds correct place of triplet
+					// otherwise the object won't appear
+					triplet->setObjectLocalIndex(i);
+					break;
+				case 0x18: // DRCS mode
+					if ((triplet->m_data & 0x30) == 0x00)
+						triplet->m_reservedData = true;
+				case 0x1f: // Termination marker
+				case 0x08: // PDC country of origin & programme source
+				case 0x09: // PDC month & day
+				case 0x0a: // PDC cursor row & announced start hour
+				case 0x0b: // PDC cursor row & announced finish hour
+				case 0x0c: // PDC cursor row & local time offset
+				case 0x0d: // PDC series ID & series code
+					break;
+				default:
+					triplet->m_reservedMode = true;
+			};
+		// Column triplet: all triplets modes except PDC and reserved move the Active Position
+		} else if (triplet->modeExt() == 0x24 || triplet->modeExt() == 0x25 || triplet->modeExt() == 0x2a)
+			triplet->m_reservedMode = true;
+		else if (triplet->modeExt() != 0x26 && !activePosition.setColumn(triplet->addressColumn()))
+			triplet->m_error = X26Triplet::ActivePositionMovedLeft;
+		else
+			switch (triplet->modeExt()) {
+				case 0x20: // Foreground colour
+				case 0x23: // Background colour
+					if (triplet->m_data & 0x60)
+						triplet->m_reservedData = true;
+					break;
+				case 0x27: // Additional flash functions
+					if (triplet->m_data >= 0x18)
+						triplet->m_reservedData = true;
+					break;
+				case 0x28: // Modified G0 and G2 character set
+					if (triplet->m_data > 0x26)
+						switch (triplet->m_data) {
+							case 0x36:
+							case 0x37:
+							case 0x40:
+							case 0x44:
+							case 0x47:
+							case 0x55:
+							case 0x57:
+								break;
+							default:
+								triplet->m_reservedData = true;
+						}
+					break;
+				case 0x2d: // DRCS character
+					if ((triplet->m_data & 0x3f) >= 48)
+						// Should really be an error?
+						triplet->m_reservedData = true;
+					break;
+				case 0x21: // G1 mosaic character
+				case 0x22: // G3 mosaic character at level 1.5
+				case 0x29: // G0 character
+				case 0x2b: // G3 mosaic character at level >=2.5
+				case 0x2f: // G2 character
+					if (triplet->m_data < 0x20)
+						triplet->m_reservedData = true;
+					break;
+				default:
+					if (triplet->modeExt() >= 0x30 && triplet->modeExt() <= 0x3f && triplet->m_data < 0x20)
+						// G0 diacritical mark
+						triplet->m_reservedData = true;
+			}
+
+		triplet->m_activePositionRow = activePosition.row();
+		triplet->m_activePositionColumn = activePosition.column();
+	}
+
+	// Now work out where the Active Position goes on a Level 1.5 decoder
+	activePosition.reset();
+
+	for (int i=0; i < m_list.size(); i++) {
+		triplet = &m_list[i];
+
+		if (triplet->modeExt() == 0x1f) // Termination marker
+			break;
+
+		switch (triplet->modeExt()) {
+			case 0x04: // Set Active Position;
+				activePosition.setRow(triplet->addressRow());
+				break;
+			case 0x07: // Address row 0
+				if (triplet->m_address == 63 && activePosition.setRow(0))
+					activePosition.setColumn(8);
+				break;
+			case 0x22: // G3 mosaic character at level 1.5
+			case 0x2f: // G2 character
+				activePosition.setColumn(triplet->addressColumn());
+				break;
+			default:
+				if (triplet->modeExt() >= 0x30 && triplet->modeExt() <= 0x3f)
+					// G0 diacritical mark
+					activePosition.setColumn(triplet->addressColumn());
+		}
+
+		triplet->m_activePositionRow1p5 = activePosition.row();
+		triplet->m_activePositionColumn1p5 = activePosition.column();
+	}
+}
+
+void X26TripletList::append(const X26Triplet &value)
+{
+	m_list.append(value);
+	updateInternalData();
+}
+
+void X26TripletList::insert(int i, const X26Triplet &value)
+{
+	m_list.insert(i, value);
+	updateInternalData();
+}
+
+void X26TripletList::removeAt(int i)
+{
+	m_list.removeAt(i);
+	if (m_list.size() != 0 && i < m_list.size())
+		updateInternalData();
+}
+
+void X26TripletList::replace(int i, const X26Triplet &value)
+{
+	m_list.replace(i, value);
+	updateInternalData();
+}
+
+
+X26TripletList::ActivePosition::ActivePosition()
+{
+	m_row = m_column = -1;
+}
+
+void X26TripletList::ActivePosition::reset()
+{
+	m_row = m_column = -1;
+}
+
+bool X26TripletList::ActivePosition::setRow(int row)
+{
+	if (row < m_row)
+		return false;
+	if (row > m_row) {
+		m_row = row;
+		m_column = -1;
+	}
+	return true;
+}
+
+bool X26TripletList::ActivePosition::setColumn(int column)
+{
+	if (column < m_column)
+		return false;
+	if (m_row == -1 and column >= 0)
+		m_row = 0;
+	m_column = column;
+	return true;
+}
+/*
+bool X26TripletList::ActivePosition::setRowAndColumn(int newRow, int newColumn)
+{
+	if (!setRow(newRow))
+		return false;
+	return setColumn(newColumn);
+}
+*/

src/qteletextdecoder/x26triplets.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef X26TRIPLETS_H
+#define X26TRIPLETS_H
+
+#include <QList>
+
+class X26Triplet
+{
+public:
+	// x26model.h has the Plain English descriptions of these errors
+	enum X26TripletError { NoError, ActivePositionMovedUp, ActivePositionMovedLeft, InvokePointerInvalid, InvokeTypeMismatch, OriginModifierAlone };
+	enum ObjectSource { InvalidObjectSource, LocalObject, POPObject, GPOPObject };
+
+	X26Triplet() {}
+//	X26Triplet(const X26Triplet &other);
+
+//	X26Triplet &operator=(const X26Triplet &other);
+
+	X26Triplet(int address, int mode, int data);
+
+	int address() const { return m_address; }
+	int mode() const { return m_mode; }
+	int modeExt() const { return (m_address >= 40) ? m_mode : (m_mode | 0x20); }
+	int data() const { return m_data; }
+	int addressRow() const { return (m_address == 40) ? 24 :m_address-40; }
+	int addressColumn() const { return (m_address); }
+	bool isRowTriplet() const { return (m_address >= 40); }
+
+	void setAddress(int address);
+	void setMode(int mode);
+	void setData(int data);
+	void setAddressRow(int addressRow);
+	void setAddressColumn(int addressColumn);
+
+	int objectSource() const { return (m_address & 0x18) >> 3; }
+
+	int objectLocalDesignationCode() const { return (((m_address & 0x01) << 3) | (m_data >> 4)); }
+	int objectLocalTripletNumber() const { return m_data & 0x0f; }
+	int objectLocalIndex() const { return objectLocalDesignationCode() * 13 + objectLocalTripletNumber(); }
+	void setObjectLocalDesignationCode(int i);
+	void setObjectLocalTripletNumber(int i);
+	void setObjectLocalIndex(int i);
+
+	int activePositionRow() const { return m_activePositionRow; }
+	int activePositionColumn() const { return m_activePositionColumn; }
+	int activePositionRow1p5() const { return m_activePositionRow1p5; }
+	int activePositionColumn1p5() const { return m_activePositionColumn1p5; }
+	X26TripletError error() const { return m_error; }
+	bool reservedMode() const { return m_reservedMode; }
+	bool reservedData() const { return m_reservedData; }
+
+	friend class X26TripletList;
+
+private:
+	// Only these variables are manipulated by the X26Triplet class
+	int m_address, m_mode, m_data;
+	// and the following are filled in by X26TripletList::updateInternalData()
+	int m_activePositionRow = -1;
+	int m_activePositionColumn = -1;
+	int m_activePositionRow1p5 = -1;
+	int m_activePositionColumn1p5 = -1;
+	X26TripletError m_error = NoError;
+	bool m_reservedMode = false;
+	bool m_reservedData = false;
+};
+
+class X26TripletList
+{
+public:
+	void append(const X26Triplet &value);
+	void insert(int i, const X26Triplet &value);
+	void removeAt(int i);
+	void replace(int i, const X26Triplet &value);
+
+	void removeLast() { m_list.removeLast(); }
+
+	const X26Triplet &at(int i) const { return m_list.at(i); }
+	bool isEmpty() const { return m_list.isEmpty(); }
+	void reserve(int alloc) { m_list.reserve(alloc); }
+	int size() const { return m_list.size(); }
+	const QList<int> &objects(int t) const { return m_objects[t]; };
+
+private:
+	void updateInternalData();
+
+	QList<X26Triplet> m_list;
+	QList<int> m_objects[3];
+
+	class ActivePosition
+	{
+	public:
+		ActivePosition();
+		void reset();
+//		int row() const { return (m_row == -1) ? 0 : m_row; }
+//		int column() const { return (m_column == -1) ? 0 : m_column; }
+		int row() const { return m_row; }
+		int column() const { return m_column; }
+		bool isDeployed() const { return m_row != -1; }
+		bool setRow(int);
+		bool setColumn(int);
+//		bool setRowAndColumn(int, int);
+
+	private:
+		int m_row, m_column;
+	};
+};
+
+#endif

src/qteletextmaker/actionicons.qrc

@@ -0,0 +1,12 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+	<file>images/copy.png</file>
+	<file>images/cut.png</file>
+	<file>images/new.png</file>
+	<file>images/open.png</file>
+	<file>images/redo.png</file>
+	<file>images/paste.png</file>
+	<file>images/save.png</file>
+	<file>images/undo.png</file>
+</qresource>
+</RCC>

src/qteletextmaker/hamming.h

@@ -0,0 +1,262 @@
+#ifndef HAMMING_H
+#define HAMMING_H
+
+// Hamming 8/4 encoding table
+// encoded_value = hamming_8_4_encode[value_to_encode]
+const unsigned char hamming_8_4_encode[16] = {
+	0x15, 0x02, 0x49, 0x5e, 0x64, 0x73, 0x38, 0x2f,
+	0xd0, 0xc7, 0x8c, 0x9b, 0xa1, 0xb6, 0xfd, 0xea
+};
+
+// Hamming 8/4 decoding table
+// decoded_value = hamming_8_4_decode[encoded_value]
+// 0xff - double bit error that can't be corrected
+const unsigned char hamming_8_4_decode[256] = {
+	0x01, 0xff, 0x01, 0x01, 0xff, 0x00, 0x01, 0xff,
+	0xff, 0x02, 0x01, 0xff, 0x0a, 0xff, 0xff, 0x07,
+	0xff, 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0x00,
+	0x06, 0xff, 0xff, 0x0b, 0xff, 0x00, 0x03, 0xff,
+	0xff, 0x0c, 0x01, 0xff, 0x04, 0xff, 0xff, 0x07,
+	0x06, 0xff, 0xff, 0x07, 0xff, 0x07, 0x07, 0x07,
+	0x06, 0xff, 0xff, 0x05, 0xff, 0x00, 0x0d, 0xff,
+	0x06, 0x06, 0x06, 0xff, 0x06, 0xff, 0xff, 0x07,
+	0xff, 0x02, 0x01, 0xff, 0x04, 0xff, 0xff, 0x09,
+	0x02, 0x02, 0xff, 0x02, 0xff, 0x02, 0x03, 0xff,
+	0x08, 0xff, 0xff, 0x05, 0xff, 0x00, 0x03, 0xff,
+	0xff, 0x02, 0x03, 0xff, 0x03, 0xff, 0x03, 0x03,
+	0x04, 0xff, 0xff, 0x05, 0x04, 0x04, 0x04, 0xff,
+	0xff, 0x02, 0x0f, 0xff, 0x04, 0xff, 0xff, 0x07,
+	0xff, 0x05, 0x05, 0x05, 0x04, 0xff, 0xff, 0x05,
+	0x06, 0xff, 0xff, 0x05, 0xff, 0x0e, 0x03, 0xff,
+	0xff, 0x0c, 0x01, 0xff, 0x0a, 0xff, 0xff, 0x09,
+	0x0a, 0xff, 0xff, 0x0b, 0x0a, 0x0a, 0x0a, 0xff,
+	0x08, 0xff, 0xff, 0x0b, 0xff, 0x00, 0x0d, 0xff,
+	0xff, 0x0b, 0x0b, 0x0b, 0x0a, 0xff, 0xff, 0x0b,
+	0x0c, 0x0c, 0xff, 0x0c, 0xff, 0x0c, 0x0d, 0xff,
+	0xff, 0x0c, 0x0f, 0xff, 0x0a, 0xff, 0xff, 0x07,
+	0xff, 0x0c, 0x0d, 0xff, 0x0d, 0xff, 0x0d, 0x0d,
+	0x06, 0xff, 0xff, 0x0b, 0xff, 0x0e, 0x0d, 0xff,
+	0x08, 0xff, 0xff, 0x09, 0xff, 0x09, 0x09, 0x09,
+	0xff, 0x02, 0x0f, 0xff, 0x0a, 0xff, 0xff, 0x09,
+	0x08, 0x08, 0x08, 0xff, 0x08, 0xff, 0xff, 0x09,
+	0x08, 0xff, 0xff, 0x0b, 0xff, 0x0e, 0x03, 0xff,
+	0xff, 0x0c, 0x0f, 0xff, 0x04, 0xff, 0xff, 0x09,
+	0x0f, 0xff, 0x0f, 0x0f, 0xff, 0x0e, 0x0f, 0xff,
+	0x08, 0xff, 0xff, 0x05, 0xff, 0x0e, 0x0d, 0xff,
+	0xff, 0x0e, 0x0f, 0xff, 0x0e, 0x0e, 0xff, 0x0e
+};
+
+const unsigned char hamming_24_18_forward[2][256] = {
+	{
+		0x8b, 0x8c, 0x92, 0x95, 0xa1, 0xa6, 0xb8, 0xbf,
+		0xc0, 0xc7, 0xd9, 0xde, 0xea, 0xed, 0xf3, 0xf4,
+		0x0a, 0x0d, 0x13, 0x14, 0x20, 0x27, 0x39, 0x3e,
+		0x41, 0x46, 0x58, 0x5f, 0x6b, 0x6c, 0x72, 0x75,
+		0x09, 0x0e, 0x10, 0x17, 0x23, 0x24, 0x3a, 0x3d,
+		0x42, 0x45, 0x5b, 0x5c, 0x68, 0x6f, 0x71, 0x76,
+		0x88, 0x8f, 0x91, 0x96, 0xa2, 0xa5, 0xbb, 0xbc,
+		0xc3, 0xc4, 0xda, 0xdd, 0xe9, 0xee, 0xf0, 0xf7,
+		0x08, 0x0f, 0x11, 0x16, 0x22, 0x25, 0x3b, 0x3c,
+		0x43, 0x44, 0x5a, 0x5d, 0x69, 0x6e, 0x70, 0x77,
+		0x89, 0x8e, 0x90, 0x97, 0xa3, 0xa4, 0xba, 0xbd,
+		0xc2, 0xc5, 0xdb, 0xdc, 0xe8, 0xef, 0xf1, 0xf6,
+		0x8a, 0x8d, 0x93, 0x94, 0xa0, 0xa7, 0xb9, 0xbe,
+		0xc1, 0xc6, 0xd8, 0xdf, 0xeb, 0xec, 0xf2, 0xf5,
+		0x0b, 0x0c, 0x12, 0x15, 0x21, 0x26, 0x38, 0x3f,
+		0x40, 0x47, 0x59, 0x5e, 0x6a, 0x6d, 0x73, 0x74,
+		0x03, 0x04, 0x1a, 0x1d, 0x29, 0x2e, 0x30, 0x37,
+		0x48, 0x4f, 0x51, 0x56, 0x62, 0x65, 0x7b, 0x7c,
+		0x82, 0x85, 0x9b, 0x9c, 0xa8, 0xaf, 0xb1, 0xb6,
+		0xc9, 0xce, 0xd0, 0xd7, 0xe3, 0xe4, 0xfa, 0xfd,
+		0x81, 0x86, 0x98, 0x9f, 0xab, 0xac, 0xb2, 0xb5,
+		0xca, 0xcd, 0xd3, 0xd4, 0xe0, 0xe7, 0xf9, 0xfe,
+		0x00, 0x07, 0x19, 0x1e, 0x2a, 0x2d, 0x33, 0x34,
+		0x4b, 0x4c, 0x52, 0x55, 0x61, 0x66, 0x78, 0x7f,
+		0x80, 0x87, 0x99, 0x9e, 0xaa, 0xad, 0xb3, 0xb4,
+		0xcb, 0xcc, 0xd2, 0xd5, 0xe1, 0xe6, 0xf8, 0xff,
+		0x01, 0x06, 0x18, 0x1f, 0x2b, 0x2c, 0x32, 0x35,
+		0x4a, 0x4d, 0x53, 0x54, 0x60, 0x67, 0x79, 0x7e,
+		0x02, 0x05, 0x1b, 0x1c, 0x28, 0x2f, 0x31, 0x36,
+		0x49, 0x4e, 0x50, 0x57, 0x63, 0x64, 0x7a, 0x7d,
+		0x83, 0x84, 0x9a, 0x9d, 0xa9, 0xae, 0xb0, 0xb7,
+		0xc8, 0xcf, 0xd1, 0xd6, 0xe2, 0xe5, 0xfb, 0xfc
+	},
+	{
+		0x00, 0x89, 0x8a, 0x03, 0x8b, 0x02, 0x01, 0x88,
+		0x01, 0x88, 0x8b, 0x02, 0x8a, 0x03, 0x00, 0x89,
+		0x02, 0x8b, 0x88, 0x01, 0x89, 0x00, 0x03, 0x8a,
+		0x03, 0x8a, 0x89, 0x00, 0x88, 0x01, 0x02, 0x8b,
+		0x03, 0x8a, 0x89, 0x00, 0x88, 0x01, 0x02, 0x8b,
+		0x02, 0x8b, 0x88, 0x01, 0x89, 0x00, 0x03, 0x8a,
+		0x01, 0x88, 0x8b, 0x02, 0x8a, 0x03, 0x00, 0x89,
+		0x00, 0x89, 0x8a, 0x03, 0x8b, 0x02, 0x01, 0x88,
+		0x08, 0x81, 0x82, 0x0b, 0x83, 0x0a, 0x09, 0x80,
+		0x09, 0x80, 0x83, 0x0a, 0x82, 0x0b, 0x08, 0x81,
+		0x0a, 0x83, 0x80, 0x09, 0x81, 0x08, 0x0b, 0x82,
+		0x0b, 0x82, 0x81, 0x08, 0x80, 0x09, 0x0a, 0x83,
+		0x0b, 0x82, 0x81, 0x08, 0x80, 0x09, 0x0a, 0x83,
+		0x0a, 0x83, 0x80, 0x09, 0x81, 0x08, 0x0b, 0x82,
+		0x09, 0x80, 0x83, 0x0a, 0x82, 0x0b, 0x08, 0x81,
+		0x08, 0x81, 0x82, 0x0b, 0x83, 0x0a, 0x09, 0x80,
+		0x09, 0x80, 0x83, 0x0a, 0x82, 0x0b, 0x08, 0x81,
+		0x08, 0x81, 0x82, 0x0b, 0x83, 0x0a, 0x09, 0x80,
+		0x0b, 0x82, 0x81, 0x08, 0x80, 0x09, 0x0a, 0x83,
+		0x0a, 0x83, 0x80, 0x09, 0x81, 0x08, 0x0b, 0x82,
+		0x0a, 0x83, 0x80, 0x09, 0x81, 0x08, 0x0b, 0x82,
+		0x0b, 0x82, 0x81, 0x08, 0x80, 0x09, 0x0a, 0x83,
+		0x08, 0x81, 0x82, 0x0b, 0x83, 0x0a, 0x09, 0x80,
+		0x09, 0x80, 0x83, 0x0a, 0x82, 0x0b, 0x08, 0x81,
+		0x01, 0x88, 0x8b, 0x02, 0x8a, 0x03, 0x00, 0x89,
+		0x00, 0x89, 0x8a, 0x03, 0x8b, 0x02, 0x01, 0x88,
+		0x03, 0x8a, 0x89, 0x00, 0x88, 0x01, 0x02, 0x8b,
+		0x02, 0x8b, 0x88, 0x01, 0x89, 0x00, 0x03, 0x8a,
+		0x02, 0x8b, 0x88, 0x01, 0x89, 0x00, 0x03, 0x8a,
+		0x03, 0x8a, 0x89, 0x00, 0x88, 0x01, 0x02, 0x8b,
+		0x00, 0x89, 0x8a, 0x03, 0x8b, 0x02, 0x01, 0x88,
+		0x01, 0x88, 0x8b, 0x02, 0x8a, 0x03, 0x00, 0x89
+	}
+};
+
+const unsigned char hamming_24_18_forward_2[4] = {
+	0x00, 0x0a, 0x0b, 0x01
+};
+
+
+const unsigned char hamming_24_18_parities[3][256] = {
+	{ // Parities of first byte
+		0x00, 0x21, 0x22, 0x03, 0x23, 0x02, 0x01, 0x20, 
+		0x24, 0x05, 0x06, 0x27, 0x07, 0x26, 0x25, 0x04, 
+		0x25, 0x04, 0x07, 0x26, 0x06, 0x27, 0x24, 0x05, 
+		0x01, 0x20, 0x23, 0x02, 0x22, 0x03, 0x00, 0x21, 
+		0x26, 0x07, 0x04, 0x25, 0x05, 0x24, 0x27, 0x06, 
+		0x02, 0x23, 0x20, 0x01, 0x21, 0x00, 0x03, 0x22, 
+		0x03, 0x22, 0x21, 0x00, 0x20, 0x01, 0x02, 0x23, 
+		0x27, 0x06, 0x05, 0x24, 0x04, 0x25, 0x26, 0x07, 
+		0x27, 0x06, 0x05, 0x24, 0x04, 0x25, 0x26, 0x07, 
+		0x03, 0x22, 0x21, 0x00, 0x20, 0x01, 0x02, 0x23, 
+		0x02, 0x23, 0x20, 0x01, 0x21, 0x00, 0x03, 0x22, 
+		0x26, 0x07, 0x04, 0x25, 0x05, 0x24, 0x27, 0x06, 
+		0x01, 0x20, 0x23, 0x02, 0x22, 0x03, 0x00, 0x21, 
+		0x25, 0x04, 0x07, 0x26, 0x06, 0x27, 0x24, 0x05, 
+		0x24, 0x05, 0x06, 0x27, 0x07, 0x26, 0x25, 0x04, 
+		0x00, 0x21, 0x22, 0x03, 0x23, 0x02, 0x01, 0x20, 
+		0x28, 0x09, 0x0a, 0x2b, 0x0b, 0x2a, 0x29, 0x08, 
+		0x0c, 0x2d, 0x2e, 0x0f, 0x2f, 0x0e, 0x0d, 0x2c, 
+		0x0d, 0x2c, 0x2f, 0x0e, 0x2e, 0x0f, 0x0c, 0x2d, 
+		0x29, 0x08, 0x0b, 0x2a, 0x0a, 0x2b, 0x28, 0x09, 
+		0x0e, 0x2f, 0x2c, 0x0d, 0x2d, 0x0c, 0x0f, 0x2e, 
+		0x2a, 0x0b, 0x08, 0x29, 0x09, 0x28, 0x2b, 0x0a, 
+		0x2b, 0x0a, 0x09, 0x28, 0x08, 0x29, 0x2a, 0x0b, 
+		0x0f, 0x2e, 0x2d, 0x0c, 0x2c, 0x0d, 0x0e, 0x2f, 
+		0x0f, 0x2e, 0x2d, 0x0c, 0x2c, 0x0d, 0x0e, 0x2f, 
+		0x2b, 0x0a, 0x09, 0x28, 0x08, 0x29, 0x2a, 0x0b, 
+		0x2a, 0x0b, 0x08, 0x29, 0x09, 0x28, 0x2b, 0x0a, 
+		0x0e, 0x2f, 0x2c, 0x0d, 0x2d, 0x0c, 0x0f, 0x2e, 
+		0x29, 0x08, 0x0b, 0x2a, 0x0a, 0x2b, 0x28, 0x09, 
+		0x0d, 0x2c, 0x2f, 0x0e, 0x2e, 0x0f, 0x0c, 0x2d, 
+		0x0c, 0x2d, 0x2e, 0x0f, 0x2f, 0x0e, 0x0d, 0x2c, 
+		0x28, 0x09, 0x0a, 0x2b, 0x0b, 0x2a, 0x29, 0x08
+	},
+	{ // Parities of second byte
+		0x00, 0x29, 0x2a, 0x03, 0x2b, 0x02, 0x01, 0x28, 
+		0x2c, 0x05, 0x06, 0x2f, 0x07, 0x2e, 0x2d, 0x04, 
+		0x2d, 0x04, 0x07, 0x2e, 0x06, 0x2f, 0x2c, 0x05, 
+		0x01, 0x28, 0x2b, 0x02, 0x2a, 0x03, 0x00, 0x29, 
+		0x2e, 0x07, 0x04, 0x2d, 0x05, 0x2c, 0x2f, 0x06, 
+		0x02, 0x2b, 0x28, 0x01, 0x29, 0x00, 0x03, 0x2a, 
+		0x03, 0x2a, 0x29, 0x00, 0x28, 0x01, 0x02, 0x2b, 
+		0x2f, 0x06, 0x05, 0x2c, 0x04, 0x2d, 0x2e, 0x07, 
+		0x2f, 0x06, 0x05, 0x2c, 0x04, 0x2d, 0x2e, 0x07, 
+		0x03, 0x2a, 0x29, 0x00, 0x28, 0x01, 0x02, 0x2b, 
+		0x02, 0x2b, 0x28, 0x01, 0x29, 0x00, 0x03, 0x2a, 
+		0x2e, 0x07, 0x04, 0x2d, 0x05, 0x2c, 0x2f, 0x06, 
+		0x01, 0x28, 0x2b, 0x02, 0x2a, 0x03, 0x00, 0x29, 
+		0x2d, 0x04, 0x07, 0x2e, 0x06, 0x2f, 0x2c, 0x05, 
+		0x2c, 0x05, 0x06, 0x2f, 0x07, 0x2e, 0x2d, 0x04, 
+		0x00, 0x29, 0x2a, 0x03, 0x2b, 0x02, 0x01, 0x28, 
+		0x30, 0x19, 0x1a, 0x33, 0x1b, 0x32, 0x31, 0x18, 
+		0x1c, 0x35, 0x36, 0x1f, 0x37, 0x1e, 0x1d, 0x34, 
+		0x1d, 0x34, 0x37, 0x1e, 0x36, 0x1f, 0x1c, 0x35, 
+		0x31, 0x18, 0x1b, 0x32, 0x1a, 0x33, 0x30, 0x19, 
+		0x1e, 0x37, 0x34, 0x1d, 0x35, 0x1c, 0x1f, 0x36, 
+		0x32, 0x1b, 0x18, 0x31, 0x19, 0x30, 0x33, 0x1a, 
+		0x33, 0x1a, 0x19, 0x30, 0x18, 0x31, 0x32, 0x1b, 
+		0x1f, 0x36, 0x35, 0x1c, 0x34, 0x1d, 0x1e, 0x37, 
+		0x1f, 0x36, 0x35, 0x1c, 0x34, 0x1d, 0x1e, 0x37, 
+		0x33, 0x1a, 0x19, 0x30, 0x18, 0x31, 0x32, 0x1b, 
+		0x32, 0x1b, 0x18, 0x31, 0x19, 0x30, 0x33, 0x1a, 
+		0x1e, 0x37, 0x34, 0x1d, 0x35, 0x1c, 0x1f, 0x36, 
+		0x31, 0x18, 0x1b, 0x32, 0x1a, 0x33, 0x30, 0x19, 
+		0x1d, 0x34, 0x37, 0x1e, 0x36, 0x1f, 0x1c, 0x35, 
+		0x1c, 0x35, 0x36, 0x1f, 0x37, 0x1e, 0x1d, 0x34, 
+		0x30, 0x19, 0x1a, 0x33, 0x1b, 0x32, 0x31, 0x18
+	},
+	{ // Parities of third byte
+		0x3f, 0x0e, 0x0d, 0x3c, 0x0c, 0x3d, 0x3e, 0x0f, 
+		0x0b, 0x3a, 0x39, 0x08, 0x38, 0x09, 0x0a, 0x3b, 
+		0x0a, 0x3b, 0x38, 0x09, 0x39, 0x08, 0x0b, 0x3a, 
+		0x3e, 0x0f, 0x0c, 0x3d, 0x0d, 0x3c, 0x3f, 0x0e, 
+		0x09, 0x38, 0x3b, 0x0a, 0x3a, 0x0b, 0x08, 0x39, 
+		0x3d, 0x0c, 0x0f, 0x3e, 0x0e, 0x3f, 0x3c, 0x0d, 
+		0x3c, 0x0d, 0x0e, 0x3f, 0x0f, 0x3e, 0x3d, 0x0c, 
+		0x08, 0x39, 0x3a, 0x0b, 0x3b, 0x0a, 0x09, 0x38, 
+		0x08, 0x39, 0x3a, 0x0b, 0x3b, 0x0a, 0x09, 0x38, 
+		0x3c, 0x0d, 0x0e, 0x3f, 0x0f, 0x3e, 0x3d, 0x0c, 
+		0x3d, 0x0c, 0x0f, 0x3e, 0x0e, 0x3f, 0x3c, 0x0d, 
+		0x09, 0x38, 0x3b, 0x0a, 0x3a, 0x0b, 0x08, 0x39, 
+		0x3e, 0x0f, 0x0c, 0x3d, 0x0d, 0x3c, 0x3f, 0x0e, 
+		0x0a, 0x3b, 0x38, 0x09, 0x39, 0x08, 0x0b, 0x3a, 
+		0x0b, 0x3a, 0x39, 0x08, 0x38, 0x09, 0x0a, 0x3b, 
+		0x3f, 0x0e, 0x0d, 0x3c, 0x0c, 0x3d, 0x3e, 0x0f, 
+		0x1f, 0x2e, 0x2d, 0x1c, 0x2c, 0x1d, 0x1e, 0x2f, 
+		0x2b, 0x1a, 0x19, 0x28, 0x18, 0x29, 0x2a, 0x1b, 
+		0x2a, 0x1b, 0x18, 0x29, 0x19, 0x28, 0x2b, 0x1a, 
+		0x1e, 0x2f, 0x2c, 0x1d, 0x2d, 0x1c, 0x1f, 0x2e, 
+		0x29, 0x18, 0x1b, 0x2a, 0x1a, 0x2b, 0x28, 0x19, 
+		0x1d, 0x2c, 0x2f, 0x1e, 0x2e, 0x1f, 0x1c, 0x2d, 
+		0x1c, 0x2d, 0x2e, 0x1f, 0x2f, 0x1e, 0x1d, 0x2c, 
+		0x28, 0x19, 0x1a, 0x2b, 0x1b, 0x2a, 0x29, 0x18, 
+		0x28, 0x19, 0x1a, 0x2b, 0x1b, 0x2a, 0x29, 0x18, 
+		0x1c, 0x2d, 0x2e, 0x1f, 0x2f, 0x1e, 0x1d, 0x2c, 
+		0x1d, 0x2c, 0x2f, 0x1e, 0x2e, 0x1f, 0x1c, 0x2d, 
+		0x29, 0x18, 0x1b, 0x2a, 0x1a, 0x2b, 0x28, 0x19, 
+		0x1e, 0x2f, 0x2c, 0x1d, 0x2d, 0x1c, 0x1f, 0x2e, 
+		0x2a, 0x1b, 0x18, 0x29, 0x19, 0x28, 0x2b, 0x1a, 
+		0x2b, 0x1a, 0x19, 0x28, 0x18, 0x29, 0x2a, 0x1b, 
+		0x1f, 0x2e, 0x2d, 0x1c, 0x2c, 0x1d, 0x1e, 0x2f
+	}
+};
+
+static const unsigned char hamming_24_18_decode_d1_d4[64] = {
+	0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 
+	0x04, 0x05, 0x04, 0x05, 0x06, 0x07, 0x06, 0x07, 
+	0x08, 0x09, 0x08, 0x09, 0x0a, 0x0b, 0x0a, 0x0b, 
+	0x0c, 0x0d, 0x0c, 0x0d, 0x0e, 0x0f, 0x0e, 0x0f, 
+	0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x03, 
+	0x04, 0x05, 0x04, 0x05, 0x06, 0x07, 0x06, 0x07, 
+	0x08, 0x09, 0x08, 0x09, 0x0a, 0x0b, 0x0a, 0x0b, 
+	0x0c, 0x0d, 0x0c, 0x0d, 0x0e, 0x0f, 0x0e, 0x0f
+};
+
+// Mapping from parity checks in hamming_24_18_parities to incorrect bit
+// 0x80000000 - double bit error that can't be corrected
+static const unsigned int hamming_24_18_decode_correct[64] = {
+	0x00000000, 0x80000000, 0x80000000, 0x80000000, 
+	0x80000000, 0x80000000, 0x80000000, 0x80000000, 
+	0x80000000, 0x80000000, 0x80000000, 0x80000000, 
+	0x80000000, 0x80000000, 0x80000000, 0x80000000, 
+	0x80000000, 0x80000000, 0x80000000, 0x80000000, 
+	0x80000000, 0x80000000, 0x80000000, 0x80000000, 
+	0x80000000, 0x80000000, 0x80000000, 0x80000000, 
+	0x80000000, 0x80000000, 0x80000000, 0x80000000, 
+	0x00000000, 0x00000000, 0x00000000, 0x00000001, 
+	0x00000000, 0x00000002, 0x00000004, 0x00000008, 
+	0x00000000, 0x00000010, 0x00000020, 0x00000040, 
+	0x00000080, 0x00000100, 0x00000200, 0x00000400, 
+	0x00000000, 0x00000800, 0x00001000, 0x00002000, 
+	0x00004000, 0x00008000, 0x00010000, 0x00020000, 
+	0x80000000, 0x80000000, 0x80000000, 0x80000000, 
+	0x80000000, 0x80000000, 0x80000000, 0x80000000
+};
+
+#endif

src/qteletextmaker/keymap.h

@@ -0,0 +1,545 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef KEYMAP_H
+#define KEYMAP_H
+
+#include <QMap>
+
+static const QMap<QChar, char> keymapping[24] = {
+	// Only used by X/26 enhancements, not directly by keyboard
+	{ // 0 Latin G0
+	},
+
+	{ // 1 Cyrillic G0 1 Serbian/Croatian
+		{ QChar(0x0427), 0x40 }, // Ч CYRILLIC CAPITAL LETTER CHE
+		{ QChar(0x0410), 0x41 }, // А CYRILLIC CAPITAL LETTER A
+		{ QChar(0x0411), 0x42 }, // Б CYRILLIC CAPITAL LETTER BE
+		{ QChar(0x0426), 0x43 }, // Ц CYRILLIC CAPITAL LETTER TSE
+		{ QChar(0x0414), 0x44 }, // Д CYRILLIC CAPITAL LETTER DE
+		{ QChar(0x0415), 0x45 }, // Е CYRILLIC CAPITAL LETTER IE
+		{ QChar(0x0424), 0x46 }, // Ф CYRILLIC CAPITAL LETTER EF
+		{ QChar(0x0413), 0x47 }, // Г CYRILLIC CAPITAL LETTER GHE
+		{ QChar(0x0425), 0x48 }, // Х CYRILLIC CAPITAL LETTER HA
+		{ QChar(0x0418), 0x49 }, // И CYRILLIC CAPITAL LETTER I
+		{ QChar(0x0408), 0x4a }, // Ј CYRILLIC CAPITAL LETTER JE
+		{ QChar(0x041a), 0x4b }, // К CYRILLIC CAPITAL LETTER KA
+		{ QChar(0x041b), 0x4c }, // Л CYRILLIC CAPITAL LETTER EL
+		{ QChar(0x041c), 0x4d }, // М CYRILLIC CAPITAL LETTER EM
+		{ QChar(0x041d), 0x4e }, // Н CYRILLIC CAPITAL LETTER EN
+		{ QChar(0x041e), 0x4f }, // О CYRILLIC CAPITAL LETTER O
+		{ QChar(0x041f), 0x50 }, // П CYRILLIC CAPITAL LETTER PE
+		{ QChar(0x040c), 0x51 }, // Ќ CYRILLIC CAPITAL LETTER KJE
+		{ QChar(0x0420), 0x52 }, // Р CYRILLIC CAPITAL LETTER ER
+		{ QChar(0x0421), 0x53 }, // С CYRILLIC CAPITAL LETTER ES
+		{ QChar(0x0422), 0x54 }, // Т CYRILLIC CAPITAL LETTER TE
+		{ QChar(0x0423), 0x55 }, // У CYRILLIC CAPITAL LETTER U
+		{ QChar(0x0412), 0x56 }, // В CYRILLIC CAPITAL LETTER VE
+		{ QChar(0x0403), 0x57 }, // Ѓ CYRILLIC CAPITAL LETTER GJE
+		{ QChar(0x0409), 0x58 }, // Љ CYRILLIC CAPITAL LETTER LJE
+		{ QChar(0x040a), 0x59 }, // Њ CYRILLIC CAPITAL LETTER NJE
+		{ QChar(0x0417), 0x5a }, // З CYRILLIC CAPITAL LETTER ZE
+		{ QChar(0x040b), 0x5b }, // Ћ CYRILLIC CAPITAL LETTER TSHE
+		{ QChar(0x0416), 0x5c }, // Ж CYRILLIC CAPITAL LETTER ZHE
+		{ QChar(0x0402), 0x5d }, // Ђ CYRILLIC CAPITAL LETTER DJE
+		{ QChar(0x0428), 0x5e }, // Ш CYRILLIC CAPITAL LETTER SHA
+		{ QChar(0x040f), 0x5f }, // Џ CYRILLIC CAPITAL LETTER DZHE
+		{ QChar(0x0447), 0x60 }, // ч CYRILLIC SMALL LETTER CHE
+		{ QChar(0x0430), 0x61 }, // а CYRILLIC SMALL LETTER A
+		{ QChar(0x0431), 0x62 }, // б CYRILLIC SMALL LETTER BE
+		{ QChar(0x0446), 0x63 }, // ц CYRILLIC SMALL LETTER TSE
+		{ QChar(0x0434), 0x64 }, // д CYRILLIC SMALL LETTER DE
+		{ QChar(0x0435), 0x65 }, // е CYRILLIC SMALL LETTER IE
+		{ QChar(0x0444), 0x66 }, // ф CYRILLIC SMALL LETTER EF
+		{ QChar(0x0433), 0x67 }, // г CYRILLIC SMALL LETTER GHE
+		{ QChar(0x0445), 0x68 }, // х CYRILLIC SMALL LETTER HA
+		{ QChar(0x0438), 0x69 }, // и CYRILLIC SMALL LETTER I
+		{ QChar(0x0458), 0x6a }, // ј CYRILLIC SMALL LETTER JE
+		{ QChar(0x043a), 0x6b }, // к CYRILLIC SMALL LETTER KA
+		{ QChar(0x043b), 0x6c }, // л CYRILLIC SMALL LETTER EL
+		{ QChar(0x043c), 0x6d }, // м CYRILLIC SMALL LETTER EM
+		{ QChar(0x043d), 0x6e }, // н CYRILLIC SMALL LETTER EN
+		{ QChar(0x043e), 0x6f }, // о CYRILLIC SMALL LETTER O
+		{ QChar(0x043f), 0x70 }, // п CYRILLIC SMALL LETTER PE
+		{ QChar(0x045c), 0x71 }, // ќ CYRILLIC SMALL LETTER KJE
+		{ QChar(0x0440), 0x72 }, // р CYRILLIC SMALL LETTER ER
+		{ QChar(0x0441), 0x73 }, // с CYRILLIC SMALL LETTER ES
+		{ QChar(0x0442), 0x74 }, // т CYRILLIC SMALL LETTER TE
+		{ QChar(0x0443), 0x75 }, // у CYRILLIC SMALL LETTER U
+		{ QChar(0x0432), 0x76 }, // в CYRILLIC SMALL LETTER VE
+		{ QChar(0x0453), 0x77 }, // ѓ CYRILLIC SMALL LETTER GJE
+		{ QChar(0x0459), 0x78 }, // љ CYRILLIC SMALL LETTER LJE
+		{ QChar(0x045a), 0x79 }, // њ CYRILLIC SMALL LETTER NJE
+		{ QChar(0x0437), 0x7a }, // з CYRILLIC SMALL LETTER ZE
+		{ QChar(0x045b), 0x7b }, // ћ CYRILLIC SMALL LETTER TSHE
+		{ QChar(0x0436), 0x7c }, // ж CYRILLIC SMALL LETTER ZHE
+		{ QChar(0x0452), 0x7d }, // ђ CYRILLIC SMALL LETTER DJE
+		{ QChar(0x0448), 0x7e }  // ш CYRILLIC SMALL LETTER SHA
+	},
+
+	{ // 2 Cyrillic G0 2 Russian/Bulgarian
+		{ QChar(0x044b), 0x26 }, // ы CYRILLIC SMALL LETTER YERU
+		{ QChar(0x042e), 0x40 }, // Ю CYRILLIC CAPITAL LETTER YU
+		{ QChar(0x0410), 0x41 }, // А CYRILLIC CAPITAL LETTER A
+		{ QChar(0x0411), 0x42 }, // Б CYRILLIC CAPITAL LETTER BE
+		{ QChar(0x0426), 0x43 }, // Ц CYRILLIC CAPITAL LETTER TSE
+		{ QChar(0x0414), 0x44 }, // Д CYRILLIC CAPITAL LETTER DE
+		{ QChar(0x0415), 0x45 }, // Е CYRILLIC CAPITAL LETTER IE
+		{ QChar(0x0424), 0x46 }, // Ф CYRILLIC CAPITAL LETTER EF
+		{ QChar(0x0413), 0x47 }, // Г CYRILLIC CAPITAL LETTER GHE
+		{ QChar(0x0425), 0x48 }, // Х CYRILLIC CAPITAL LETTER HA
+		{ QChar(0x0418), 0x49 }, // И CYRILLIC CAPITAL LETTER I
+		{ QChar(0x0419), 0x4a }, // Й CYRILLIC CAPITAL LETTER SHORT I
+		{ QChar(0x041a), 0x4b }, // К CYRILLIC CAPITAL LETTER KA
+		{ QChar(0x041b), 0x4c }, // Л CYRILLIC CAPITAL LETTER EL
+		{ QChar(0x041c), 0x4d }, // М CYRILLIC CAPITAL LETTER EM
+		{ QChar(0x041d), 0x4e }, // Н CYRILLIC CAPITAL LETTER EN
+		{ QChar(0x041e), 0x4f }, // О CYRILLIC CAPITAL LETTER O
+		{ QChar(0x041f), 0x50 }, // П CYRILLIC CAPITAL LETTER PE
+		{ QChar(0x042f), 0x51 }, // Я CYRILLIC CAPITAL LETTER YA
+		{ QChar(0x0420), 0x52 }, // Р CYRILLIC CAPITAL LETTER ER
+		{ QChar(0x0421), 0x53 }, // С CYRILLIC CAPITAL LETTER ES
+		{ QChar(0x0422), 0x54 }, // Т CYRILLIC CAPITAL LETTER TE
+		{ QChar(0x0423), 0x55 }, // У CYRILLIC CAPITAL LETTER U
+		{ QChar(0x0416), 0x56 }, // Ж CYRILLIC CAPITAL LETTER ZHE
+		{ QChar(0x0412), 0x57 }, // В CYRILLIC CAPITAL LETTER VE
+		{ QChar(0x042c), 0x58 }, // Ь CYRILLIC CAPITAL LETTER SOFT SIGN
+		{ QChar(0x042a), 0x59 }, // Ъ CYRILLIC CAPITAL LETTER HARD SIGN
+		{ QChar(0x0417), 0x5a }, // З CYRILLIC CAPITAL LETTER ZE
+		{ QChar(0x0428), 0x5b }, // Ш CYRILLIC CAPITAL LETTER SHA
+		{ QChar(0x042d), 0x5c }, // Э CYRILLIC CAPITAL LETTER E
+		{ QChar(0x0429), 0x5d }, // Щ CYRILLIC CAPITAL LETTER SHCHA
+		{ QChar(0x0427), 0x5e }, // Ч CYRILLIC CAPITAL LETTER CHE
+		{ QChar(0x042b), 0x5f }, // Ы CYRILLIC CAPITAL LETTER YERU
+		{ QChar(0x044e), 0x60 }, // ю CYRILLIC SMALL LETTER YU
+		{ QChar(0x0430), 0x61 }, // а CYRILLIC SMALL LETTER A
+		{ QChar(0x0431), 0x62 }, // б CYRILLIC SMALL LETTER BE
+		{ QChar(0x0446), 0x63 }, // ц CYRILLIC SMALL LETTER TSE
+		{ QChar(0x0434), 0x64 }, // д CYRILLIC SMALL LETTER DE
+		{ QChar(0x0435), 0x65 }, // е CYRILLIC SMALL LETTER IE
+		{ QChar(0x0444), 0x66 }, // ф CYRILLIC SMALL LETTER EF
+		{ QChar(0x0433), 0x67 }, // г CYRILLIC SMALL LETTER GHE
+		{ QChar(0x0445), 0x68 }, // х CYRILLIC SMALL LETTER HA
+		{ QChar(0x0438), 0x69 }, // и CYRILLIC SMALL LETTER I
+		{ QChar(0x0439), 0x6a }, // й CYRILLIC SMALL LETTER SHORT I
+		{ QChar(0x043a), 0x6b }, // к CYRILLIC SMALL LETTER KA
+		{ QChar(0x043b), 0x6c }, // л CYRILLIC SMALL LETTER EL
+		{ QChar(0x043c), 0x6d }, // м CYRILLIC SMALL LETTER EM
+		{ QChar(0x043d), 0x6e }, // н CYRILLIC SMALL LETTER EN
+		{ QChar(0x043e), 0x6f }, // о CYRILLIC SMALL LETTER O
+		{ QChar(0x043f), 0x70 }, // п CYRILLIC SMALL LETTER PE
+		{ QChar(0x044f), 0x71 }, // я CYRILLIC SMALL LETTER YA
+		{ QChar(0x0440), 0x72 }, // р CYRILLIC SMALL LETTER ER
+		{ QChar(0x0441), 0x73 }, // с CYRILLIC SMALL LETTER ES
+		{ QChar(0x0442), 0x74 }, // т CYRILLIC SMALL LETTER TE
+		{ QChar(0x0443), 0x75 }, // у CYRILLIC SMALL LETTER U
+		{ QChar(0x0436), 0x76 }, // ж CYRILLIC SMALL LETTER ZHE
+		{ QChar(0x0432), 0x77 }, // в CYRILLIC SMALL LETTER VE
+		{ QChar(0x044c), 0x78 }, // ь CYRILLIC SMALL LETTER SOFT SIGN
+		{ QChar(0x044a), 0x79 }, // ъ CYRILLIC SMALL LETTER HARD SIGN
+		{ QChar(0x0437), 0x7a }, // з CYRILLIC SMALL LETTER ZE
+		{ QChar(0x0448), 0x7b }, // ш CYRILLIC SMALL LETTER SHA
+		{ QChar(0x044d), 0x7c }, // э CYRILLIC SMALL LETTER E
+		{ QChar(0x0449), 0x7d }, // щ CYRILLIC SMALL LETTER SHCHA
+		{ QChar(0x0447), 0x7e }  // ч CYRILLIC SMALL LETTER CHE
+	},
+
+	{ // 3 Cyrillic G0 3 Ukranian
+		{ QChar(0x0457), 0x26 }, // ї CYRILLIC SMALL LETTER YI
+		{ QChar(0x042e), 0x40 }, // Ю CYRILLIC CAPITAL LETTER YU
+		{ QChar(0x0410), 0x41 }, // А CYRILLIC CAPITAL LETTER A
+		{ QChar(0x0411), 0x42 }, // Б CYRILLIC CAPITAL LETTER BE
+		{ QChar(0x0426), 0x43 }, // Ц CYRILLIC CAPITAL LETTER TSE
+		{ QChar(0x0414), 0x44 }, // Д CYRILLIC CAPITAL LETTER DE
+		{ QChar(0x0415), 0x45 }, // Е CYRILLIC CAPITAL LETTER IE
+		{ QChar(0x0424), 0x46 }, // Ф CYRILLIC CAPITAL LETTER EF
+		{ QChar(0x0413), 0x47 }, // Г CYRILLIC CAPITAL LETTER GHE
+		{ QChar(0x0425), 0x48 }, // Х CYRILLIC CAPITAL LETTER HA
+		{ QChar(0x0418), 0x49 }, // И CYRILLIC CAPITAL LETTER I
+		{ QChar(0x0419), 0x4a }, // Й CYRILLIC CAPITAL LETTER SHORT I
+		{ QChar(0x041a), 0x4b }, // К CYRILLIC CAPITAL LETTER KA
+		{ QChar(0x041b), 0x4c }, // Л CYRILLIC CAPITAL LETTER EL
+		{ QChar(0x041c), 0x4d }, // М CYRILLIC CAPITAL LETTER EM
+		{ QChar(0x041d), 0x4e }, // Н CYRILLIC CAPITAL LETTER EN
+		{ QChar(0x041e), 0x4f }, // О CYRILLIC CAPITAL LETTER O
+		{ QChar(0x041f), 0x50 }, // П CYRILLIC CAPITAL LETTER PE
+		{ QChar(0x042f), 0x51 }, // Я CYRILLIC CAPITAL LETTER YA
+		{ QChar(0x0420), 0x52 }, // Р CYRILLIC CAPITAL LETTER ER
+		{ QChar(0x0421), 0x53 }, // С CYRILLIC CAPITAL LETTER ES
+		{ QChar(0x0422), 0x54 }, // Т CYRILLIC CAPITAL LETTER TE
+		{ QChar(0x0423), 0x55 }, // У CYRILLIC CAPITAL LETTER U
+		{ QChar(0x0416), 0x56 }, // Ж CYRILLIC CAPITAL LETTER ZHE
+		{ QChar(0x0412), 0x57 }, // В CYRILLIC CAPITAL LETTER VE
+		{ QChar(0x042c), 0x58 }, // Ь CYRILLIC CAPITAL LETTER SOFT SIGN
+		{ QChar(0x0406), 0x59 }, // І CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I
+		{ QChar(0x0417), 0x5a }, // З CYRILLIC CAPITAL LETTER ZE
+		{ QChar(0x0428), 0x5b }, // Ш CYRILLIC CAPITAL LETTER SHA
+		{ QChar(0x0404), 0x5c }, // Є CYRILLIC CAPITAL LETTER UKRAINIAN IE
+		{ QChar(0x0429), 0x5d }, // Щ CYRILLIC CAPITAL LETTER SHCHA
+		{ QChar(0x0427), 0x5e }, // Ч CYRILLIC CAPITAL LETTER CHE
+		{ QChar(0x0407), 0x5f }, // Ї CYRILLIC CAPITAL LETTER YI
+		{ QChar(0x044e), 0x60 }, // ю CYRILLIC SMALL LETTER YU
+		{ QChar(0x0430), 0x61 }, // а CYRILLIC SMALL LETTER A
+		{ QChar(0x0431), 0x62 }, // б CYRILLIC SMALL LETTER BE
+		{ QChar(0x0446), 0x63 }, // ц CYRILLIC SMALL LETTER TSE
+		{ QChar(0x0434), 0x64 }, // д CYRILLIC SMALL LETTER DE
+		{ QChar(0x0435), 0x65 }, // е CYRILLIC SMALL LETTER IE
+		{ QChar(0x0444), 0x66 }, // ф CYRILLIC SMALL LETTER EF
+		{ QChar(0x0433), 0x67 }, // г CYRILLIC SMALL LETTER GHE
+		{ QChar(0x0445), 0x68 }, // х CYRILLIC SMALL LETTER HA
+		{ QChar(0x0438), 0x69 }, // и CYRILLIC SMALL LETTER I
+		{ QChar(0x0439), 0x6a }, // й CYRILLIC SMALL LETTER SHORT I
+		{ QChar(0x043a), 0x6b }, // к CYRILLIC SMALL LETTER KA
+		{ QChar(0x043b), 0x6c }, // л CYRILLIC SMALL LETTER EL
+		{ QChar(0x043c), 0x6d }, // м CYRILLIC SMALL LETTER EM
+		{ QChar(0x043d), 0x6e }, // н CYRILLIC SMALL LETTER EN
+		{ QChar(0x043e), 0x6f }, // о CYRILLIC SMALL LETTER O
+		{ QChar(0x043f), 0x70 }, // п CYRILLIC SMALL LETTER PE
+		{ QChar(0x044f), 0x71 }, // я CYRILLIC SMALL LETTER YA
+		{ QChar(0x0440), 0x72 }, // р CYRILLIC SMALL LETTER ER
+		{ QChar(0x0441), 0x73 }, // с CYRILLIC SMALL LETTER ES
+		{ QChar(0x0442), 0x74 }, // т CYRILLIC SMALL LETTER TE
+		{ QChar(0x0443), 0x75 }, // у CYRILLIC SMALL LETTER U
+		{ QChar(0x0436), 0x76 }, // ж CYRILLIC SMALL LETTER ZHE
+		{ QChar(0x0432), 0x77 }, // в CYRILLIC SMALL LETTER VE
+		{ QChar(0x044c), 0x78 }, // ь CYRILLIC SMALL LETTER SOFT SIGN
+		{ QChar(0x0456), 0x79 }, // і CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+		{ QChar(0x0437), 0x7a }, // з CYRILLIC SMALL LETTER ZE
+		{ QChar(0x0448), 0x7b }, // ш CYRILLIC SMALL LETTER SHA
+		{ QChar(0x0454), 0x7c }, // є CYRILLIC SMALL LETTER UKRAINIAN IE
+		{ QChar(0x0449), 0x7d }, // щ CYRILLIC SMALL LETTER SHCHA
+		{ QChar(0x0447), 0x7e }  // ч CYRILLIC SMALL LETTER CHE
+	},
+
+	{ // 4 Greek
+		{ QChar(0x0390), 0x40 }, // ΐ GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
+		{ QChar(0x0391), 0x41 }, // Α GREEK CAPITAL LETTER ALPHA
+		{ QChar(0x0392), 0x42 }, // Β GREEK CAPITAL LETTER BETA
+		{ QChar(0x0393), 0x43 }, // Γ GREEK CAPITAL LETTER GAMMA
+		{ QChar(0x0394), 0x44 }, // Δ GREEK CAPITAL LETTER DELTA
+		{ QChar(0x0395), 0x45 }, // Ε GREEK CAPITAL LETTER EPSILON
+		{ QChar(0x0396), 0x46 }, // Ζ GREEK CAPITAL LETTER ZETA
+		{ QChar(0x0397), 0x47 }, // Η GREEK CAPITAL LETTER ETA
+		{ QChar(0x0398), 0x48 }, // Θ GREEK CAPITAL LETTER THETA
+		{ QChar(0x0399), 0x49 }, // Ι GREEK CAPITAL LETTER IOTA
+		{ QChar(0x039a), 0x4a }, // Κ GREEK CAPITAL LETTER KAPPA
+		{ QChar(0x039b), 0x4b }, // Λ GREEK CAPITAL LETTER LAMBDA
+		{ QChar(0x039c), 0x4c }, // Μ GREEK CAPITAL LETTER MU
+		{ QChar(0x039d), 0x4d }, // Ν GREEK CAPITAL LETTER NU
+		{ QChar(0x039e), 0x4e }, // Ξ GREEK CAPITAL LETTER XI
+		{ QChar(0x039f), 0x4f }, // Ο GREEK CAPITAL LETTER OMICRON
+		{ QChar(0x03a0), 0x50 }, // Π GREEK CAPITAL LETTER PI
+		{ QChar(0x03a1), 0x51 }, // Ρ GREEK CAPITAL LETTER RHO
+		{ QChar(0x03a3), 0x53 }, // Σ GREEK CAPITAL LETTER SIGMA
+		{ QChar(0x03a4), 0x54 }, // Τ GREEK CAPITAL LETTER TAU
+		{ QChar(0x03a5), 0x55 }, // Υ GREEK CAPITAL LETTER UPSILON
+		{ QChar(0x03a6), 0x56 }, // Φ GREEK CAPITAL LETTER PHI
+		{ QChar(0x03a7), 0x57 }, // Χ GREEK CAPITAL LETTER CHI
+		{ QChar(0x03a8), 0x58 }, // Ψ GREEK CAPITAL LETTER PSI
+		{ QChar(0x03a9), 0x59 }, // Ω GREEK CAPITAL LETTER OMEGA
+		{ QChar(0x03aa), 0x5a }, // Ϊ GREEK CAPITAL LETTER IOTA WITH DIALYTIKA
+		{ QChar(0x03ab), 0x5b }, // Ϋ GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA
+		{ QChar(0x03ac), 0x5c }, // ά GREEK SMALL LETTER ALPHA WITH TONOS
+		{ QChar(0x03ad), 0x5d }, // έ GREEK SMALL LETTER EPSILON WITH TONOS
+		{ QChar(0x03ae), 0x5e }, // ή GREEK SMALL LETTER ETA WITH TONOS
+		{ QChar(0x03af), 0x5f }, // ί GREEK SMALL LETTER IOTO WITH TONOS
+		{ QChar(0x03b0), 0x60 }, // ΰ GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
+		{ QChar(0x03b1), 0x61 }, // α GREEK SMALL LETTER ALPHA
+		{ QChar(0x03b2), 0x62 }, // β GREEK SMALL LETTER BETA
+		{ QChar(0x03b3), 0x63 }, // γ GREEK SMALL LETTER GAMMA
+		{ QChar(0x03b4), 0x64 }, // δ GREEK SMALL LETTER DELTA
+		{ QChar(0x03b5), 0x65 }, // ε GREEK SMALL LETTER EPSILON
+		{ QChar(0x03b6), 0x66 }, // ζ GREEK SMALL LETTER ZETA
+		{ QChar(0x03b7), 0x67 }, // η GREEK SMALL LETTER ETA
+		{ QChar(0x03b8), 0x68 }, // θ GREEK SMALL LETTER THETA
+		{ QChar(0x03b9), 0x69 }, // ι GREEK SMALL LETTER IOTA
+		{ QChar(0x03ba), 0x6a }, // κ GREEK SMALL LETTER KAPPA
+		{ QChar(0x03bb), 0x6b }, // λ GREEK SMALL LETTER LAMBDA
+		{ QChar(0x03bc), 0x6c }, // μ GREEK SMALL LETTER MU
+		{ QChar(0x03bd), 0x6d }, // ν GREEK SMALL LETTER NU
+		{ QChar(0x03be), 0x6e }, // ξ GREEK SMALL LETTER XI
+		{ QChar(0x03bf), 0x6f }, // ο GREEK SMALL LETTER OMICRON
+		{ QChar(0x03c0), 0x70 }, // π GREEK SMALL LETTER PI
+		{ QChar(0x03c1), 0x71 }, // ρ GREEK SMALL LETTER RHO
+		{ QChar(0x03c2), 0x72 }, // ς GREEK SMALL LETTER FINAL SIGMA
+		{ QChar(0x03c3), 0x73 }, // σ GREEK SMALL LETTER SIGMA
+		{ QChar(0x03c4), 0x74 }, // τ GREEK SMALL LETTER TAU
+		{ QChar(0x03c5), 0x75 }, // υ GREEK SMALL LETTER UPSILON
+		{ QChar(0x03c6), 0x76 }, // φ GREEK SMALL LETTER PHI
+		{ QChar(0x03c7), 0x77 }, // χ GREEK SMALL LETTER CHI
+		{ QChar(0x03c8), 0x78 }, // ψ GREEK SMALL LETTER PSI
+		{ QChar(0x03c9), 0x79 }, // ω GREEK SMALL LETTER OMEGA
+		{ QChar(0x03ca), 0x7a }, // ϊ GREEK SMALL LETTER IOTA WITH DIALYTIKA
+		{ QChar(0x03cb), 0x7b }, // ϋ GREEK SMALL LETTER UPSILON WITH DIALYTIKA
+		{ QChar(0x03cc), 0x7c }, // ό GREEK SMALL LETTER OMICRON WITH TONOS
+		{ QChar(0x03cd), 0x7d }, // ύ GREEK SMALL LETTER UPSILON WITH TONOS
+		{ QChar(0x03ce), 0x7e }  // ώ GREEK SMALL LETTER OMEGA WITH TONOS
+	},
+
+	{ // TODO 5 Arabic G0
+	},
+
+	{ // 6 Hebrew G0
+		{ QChar(0x05d0), 0x60 }, // א HEBREW LETTER ALEF
+		{ QChar(0x05d1), 0x61 }, // ב HEBREW LETTER BET
+		{ QChar(0x05d2), 0x62 }, // ג HEBREW LETTER GIMEL
+		{ QChar(0x05d3), 0x63 }, // ד HEBREW LETTER DALET
+		{ QChar(0x05d4), 0x64 }, // ה HEBREW LETTER HE
+		{ QChar(0x05d5), 0x65 }, // ו HEBREW LETTER VAV
+		{ QChar(0x05d6), 0x66 }, // ז HEBREW LETTER ZAYIN
+		{ QChar(0x05d7), 0x67 }, // ח HEBREW LETTER HET
+		{ QChar(0x05d8), 0x68 }, // ט HEBREW LETTER TET
+		{ QChar(0x05d9), 0x69 }, // י HEBREW LETTER YOD
+		{ QChar(0x05da), 0x6a }, // ך HEBREW LETTER FINAL KAF
+		{ QChar(0x05db), 0x6b }, // כ HEBREW LETTER KAF
+		{ QChar(0x05dc), 0x6c }, // ל HEBREW LETTER LAMED
+		{ QChar(0x05dd), 0x6d }, // ם HEBREW LETTER FINAL MEM
+		{ QChar(0x05de), 0x6e }, // מ HEBREW LETTER MEM
+		{ QChar(0x05df), 0x6f }, // ן HEBREW LETTER FINAL NUN
+		{ QChar(0x05e0), 0x70 }, // נ HEBREW LETTER NUN
+		{ QChar(0x05e1), 0x71 }, // ס HEBREW LETTER SAMEKH
+		{ QChar(0x05e2), 0x72 }, // ע HEBREW LETTER AYIN
+		{ QChar(0x05e3), 0x73 }, // ף HEBREW LETTER FINAL PE
+		{ QChar(0x05e4), 0x74 }, // פ HEBREW LETTER PE
+		{ QChar(0x05e5), 0x75 }, // ץ HEBREW LETTER FINAL TSADI
+		{ QChar(0x05e6), 0x76 }, // צ HEBREW LETTER TSADI
+		{ QChar(0x05e7), 0x77 }, // ק HEBREW LETTER QOF
+		{ QChar(0x05e8), 0x78 }, // ר HEBREW LETTER RESH
+		{ QChar(0x05e9), 0x79 }, // ש HEBREW LETTER SHIN
+		{ QChar(0x05ea), 0x7a }, // ת HEBREW LETTER TAV
+		{ QChar(0x20aa), 0x7b }, // ₪ NEW SHEQEL SIGN
+		{ QChar(0x00be), 0x7d }, // ½ VULGAR FRACTION THREE QUARTERS
+		{ QChar(0x00f7), 0x7e }  // ÷ DIVISION SIGN
+	},
+
+	// Only used by X/26 enhancements, not directly by keyboard
+	{ // 7 Latin G2
+	},
+	{ // 8 Cyrillic G2
+	},
+	{ // 9 Greek G2
+	},
+	{ // 10 Arabic G2
+	},
+
+	{ // 11 Czech/Slovak
+		{ QChar(0x016f), 0x24 }, // ů LATIN SMALL LETTER U WITH RING ABOVE
+		{ QChar(0x010d), 0x40 }, // č LATIN SMALL LETTER C WITH CARON
+		{ QChar(0x0165), 0x5b }, // ť LATIN SMALL LETTER T WITH CARON
+		{ QChar(0x017e), 0x5c }, // ž LATIN SMALL LETTER Z WITH CARON
+		{ QChar(0x00fd), 0x5d }, // ý LATIN SMALL LETTER Y WITH ACUTE
+		{ QChar(0x00ed), 0x5e }, // í LATIN SMALL LETTER I WITH ACUTE
+		{ QChar(0x0159), 0x5f }, // ř LATIN SMALL LETTER R WITH CARON
+		{ QChar(0x00e9), 0x60 }, // é LATIN SMALL LETTER E WITH ACUTE
+		{ QChar(0x00e1), 0x7b }, // á LATIN SMALL LETTER A WITH ACUTE
+		{ QChar(0x011b), 0x7c }, // ě LATIN SMALL LETTER E WITH CARON
+		{ QChar(0x00fa), 0x7d }, // ú LATIN SMALL LETTER U WITH ACUTE
+		{ QChar(0x0161), 0x7e }  // š LATIN SMALL LETTER S WITH CARON
+	},
+
+	{ // 12 English
+		{ QChar(0x00a3), 0x23 }, // £ POUND SIGN
+		{ QChar(0x0023), 0x5f }, // # NUMBER SIGN
+		{ QChar(0x005f), 0x60 }, // ─ LOW LINE - rendered as U+2500 BOX DRAWINGS LIGHT HORIZONTAL
+
+		{ QChar(0x00bc), 0x7b }, // ¼ VULGAR FRACTION ONE QUARTER
+		{ QChar(0x00bd), 0x5c }, // ½ VULGAR FRACTION ONE HALF
+		{ QChar(0x00be), 0x7b }, // ¾ VULGAR FRACTION THREE QUARTERS
+		{ QChar(0x00f7), 0x7e }  // ÷ DIVISION SIGN
+	},
+
+	{ // 13 Estonian
+		{ QChar(0x00f5), 0x24 }, // õ LATIN SMALL LETTER O WITH TILDE
+		{ QChar(0x0160), 0x40 }, // Š LATIN CAPITAL LETTER S WITH CARON
+		{ QChar(0x00c4), 0x5b }, // Ä LATIN CAPITAL LETTER A WITH DIAERESIS
+		{ QChar(0x00d6), 0x5c }, // Ö LATIN CAPITAL LETTER O WITH DIAERESIS
+		{ QChar(0x017d), 0x5d }, // Ž LATIN CAPITAL LETTER Z WITH CARON
+		{ QChar(0x00dc), 0x5e }, // Ü LATIN CAPITAL LETTER U WITH DIAERESIS
+		{ QChar(0x00d5), 0x5f }, // Õ LATIN CAPITAL LETTER O WITH TILDE
+		{ QChar(0x0161), 0x60 }, // š LATIN SMALL LETTER S WITH CARON
+		{ QChar(0x00e4), 0x7b }, // ä LATIN SMALL LETTER A WITH DIAERESIS
+		{ QChar(0x00f6), 0x7c }, // ö LATIN SMALL LETTER O WITH DIAERESIS
+		{ QChar(0x017e), 0x7d }, // ž LATIN SMALL LETTER Z WITH CARON
+		{ QChar(0x00fc), 0x7e }  // ü LATIN SMALL LETTER U WITH DIAERESIS
+	},
+
+	{ // 14 French - aze qsd wxc
+		{ QChar(0x00e9), 0x23 }, // é LATIN SMALL LETTER E WITH ACUTE
+		{ QChar(0x00ef), 0x24 }, // ï LATIN SMALL LETTER I WITH DIAERESIS
+		{ QChar(0x00e0), 0x40 }, // à LATIN SMALL LETTER A WITH GRAVE
+		{ QChar(0x00eb), 0x5b }, // ë LATIN SMALL LETTER E WITH DIAERESIS
+		{ QChar(0x00ea), 0x5c }, // ê LATIN SMALL LETTER E WITH CIRCUMFLEX
+		{ QChar(0x00f9), 0x5d }, // ù LATIN SMALL LETTER U WITH GRAVE
+		{ QChar(0x00ee), 0x5e }, // î LATIN SMALL LETTER I WITH CIRCUMFLEX
+		{ QChar(0x0023), 0x5f }, // # NUMBER SIGN
+		{ QChar(0x00e8), 0x60 }, // è LATIN SMALL LETTER E WITH GRAVE
+		{ QChar(0x00e2), 0x7b }, // â LATIN SMALL LETTER A WITH CIRCUMFLEX
+		{ QChar(0x00f4), 0x7c }, // ô LATIN SMALL LETTER O WITH CIRCUMFLEX
+		{ QChar(0x00fb), 0x7d }, // û LATIN SMALL LETTER U WITH CIRCUMFLEX
+		{ QChar(0x00e7), 0x7e }  // ç LATIN SMALL LETTER C WITH CEDILLA
+	},
+
+	{ // 15 German
+		{ QChar(0x00a7), 0x40 }, // § SECTION SIGN
+		{ QChar(0x00c4), 0x5b }, // Ä LATIN CAPITAL LETTER A WITH DIAERESIS
+		{ QChar(0x00d6), 0x5c }, // Ö LATIN CAPITAL LETTER O WITH DIAERESIS
+		{ QChar(0x00dc), 0x5d }, // Ü LATIN CAPITAL LETTER U WITH DIAERESIS
+		{ QChar(0x00b0), 0x60 }, // ° DEGREE SIGN
+		{ QChar(0x00e4), 0x7b }, // ä LATIN SMALL LETTER A WITH DIAERESIS
+		{ QChar(0x00f6), 0x7c }, // ö LATIN SMALL LETTER O WITH DIAERESIS
+		{ QChar(0x00fc), 0x7d }, // ü LATIN SMALL LETTER U WITH DIAERESIS
+		{ QChar(0x00df), 0x7e }  // ß LATIN SMALL LETTER SHARP S
+	},
+
+	{ // 16 Italian
+		{ QChar(0x00a3), 0x23 }, // £ POUND SIGN
+		{ QChar(0x00e9), 0x40 }, // é LATIN SMALL LETTER E WITH ACUTE
+		{ QChar(0x00b0), 0x5b }, // ° DEGREE SIGN
+		{ QChar(0x00e7), 0x5c }, // ç LATIN SMALL LETTER C WITH CEDILLA
+		{ QChar(0x0023), 0x5f }, // # NUMBER SIGN
+		{ QChar(0x00f9), 0x60 }, // ù LATIN SMALL LETTER U WITH GRAVE
+		{ QChar(0x00e0), 0x7b }, // à LATIN SMALL LETTER A WITH GRAVE
+		{ QChar(0x00f2), 0x7c }, // ò LATIN SMALL LETTER O WITH GRAVE
+		{ QChar(0x00e8), 0x7d }, // è LATIN SMALL LETTER E WITH GRAVE
+		{ QChar(0x00ec), 0x7e }  // ì LATIN SMALL LETTER I WITH GRAVE
+	},
+
+	{ // 17 Lettish/Lithuanian
+		{ QChar(0x0160), 0x40 }, // Š LATIN CAPITAL LETTER S WITH CARON
+		{ QChar(0x0117), 0x5b }, // ė LATIN SMALL LETTER E WITH DOT ABOVE
+		{ QChar(0x0119), 0x5c }, // ę LATIN SMALL LETTER E WITH OGONEK
+		{ QChar(0x017d), 0x5d }, // Ž LATIN CAPITAL LETTER Z WITH CARON
+		{ QChar(0x010d), 0x5e }, // č LATIN SMALL LETTER C WITH CARON
+		{ QChar(0x016b), 0x5f }, // ū LATIN SMALL LETTER U WITH MACRON
+		{ QChar(0x0161), 0x60 }, // š LATIN SMALL LETTER S WITH CARON
+		{ QChar(0x0105), 0x7b }, // ą LATIN SMALL LETTER A WITH OGONEK
+		{ QChar(0x0173), 0x7c }, // ų LATIN SMALL LETTER U WITH OGONEK
+		{ QChar(0x017e), 0x7d }, // ž LATIN SMALL LETTER Z WITH CARON
+		{ QChar(0x012f), 0x7e }  // į LATIN SMALL LETTER I WITH OGONEK
+	},
+
+	{ // 18 Polish
+		{ QChar(0x0144), 0x24 }, // ń LATIN SMALL LETTER N WITH ACUTE
+		{ QChar(0x0105), 0x40 }, // ą LATIN SMALL LETTER A WITH OGONEK
+		{ QChar(0x017b), 0x5b }, // Ż LATIN CAPITAL LETTER Z WITH DOT ABOVE - rendered as U+01B5 ...WITH STROKE
+		{ QChar(0x015a), 0x5c }, // Ś LATIN CAPITAL LETTER S WITH ACUTE
+		{ QChar(0x0141), 0x5d }, // Ł LATIN CAPITAL LETTER L WITH STROKE
+		{ QChar(0x0107), 0x5e }, // ć LATIN SMALL LETTER C WITH ACUTE
+		{ QChar(0x00f3), 0x5f }, // ó LATIN SMALL LETTER O WITH ACUTE
+		{ QChar(0x0119), 0x60 }, // ę LATIN SMALL LETTER E WITH OGONEK
+		{ QChar(0x017c), 0x7b }, // ż LATIN SMALL LETTER Z WITH DOT ABOVE
+		{ QChar(0x015b), 0x7c }, // ś LATIN SMALL LETTER S WITH ACUTE
+		{ QChar(0x0142), 0x7d }, // ł LATIN SMALL LETTER L WITH STROKE
+		{ QChar(0x017a), 0x7e }  // ź LATIN SMALL LETTER Z WITH ACUTE
+	},
+
+	{ // 19 Portuguese/Spanish
+		{ QChar(0x00e7), 0x23 }, // ç LATIN SMALL LETTER C WITH CEDILLA
+		{ QChar(0x00a1), 0x40 }, // ¡ INVERTED EXCLAMATION MARK
+		{ QChar(0x00e1), 0x5b }, // á LATIN SMALL LETTER A WITH ACUTE
+		{ QChar(0x00e9), 0x5c }, // é LATIN SMALL LETTER E WITH ACUTE
+		{ QChar(0x00ed), 0x5d }, // í LATIN SMALL LETTER I WITH ACUTE
+		{ QChar(0x00f3), 0x5e }, // ó LATIN SMALL LETTER O WITH ACUTE
+		{ QChar(0x00fa), 0x5f }, // ú LATIN SMALL LETTER U WITH ACUTE
+		{ QChar(0x00bf), 0x60 }, // ¿ INVERTED QUESTION MARK
+		{ QChar(0x00fc), 0x7b }, // ü LATIN SMALL LETTER U WITH DIAERESIS
+		{ QChar(0x00f1), 0x7c }, // ñ LATIN SMALL LETTER N WITH TILDE
+		{ QChar(0x00e8), 0x7d }, // è LATIN SMALL LETTER E WITH GRAVE
+		{ QChar(0x00e0), 0x7e }  // à LATIN SMALL LETTER A WITH GRAVE
+	},
+
+	{ // 20 Rumanian
+		{ QChar(0x00a4), 0x24 }, // ¤ CURRENCY SIGN
+		{ QChar(0x021a), 0x40 }, // Ț LATIN CAPITAL LETTER T WITH COMMA BELOW
+		{ QChar(0x00c2), 0x5b }, // Â LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+		{ QChar(0x0218), 0x5c }, // Ș LATIN CAPITAL LETTER S WITH COMMA BELOW
+		{ QChar(0x0102), 0x5d }, // Ă LATIN CAPITAL LETTER A WITH BREVE
+		{ QChar(0x00c3), 0x5e }, // Î LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+		{ QChar(0x0131), 0x5f }, // ı LATIN SMALL LETTER DOTLESS I
+		{ QChar(0x021b), 0x60 }, // ț LATIN SMALL LETTER T WITH COMMA BELOW
+		{ QChar(0x00e2), 0x7b }, // â LATIN SMALL LETTER A WITH CIRCUMFLEX
+		{ QChar(0x0219), 0x7c }, // ș LATIN SMALL LETTER S WITH COMMA BELOW
+		{ QChar(0x0103), 0x7d }, // ă LATIN SMALL LETTER A WITH BREVE
+		{ QChar(0x00ee), 0x7e }  // î LATIN SMALL LETTER I WITH CIRCUMFLEX
+	},
+
+	{ // 21 Serbian/Croatian/Slovenian
+		{ QChar(0x00cb), 0x24 }, // Ë LATIN CAPITAL LETTER E WITH DIAERESIS
+		{ QChar(0x010c), 0x40 }, // Č LATIN CAPITAL LETTER C WITH CARON
+		{ QChar(0x0106), 0x5b }, // Ć LATIN CAPITAL LETTER C WITH ACUTE
+		{ QChar(0x017d), 0x5c }, // Ž LATIN CAPITAL LETTER Z WITH CARON
+		{ QChar(0x0110), 0x5d }, // Đ LATIN CAPITAL LETTER D WITH STROKE
+		{ QChar(0x0160), 0x5e }, // Š LATIN CAPITAL LETTER S WITH CARON
+		{ QChar(0x00eb), 0x5f }, // ë LATIN SMALL LETTER E WITH DIAERESIS
+		{ QChar(0x010d), 0x60 }, // č LATIN SMALL LETTER C WITH CARON
+		{ QChar(0x0107), 0x7b }, // ć LATIN SMALL LETTER C WITH ACUTE
+		{ QChar(0x017e), 0x7c }, // ž LATIN SMALL LETTER Z WITH CARON
+		{ QChar(0x0111), 0x7d }, // đ LATIN SMALL LETTER D WITH STROKE
+		{ QChar(0x0161), 0x7e }  // š LATIN SMALL LETTER S WITH CARON
+	},
+
+	{ // 22 Swedish/Finnish/Hungarian
+		{ QChar(0x00a4), 0x24 }, // ¤ CURRENCY SIGN
+		{ QChar(0x00c9), 0x40 }, // É LATIN CAPITAL LETTER E WITH ACUTE
+		{ QChar(0x00c4), 0x5b }, // Ä LATIN CAPITAL LETTER A WITH DIAERESIS
+		{ QChar(0x00d6), 0x5c }, // Ö LATIN CAPITAL LETTER O WITH DIAERESIS
+		{ QChar(0x00c5), 0x5d }, // Å LATIN CAPITAL LETTER A WITH RING ABOVE
+		{ QChar(0x00dc), 0x5e }, // Ü LATIN CAPITAL LETTER U WITH DIAERESIS
+		{ QChar(0x00e9), 0x60 }, // é LATIN SMALL LETTER E WITH ACUTE
+		{ QChar(0x00e4), 0x7b }, // ä LATIN SMALL LETTER A WITH DIAERESIS
+		{ QChar(0x00f6), 0x7c }, // ö LATIN SMALL LETTER O WITH DIAERESIS
+		{ QChar(0x00e5), 0x7d }, // å LATIN SMALL LETTER A WITH RING ABOVE
+		{ QChar(0x00fc), 0x7e }  // ü LATIN SMALL LETTER U WITH DIAERESIS
+	},
+
+	{ // 23 Turkish
+		{ QChar(0x20ba), 0x23 }, // ₺ TURKISH LIRA SIGN
+		{ QChar(0x011f), 0x24 }, // ğ LATIN SMALL LETTER G WITH BREVE
+		{ QChar(0x0130), 0x40 }, // İ LATIN CAPITAL LETTER I WITH DOT ABOVE
+		{ QChar(0x015e), 0x5b }, // Ş LATIN CAPITAL LETTER S WITH CEDILLA
+		{ QChar(0x00d6), 0x5c }, // Ö LATIN CAPITAL LETTER O WITH DIAERESIS
+		{ QChar(0x00c7), 0x5d }, // Ç LATIN CAPITAL LETTER C WITH CEDILLA
+		{ QChar(0x00dc), 0x5e }, // Ü LATIN CAPITAL LETTER U WITH DIAERESIS
+		{ QChar(0x011e), 0x5f }, // Ğ LATIN CAPITAL LETTER G WITH BREVE
+		{ QChar(0x0131), 0x60 }, // ı LATIN SMALL LETTER DOTLESS I
+		{ QChar(0x015f), 0x7b }, // ş LATIN SMALL LETTER S WITH CEDILLA
+		{ QChar(0x00f6), 0x7c }, // ö LATIN SMALL LETTER O WITH DIAERESIS
+		{ QChar(0x00e7), 0x7d }, // ç LATIN SMALL LETTER C WITH CEDILLA
+		{ QChar(0x00fc), 0x7e }  // ü LATIN SMALL LETTER U WITH DIAERESIS
+	}
+};
+
+
+// Native scan codes to toggle mosaic bits - different platforms have different scan codes!
+// Order is top left, top right, middle left, middle right, bottom left, bottom right,
+// invert, set all, clear all, dither
+
+#ifdef Q_OS_UNIX
+static constexpr quint32 mosaicNativeScanCodes[10] = {
+	0x18, 0x19, 0x26, 0x27, 0x34, 0x35, 0x1b, 0x29, 0x36, 0x28
+};
+#elif defined(Q_OS_WIN)
+static constexpr quint32 mosaicNativeScanCodes[10] = {
+	0x10, 0x11, 0x1e, 0x1f, 0x2c, 0x2d, 0x13, 0x21, 0x2e, 0x20
+};
+#else
+#define QTTM_NONATIVESCANCODES
+#endif
+
+#endif

src/qteletextmaker/levelonecommands.cpp

@@ -0,0 +1,948 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QApplication>
+#include <QByteArray>
+#include <QByteArrayList>
+#include <QClipboard>
+#include <QImage>
+#include <QMimeData>
+#include <QRegularExpression>
+#include <QSet>
+
+#include "levelonecommands.h"
+
+#include "document.h"
+#include "keymap.h"
+
+LevelOneCommand::LevelOneCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : QUndoCommand(parent)
+{
+	m_teletextDocument = teletextDocument;
+	m_subPageIndex = teletextDocument->currentSubPageIndex();
+	m_row = teletextDocument->cursorRow();
+	m_column = teletextDocument->cursorColumn();
+	m_firstDo = true;
+}
+
+QByteArrayList LevelOneCommand::storeCharacters(int topRow, int leftColumn, int bottomRow, int rightColumn)
+{
+	QByteArrayList result;
+
+	for (int r=topRow; r<=bottomRow; r++) {
+		QByteArray rowArray;
+
+		for (int c=leftColumn; c<=rightColumn; c++)
+			// Guard against size of pasted block going beyond last line or column
+			if (r < 25 && c < 40)
+				rowArray.append(m_teletextDocument->currentSubPage()->character(r, c));
+			else
+				// Gone beyond last line or column - store a filler character which we won't see
+				// Not sure if this is really necessary as out-of-bounds access might not occur?
+				rowArray.append(0x7f);
+
+		result.append(rowArray);
+	}
+
+	return result;
+}
+
+void LevelOneCommand::retrieveCharacters(int topRow, int leftColumn, const QByteArrayList &storedChars)
+{
+	const int bottomRow = topRow + storedChars.size() - 1;
+	const int rightColumn = leftColumn + storedChars.at(0).size() - 1;
+
+	int arrayR = 0;
+	int arrayC;
+
+	for (int r=topRow; r<=bottomRow; r++) {
+		arrayC = 0;
+		for (int c=leftColumn; c<=rightColumn; c++)
+			// Guard against size of pasted block going beyond last line or column
+			if (r < 25 && c < 40) {
+				m_teletextDocument->currentSubPage()->setCharacter(r, c, storedChars.at(arrayR).at(arrayC));
+
+				arrayC++;
+			}
+
+		arrayR++;
+	}
+}
+
+
+TypeCharacterCommand::TypeCharacterCommand(TeletextDocument *teletextDocument, unsigned char newCharacter, bool insertMode, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	m_columnStart = m_columnEnd = m_column;
+	m_newCharacter = newCharacter;
+	m_insertMode = insertMode;
+
+	for (int c=0; c<40; c++)
+		m_oldRowContents[c] = m_newRowContents[c] = m_teletextDocument->currentSubPage()->character(m_row, c);
+
+	if (m_insertMode)
+		setText(QObject::tr("insert character"));
+	else
+		setText(QObject::tr("overwrite character"));
+}
+
+void TypeCharacterCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	// Only apply the typed character on the first do, m_newRowContents will remember it if we redo
+	if (m_firstDo) {
+		if (m_insertMode) {
+			// Insert - Move characters rightwards
+			for (int c=39; c>m_columnEnd; c--)
+				m_newRowContents[c] = m_newRowContents[c-1];
+		}
+		m_newRowContents[m_columnEnd] = m_newCharacter;
+		m_firstDo = false;
+	}
+	for (int c=0; c<40; c++)
+		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_newRowContents[c]);
+
+	m_teletextDocument->moveCursor(m_row, m_columnEnd);
+	m_teletextDocument->cursorRight();
+	emit m_teletextDocument->contentsChanged();
+}
+
+void TypeCharacterCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	for (int c=0; c<40; c++)
+		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_oldRowContents[c]);
+
+	m_teletextDocument->moveCursor(m_row, m_columnStart);
+	emit m_teletextDocument->contentsChanged();
+}
+
+bool TypeCharacterCommand::mergeWith(const QUndoCommand *command)
+{
+	const TypeCharacterCommand *newerCommand = static_cast<const TypeCharacterCommand *>(command);
+
+	// Has to be the next typed column on the same row
+	if (m_subPageIndex != newerCommand->m_subPageIndex || m_row != newerCommand->m_row || m_columnEnd != newerCommand->m_columnEnd-1)
+		return false;
+
+	m_columnEnd = newerCommand->m_columnEnd;
+	for (int c=0; c<40; c++)
+		m_newRowContents[c] = newerCommand->m_newRowContents[c];
+
+	return true;
+}
+
+
+ToggleMosaicBitCommand::ToggleMosaicBitCommand(TeletextDocument *teletextDocument, unsigned char bitToToggle, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	m_oldCharacter = teletextDocument->currentSubPage()->character(m_row, m_column);
+
+	if (bitToToggle == 0x20 || bitToToggle == 0x7f)
+		// Clear or fill the whole mosaic character
+		m_newCharacter = bitToToggle;
+	else if (bitToToggle == 0x66)
+		// Dither
+		m_newCharacter = (m_row & 1) ? 0x66 : 0x39;
+	else if (m_oldCharacter & 0x20)
+		// Previous character was mosaic, just toggle the bit(s)
+		m_newCharacter = m_oldCharacter ^ bitToToggle;
+	else
+		// Previous character was blast-through, change to mosaic and set bit alone
+		m_newCharacter = bitToToggle | 0x20;
+
+	setText(QObject::tr("mosaic"));
+
+}
+
+void ToggleMosaicBitCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setCharacter(m_row, m_column, m_newCharacter);
+
+	m_teletextDocument->moveCursor(m_row, m_column);
+	emit m_teletextDocument->contentsChanged();
+}
+
+void ToggleMosaicBitCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setCharacter(m_row, m_column, m_oldCharacter);
+
+	m_teletextDocument->moveCursor(m_row, m_column);
+	emit m_teletextDocument->contentsChanged();
+}
+
+bool ToggleMosaicBitCommand::mergeWith(const QUndoCommand *command)
+{
+	const ToggleMosaicBitCommand *newerCommand = static_cast<const ToggleMosaicBitCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex || m_row != newerCommand->m_row || m_column != newerCommand->m_column)
+		return false;
+	m_newCharacter = newerCommand->m_newCharacter;
+	return true;
+}
+
+
+BackspaceKeyCommand::BackspaceKeyCommand(TeletextDocument *teletextDocument, bool insertMode, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	m_columnStart = m_column - 1;
+
+	if (m_columnStart == -1) {
+		m_columnStart = 39;
+		if (--m_row == 0)
+			m_row = 24;
+	}
+	m_columnEnd = m_columnStart;
+	m_insertMode = insertMode;
+
+	for (int c=0; c<40; c++)
+		m_oldRowContents[c] = m_newRowContents[c] = m_teletextDocument->currentSubPage()->character(m_row, c);
+
+	setText(QObject::tr("backspace"));
+}
+
+void BackspaceKeyCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	if (m_firstDo) {
+		if (m_insertMode) {
+			// Insert - Move characters leftwards and put a space on the far right
+			for (int c=m_columnEnd; c<39; c++)
+				m_newRowContents[c] = m_newRowContents[c+1];
+			m_newRowContents[39] = 0x20;
+		} else
+			// Replace - Overwrite backspaced character with a space
+			m_newRowContents[m_columnEnd] = 0x20;
+		m_firstDo = false;
+	}
+
+	for (int c=0; c<40; c++)
+		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_newRowContents[c]);
+
+	m_teletextDocument->moveCursor(m_row, m_columnEnd);
+	emit m_teletextDocument->contentsChanged();
+}
+
+void BackspaceKeyCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	for (int c=0; c<40; c++)
+		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_oldRowContents[c]);
+
+	m_teletextDocument->moveCursor(m_row, m_columnStart);
+	m_teletextDocument->cursorRight();
+	emit m_teletextDocument->contentsChanged();
+}
+
+bool BackspaceKeyCommand::mergeWith(const QUndoCommand *command)
+{
+	const BackspaceKeyCommand *newerCommand = static_cast<const BackspaceKeyCommand *>(command);
+
+	// Has to be the next backspaced column on the same row
+	if (m_subPageIndex != newerCommand->m_subPageIndex || m_row != newerCommand->m_row || m_columnEnd != newerCommand->m_columnEnd+1)
+		return false;
+
+	// For backspacing m_columnStart is where we began backspacing and m_columnEnd is where we ended backspacing
+	// so m_columnEnd will be less than m_columnStart
+	m_columnEnd = newerCommand->m_columnEnd;
+	for (int c=0; c<40; c++)
+		m_newRowContents[c] = newerCommand->m_newRowContents[c];
+
+	return true;
+}
+
+
+DeleteKeyCommand::DeleteKeyCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	for (int c=0; c<40; c++)
+		m_oldRowContents[c] = m_newRowContents[c] = m_teletextDocument->currentSubPage()->character(m_row, c);
+
+	setText(QObject::tr("delete"));
+}
+
+void DeleteKeyCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	// Move characters leftwards and put a space on the far right
+	for (int c=m_column; c<39; c++)
+		m_newRowContents[c] = m_newRowContents[c+1];
+	m_newRowContents[39] = 0x20;
+
+	for (int c=0; c<40; c++)
+		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_newRowContents[c]);
+
+	m_teletextDocument->moveCursor(m_row, m_column);
+	emit m_teletextDocument->contentsChanged();
+}
+
+void DeleteKeyCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	for (int c=0; c<40; c++)
+		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_oldRowContents[c]);
+
+	m_teletextDocument->moveCursor(m_row, m_column);
+	emit m_teletextDocument->contentsChanged();
+}
+
+bool DeleteKeyCommand::mergeWith(const QUndoCommand *command)
+{
+	const DeleteKeyCommand *newerCommand = static_cast<const DeleteKeyCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex || m_row != newerCommand->m_row || m_column != newerCommand->m_column)
+		return false;
+
+	for (int c=0; c<40; c++)
+		m_newRowContents[c] = newerCommand->m_newRowContents[c];
+
+	return true;
+}
+
+
+ShiftMosaicsCommand::ShiftMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	m_selectionTopRow = m_teletextDocument->selectionTopRow();
+	m_selectionLeftColumn = m_teletextDocument->selectionLeftColumn();
+	m_selectionBottomRow = m_teletextDocument->selectionBottomRow();
+	m_selectionRightColumn = m_teletextDocument->selectionRightColumn();
+
+	m_selectionCornerRow = m_teletextDocument->selectionCornerRow();
+	m_selectionCornerColumn = m_teletextDocument->selectionCornerColumn();
+
+	m_mosaicList = mosaicList;
+
+	m_oldCharacters = storeCharacters(m_selectionTopRow, m_selectionLeftColumn, m_selectionBottomRow, m_selectionRightColumn);
+	m_newCharacters = m_oldCharacters;
+}
+
+void ShiftMosaicsCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	retrieveCharacters(m_selectionTopRow, m_selectionLeftColumn, m_newCharacters);
+
+	emit m_teletextDocument->contentsChanged();
+
+	m_teletextDocument->setSelectionCorner(m_selectionCornerRow, m_selectionCornerColumn);
+	m_teletextDocument->moveCursor(m_row, m_column, true);
+}
+
+void ShiftMosaicsCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	retrieveCharacters(m_selectionTopRow, m_selectionLeftColumn, m_oldCharacters);
+
+	emit m_teletextDocument->contentsChanged();
+
+	m_teletextDocument->setSelectionCorner(m_selectionCornerRow, m_selectionCornerColumn);
+	m_teletextDocument->moveCursor(m_row, m_column, true);
+}
+
+bool ShiftMosaicsCommand::mergeWith(const QUndoCommand *command)
+{
+	const ShiftMosaicsCommand *newerCommand = static_cast<const ShiftMosaicsCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex || m_selectionTopRow != newerCommand->m_selectionTopRow || m_selectionLeftColumn != newerCommand->m_selectionLeftColumn || m_selectionBottomRow != newerCommand->m_selectionBottomRow || m_selectionRightColumn != newerCommand->m_selectionRightColumn)
+		return false;
+
+	m_newCharacters = newerCommand->m_newCharacters;
+
+	return true;
+}
+
+ShiftMosaicsUpCommand::ShiftMosaicsUpCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++)
+		for (int c=m_selectionLeftColumn; c<=m_selectionRightColumn; c++)
+			if (m_mosaicList.contains(qMakePair(r, c))) {
+				const int lr = r - m_selectionTopRow;
+				const int lc = c - m_selectionLeftColumn;
+				unsigned char mosaicWrap = 0x00;
+
+				for (int sr=r+1; sr<=m_selectionBottomRow; sr++)
+					if (m_mosaicList.contains(qMakePair(sr, c))) {
+						mosaicWrap = m_newCharacters[sr - m_selectionTopRow][lc];
+						mosaicWrap = ((mosaicWrap & 0x01) << 4) | ((mosaicWrap & 0x02) << 5);
+						break;
+					}
+
+				m_newCharacters[lr][lc] = ((m_newCharacters[lr][lc] >> 2) & 0x07) | ((m_newCharacters[lr][lc] & 0x40) >> 3) | mosaicWrap | 0x20;
+			}
+
+	setText(QObject::tr("shift mosaics up"));
+}
+
+ShiftMosaicsDownCommand::ShiftMosaicsDownCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (int r=m_selectionBottomRow; r>=m_selectionTopRow; r--)
+		for (int c=m_selectionLeftColumn; c<=m_selectionRightColumn; c++)
+			if (m_mosaicList.contains(qMakePair(r, c))) {
+				const int lr = r - m_selectionTopRow;
+				const int lc = c - m_selectionLeftColumn;
+				unsigned char mosaicWrap = 0x00;
+
+				for (int sr=r-1; sr>=m_selectionTopRow; sr--)
+					if (m_mosaicList.contains(qMakePair(sr, c))) {
+						mosaicWrap = m_newCharacters[sr - m_selectionTopRow][lc];
+						mosaicWrap = ((mosaicWrap & 0x10) >> 4) | ((mosaicWrap & 0x40) >> 5);
+						break;
+					}
+
+				m_newCharacters[lr][lc] = ((m_newCharacters[lr][lc] & 0x07) << 2) | ((m_newCharacters[lr][lc] & 0x08) << 3) | mosaicWrap | 0x20;
+			}
+
+	setText(QObject::tr("shift mosaics down"));
+}
+
+ShiftMosaicsLeftCommand::ShiftMosaicsLeftCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (int c=m_selectionLeftColumn; c<=m_selectionRightColumn; c++)
+		for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++)
+			if (m_mosaicList.contains(qMakePair(r, c))) {
+				const int lr = r - m_selectionTopRow;
+				const int lc = c - m_selectionLeftColumn;
+				unsigned char mosaicWrap = 0x00;
+
+				for (int sc=c+1; sc<=m_selectionRightColumn; sc++)
+					if (m_mosaicList.contains(qMakePair(r, sc))) {
+						mosaicWrap = m_newCharacters[lr][sc - m_selectionLeftColumn];
+						mosaicWrap = ((mosaicWrap & 0x05) << 1) | ((mosaicWrap & 0x10) << 2);
+						break;
+					}
+
+				m_newCharacters[lr][lc] = ((m_newCharacters[lr][lc] & 0x0a) >> 1) | ((m_newCharacters[lr][lc] & 0x40) >> 2) | mosaicWrap | 0x20;
+			}
+
+	setText(QObject::tr("shift mosaics left"));
+}
+
+ShiftMosaicsRightCommand::ShiftMosaicsRightCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (int c=m_selectionRightColumn; c>=m_selectionLeftColumn; c--)
+		for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++)
+			if (m_mosaicList.contains(qMakePair(r, c))) {
+				const int lr = r - m_selectionTopRow;
+				const int lc = c - m_selectionLeftColumn;
+				unsigned char mosaicWrap = 0x00;
+
+				for (int sc=c-1; sc>=m_selectionLeftColumn; sc--)
+					if (m_mosaicList.contains(qMakePair(r, sc))) {
+						mosaicWrap = m_newCharacters[lr][sc - m_selectionLeftColumn];
+						mosaicWrap = ((mosaicWrap & 0x0a) >> 1) | ((mosaicWrap & 0x40) >> 2);
+						break;
+					}
+
+				m_newCharacters[lr][lc] = ((m_newCharacters[lr][lc] & 0x05) << 1) | ((m_newCharacters[lr][lc] & 0x10) << 2) | mosaicWrap | 0x20;
+			}
+
+	setText(QObject::tr("shift mosaics right"));
+}
+
+
+InsertRowCommand::InsertRowCommand(TeletextDocument *teletextDocument, bool copyRow, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	m_copyRow = copyRow;
+
+	if (m_copyRow)
+		setText(QObject::tr("insert copy row"));
+	else
+		setText(QObject::tr("insert blank row"));
+}
+
+void InsertRowCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->moveCursor(m_row, -1);
+	// Store copy of the bottom row we're about to push out, for undo
+	for (int c=0; c<40; c++)
+		m_deletedBottomRow[c] = m_teletextDocument->currentSubPage()->character(23, c);
+	// Move lines below the inserting row downwards without affecting the FastText row
+	for (int r=22; r>=m_row; r--)
+		for (int c=0; c<40; c++)
+			m_teletextDocument->currentSubPage()->setCharacter(r+1, c, m_teletextDocument->currentSubPage()->character(r, c));
+	if (!m_copyRow)
+		// The above movement leaves a duplicate of the current row, so blank it if requested
+		for (int c=0; c<40; c++)
+			m_teletextDocument->currentSubPage()->setCharacter(m_row, c, ' ');
+
+	emit m_teletextDocument->contentsChanged();
+}
+
+void InsertRowCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->moveCursor(m_row, -1);
+	// Move lines below the deleting row upwards without affecting the FastText row
+	for (int r=m_row; r<23; r++)
+		for (int c=0; c<40; c++)
+			m_teletextDocument->currentSubPage()->setCharacter(r, c, m_teletextDocument->currentSubPage()->character(r+1, c));
+	// Now repair the bottom row we pushed out
+	for (int c=0; c<40; c++)
+		m_teletextDocument->currentSubPage()->setCharacter(23, c, m_deletedBottomRow[c]);
+
+	emit m_teletextDocument->contentsChanged();
+}
+
+
+DeleteRowCommand::DeleteRowCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	setText(QObject::tr("delete row"));
+}
+
+void DeleteRowCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->moveCursor(m_row, -1);
+	// Store copy of the row we're going to delete, for undo
+	for (int c=0; c<40; c++)
+		m_deletedRow[c] = m_teletextDocument->currentSubPage()->character(m_row, c);
+	// Move lines below the deleting row upwards without affecting the FastText row
+	for (int r=m_row; r<23; r++)
+		for (int c=0; c<40; c++)
+			m_teletextDocument->currentSubPage()->setCharacter(r, c, m_teletextDocument->currentSubPage()->character(r+1, c));
+	// If we deleted the FastText row blank that row, otherwise blank the last row
+	int blankingRow = (m_row < 24) ? 23 : 24;
+		for (int c=0; c<40; c++)
+			m_teletextDocument->currentSubPage()->setCharacter(blankingRow, c, ' ');
+
+	emit m_teletextDocument->contentsChanged();
+}
+
+void DeleteRowCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->moveCursor(m_row, -1);
+	// Move lines below the inserting row downwards without affecting the FastText row
+	for (int r=22; r>=m_row; r--)
+		for (int c=0; c<40; c++)
+			m_teletextDocument->currentSubPage()->setCharacter(r+1, c, m_teletextDocument->currentSubPage()->character(r, c));
+	// Now repair the row we deleted
+	for (int c=0; c<40; c++)
+		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_deletedRow[c]);
+
+	emit m_teletextDocument->contentsChanged();
+}
+
+
+#ifndef QT_NO_CLIPBOARD
+CutCommand::CutCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	m_selectionTopRow = m_teletextDocument->selectionTopRow();
+	m_selectionBottomRow = m_teletextDocument->selectionBottomRow();
+	m_selectionLeftColumn = m_teletextDocument->selectionLeftColumn();
+	m_selectionRightColumn = m_teletextDocument->selectionRightColumn();
+
+	m_selectionCornerRow = m_teletextDocument->selectionCornerRow();
+	m_selectionCornerColumn = m_teletextDocument->selectionCornerColumn();
+
+	m_oldCharacters = storeCharacters(m_selectionTopRow, m_selectionLeftColumn, m_selectionBottomRow, m_selectionRightColumn);
+
+	setText(QObject::tr("cut"));
+}
+
+void CutCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++) {
+		for (int c=m_selectionLeftColumn; c<=m_selectionRightColumn; c++)
+			m_teletextDocument->currentSubPage()->setCharacter(r, c, 0x20);
+	}
+
+	emit m_teletextDocument->contentsChanged();
+}
+
+void CutCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	retrieveCharacters(m_selectionTopRow, m_selectionLeftColumn, m_oldCharacters);
+
+	emit m_teletextDocument->contentsChanged();
+
+	m_teletextDocument->setSelectionCorner(m_selectionCornerRow, m_selectionCornerColumn);
+	m_teletextDocument->moveCursor(m_row, m_column, true);
+}
+
+
+PasteCommand::PasteCommand(TeletextDocument *teletextDocument, int pageCharSet, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	const QClipboard *clipboard = QApplication::clipboard();
+	const QMimeData *mimeData = clipboard->mimeData();
+	QByteArray nativeData;
+
+	m_selectionActive = m_teletextDocument->selectionActive();
+	if (m_selectionActive) {
+		m_selectionCornerRow = m_teletextDocument->selectionCornerRow();
+		m_selectionCornerColumn = m_teletextDocument->selectionCornerColumn();
+		m_pasteTopRow = m_teletextDocument->selectionTopRow();
+		m_pasteBottomRow = m_teletextDocument->selectionBottomRow();
+		m_pasteLeftColumn = m_teletextDocument->selectionLeftColumn();
+		m_pasteRightColumn = m_teletextDocument->selectionRightColumn();
+	} else {
+		m_pasteTopRow = m_row;
+		m_pasteLeftColumn = m_column;
+		// m_pasteBottomRow and m_pasteRightColumn will be filled in later
+		// when the size of the clipboard data is known
+	}
+
+	// Zero size here represents invalid or empty clipboard data
+	m_clipboardDataHeight = m_clipboardDataWidth = 0;
+
+	// Try to get something from the clipboard
+	// FIXME is this a correct "custom" mime type? Or should we use vnd?
+	nativeData = mimeData->data("application/x-teletext");
+	if (nativeData.size() > 2) {
+		// Native clipboard data: we put it there ourselves
+		m_plainText = false;
+		m_clipboardDataHeight = nativeData.at(0);
+		m_clipboardDataWidth = nativeData.at(1);
+
+		// Guard against invalid dimensions or total size not matching stated dimensions
+		if (m_clipboardDataHeight > 0 && m_clipboardDataWidth > 0 && m_clipboardDataHeight <= 25 && m_clipboardDataWidth <= 40 && nativeData.size() == m_clipboardDataHeight * m_clipboardDataWidth + 2)
+			for (int r=0; r<m_clipboardDataHeight; r++)
+				m_pastingCharacters.append(nativeData.mid(2 + r * m_clipboardDataWidth, m_clipboardDataWidth));
+		else {
+			// Invalidate
+			m_clipboardDataHeight = m_clipboardDataWidth = 0;
+			return;
+		}
+
+		if (!m_selectionActive) {
+			m_pasteBottomRow = m_row + m_clipboardDataHeight - 1;
+			m_pasteRightColumn = m_column + m_clipboardDataWidth - 1;
+		}
+	} else if (mimeData->hasText()) {
+		// Plain text
+		m_plainText = true;
+
+		const int rightColumn = m_selectionActive ? m_pasteRightColumn : 39;
+
+		// Parse line-feeds in the clipboard data
+		QStringList plainTextData = mimeData->text().split(QRegularExpression("\n|\r\n|\r"));
+
+		// "if" statement will be false if clipboard data is a single line of text
+		// that will fit from the cursor position
+		if (plainTextData.size() != 1 || m_pasteLeftColumn + plainTextData.at(0).size() - 1 > rightColumn) {
+			bool wrappingNeeded = false;
+
+			if (!m_selectionActive) {
+				// If selection is NOT active, use the full width of the page to paste.
+				// The second and subsequent lines will start at column 1
+				m_pasteLeftColumn = 1;
+
+				// Check if first word in the first line will fit from the cursor position
+				bool firstWordFits = true;
+				const int firstSpace = plainTextData.at(0).indexOf(' ');
+
+				if (firstSpace == -1 && m_column + plainTextData.at(0).size() > 40)
+					firstWordFits = false; // Only one word in first line, and it won't fit
+				else if (m_column + firstSpace > 40)
+					firstWordFits = false; // First word in first line won't fit
+
+				// If the first word WILL fit at the cursor position, pad the first line
+				// to match the cursor position using null characters.
+				// In the QString null characters represent character cells in the
+				// pasting rectangle that won't overwrite what's on the page.
+				// If the first word WON'T fit, start pasting at the beginning of the next row.
+				if (firstWordFits)
+					plainTextData[0] = QString(m_column-m_pasteLeftColumn, QChar::Null) + plainTextData.at(0);
+				else if (m_pasteTopRow < 24)
+					m_pasteTopRow++;
+				else
+					return;
+			}
+
+			const int pasteWidth = rightColumn - m_pasteLeftColumn + 1;
+
+			// Find out if we need to word-wrap
+			for (int i=0; i<plainTextData.size(); i++)
+				if (plainTextData.at(i).size() > pasteWidth) {
+					wrappingNeeded = true;
+					break;
+				}
+
+			if (wrappingNeeded) {
+				QStringList wrappedText;
+
+				for (int i=0; i<plainTextData.size(); i++) {
+					// Split this line into individual words
+					QStringList lineWords = plainTextData.at(i).split(' ');
+
+					// If there's any words which are too long to fit,
+					// break them across multiple lines
+					for (int j=0; j<lineWords.size(); j++)
+						if (lineWords.at(j).size() > pasteWidth) {
+							lineWords.insert(j+1, lineWords.at(j).mid(pasteWidth));
+							lineWords[j].truncate(pasteWidth);
+						}
+
+					// Now reassemble the words into lines that will fit
+					QString currentLine = lineWords.at(0);
+
+					for (int j=1; j<lineWords.size(); j++)
+						if (currentLine.size() + 1 + lineWords.at(j).size() <= pasteWidth)
+							currentLine.append(' ' + lineWords.at(j));
+						else {
+							wrappedText.append(currentLine);
+							currentLine = lineWords.at(j);
+						}
+
+					wrappedText.append(currentLine);
+				}
+				plainTextData.swap(wrappedText);
+			}
+		}
+
+		m_clipboardDataHeight = plainTextData.size();
+		m_clipboardDataWidth = 0;
+
+		// Convert the unicode clipboard text into teletext bytes matching the current Level 1
+		// character set of this page
+		for (int r=0; r<m_clipboardDataHeight; r++) {
+			m_pastingCharacters.append(QByteArray());
+			for (int c=0; c<plainTextData.at(r).size(); c++) {
+				char convertedChar;
+				const QChar charToConvert = plainTextData.at(r).at(c);
+
+				// Map a null character in the QString to 0xff (or -1)
+				// In the QByteArray 0xff bytes represent character cells in the pasting rectangle
+				// that won't overwrite what's on the page
+				if (charToConvert == QChar::Null)
+					convertedChar = -1;
+				else if (charToConvert >= QChar(0x01) && charToConvert <= QChar(0x1f))
+					convertedChar = ' ';
+				else if (keymapping[pageCharSet].contains(charToConvert))
+					// Remapped character or non-Latin character converted successfully
+					convertedChar = keymapping[pageCharSet].value(charToConvert);
+				else {
+					// Either a Latin character or non-Latin character that can't be converted
+					// See if it's a Latin character
+					convertedChar = charToConvert.toLatin1();
+					if (convertedChar <= 0)
+						// Couldn't convert - make it a block character so it doesn't need to be inserted-between later on
+						convertedChar = 0x7f;
+				}
+
+				m_pastingCharacters[r].append(convertedChar);
+			}
+			m_clipboardDataWidth = qMax(m_pastingCharacters.at(r).size(), m_clipboardDataWidth);
+		}
+		// Pad the end of short lines with spaces to make a box
+		for (int r=0; r<m_clipboardDataHeight; r++)
+			m_pastingCharacters[r] = m_pastingCharacters.at(r).leftJustified(m_clipboardDataWidth);
+
+		if (!m_selectionActive) {
+			m_pasteBottomRow = m_pasteTopRow + m_clipboardDataHeight - 1;
+			m_pasteRightColumn = m_pasteLeftColumn + m_clipboardDataWidth - 1;
+		}
+	} else if (mimeData->hasImage()) {
+		QImage imageData = qvariant_cast<QImage>(mimeData->imageData());
+		m_plainText = false;
+		// Round up when dividing pixel size into character cell size
+		m_clipboardDataHeight = (imageData.height() + 2) / 3;
+		m_clipboardDataWidth = (imageData.width() + 1) / 2;
+
+		// Format_MonoLSB reverses the bits which makes them easier to shuffle into sixels
+		if (imageData.depth() == 1)
+			imageData.convertTo(QImage::Format_MonoLSB);
+		else
+			// Only pure black and white images convert reliably this way...
+			imageData = imageData.convertToFormat(QImage::Format_MonoLSB, QVector<QRgb>{0x000000ff, 0xffffffff});
+
+		for (int r=0; r<m_clipboardDataHeight; r++)
+			m_pastingCharacters.append(QByteArray(m_clipboardDataWidth, 0x00));
+
+		// Directly read the pixel-bits and convert them to sixels with some funky bit manipulation
+		for (int y=0; y<imageData.height(); y++) {
+			const unsigned char *bytePointer = imageData.constScanLine(y);
+			// Three rows of sixels per character cell
+			const int r = y / 3;
+			// Where to shuffle the bits into the top, middle or bottom row of sixels
+			// Yes it does put the bottom right sixel into bit 5 instead of bit 6;
+			// this gets remedied further on
+			const int yShift = (y % 3) * 2;
+			// The loop does eight horizontal pixels into four character cells at a time
+			for (int x=0; x<imageData.width(); x+=8) {
+				const unsigned char byteScanned = *bytePointer;
+				const int c = x / 2;
+
+				m_pastingCharacters[r][c] = m_pastingCharacters[r][c] | ((byteScanned & 0x03) << yShift);
+				// Since we're doing four character cells at a time, we need to exit the loop
+				// early before we go out of bounds.
+				// Yes it does leave an undefined last column of sixels from images that are an
+				// odd numbered number of pixels wide; this gets remedied further on
+				if (x + 2 >= imageData.width())
+					continue;
+				m_pastingCharacters[r][c+1] = m_pastingCharacters[r][c+1] | (((byteScanned >> 2) & 0x03) << yShift);
+				if (x + 4 >= imageData.width())
+					continue;
+				m_pastingCharacters[r][c+2] = m_pastingCharacters[r][c+2] | (((byteScanned >> 4) & 0x03) << yShift);
+				if (x + 6 >= imageData.width())
+					continue;
+				m_pastingCharacters[r][c+3] = m_pastingCharacters[r][c+3] | (((byteScanned >> 6) & 0x03) << yShift);
+
+				bytePointer++;
+			}
+		}
+
+		for (int r=0; r<m_clipboardDataHeight; r++) {
+			for (int c=0; c<m_clipboardDataWidth; c++)
+				if (m_pastingCharacters.at(r).at(c) & 0x20)
+					// If bit 5 was set, correct this to bit 6
+					// but we keep bit 5 set as all mosaic characters have bit 5 set
+					m_pastingCharacters[r][c] = m_pastingCharacters.at(r).at(c) | 0x40;
+				else
+					// Set bit 5 to have it recognised as a mosaic character
+					m_pastingCharacters[r][c] = m_pastingCharacters.at(r).at(c) | 0x20;
+			// If image was an odd numbered width, neutralise the undefined sixels
+			// on the right half
+			if (imageData.width() & 0x01)
+				m_pastingCharacters[r][m_clipboardDataWidth-1] = m_pastingCharacters.at(r).at(m_clipboardDataWidth-1) & 0x35;
+		}
+
+		if (!m_selectionActive) {
+			m_pasteBottomRow = m_row + m_clipboardDataHeight - 1;
+			m_pasteRightColumn = m_column + m_clipboardDataWidth - 1;
+		}
+	}
+
+	if (m_clipboardDataWidth == 0 || m_clipboardDataHeight == 0)
+		return;
+
+	m_oldCharacters = storeCharacters(m_pasteTopRow, m_pasteLeftColumn, m_pasteBottomRow, m_pasteRightColumn);
+
+	setText(QObject::tr("paste"));
+}
+
+void PasteCommand::redo()
+{
+	if (m_clipboardDataWidth == 0 || m_clipboardDataHeight == 0)
+		return;
+
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	int arrayR = 0;
+	int arrayC;
+
+	for (int r=m_pasteTopRow; r<=m_pasteBottomRow; r++) {
+		arrayC = 0;
+		for (int c=m_pasteLeftColumn; c<=m_pasteRightColumn; c++)
+			// Guard against size of pasted block going beyond last line or column
+			if (r < 25 && c < 40) {
+				// Check for 0xff bytes using "-1"
+				// gcc complains about "comparision always true due to limited range"
+				if (m_pastingCharacters.at(arrayR).at(arrayC) != -1)
+					m_teletextDocument->currentSubPage()->setCharacter(r, c, m_pastingCharacters.at(arrayR).at(arrayC));
+
+				arrayC++;
+
+				// If paste area is wider than clipboard data, repeat the pattern
+				// if it wasn't plain text
+				if (arrayC == m_clipboardDataWidth) {
+					if (!m_plainText)
+						arrayC = 0;
+					else
+						break;
+				}
+			}
+
+		arrayR++;
+		// If paste area is taller than clipboard data, repeat the pattern
+		// if it wasn't plain text
+		if (arrayR == m_clipboardDataHeight) {
+			if (!m_plainText)
+				arrayR = 0;
+			else
+				break;
+		}
+	}
+
+	emit m_teletextDocument->contentsChanged();
+
+	if (m_selectionActive) {
+		m_teletextDocument->setSelectionCorner(m_selectionCornerRow, m_selectionCornerColumn);
+		m_teletextDocument->moveCursor(m_row, m_column, true);
+	} else {
+		m_teletextDocument->moveCursor(m_row, qMin(m_column+m_clipboardDataWidth-1, 39));
+		m_teletextDocument->cursorRight();
+	}
+}
+
+void PasteCommand::undo()
+{
+	if (m_clipboardDataWidth == 0 || m_clipboardDataHeight == 0)
+		return;
+
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	retrieveCharacters(m_pasteTopRow, m_pasteLeftColumn, m_oldCharacters);
+
+	emit m_teletextDocument->contentsChanged();
+
+	if (!m_selectionActive)
+		m_teletextDocument->moveCursor(m_row, m_column);
+}
+#endif // !QT_NO_CLIPBOARD
+
+
+InsertSubPageCommand::InsertSubPageCommand(TeletextDocument *teletextDocument, bool afterCurrentSubPage, bool copySubPage, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	m_newSubPageIndex = m_subPageIndex + afterCurrentSubPage;
+	m_copySubPage = copySubPage;
+
+	setText(QObject::tr("insert subpage"));
+
+}
+
+void InsertSubPageCommand::redo()
+{
+	m_teletextDocument->insertSubPage(m_newSubPageIndex, m_copySubPage);
+
+	m_teletextDocument->selectSubPageIndex(m_newSubPageIndex, true);
+}
+
+void InsertSubPageCommand::undo()
+{
+	m_teletextDocument->deleteSubPage(m_newSubPageIndex);
+	//TODO should we always wrench to "subpage viewed when we inserted"? Or just if subpage viewed is being deleted?
+
+	m_teletextDocument->selectSubPageIndex(qMin(m_newSubPageIndex, m_teletextDocument->numberOfSubPages()-1), true);
+}
+
+
+DeleteSubPageCommand::DeleteSubPageCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	setText(QObject::tr("delete subpage"));
+}
+
+void DeleteSubPageCommand::redo()
+{
+	m_teletextDocument->deleteSubPageToRecycle(m_subPageIndex);
+	m_teletextDocument->selectSubPageIndex(qMin(m_subPageIndex, m_teletextDocument->numberOfSubPages()-1), true);
+}
+
+void DeleteSubPageCommand::undo()
+{
+	m_teletextDocument->unDeleteSubPageFromRecycle(m_subPageIndex);
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
+}

src/qteletextmaker/levelonecommands.h

@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef LEVELONECOMMANDS_H
+#define LEVELONECOMMANDS_H
+
+#include <QByteArrayList>
+#include <QSet>
+#include <QUndoCommand>
+
+#include "document.h"
+
+class LevelOneCommand : public QUndoCommand
+{
+public:
+	LevelOneCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+protected:
+	QByteArrayList storeCharacters(int topRow, int leftColumn, int bottomRow, int rightColumn);
+	void retrieveCharacters(int topRow, int leftColumn, const QByteArrayList &oldChars);
+
+	TeletextDocument *m_teletextDocument;
+	int m_subPageIndex, m_row, m_column;
+	bool m_firstDo;
+};
+
+class TypeCharacterCommand : public LevelOneCommand
+{
+public:
+	enum { Id = 101 };
+
+	TypeCharacterCommand(TeletextDocument *teletextDocument, unsigned char newCharacter, bool insertMode, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	unsigned char m_newCharacter, m_oldRowContents[40], m_newRowContents[40];
+	int m_columnStart, m_columnEnd;
+	bool m_insertMode;
+};
+
+class ToggleMosaicBitCommand : public LevelOneCommand
+{
+public:
+	enum { Id = 102 };
+
+	ToggleMosaicBitCommand(TeletextDocument *teletextDocument, unsigned char bitToToggle, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	unsigned char m_oldCharacter, m_newCharacter;
+};
+
+class BackspaceKeyCommand : public LevelOneCommand
+{
+public:
+	enum { Id = 103 };
+
+	BackspaceKeyCommand(TeletextDocument *teletextDocument, bool insertMode, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	unsigned char m_oldRowContents[40], m_newRowContents[40];
+	int m_columnStart, m_columnEnd;
+	bool m_insertMode;
+};
+
+class DeleteKeyCommand : public LevelOneCommand
+{
+public:
+	enum { Id = 104 };
+
+	DeleteKeyCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	unsigned char m_oldRowContents[40], m_newRowContents[40];
+};
+
+class ShiftMosaicsCommand : public LevelOneCommand
+{
+public:
+	ShiftMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+
+protected:
+	QByteArrayList m_oldCharacters, m_newCharacters;
+	QSet<QPair<int, int>> m_mosaicList;
+	int m_selectionTopRow, m_selectionBottomRow, m_selectionLeftColumn, m_selectionRightColumn;
+	int m_selectionCornerRow, m_selectionCornerColumn;
+};
+
+class ShiftMosaicsUpCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 110 };
+
+	ShiftMosaicsUpCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class ShiftMosaicsDownCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 111 };
+
+	ShiftMosaicsDownCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class ShiftMosaicsLeftCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 112 };
+
+	ShiftMosaicsLeftCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class ShiftMosaicsRightCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 113 };
+
+	ShiftMosaicsRightCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class InsertSubPageCommand : public LevelOneCommand
+{
+public:
+	InsertSubPageCommand(TeletextDocument *teletextDocument, bool afterCurrentSubPage, bool copySubPage, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	int m_newSubPageIndex;
+	bool m_copySubPage;
+};
+
+class DeleteSubPageCommand : public LevelOneCommand
+{
+public:
+	DeleteSubPageCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+};
+
+class InsertRowCommand : public LevelOneCommand
+{
+public:
+	InsertRowCommand(TeletextDocument *teletextDocument, bool copyRow, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	bool m_copyRow;
+	unsigned char m_deletedBottomRow[40];
+};
+
+class DeleteRowCommand : public LevelOneCommand
+{
+public:
+	DeleteRowCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	unsigned char m_deletedRow[40];
+};
+
+#ifndef QT_NO_CLIPBOARD
+class CutCommand : public LevelOneCommand
+{
+public:
+	CutCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	QByteArrayList m_oldCharacters;
+	int m_selectionTopRow, m_selectionBottomRow, m_selectionLeftColumn, m_selectionRightColumn;
+	int m_selectionCornerRow, m_selectionCornerColumn;
+};
+
+class PasteCommand : public LevelOneCommand
+{
+public:
+	PasteCommand(TeletextDocument *teletextDocument, int pageCharSet, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	QByteArrayList m_oldCharacters, m_pastingCharacters;
+	int m_pasteTopRow, m_pasteBottomRow, m_pasteLeftColumn, m_pasteRightColumn;
+	int m_clipboardDataHeight, m_clipboardDataWidth;
+	int m_selectionCornerRow, m_selectionCornerColumn;
+	bool m_selectionActive, m_plainText;
+};
+#endif // !QT_NO_CLIPBOARD
+
+#endif

src/qteletextmaker/loadsave.cpp

@@ -0,0 +1,811 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "loadsave.h"
+
+#include <QByteArray>
+#include <QDataStream>
+#include <QFile>
+#include <QSaveFile>
+#include <QString>
+#include <QTextStream>
+
+#include "document.h"
+#include "hamming.h"
+#include "levelonepage.h"
+#include "pagebase.h"
+
+void loadTTI(QFile *inFile, TeletextDocument *document)
+{
+	QByteArray inLine;
+	bool firstSubPageAlreadyFound = false;
+	int cycleCommandsFound = 0;
+	int mostRecentCycleValue = -1;
+	LevelOnePage::CycleTypeEnum mostRecentCycleType;
+
+	LevelOnePage* loadingPage = document->subPage(0);
+
+	for (;;) {
+		inLine = inFile->readLine(160).trimmed();
+		if (inLine.isEmpty())
+			break;
+		if (inLine.startsWith("DE,"))
+			document->setDescription(QString(inLine.remove(0, 3)));
+		if (inLine.startsWith("PN,")) {
+			// When second and subsequent PN commands are found, firstSubPageAlreadyFound==true at this point
+			// This assumes that PN is the first command of a new subpage...
+			if (firstSubPageAlreadyFound) {
+				document->insertSubPage(document->numberOfSubPages(), false);
+				loadingPage = document->subPage(document->numberOfSubPages()-1);
+			} else {
+				document->setPageNumberFromString(inLine.mid(3,3));
+				firstSubPageAlreadyFound = true;
+			}
+		}
+/*		if (lineType == "SC,") {
+			bool subPageNumberOk;
+			int subPageNumberRead = inLine.mid(3, 4).toInt(&subPageNumberOk, 16);
+			if ((!subPageNumberOk) || subPageNumberRead > 0x3f7f)
+				subPageNumberRead = 0;
+			loadingPage->setSubPageNumber(subPageNumberRead);
+		}*/
+		if (inLine.startsWith("PS,")) {
+			bool pageStatusOk;
+			int pageStatusRead = inLine.mid(3, 4).toInt(&pageStatusOk, 16);
+			if (pageStatusOk) {
+				loadingPage->setControlBit(PageBase::C4ErasePage, pageStatusRead & 0x4000);
+				for (int i=PageBase::C5Newsflash, pageStatusBit=0x0001; i<=PageBase::C11SerialMagazine; i++, pageStatusBit<<=1)
+					loadingPage->setControlBit(i, pageStatusRead & pageStatusBit);
+				loadingPage->setDefaultNOS(((pageStatusRead & 0x0200) >> 9) | ((pageStatusRead & 0x0100) >> 7) | ((pageStatusRead & 0x0080) >> 5));
+			}
+		}
+		if (inLine.startsWith("CT,") && (inLine.endsWith(",C") || inLine.endsWith(",T"))) {
+			bool cycleValueOk;
+			int cycleValueRead = inLine.mid(3, inLine.size()-5).toInt(&cycleValueOk);
+			if (cycleValueOk) {
+				cycleCommandsFound++;
+				// House-keep CT command values, in case it's the only one within multiple subpages
+				mostRecentCycleValue = cycleValueRead;
+				loadingPage->setCycleValue(cycleValueRead);
+				mostRecentCycleType = inLine.endsWith("C") ? LevelOnePage::CTcycles : LevelOnePage::CTseconds;
+				loadingPage->setCycleType(mostRecentCycleType);
+			}
+		}
+		if (inLine.startsWith("FL,")) {
+			bool fastTextLinkOk;
+			int fastTextLinkRead;
+			QString flLine = QString(inLine.remove(0, 3));
+			if (flLine.count(',') == 5)
+				for (int i=0; i<6; i++) {
+					fastTextLinkRead = flLine.section(',', i, i).toInt(&fastTextLinkOk, 16);
+					if (fastTextLinkOk) {
+						if (fastTextLinkRead == 0)
+							fastTextLinkRead = 0x8ff;
+						// Stored as page link with relative magazine number, convert from absolute page number that was read
+						fastTextLinkRead ^= document->pageNumber() & 0x700;
+						fastTextLinkRead &= 0x7ff; // Fixes magazine 8 to 0
+						loadingPage->setFastTextLinkPageNumber(i, fastTextLinkRead);
+					}
+				}
+		}
+		if (inLine.startsWith("OL,")) {
+			bool lineNumberOk;
+			int lineNumber, secondCommaPosition;
+
+			secondCommaPosition = inLine.indexOf(",", 3);
+			if (secondCommaPosition != 4 && secondCommaPosition != 5)
+				continue;
+
+			lineNumber = inLine.mid(3, secondCommaPosition-3).toInt(&lineNumberOk, 10);
+			if (lineNumberOk && lineNumber>=0 && lineNumber<=29) {
+				inLine.remove(0, secondCommaPosition+1);
+				if (lineNumber <= 25) {
+					for (int c=0; c<40; c++) {
+						// trimmed() helpfully removes CRLF line endings from the just-read line for us
+						// But it also (un)helpfully removes spaces at the end of a 40 character line, so put them back
+						if (c >= inLine.size())
+							inLine.append(' ');
+						if (inLine.at(c) & 0x80)
+							inLine[c] = inLine.at(c) & 0x7f;
+						else if (inLine.at(c) == 0x10)
+							inLine[c] = 0x0d;
+						else if (inLine.at(c) == 0x1b) {
+							inLine.remove(c, 1);
+							inLine[c] = inLine.at(c) & 0xbf;
+						}
+					}
+					loadingPage->setPacket(lineNumber, inLine);
+				} else {
+					int designationCode = inLine.at(0) & 0x3f;
+					if (inLine.size() < 40) {
+						// OL is too short!
+						if (lineNumber == 26) {
+							// For a too-short enhancement triplets OL, first trim the line down to nearest whole triplet
+							inLine.resize((inLine.size() / 3 * 3) + 1);
+							// Then use "dummy" enhancement triplets to extend the line to the proper length
+							for (int i=inLine.size(); i<40; i+=3)
+								inLine.append("i^@"); // Address 41, Mode 0x1e, Data 0
+						} else
+							// For other triplet OLs and Hamming 8/4 OLs, just pad with zero data
+							for (int i=inLine.size(); i<40; i++)
+								inLine.append("@");
+					}
+					for (int i=1; i<=39; i++)
+						inLine[i] = inLine.at(i) & 0x3f;
+					// Import M/29 whole-magazine packets as X/28 per-page packets
+					if (lineNumber == 29) {
+						if ((document->pageNumber() & 0xff) != 0xff)
+							qDebug("M/29/%d packet found, but page number is not xFF!", designationCode);
+						lineNumber = 28;
+					}
+					loadingPage->setPacket(lineNumber, designationCode, inLine);
+				}
+			}
+		}
+	}
+	// If there's more than one subpage but only one valid CT command was found, apply it to all subpages
+	// I don't know if this is correct
+	if (cycleCommandsFound == 1 && document->numberOfSubPages()>1)
+		for (int i=0; i<document->numberOfSubPages(); i++) {
+			document->subPage(i)->setCycleValue(mostRecentCycleValue);
+			document->subPage(i)->setCycleType(mostRecentCycleType);
+		}
+}
+
+void importT42(QFile *inFile, TeletextDocument *document)
+{
+	unsigned char inLine[42];
+	int readMagazineNumber, readPacketNumber;
+	int foundMagazineNumber = -1;
+	int foundPageNumber = -1;
+	bool firstPacket0Found = false;
+	bool pageBodyPacketsFound = false;
+
+	for (;;) {
+		if (inFile->read((char *)inLine, 42) != 42)
+			// Reached end of .t42 file, or less than 42 bytes left
+			break;
+
+		// Magazine and packet numbers
+		inLine[0] = hamming_8_4_decode[inLine[0]];
+		inLine[1] = hamming_8_4_decode[inLine[1]];
+		if (inLine[0] == 0xff || inLine[1] == 0xff)
+			// Error decoding magazine or packet number
+			continue;
+		readMagazineNumber = inLine[0] & 0x07;
+		readPacketNumber = (inLine[0] >> 3) | (inLine[1] << 1);
+
+		if (readPacketNumber == 0) {
+			// Hamming decode page number, subcodes and control bits
+			for (int i=2; i<10; i++)
+				inLine[i] = hamming_8_4_decode[inLine[i]];
+			// See if the page number is valid
+			if (inLine[2] == 0xff || inLine[3] == 0xff)
+				// Error decoding page number
+				continue;
+
+			const int readPageNumber = (inLine[3] << 4) | inLine[2];
+
+			if (readPageNumber == 0xff)
+				// Time filling header
+				continue;
+
+			// A second or subsequent X/0 has been found
+			if (firstPacket0Found) {
+				if (readMagazineNumber != foundMagazineNumber)
+					// Packet from different magazine broadcast in parallel mode
+					continue;
+				if ((readPageNumber == foundPageNumber) && pageBodyPacketsFound)
+					// X/0 with same page number found after page body packets loaded - assume end of page
+					break;
+				if (readPageNumber != foundPageNumber) {
+					// More than one page in .t42 file - end of current page reached
+					qDebug("More than one page in .t42 file");
+					break;
+				}
+				// Could get here if X/0 with same page number was found with no body packets inbetween
+				continue;
+			} else {
+				// First X/0 found
+				foundMagazineNumber = readMagazineNumber;
+				foundPageNumber = readPageNumber;
+				firstPacket0Found = true;
+
+				if (foundMagazineNumber == 0)
+					document->setPageNumber(0x800 | foundPageNumber);
+				else
+					document->setPageNumber((foundMagazineNumber << 8) | foundPageNumber);
+
+				document->subPage(0)->setControlBit(PageBase::C4ErasePage, inLine[5] & 0x08);
+				document->subPage(0)->setControlBit(PageBase::C5Newsflash, inLine[7] & 0x04);
+				document->subPage(0)->setControlBit(PageBase::C6Subtitle, inLine[7] & 0x08);
+				for (int i=0; i<4; i++)
+					document->subPage(0)->setControlBit(PageBase::C7SuppressHeader+i, inLine[8] & (1 << i));
+				document->subPage(0)->setControlBit(PageBase::C11SerialMagazine, inLine[9] & 0x01);
+				document->subPage(0)->setControlBit(PageBase::C12NOS, inLine[9] & 0x08);
+				document->subPage(0)->setControlBit(PageBase::C13NOS, inLine[9] & 0x04);
+				document->subPage(0)->setControlBit(PageBase::C14NOS, inLine[9] & 0x02);
+
+				continue;
+			}
+		}
+
+		// No X/0 has been found yet, keep looking for one
+		if (!firstPacket0Found)
+			continue;
+
+		// Disregard whole-magazine packets
+		if (readPacketNumber > 28)
+			continue;
+
+		// We get here when a page-body packet belonging to the found X/0 header was found
+		pageBodyPacketsFound = true;
+
+		// At the moment this only loads a Level One Page properly
+		// because it assumes X/1 to X/25 is odd partity
+		if (readPacketNumber < 25) {
+			for (int i=2; i<42; i++)
+				// TODO - obey odd parity?
+				inLine[i] &= 0x7f;
+			document->subPage(0)->setPacket(readPacketNumber, QByteArray((const char *)&inLine[2], 40));
+			continue;
+		}
+
+		// X/26, X/27 or X/28
+		int readDesignationCode = hamming_8_4_decode[inLine[2]];
+
+		if (readDesignationCode == 0xff)
+			// Error decoding designation code
+			continue;
+
+		if (readPacketNumber == 27 && readDesignationCode < 4) {
+			// X/27/0 to X/27/3 for Editorial Linking
+			// Decode Hamming 8/4 on each of the six links, checking for errors on the way
+			for (int i=0; i<6; i++) {
+				bool decodingError = false;
+				const int b = 3 + i*6; // First byte of this link
+
+				for (int j=0; j<6; j++) {
+					inLine[b+j] = hamming_8_4_decode[inLine[b+j]];
+					if (inLine[b+j] == 0xff) {
+						decodingError = true;
+						break;
+					}
+				}
+
+				if (decodingError) {
+					// Error found in at least one byte of the link
+					// Neutralise the whole link to same magazine, page FF, subcode 3F7F
+					qDebug("X/27/%d link %d decoding error", readDesignationCode, i);
+					inLine[b]   = 0xf;
+					inLine[b+1] = 0xf;
+					inLine[b+2] = 0xf;
+					inLine[b+3] = 0x7;
+					inLine[b+4] = 0xf;
+					inLine[b+5] = 0x3;
+				}
+			}
+			document->subPage(0)->setPacket(readPacketNumber, readDesignationCode, QByteArray((const char *)&inLine[2], 40));
+
+			continue;
+		}
+
+		// X/26, or X/27/4 to X/27/15, or X/28
+		// Decode Hamming 24/18
+		for (int i=0; i<13; i++) {
+			const int b = 3 + i*3; // First byte of triplet
+
+			const int p0 = inLine[b];
+			const int p1 = inLine[b+1];
+			const int p2 = inLine[b+2];
+
+			unsigned int D1_D4;
+			unsigned int D5_D11;
+			unsigned int D12_D18;
+			unsigned int ABCDEF;
+			int32_t d;
+
+			D1_D4 = hamming_24_18_decode_d1_d4[p0 >> 2];
+			D5_D11 = p1 & 0x7f;
+			D12_D18 = p2 & 0x7f;
+
+			d = D1_D4 | (D5_D11 << 4) | (D12_D18 << 11);
+
+			ABCDEF = (hamming_24_18_parities[0][p0] ^ hamming_24_18_parities[1][p1]  ^ hamming_24_18_parities[2][p2]);
+
+			d ^= (int)hamming_24_18_decode_correct[ABCDEF];
+
+			if ((d & 0x80000000) == 0x80000000) {
+				// Error decoding Hamming 24/18
+				qDebug("X/%d/%d triplet %d decoding error", readPacketNumber, readDesignationCode, i);
+				if (readPacketNumber == 26) {
+					// Enhancements packet, set to "dummy" Address 41, Mode 0x1e, Data 0
+					inLine[b]   = 41;
+					inLine[b+1] = 0x1e;
+					inLine[b+2] = 0;
+				} else {
+					// Zero out whole decoded triplet, bound to make things go wrong...
+					inLine[b]   = 0x00;
+					inLine[b+1] = 0x00;
+					inLine[b+2] = 0x00;
+				}
+			} else {
+				inLine[b]   = d & 0x0003f;
+				inLine[b+1] = (d & 0x00fc0) >> 6;
+				inLine[b+2] = d >> 12;
+			}
+		}
+		document->subPage(0)->setPacket(readPacketNumber, readDesignationCode, QByteArray((const char *)&inLine[2], 40));
+	}
+
+	if (!firstPacket0Found)
+		qDebug("No X/0 found");
+	else if (!pageBodyPacketsFound)
+		qDebug("X/0 found, but no page body packets were found");
+}
+
+// Used by saveTTI and HashString
+int controlBitsToPS(PageBase *subPage)
+{
+	// C4 Erase page is stored in bit 14
+	int pageStatus = 0x8000 | (subPage->controlBit(PageBase::C4ErasePage) << 14); 
+	// C5 to C11 stored in order from bits 1 to 6
+	for (int i=PageBase::C5Newsflash; i<=PageBase::C11SerialMagazine; i++)
+		pageStatus |= subPage->controlBit(i) << (i-1);
+	// Apparently the TTI format stores the NOS bits backwards
+	pageStatus |= subPage->controlBit(PageBase::C12NOS) << 9;
+	pageStatus |= subPage->controlBit(PageBase::C13NOS) << 8;
+	pageStatus |= subPage->controlBit(PageBase::C14NOS) << 7;
+	return pageStatus;
+}
+
+void saveTTI(QSaveFile &file, const TeletextDocument &document)
+{
+	int p;
+	QTextStream outStream(&file);
+
+	auto write7bitPacket=[&](int packetNumber)
+	{
+		if (document.subPage(p)->packetExists(packetNumber)) {
+			QByteArray outLine = document.subPage(p)->packet(packetNumber);
+
+			outStream << QString("OL,%1,").arg(packetNumber);
+			for (int c=0; c<outLine.size(); c++)
+				if (outLine.at(c) < 0x20) {
+					// TTI files are plain text, so put in escape followed by control code with bit 6 set
+					outLine[c] = outLine.at(c) | 0x40;
+					outLine.insert(c, 0x1b);
+					c++;
+				}
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+			outStream << outLine << Qt::endl;
+#else
+			outStream << outLine << endl;
+#endif
+		}
+	};
+
+	auto writeHammingPacket=[&](int packetNumber, int designationCode=0)
+	{
+		if (document.subPage(p)->packetExists(packetNumber, designationCode)) {
+			QByteArray outLine = document.subPage(p)->packet(packetNumber, designationCode);
+
+			outStream << QString("OL,%1,").arg(packetNumber);
+			// TTI stores raw values with bit 6 set, doesn't do Hamming encoding
+			outLine[0] = designationCode | 0x40;
+			for (int c=1; c<outLine.size(); c++)
+				outLine[c] = outLine.at(c) | 0x40;
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+			outStream << outLine << Qt::endl;
+#else
+			outStream << outLine << endl;
+#endif
+		}
+	};
+
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+	outStream.setCodec("ISO-8859-1");
+#else
+	outStream.setEncoding(QStringConverter::Latin1);
+#endif
+
+	if (!document.description().isEmpty())
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+		outStream << "DE," << document.description() << Qt::endl;
+#else
+		outStream << "DE," << document.description() << endl;
+#endif
+
+	// TODO DS and SP commands
+
+	// If there's just one subpage then we save it with a subcode of 0000
+	// otherwise start with a subcode of 0001
+	int subPageNumber = document.numberOfSubPages() > 1;
+
+	for (p=0; p<document.numberOfSubPages(); p++) {
+
+		// Page number
+		outStream << QString("PN,%1%2").arg(document.pageNumber(), 3, 16, QChar('0')).arg(subPageNumber & 0xff, 2, 10, QChar('0'));
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+			outStream << Qt::endl;
+#else
+			outStream << endl;
+#endif
+
+		// Subpage
+		// Magazine Organisation Table and Magazine Inventory Page don't have subpages
+		if (document.pageFunction() != TeletextDocument::PFMOT && document.pageFunction() != TeletextDocument::PFMIP) {
+			outStream << QString("SC,%1").arg(subPageNumber, 4, 10, QChar('0'));
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+			outStream << Qt::endl;
+#else
+			outStream << endl;
+#endif
+		}
+
+		// Status bits
+		outStream << QString("PS,%1").arg(0x8000 | controlBitsToPS(document.subPage(p)), 4, 16, QChar('0'));
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+		outStream << Qt::endl;
+#else
+		outStream << endl;
+#endif
+
+		// Cycle time
+		if (document.pageFunction() == TeletextDocument::PFLevelOnePage)
+			// Assume that only Level One Pages have configurable cycle times
+			outStream << QString("CT,%1,%2").arg(document.subPage(p)->cycleValue()).arg(document.subPage(p)->cycleType()==LevelOnePage::CTcycles ? 'C' : 'T');
+		else
+			// X/28/0 specifies page function and coding but the PF command
+			// should make it obvious to a human that this isn't a Level One Page
+			outStream << QString("PF,%1,%2").arg(document.pageFunction()).arg(document.packetCoding());
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+		outStream << Qt::endl;
+#else
+		outStream << endl;
+#endif
+
+		// FastText links
+		bool writeFLCommand = false;
+		if (document.pageFunction() == TeletextDocument::PFLevelOnePage && document.subPage(p)->packetExists(27,0)) {
+			// Subpage has FastText links - if any link to a specific subpage, we need to write X/27/0 as raw
+			// otherwise we write the links as a human-readable FL command later on
+			writeFLCommand = true;
+			// TODO uncomment this when we can edit FastText subpage links
+			/*for (int i=0; i<6; i++)
+				if (document.subPage(p)->fastTextLinkSubPageNumber(i) != 0x3f7f) {
+					writeFLCommand = false;
+					break;
+				}*/
+		}
+
+		// X/27 then X/28 always come first
+		for (int i=(writeFLCommand ? 1 : 0); i<16; i++)
+			writeHammingPacket(27, i);
+		for (int i=0; i<16; i++)
+			writeHammingPacket(28, i);
+
+		if (document.packetCoding() == TeletextDocument::Coding7bit) {
+			// For 7 bit coding i.e. Level One Pages, X/26 are written before X/1 to X/25
+			for (int i=0; i<16; i++)
+				writeHammingPacket(26, i);
+			for (int i=1; i<=24; i++)
+				write7bitPacket(i);
+		} else {
+			// For others (especially (G)POP pages) X/1 to X/25 are written before X/26
+			for (int i=1; i<=25; i++)
+				writeHammingPacket(i);
+			for (int i=0; i<16; i++)
+				writeHammingPacket(26, i);
+		}
+
+		if (writeFLCommand) {
+			outStream << "FL,";
+			for (int i=0; i<6; i++) {
+				// Stored as page link with relative magazine number, convert to absolute page number for display
+				int absoluteLinkPageNumber = document.subPage(p)->fastTextLinkPageNumber(i) ^ (document.pageNumber() & 0x700);
+				// Fix magazine 0 to 8
+				if ((absoluteLinkPageNumber & 0x700) == 0x000)
+					absoluteLinkPageNumber |= 0x800;
+
+				outStream << QString("%1").arg(absoluteLinkPageNumber, 3, 16, QChar('0'));
+				if (i<5)
+					outStream << ',';
+			}
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+			outStream << Qt::endl;
+#else
+			outStream << endl;
+#endif
+		}
+
+		subPageNumber++;
+	}
+}
+
+void exportM29File(QSaveFile &file, const TeletextDocument &document)
+{
+	const PageBase &subPage = *document.currentSubPage();
+	QTextStream outStream(&file);
+
+	auto writeM29Packet=[&](int designationCode)
+	{
+		if (subPage.packetExists(28, designationCode)) {
+			QByteArray outLine = subPage.packet(28, designationCode);
+
+			outStream << QString("OL,29,");
+			// TTI stores raw values with bit 6 set, doesn't do Hamming encoding
+			outLine[0] = designationCode | 0x40;
+			for (int c=1; c<outLine.size(); c++)
+				outLine[c] = outLine.at(c) | 0x40;
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+			outStream << outLine << Qt::endl;
+#else
+			outStream << outLine << endl;
+#endif
+		}
+	};
+
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+	outStream.setCodec("ISO-8859-1");
+#else
+	outStream.setEncoding(QStringConverter::Latin1);
+#endif
+
+	if (!document.description().isEmpty())
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+	outStream << "DE," << document.description() << Qt::endl;
+#else
+	outStream << "DE," << document.description() << endl;
+#endif
+
+	// Force page number to xFF
+	outStream << QString("PN,%1ff00").arg(document.pageNumber() >> 8, 1, 16);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+	outStream << Qt::endl;
+#else
+	outStream << endl;
+#endif
+
+	outStream << "PS,8000";
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+	outStream << Qt::endl;
+#else
+	outStream << endl;
+#endif
+
+	writeM29Packet(0);
+	writeM29Packet(1);
+	writeM29Packet(4);
+}
+
+void exportT42File(QSaveFile &file, const TeletextDocument &document)
+{
+	const PageBase &subPage = *document.currentSubPage();
+
+	QDataStream outStream(&file);
+	// Displayable row header we export as spaces, hence the (odd parity valid) 0x20 init value
+	QByteArray outLine(42, 0x20);
+	int magazineNumber = (document.pageNumber() & 0xf00) >> 8;
+
+	auto write7bitPacket=[&](int packetNumber)
+	{
+		if (subPage.packetExists(packetNumber)) {
+			outLine[0] = hamming_8_4_encode[magazineNumber | ((packetNumber & 0x01) << 3)];
+			outLine[1] = hamming_8_4_encode[packetNumber >> 1];
+			outLine.replace(2, 40, subPage.packet(packetNumber));
+
+			// Odd parity encoding
+			for (int c=0; c<outLine.size(); c++) {
+				char p = outLine.at(c);
+
+				// Recursively divide integer into two equal halves and take their XOR until only 1 bit is left
+				p ^= p >> 4;
+				p ^= p >> 2;
+				p ^= p >> 1;
+				// If last bit left is 0 then it started with an even number of bits, so do the odd parity
+				if (!(p & 1))
+					outLine[c] = outLine.at(c) | 0x80;
+			}
+			outStream.writeRawData(outLine.constData(), 42);
+		}
+	};
+
+	auto writeHamming8_4Packet=[&](int packetNumber, int designationCode=0)
+	{
+		if (subPage.packetExists(packetNumber, designationCode)) {
+			outLine[0] = hamming_8_4_encode[magazineNumber | ((packetNumber & 0x01) << 3)];
+			outLine[1] = hamming_8_4_encode[packetNumber >> 1];
+			outLine.replace(2, 40, subPage.packet(packetNumber, designationCode));
+			outLine[2] = hamming_8_4_encode[designationCode];
+
+			for (int c=3; c<outLine.size(); c++)
+				outLine[c] = hamming_8_4_encode[(int)outLine.at(c)];
+
+			outStream.writeRawData(outLine.constData(), 42);
+		}
+	};
+
+	auto writeHamming24_18Packet=[&](int packetNumber, int designationCode=0)
+	{
+		if (subPage.packetExists(packetNumber, designationCode)) {
+			outLine[0] = hamming_8_4_encode[magazineNumber | ((packetNumber & 0x01) << 3)];
+			outLine[1] = hamming_8_4_encode[packetNumber >> 1];
+			outLine.replace(2, 40, subPage.packet(packetNumber, designationCode));
+			outLine[2] = hamming_8_4_encode[designationCode];
+
+			for (int c=3; c<outLine.size(); c+=3) {
+				unsigned int D5_D11;
+				unsigned int D12_D18;
+				unsigned int P5, P6;
+				unsigned int Byte_0;
+
+				const unsigned int toEncode = outLine[c] | (outLine[c+1] << 6) | (outLine[c+2] << 12);
+
+				Byte_0 = (hamming_24_18_forward[0][(toEncode >> 0) & 0xff] ^ hamming_24_18_forward[1][(toEncode >> 8) & 0xff] ^ hamming_24_18_forward_2[(toEncode >> 16) & 0x03]);
+				outLine[c] = Byte_0;
+
+				D5_D11 = (toEncode >> 4) & 0x7f;
+				D12_D18 = (toEncode >> 11) & 0x7f;
+
+				P5 = 0x80 & ~(hamming_24_18_parities[0][D12_D18] << 2);
+				outLine[c+1] = D5_D11 | P5;
+
+				P6 = 0x80 & ((hamming_24_18_parities[0][Byte_0] ^ hamming_24_18_parities[0][D5_D11]) << 2);
+				outLine[c+2] = D12_D18 | P6;
+			}
+
+			outStream.writeRawData(outLine.constData(), 42);
+		}
+	};
+
+
+	if (magazineNumber == 8)
+		magazineNumber = 0;
+
+	// Write X/0 separately as it features both Hamming 8/4 and 7-bit odd parity within
+	outLine[0] = magazineNumber & 0x07;
+	outLine[1] = 0; // Packet number 0
+	outLine[2] = document.pageNumber() & 0x00f;
+	outLine[3] = (document.pageNumber() & 0x0f0) >> 4;
+	outLine[4] = 0; // Subcode S1 - always export as 0
+	outLine[5] = subPage.controlBit(PageBase::C4ErasePage) << 3;
+	outLine[6] = 0; // Subcode S3 - always export as 0
+	outLine[7] = (subPage.controlBit(PageBase::C5Newsflash) << 2) | (subPage.controlBit(PageBase::C6Subtitle) << 3);
+	outLine[8] = subPage.controlBit(PageBase::C7SuppressHeader) | (subPage.controlBit(PageBase::C8Update) << 1) | (subPage.controlBit(PageBase::C9InterruptedSequence) << 2) | (subPage.controlBit(PageBase::C10InhibitDisplay) << 3);
+	outLine[9] = subPage.controlBit(PageBase::C11SerialMagazine) | (subPage.controlBit(PageBase::C14NOS) << 1) | (subPage.controlBit(PageBase::C13NOS) << 2) | (subPage.controlBit(PageBase::C12NOS) << 3);
+
+	for (int i=0; i<10; i++)
+		outLine[i] = hamming_8_4_encode[(int)outLine.at(i)];
+
+	// If we allow text in the row header, we'd odd-parity encode it here
+
+	outStream.writeRawData(outLine.constData(), 42);
+
+	// After X/0, X/27 then X/28 always come next
+	for (int i=0; i<4; i++)
+		writeHamming8_4Packet(27, i);
+	for (int i=4; i<16; i++)
+		writeHamming24_18Packet(27, i);
+	for (int i=0; i<16; i++)
+		writeHamming24_18Packet(28, i);
+
+	if (document.packetCoding() == TeletextDocument::Coding7bit) {
+		// For 7 bit coding i.e. Level One Pages, X/26 are written before X/1 to X/25
+		for (int i=0; i<16; i++)
+			writeHamming24_18Packet(26, i);
+		for (int i=1; i<=24; i++)
+			write7bitPacket(i);
+	} else {
+		// For others (especially (G)POP pages) X/1 to X/25 are written before X/26
+		if (document.packetCoding() == TeletextDocument::Coding18bit)
+			for (int i=1; i<=25; i++)
+				writeHamming24_18Packet(i);
+		else if (document.packetCoding() == TeletextDocument::Coding4bit)
+			for (int i=1; i<=25; i++)
+				writeHamming8_4Packet(i);
+		else
+			qDebug("Exported broken file as page coding is not supported");
+		for (int i=0; i<16; i++)
+			writeHamming24_18Packet(26, i);
+	}
+}
+
+QByteArray rowPacketAlways(PageBase *subPage, int packetNumber)
+{
+	if (subPage->packetExists(packetNumber))
+		return subPage->packet(packetNumber);
+	else
+		return QByteArray(40, ' ');
+}
+
+QString exportHashStringPage(LevelOnePage *subPage)
+{
+	int hashDigits[1167]={0};
+	int totalBits, charBit;
+	const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+	QString hashString;
+
+	// TODO int editTFCharacterSet = 5;
+	bool blackForeground = false;
+
+	for (int r=0; r<25; r++) {
+		QByteArray rowPacket = rowPacketAlways(subPage, r);
+		for (int c=0; c<40; c++) {
+			if (rowPacket.at(c) == 0x00 || rowPacket.at(c) == 0x10)
+				blackForeground = true;
+			for (int b=0; b<7; b++) {
+				totalBits = (r * 40 + c) * 7 + b;
+				charBit = ((rowPacket.at(c)) >> (6 - b)) & 0x01;
+				hashDigits[totalBits / 6] |= charBit << (5 - (totalBits % 6));
+			}
+		}
+	}
+
+	hashString.append(QString("#%1:").arg(blackForeground ? 8 : 0, 1, 16));
+
+	for (int i=0; i<1167; i++)
+		hashString.append(base64[hashDigits[i]]);
+
+	return hashString;
+}
+
+QString exportHashStringPackets(LevelOnePage *subPage)
+{
+	auto colourToHexString=[&](int whichCLUT)
+	{
+		QString resultHexString;
+
+		for (int i=whichCLUT*8; i<whichCLUT*8+8; i++)
+			resultHexString.append(QString("%1").arg(subPage->CLUT(i), 3, 16, QChar('0')));
+		return resultHexString;
+	};
+
+	const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+	QString result;
+
+	if (subPage->packetExists(28,0) || subPage->packetExists(28,4)) {
+		// X/28/0 and X/28/4 are duplicates apart from the CLUT definitions
+		// Assemble the duplicate beginning and ending of both packets
+		QString x28StringBegin, x28StringEnd;
+
+		x28StringBegin.append(QString("00%1").arg((subPage->defaultCharSet() << 3) | subPage->defaultNOS(), 2, 16, QChar('0')).toUpper());
+		x28StringBegin.append(QString("%1").arg((subPage->secondCharSet() << 3) | subPage->secondNOS(), 2, 16, QChar('0')).toUpper());
+		x28StringBegin.append(QString("%1%2%3%4").arg(subPage->leftSidePanelDisplayed(), 1, 10).arg(subPage->rightSidePanelDisplayed(), 1, 10).arg(subPage->sidePanelStatusL25(), 1, 10).arg(subPage->sidePanelColumns(), 1, 16));
+
+		x28StringEnd = QString("%1%2%3%4").arg(subPage->defaultScreenColour(), 2, 16, QChar('0')).arg(subPage->defaultRowColour(), 2, 16, QChar('0')).arg(subPage->blackBackgroundSubst(), 1, 10).arg(subPage->colourTableRemap(), 1, 10);
+
+		if (subPage->packetExists(28,0))
+			result.append(":X280=" + x28StringBegin + colourToHexString(2) + colourToHexString(3) + x28StringEnd);
+		if (subPage->packetExists(28,4))
+			result.append(":X284=" + x28StringBegin + colourToHexString(0) + colourToHexString(1) + x28StringEnd);
+	}
+
+	if (!subPage->enhancements()->isEmpty()) {
+		result.append(":X26=");
+		for (int i=0; i<subPage->enhancements()->size(); i++) {
+			result.append(base64[subPage->enhancements()->at(i).data() >> 1]);
+			result.append(base64[subPage->enhancements()->at(i).mode() | ((subPage->enhancements()->at(i).data() & 1) << 5)]);
+			result.append(base64[subPage->enhancements()->at(i).address()]);
+		}
+	}
+
+	result.append(QString(":PS=%1").arg(0x8000 | controlBitsToPS(subPage), 0, 16, QChar('0')));
+	return result;
+}

src/qteletextmaker/loadsave.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef LOADSAVE_H
+#define LOADSAVE_H
+
+#include <QByteArray>
+#include <QFile>
+#include <QSaveFile>
+#include <QString>
+#include <QTextStream>
+
+#include "document.h"
+#include "levelonepage.h"
+#include "pagebase.h"
+
+void loadTTI(QFile *inFile, TeletextDocument *document);
+void importT42(QFile *inFile, TeletextDocument *document);
+
+int controlBitsToPS(PageBase *subPage);
+
+void saveTTI(QSaveFile &file, const TeletextDocument &document);
+void exportT42File(QSaveFile &file, const TeletextDocument &document);
+void exportM29File(QSaveFile &file, const TeletextDocument &document);
+
+QByteArray rowPacketAlways(PageBase *subPage, int packetNumber);
+
+QString exportHashStringPage(LevelOnePage *subPage);
+QString exportHashStringPackets(LevelOnePage *subPage);
+
+#endif

src/qteletextmaker/main.cpp

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QApplication>
+#include <QCommandLineParser>
+
+#include "mainwindow.h"
+
+int main(int argc, char *argv[])
+{
+	Q_INIT_RESOURCE(actionicons);
+	QApplication app(argc, argv);
+	QApplication::setApplicationName("QTeletextMaker");
+	QApplication::setApplicationDisplayName(QApplication::applicationName());
+	QApplication::setOrganizationName("gkmac.co.uk");
+	QApplication::setOrganizationDomain("gkmac.co.uk");
+	QApplication::setApplicationVersion("0.6.4-beta");
+	QCommandLineParser parser;
+	parser.setApplicationDescription(QApplication::applicationName());
+	parser.addHelpOption();
+	parser.addVersionOption();
+	parser.addPositionalArgument("file", "The file(s) to open.");
+	parser.process(app);
+
+	MainWindow *mainWin = Q_NULLPTR;
+	foreach (const QString &file, parser.positionalArguments()) {
+		MainWindow *newWin = new MainWindow(file);
+		newWin->tile(mainWin);
+		newWin->show();
+		mainWin = newWin;
+	}
+
+	if (!mainWin)
+		mainWin = new MainWindow;
+	mainWin->show();
+
+	return app.exec();
+}

src/qteletextmaker/mainwidget.cpp

@@ -0,0 +1,797 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QApplication>
+#include <QBitmap>
+#include <QClipboard>
+#include <QFrame>
+#include <QGraphicsItem>
+#include <QGraphicsItemGroup>
+#include <QGraphicsProxyWidget>
+#include <QGraphicsScene>
+#include <QGraphicsSceneEvent>
+#include <QImage>
+#include <QKeyEvent>
+#include <QMenu>
+#include <QMimeData>
+#include <QPainter>
+#include <QPair>
+#include <QSet>
+#include <QUndoCommand>
+#include <QWidget>
+#include <vector>
+#include <iostream>
+
+#include "mainwidget.h"
+
+#include "decode.h"
+#include "document.h"
+#include "keymap.h"
+#include "levelonecommands.h"
+#include "levelonepage.h"
+#include "render.h"
+#include "x26triplets.h"
+
+TeletextWidget::TeletextWidget(QFrame *parent) : QFrame(parent)
+{
+	this->resize(QSize(480, 250));
+	this->setAttribute(Qt::WA_NoSystemBackground);
+	this->setAttribute(Qt::WA_InputMethodEnabled, true);
+	m_teletextDocument = new TeletextDocument();
+	m_levelOnePage = m_teletextDocument->currentSubPage();
+	m_pageDecode.setTeletextPage(m_levelOnePage);
+	m_pageRender.setDecoder(&m_pageDecode);
+	m_insertMode = false;
+	m_selectionInProgress = false;
+	setFocusPolicy(Qt::StrongFocus);
+	m_flashTiming = m_flashPhase = 0;
+	connect(&m_pageRender, &TeletextPageRender::flashChanged, this, &TeletextWidget::updateFlashTimer);
+	connect(&m_pageDecode, &TeletextPageDecode::sidePanelsChanged, this, &TeletextWidget::changeSize);
+	connect(m_teletextDocument, &TeletextDocument::subPageSelected, this, &TeletextWidget::subPageSelected);
+	connect(m_teletextDocument, &TeletextDocument::contentsChanged, this, &TeletextWidget::refreshPage);
+	connect(m_teletextDocument, &TeletextDocument::colourChanged, &m_pageRender, &TeletextPageRender::colourChanged);
+}
+
+TeletextWidget::~TeletextWidget()
+{
+	if (m_flashTimer.isActive())
+		m_flashTimer.stop();
+	delete m_teletextDocument;
+}
+
+// Re-implemented so compose/dead keys work properly
+void TeletextWidget::inputMethodEvent(QInputMethodEvent* event)
+{
+	if (!event->commitString().isEmpty()) {
+		QKeyEvent keyEvent(QEvent::KeyPress, 0, Qt::NoModifier, event->commitString());
+
+		keyPressEvent(&keyEvent);
+	}
+	event->accept();
+}
+
+void TeletextWidget::subPageSelected()
+{
+	m_levelOnePage = m_teletextDocument->currentSubPage();
+	m_pageDecode.setTeletextPage(m_levelOnePage);
+	m_pageDecode.decodePage();
+	m_pageRender.renderPage(true);
+	update();
+}
+
+void TeletextWidget::refreshPage()
+{
+	m_pageDecode.decodePage();
+	update();
+}
+
+void TeletextWidget::paintEvent(QPaintEvent *event)
+{
+	Q_UNUSED(event);
+	QPainter widgetPainter(this);
+
+	m_pageRender.renderPage();
+	widgetPainter.drawImage(m_pageDecode.leftSidePanelColumns()*12, 0, *m_pageRender.image(m_flashPhase), 0, 0, 480, 250);
+	if (m_pageDecode.leftSidePanelColumns())
+		widgetPainter.drawImage(0, 0, *m_pageRender.image(m_flashPhase), 864-m_pageDecode.leftSidePanelColumns()*12, 0, m_pageDecode.leftSidePanelColumns()*12, 250);
+	if (m_pageDecode.rightSidePanelColumns())
+		widgetPainter.drawImage(480+m_pageDecode.leftSidePanelColumns()*12, 0, *m_pageRender.image(m_flashPhase), 480, 0, m_pageDecode.rightSidePanelColumns()*12, 250);
+}
+
+void TeletextWidget::updateFlashTimer(int newFlashTimer)
+{
+	m_flashTiming = newFlashTimer;
+	m_flashPhase = 0;
+	if (newFlashTimer == 0) {
+		m_flashTimer.stop();
+		update();
+		return;
+	}
+	m_flashTimer.start((newFlashTimer == 1) ? 500 : 167, this);
+}
+
+void TeletextWidget::timerEvent(QTimerEvent *event)
+{
+	if (event->timerId() == m_flashTimer.timerId()) {
+		if (m_flashTiming == 1)
+			m_flashPhase += 3;
+		else
+			m_flashPhase++;
+		if (m_flashPhase == 6)
+			m_flashPhase = 0;
+		update();
+	} else
+		QWidget::timerEvent(event);
+}
+
+void TeletextWidget::pauseFlash(bool pauseNow)
+{
+	if (pauseNow && m_flashTiming != 0) {
+		m_flashTimer.stop();
+		m_flashPhase = 0;
+		update();
+	} else if (m_flashTiming != 0)
+		m_flashTimer.start((m_flashTiming == 1) ? 500 : 167, this);
+}
+
+void TeletextWidget::setInsertMode(bool insertMode)
+{
+	m_insertMode = insertMode;
+}
+
+void TeletextWidget::setReveal(bool reveal)
+{
+	m_pageRender.setReveal(reveal);
+	update();
+}
+
+void TeletextWidget::setMix(bool mix)
+{
+	m_pageRender.setMix(mix);
+	update();
+}
+
+void TeletextWidget::setShowControlCodes(bool showControlCodes)
+{
+	m_pageRender.setShowControlCodes(showControlCodes);
+	update();
+}
+
+void TeletextWidget::setControlBit(int bitNumber, bool active)
+{
+	m_levelOnePage->setControlBit(bitNumber, active);
+	if (bitNumber == 1 || bitNumber == 2) {
+		m_pageDecode.decodePage();
+		m_pageRender.renderPage(true);
+		update();
+	}
+}
+
+void TeletextWidget::setDefaultCharSet(int newDefaultCharSet)
+{
+	m_levelOnePage->setDefaultCharSet(newDefaultCharSet);
+}
+
+void TeletextWidget::setDefaultNOS(int newDefaultNOS)
+{
+	m_levelOnePage->setDefaultNOS(newDefaultNOS);
+}
+
+void TeletextWidget::setSidePanelWidths(int newLeftSidePanelColumns, int newRightSidePanelColumns)
+{
+	m_levelOnePage->setLeftSidePanelDisplayed(newLeftSidePanelColumns != 0);
+	m_levelOnePage->setRightSidePanelDisplayed(newRightSidePanelColumns != 0);
+	if (newLeftSidePanelColumns)
+		m_levelOnePage->setSidePanelColumns((newLeftSidePanelColumns == 16) ? 0 : newLeftSidePanelColumns);
+	else
+		m_levelOnePage->setSidePanelColumns((newRightSidePanelColumns == 0) ? 0 : 16-newRightSidePanelColumns);
+	m_pageDecode.updateSidePanels();
+}
+
+void TeletextWidget::setSidePanelAtL35Only(bool newSidePanelAtL35Only)
+{
+	m_levelOnePage->setSidePanelStatusL25(!newSidePanelAtL35Only);
+	m_pageDecode.updateSidePanels();
+}
+
+void TeletextWidget::changeSize()
+{
+	setFixedSize(QSize(480+(pageDecode()->leftSidePanelColumns()+pageDecode()->rightSidePanelColumns())*12, 250));
+	emit sizeChanged();
+}
+
+void TeletextWidget::keyPressEvent(QKeyEvent *event)
+{
+	if (event->key() < 0x01000000) {
+		// A character-typing key was pressed
+		// Try to keymap it, if not keymapped then plain ASCII code (may be) returned
+		char mappedKeyPress = keymapping[m_pageDecode.level1CharSet(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn())].value(event->text().at(0), *qPrintable(event->text().at(0)));
+		if (mappedKeyPress >= 0x00 && mappedKeyPress <= 0x1f)
+			return;
+		// If outside ASCII map then the character can't be represented by current Level 1 character set
+		// Map it to block character so it doesn't need to be inserted-between later on
+		if (mappedKeyPress & 0x80)
+			mappedKeyPress = 0x7f;
+		if (m_pageDecode.level1MosaicAttr(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn()) && (mappedKeyPress < 0x40 || mappedKeyPress > 0x5f)) {
+			// We're on a mosaic and a blast-through character was NOT pressed
+			if (event->key() >= Qt::Key_0 && event->key() <= Qt::Key_9 && event->modifiers() & Qt::KeypadModifier) {
+				switch (event->key()) {
+					case Qt::Key_7:
+						toggleCharacterBit(0x01); // Top left
+						break;
+					case Qt::Key_8:
+						toggleCharacterBit(0x02); // Top right
+						break;
+					case Qt::Key_4:
+						toggleCharacterBit(0x04); // Middle left
+						break;
+					case Qt::Key_5:
+						toggleCharacterBit(0x08); // Middle right
+						break;
+					case Qt::Key_1:
+						toggleCharacterBit(0x10); // Bottom left
+						break;
+					case Qt::Key_2:
+						toggleCharacterBit(0x40); // Bottom right
+						break;
+					case Qt::Key_9:
+						toggleCharacterBit(0x5f); // Invert
+						break;
+					case Qt::Key_6:
+						toggleCharacterBit(0x7f); // Set all
+						break;
+					case Qt::Key_3:
+						toggleCharacterBit(0x20); // Clear all
+						break;
+					case Qt::Key_0:
+						toggleCharacterBit(0x66); // Dither
+						break;
+				}
+				return;
+			}
+			if (event->key() == Qt::Key_Space) {
+				setCharacter(0x20);
+				return;
+			}
+
+			// This macro is defined in keymap.h if no native scan codes are defined
+			// for the platform we are compiling on
+#ifndef QTTM_NONATIVESCANCODES
+			if (event->nativeScanCode() > 1) {
+				switch (event->nativeScanCode()) {
+					case mosaicNativeScanCodes[0]:
+						toggleCharacterBit(0x01); // Top left
+						break;
+					case mosaicNativeScanCodes[1]:
+						toggleCharacterBit(0x02); // Top right
+						break;
+					case mosaicNativeScanCodes[2]:
+						toggleCharacterBit(0x04); // Middle left
+						break;
+					case mosaicNativeScanCodes[3]:
+						toggleCharacterBit(0x08); // Middle right
+						break;
+					case mosaicNativeScanCodes[4]:
+						toggleCharacterBit(0x10); // Bottom left
+						break;
+					case mosaicNativeScanCodes[5]:
+						toggleCharacterBit(0x40); // Bottom right
+						break;
+					case mosaicNativeScanCodes[6]:
+						toggleCharacterBit(0x5f); // Invert
+						break;
+					case mosaicNativeScanCodes[7]:
+						toggleCharacterBit(0x7f); // Set all
+						break;
+					case mosaicNativeScanCodes[8]:
+						toggleCharacterBit(0x20); // Clear all
+						break;
+					case mosaicNativeScanCodes[9]:
+						toggleCharacterBit(0x66); // Dither
+						break;
+				}
+				return;
+			} else
+				qDebug("nativeScanCode not usable! Please use numeric keypad to toggle mosaic bits.");
+#else
+			qDebug("nativeScanCode was not compiled in! Please use numeric keypad to toggle mosaic bits.");
+#endif
+
+			// TODO some contingency plan if nativeScanCode didn't work?
+			return;
+		}
+		setCharacter(mappedKeyPress);
+		return;
+	}
+
+	switch (event->key()) {
+		case Qt::Key_Backspace:
+			m_teletextDocument->undoStack()->push(new BackspaceKeyCommand(m_teletextDocument, m_insertMode));
+			break;
+		case Qt::Key_Tab:
+			m_teletextDocument->undoStack()->push(new TypeCharacterCommand(m_teletextDocument, 0x20, true));
+			break;
+		case Qt::Key_Delete:
+			m_teletextDocument->undoStack()->push(new DeleteKeyCommand(m_teletextDocument));
+			break;
+		case Qt::Key_Insert:
+			emit insertKeyPressed();
+			break;
+
+		case Qt::Key_Up:
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
+				m_teletextDocument->cursorUp(event->modifiers() & Qt::ShiftModifier);
+			break;
+		case Qt::Key_Down:
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
+				m_teletextDocument->cursorDown(event->modifiers() & Qt::ShiftModifier);
+			break;
+		case Qt::Key_Left:
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
+				m_teletextDocument->cursorLeft(event->modifiers() & Qt::ShiftModifier);
+			break;
+		case Qt::Key_Right:
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
+				m_teletextDocument->cursorRight(event->modifiers() & Qt::ShiftModifier);
+			break;
+		case Qt::Key_Return:
+		case Qt::Key_Enter:
+			m_teletextDocument->cursorDown();
+			m_teletextDocument->moveCursor(m_teletextDocument->cursorRow(), 0);
+			break;
+		case Qt::Key_Home:
+			m_teletextDocument->moveCursor(m_teletextDocument->cursorRow(), 0, event->modifiers() & Qt::ShiftModifier);
+			break;
+		case Qt::Key_End:
+			m_teletextDocument->moveCursor(m_teletextDocument->cursorRow(), 39, event->modifiers() & Qt::ShiftModifier);
+			break;
+
+		case Qt::Key_PageUp:
+			m_teletextDocument->selectSubPageNext();
+			break;
+		case Qt::Key_PageDown:
+			m_teletextDocument->selectSubPagePrevious();
+			break;
+		default:
+			QFrame::keyPressEvent(event);
+	}
+}
+
+void TeletextWidget::setCharacter(unsigned char newCharacter)
+{
+	m_teletextDocument->undoStack()->push(new TypeCharacterCommand(m_teletextDocument, newCharacter, m_insertMode));
+}
+
+void TeletextWidget::toggleCharacterBit(unsigned char bitToToggle)
+{
+	m_teletextDocument->undoStack()->push(new ToggleMosaicBitCommand(m_teletextDocument, bitToToggle));
+}
+
+void TeletextWidget::shiftMosaics(int key)
+{
+	if (!m_teletextDocument->selectionActive())
+		return;
+
+	QSet<QPair<int, int>> mosaicList;
+
+	for (int r=m_teletextDocument->selectionTopRow(); r<=m_teletextDocument->selectionBottomRow(); r++)
+		for (int c=m_teletextDocument->selectionLeftColumn(); c<=m_teletextDocument->selectionRightColumn(); c++)
+			if (m_pageDecode.level1MosaicChar(r, c))
+				mosaicList.insert(qMakePair(r, c));
+
+	if (!mosaicList.isEmpty())
+		switch (key) {
+			case Qt::Key_Up:
+				m_teletextDocument->undoStack()->push(new ShiftMosaicsUpCommand(m_teletextDocument, mosaicList));
+				break;
+			case Qt::Key_Down:
+				m_teletextDocument->undoStack()->push(new ShiftMosaicsDownCommand(m_teletextDocument, mosaicList));
+				break;
+			case Qt::Key_Left:
+				m_teletextDocument->undoStack()->push(new ShiftMosaicsLeftCommand(m_teletextDocument, mosaicList));
+				break;
+			case Qt::Key_Right:
+				m_teletextDocument->undoStack()->push(new ShiftMosaicsRightCommand(m_teletextDocument, mosaicList));
+				break;
+		}
+}
+
+void TeletextWidget::selectionToClipboard()
+{
+	QByteArray nativeData;
+	QString plainTextData;
+	QImage *imageData = nullptr;
+	QClipboard *clipboard = QApplication::clipboard();
+
+	nativeData.resize(2 + m_teletextDocument->selectionWidth() * m_teletextDocument->selectionHeight());
+	nativeData[0] = m_teletextDocument->selectionHeight();
+	nativeData[1] = m_teletextDocument->selectionWidth();
+
+	plainTextData.reserve((m_teletextDocument->selectionWidth()+1) * m_teletextDocument->selectionHeight() - 1);
+
+	int i = 2;
+
+	for (int r=m_teletextDocument->selectionTopRow(); r<=m_teletextDocument->selectionBottomRow(); r++) {
+		for (int c=m_teletextDocument->selectionLeftColumn(); c<=m_teletextDocument->selectionRightColumn(); c++) {
+			nativeData[i++] = m_teletextDocument->currentSubPage()->character(r, c);
+
+			if (m_teletextDocument->currentSubPage()->character(r, c) >= 0x20)
+				plainTextData.append(keymapping[m_pageDecode.level1CharSet(r, c)].key(m_teletextDocument->currentSubPage()->character(r, c), QChar(m_teletextDocument->currentSubPage()->character(r, c))));
+			else
+				plainTextData.append(' ');
+
+			if (m_pageDecode.level1MosaicChar(r, c)) {
+				// A first mosaic character was found so create the image "just in time"
+				if (imageData == nullptr) {
+					imageData = new QImage(m_teletextDocument->selectionWidth() * 2, m_teletextDocument->selectionHeight() * 3, QImage::Format_Mono);
+
+					imageData->fill(0);
+				}
+
+				const int ix = (c - m_teletextDocument->selectionLeftColumn()) * 2;
+				const int iy = (r - m_teletextDocument->selectionTopRow()) * 3;
+
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x01)
+					imageData->setPixel(ix, iy, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x02)
+					imageData->setPixel(ix+1, iy, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x04)
+					imageData->setPixel(ix, iy+1, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x08)
+					imageData->setPixel(ix+1, iy+1, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x10)
+					imageData->setPixel(ix, iy+2, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x40)
+					imageData->setPixel(ix+1, iy+2, 1);
+			}
+		}
+
+		plainTextData.append('\n');
+	}
+
+	QMimeData *mimeData = new QMimeData();
+	mimeData->setData("application/x-teletext", nativeData);
+	mimeData->setText(plainTextData);
+	if (imageData != nullptr) {
+		mimeData->setImageData(*imageData);
+		delete imageData;
+	}
+
+	clipboard->setMimeData(mimeData);
+}
+
+void TeletextWidget::cut()
+{
+	if (!m_teletextDocument->selectionActive())
+		return;
+
+	selectionToClipboard();
+	m_teletextDocument->undoStack()->push(new CutCommand(m_teletextDocument));
+}
+
+void TeletextWidget::copy()
+{
+	if (!m_teletextDocument->selectionActive())
+		return;
+
+	selectionToClipboard();
+}
+
+void TeletextWidget::paste()
+{
+	m_teletextDocument->undoStack()->push(new PasteCommand(m_teletextDocument, m_pageDecode.level1CharSet(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn())));
+}
+
+QPair<int, int> TeletextWidget::mouseToRowAndColumn(const QPoint &mousePosition)
+{
+	int row = mousePosition.y() / 10;
+	int column = mousePosition.x() / 12 - m_pageDecode.leftSidePanelColumns();
+	if (row < 1)
+		row = 1;
+	if (row > 24)
+		row = 24;
+	if (column < 0)
+		column = 0;
+	if (column > 39)
+		column = 39;
+	return qMakePair(row, column);
+}
+
+void TeletextWidget::mousePressEvent(QMouseEvent *event)
+{
+	if (event->button() == Qt::LeftButton) {
+		m_teletextDocument->cancelSelection();
+		QPair<int, int> position = mouseToRowAndColumn(event->pos());
+		m_teletextDocument->moveCursor(position.first, position.second);
+		update();
+	}
+}
+
+void TeletextWidget::mouseMoveEvent(QMouseEvent *event)
+{
+	if (event->buttons() & Qt::LeftButton) {
+		QPair<int, int> position = mouseToRowAndColumn(event->pos());
+		if (position.first != m_teletextDocument->cursorRow() || position.second != m_teletextDocument->cursorColumn()) {
+			if (!m_selectionInProgress) {
+				m_selectionInProgress = true;
+				m_teletextDocument->setSelectionCorner(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn());
+			}
+			m_teletextDocument->moveCursor(position.first, position.second, true);
+		}
+	}
+}
+
+void TeletextWidget::mouseReleaseEvent(QMouseEvent *event)
+{
+	if (event->button() == Qt::LeftButton)
+		m_selectionInProgress = false;
+}
+
+void TeletextWidget::focusInEvent(QFocusEvent *event)
+{
+	QFrame::focusInEvent(event);
+}
+
+void TeletextWidget::focusOutEvent(QFocusEvent *event)
+{
+	QFrame::focusOutEvent(event);
+}
+
+
+LevelOneScene::LevelOneScene(QWidget *levelOneWidget, QObject *parent) : QGraphicsScene(parent)
+{
+	m_grid = false;
+
+	// These dimensions are scratch, setBorderDimensions will get called straight away to adjust them
+	setSceneRect(0, 0, 600, 288);
+
+	// Full screen colours
+	m_fullScreenTopRectItem = new QGraphicsRectItem(0, 0, 600, 19);
+	m_fullScreenTopRectItem->setPen(Qt::NoPen);
+	m_fullScreenTopRectItem->setBrush(QBrush(QColor(0, 0, 0)));
+	addItem(m_fullScreenTopRectItem);
+	m_fullScreenBottomRectItem = new QGraphicsRectItem(0, 269, 600, 19);
+	m_fullScreenBottomRectItem->setPen(Qt::NoPen);
+	m_fullScreenBottomRectItem->setBrush(QBrush(QColor(0, 0, 0)));
+	addItem(m_fullScreenBottomRectItem);
+
+	// Full row colours
+	for (int r=0; r<25; r++) {
+		m_fullRowLeftRectItem[r] = new QGraphicsRectItem(0, 19+r*10, 60, 10);
+		m_fullRowLeftRectItem[r]->setPen(Qt::NoPen);
+		m_fullRowLeftRectItem[r]->setBrush(QBrush(QColor(0, 0, 0)));
+		addItem(m_fullRowLeftRectItem[r]);
+		m_fullRowRightRectItem[r] = new QGraphicsRectItem(540, 19+r*10, 60, 10);
+		m_fullRowRightRectItem[r]->setPen(Qt::NoPen);
+		m_fullRowRightRectItem[r]->setBrush(QBrush(QColor(0, 0, 0)));
+		addItem(m_fullRowRightRectItem[r]);
+	}
+
+	// Main text widget
+	m_levelOneProxyWidget = addWidget(levelOneWidget);
+	m_levelOneProxyWidget->setPos(60, 19);
+	m_levelOneProxyWidget->setAutoFillBackground(false);
+	m_levelOneProxyWidget->setFocus();
+
+	// Selection
+	m_selectionRectItem = new QGraphicsRectItem(0, 0, 12, 10);
+	m_selectionRectItem->setVisible(false);
+	m_selectionRectItem->setPen(QPen(QColor(192, 192, 192), 1, Qt::DashLine));
+	m_selectionRectItem->setBrush(QBrush(QColor(255, 255, 255, 64)));
+	addItem(m_selectionRectItem);
+
+	// Cursor
+	m_cursorRectItem = new QGraphicsRectItem(0, 0, 12, 10);
+	m_cursorRectItem->setPen(Qt::NoPen);
+	m_cursorRectItem->setBrush(QBrush(QColor(128, 128, 128, 192)));
+	addItem(m_cursorRectItem);
+
+	// Optional grid overlay for text widget
+	m_mainGridItemGroup = new QGraphicsItemGroup;
+	m_mainGridItemGroup->setVisible(false);
+	addItem(m_mainGridItemGroup);
+	// Additional vertical pieces of grid for side panels
+	for (int i=0; i<32; i++) {
+		m_sidePanelGridNeeded[i] = false;
+		m_sidePanelGridItemGroup[i] = new QGraphicsItemGroup;
+		m_sidePanelGridItemGroup[i]->setVisible(false);
+		addItem(m_sidePanelGridItemGroup[i]);
+	}
+	for (int r=1; r<25; r++) {
+		for (int c=0; c<40; c++) {
+			QGraphicsRectItem *gridPiece = new QGraphicsRectItem(c*12, r*10, 12, 10);
+			gridPiece->setPen(QPen(QBrush(QColor(128, 128, 128, r<24 ? 192 : 128)), 0));
+			m_mainGridItemGroup->addToGroup(gridPiece);
+		}
+
+		if (r < 24)
+			for (int c=0; c<32; c++) {
+				QGraphicsRectItem *gridPiece = new QGraphicsRectItem(0, r*10, 12, 10);
+				gridPiece->setPen(QPen(QBrush(QColor(128, 128, 128, 64)), 0));
+				m_sidePanelGridItemGroup[c]->addToGroup(gridPiece);
+			}
+	}
+
+	installEventFilter(this);
+}
+
+void LevelOneScene::setBorderDimensions(int sceneWidth, int sceneHeight, int widgetWidth, int leftSidePanelColumns, int rightSidePanelColumns)
+{
+	setSceneRect(0, 0, sceneWidth, sceneHeight);
+
+	// Assume text widget height is always 250
+	int topBottomBorders = (sceneHeight-250) / 2;
+	// Ideally we'd use m_levelOneProxyWidget->size() to discover the widget width ourselves
+	// but this causes a stubborn segfault, so we have to receive the widgetWidth as a parameter
+	int leftRightBorders = (sceneWidth-widgetWidth) / 2;
+
+	m_levelOneProxyWidget->setPos(leftRightBorders, topBottomBorders);
+
+	// Position grid to cover central 40 columns
+	m_mainGridItemGroup->setPos(leftRightBorders + leftSidePanelColumns*12, topBottomBorders);
+
+	updateCursor();
+	updateSelection();
+
+	// Grid for right side panel
+	for (int c=0; c<16; c++)
+		if (rightSidePanelColumns > c) {
+			m_sidePanelGridItemGroup[c]->setPos(leftRightBorders + leftSidePanelColumns*12 + 480 + c*12, topBottomBorders);
+			m_sidePanelGridItemGroup[c]->setVisible(m_grid);
+			m_sidePanelGridNeeded[c] = true;
+		} else {
+			m_sidePanelGridItemGroup[c]->setVisible(false);
+			m_sidePanelGridNeeded[c] = false;
+		}
+	// Grid for left side panel
+	for (int c=0; c<16; c++)
+		if (c < leftSidePanelColumns) {
+			m_sidePanelGridItemGroup[31-c]->setPos(leftRightBorders + (leftSidePanelColumns-c-1)*12, topBottomBorders);
+			m_sidePanelGridItemGroup[31-c]->setVisible(m_grid);
+			m_sidePanelGridNeeded[31-c] = true;
+		} else {
+			m_sidePanelGridItemGroup[31-c]->setVisible(false);
+			m_sidePanelGridNeeded[31-c] = false;
+		}
+
+	// Full screen colours
+	m_fullScreenTopRectItem->setRect(0, 0, sceneWidth, topBottomBorders);
+	m_fullScreenBottomRectItem->setRect(0, 250+topBottomBorders, sceneWidth, topBottomBorders);
+	// Full row colours
+	for (int r=0; r<25; r++) {
+		m_fullRowLeftRectItem[r]->setRect(0, topBottomBorders+r*10, leftRightBorders+1, 10);
+		m_fullRowRightRectItem[r]->setRect(sceneWidth-leftRightBorders-1, topBottomBorders+r*10, leftRightBorders+1, 10);
+	}
+}
+
+void LevelOneScene::updateCursor()
+{
+	m_cursorRectItem->setPos(m_mainGridItemGroup->pos().x() + static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->cursorColumn()*12, m_mainGridItemGroup->pos().y() + static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->cursorRow()*10);
+}
+
+void LevelOneScene::updateSelection()
+{
+	if (!static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->selectionActive()) {
+		m_selectionRectItem->setVisible(false);
+		return;
+	}
+
+	m_selectionRectItem->setRect(m_mainGridItemGroup->pos().x() + static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->selectionLeftColumn()*12, m_mainGridItemGroup->pos().y() + static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->selectionTopRow()*10, static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->selectionWidth()*12-1, static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->selectionHeight()*10-1);
+
+	m_selectionRectItem->setVisible(true);
+}
+
+void LevelOneScene::setMix(bool mix)
+{
+	if (mix) {
+		m_fullScreenTopRectItem->setBrush(Qt::transparent);
+		m_fullScreenBottomRectItem->setBrush(Qt::transparent);
+		for (int r=0; r<25; r++) {
+			m_fullRowLeftRectItem[r]->setBrush(Qt::transparent);
+			m_fullRowRightRectItem[r]->setBrush(Qt::transparent);
+		}
+	} else {
+		setFullScreenColour(static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageDecode()->fullScreenQColor());
+		for (int r=0; r<25; r++)
+			setFullRowColour(r, static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageDecode()->fullRowQColor(r));
+	}
+}
+
+void LevelOneScene::toggleGrid(bool gridOn)
+{
+	m_grid = gridOn;
+	m_mainGridItemGroup->setVisible(gridOn);
+	for (int i=0; i<32; i++)
+		if (m_sidePanelGridNeeded[i])
+			m_sidePanelGridItemGroup[i]->setVisible(gridOn);
+}
+
+void LevelOneScene::hideGUIElements(bool hidden)
+{
+	if (hidden) {
+		m_cursorRectItem->setVisible(false);
+		m_selectionRectItem->setVisible(false);
+	} else {
+		if (static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->selectionActive())
+			m_selectionRectItem->setVisible(true);
+
+		m_cursorRectItem->setVisible(true);
+	}
+}
+
+// Implements Ctrl+mousewheel zoom
+bool LevelOneScene::eventFilter(QObject *object, QEvent *event)
+{
+	Q_UNUSED(object);
+
+	if (event->type() == QEvent::GraphicsSceneWheel && static_cast<QGraphicsSceneWheelEvent *>(event)->modifiers() == Qt::ControlModifier) {
+		if (static_cast<QGraphicsSceneWheelEvent *>(event)->delta() > 0)
+			emit mouseZoomIn();
+		else if (static_cast<QGraphicsSceneWheelEvent *>(event)->delta() < 0)
+			emit mouseZoomOut();
+
+		event->accept();
+		return true;
+	}
+	return false;
+}
+
+// Clicking outside the main text widget but still within the scene would
+// cause keyboard focus loss.
+// So on every keypress within the scene, wrench the focus back to the widget
+// if necessary.
+void LevelOneScene::keyPressEvent(QKeyEvent *keyEvent)
+{
+	if (focusItem() != m_levelOneProxyWidget)
+		setFocusItem(m_levelOneProxyWidget);
+
+	QGraphicsScene::keyPressEvent(keyEvent);
+}
+
+void LevelOneScene::keyReleaseEvent(QKeyEvent *keyEvent)
+{
+	if (focusItem() != m_levelOneProxyWidget)
+		setFocusItem(m_levelOneProxyWidget);
+
+	QGraphicsScene::keyReleaseEvent(keyEvent);
+}
+
+void LevelOneScene::setFullScreenColour(const QColor &newColor)
+{
+	if (!static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageRender()->mix()) {
+		m_fullScreenTopRectItem->setBrush(newColor);
+		m_fullScreenBottomRectItem->setBrush(newColor);
+	}
+}
+
+void LevelOneScene::setFullRowColour(int row, const QColor &newColor)
+{
+	if (!static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageRender()->mix()) {
+		m_fullRowLeftRectItem[row]->setBrush(newColor);
+		m_fullRowRightRectItem[row]->setBrush(newColor);
+	}
+}

src/qteletextmaker/mainwidget.h

@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAINWIDGET_H
+#define MAINWIDGET_H
+
+#include <QBasicTimer>
+#include <QFrame>
+#include <QGraphicsItemGroup>
+#include <QGraphicsProxyWidget>
+#include <QGraphicsScene>
+#include <QPair>
+#include <QTextStream>
+#include <vector>
+
+#include "decode.h"
+#include "document.h"
+#include "levelonepage.h"
+#include "render.h"
+
+class QPaintEvent;
+
+class TeletextWidget : public QFrame
+{
+	Q_OBJECT
+
+public:
+	TeletextWidget(QFrame *parent = 0);
+	~TeletextWidget();
+	void setCharacter(unsigned char newCharacter);
+	void toggleCharacterBit(unsigned char bitToToggle);
+	bool insertMode() const { return m_insertMode; };
+	void setInsertMode(bool insertMode);
+	bool showControlCodes() const { return m_pageRender.showControlCodes(); };
+
+	QSize sizeHint() { return QSize(480+(pageDecode()->leftSidePanelColumns()+pageDecode()->rightSidePanelColumns())*12, 250); }
+
+	void inputMethodEvent(QInputMethodEvent *event);
+
+	TeletextDocument* document() const { return m_teletextDocument; }
+	TeletextPageDecode *pageDecode() { return &m_pageDecode; }
+	TeletextPageRender *pageRender() { return &m_pageRender; }
+
+signals:
+	void sizeChanged();
+	void insertKeyPressed();
+
+public slots:
+	void subPageSelected();
+	void refreshPage();
+	void setReveal(bool reveal);
+	void setMix(bool mix);
+	void setShowControlCodes(bool showControlCodes);
+	void updateFlashTimer(int newFlashTimer);
+	void pauseFlash(bool pauseNow);
+
+	void setControlBit(int bitNumber, bool active);
+	void setDefaultCharSet(int newDefaultCharSet);
+	void setDefaultNOS(int newDefaultNOS);
+	void setSidePanelWidths(int newLeftSidePanelColumns, int newRightSidePanelColumns);
+	void setSidePanelAtL35Only(bool newSidePanelAtL35Only);
+
+	void cut();
+	void copy();
+	void paste();
+
+	void changeSize();
+
+protected:
+	void paintEvent(QPaintEvent *event) override;
+	void keyPressEvent(QKeyEvent *event) override;
+	void mousePressEvent(QMouseEvent *event) override;
+	void mouseMoveEvent(QMouseEvent *event) override;
+	void mouseReleaseEvent(QMouseEvent *event) override;
+	void focusInEvent(QFocusEvent *event) override;
+	void focusOutEvent(QFocusEvent *event) override;
+
+	TeletextPageDecode m_pageDecode;
+	TeletextPageRender m_pageRender;
+
+private:
+	TeletextDocument* m_teletextDocument;
+	LevelOnePage* m_levelOnePage;
+	bool m_insertMode, m_selectionInProgress;
+	QBasicTimer m_flashTimer;
+	int m_flashTiming, m_flashPhase;
+
+	void timerEvent(QTimerEvent *event) override;
+	void shiftMosaics(int key);
+	void selectionToClipboard();
+
+	QPair<int, int> mouseToRowAndColumn(const QPoint &mousePosition);
+};
+
+class LevelOneScene : public QGraphicsScene
+{
+	Q_OBJECT
+
+public:
+	LevelOneScene(QWidget *levelOneWidget, QObject *parent = nullptr);
+	void setBorderDimensions(int sceneWidth, int sceneHeight, int widgetWidth, int leftSidePanelColumns, int rightSidePanelColumns);
+	QGraphicsRectItem *cursorRectItem() const { return m_cursorRectItem; }
+
+public slots:
+	void updateCursor();
+	void updateSelection();
+	void setMix(bool mix);
+	void toggleGrid(bool gridOn);
+	void hideGUIElements(bool hidden);
+	void setFullScreenColour(const QColor &newColor);
+	void setFullRowColour(int row, const QColor &newColor);
+
+signals:
+	void mouseZoomIn();
+	void mouseZoomOut();
+
+protected:
+	bool eventFilter(QObject *object, QEvent *event);
+	void keyPressEvent(QKeyEvent *event);
+	void keyReleaseEvent(QKeyEvent *keyEvent);
+
+private:
+	QGraphicsRectItem *m_fullScreenTopRectItem, *m_fullScreenBottomRectItem;
+	QGraphicsRectItem *m_fullRowLeftRectItem[25], *m_fullRowRightRectItem[25];
+	QGraphicsProxyWidget *m_levelOneProxyWidget;
+	QGraphicsRectItem *m_cursorRectItem, *m_selectionRectItem;
+	QGraphicsItemGroup *m_mainGridItemGroup, *m_sidePanelGridItemGroup[32];
+	bool m_grid, m_sidePanelGridNeeded[32];
+};
+
+#endif

src/qteletextmaker/mainwindow.h

@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QCheckBox>
+#include <QGraphicsProxyWidget>
+#include <QGraphicsScene>
+#include <QGraphicsView>
+#include <QMainWindow>
+#include <QLabel>
+#include <QPushButton>
+#include <QSlider>
+#include <QToolButton>
+
+#include "mainwidget.h"
+#include "pagecomposelinksdockwidget.h"
+#include "pageenhancementsdockwidget.h"
+#include "pageoptionsdockwidget.h"
+#include "palettedockwidget.h"
+#include "x26dockwidget.h"
+
+class QAction;
+class QMenu;
+class TeletextWidget;
+
+class MainWindow : public QMainWindow
+{
+	Q_OBJECT
+
+public:
+	MainWindow();
+	explicit MainWindow(const QString &fileName);
+
+	void tile(const QMainWindow *previous);
+
+protected:
+	void closeEvent(QCloseEvent *event) override;
+
+private slots:
+	void newFile();
+	void open();
+	bool save();
+	bool saveAs();
+	void reload();
+	void exportAuto();
+	void exportT42(bool fromAuto);
+	void exportZXNet();
+	void exportEditTF();
+	void exportPNG();
+	void exportM29();
+	void updateRecentFileActions();
+	void updateExportAutoAction();
+	void openRecentFile();
+	void about();
+	void updatePageWidgets();
+	void updateCursorPosition();
+
+	void insertRow(bool copyRow);
+	void deleteRow();
+	void insertSubPage(bool afterCurrentSubPage, bool copyCurrentSubPage);
+	void deleteSubPage();
+
+	void setSceneDimensions();
+	void setBorder(int newViewBorder);
+	void setAspectRatio(int newViewAspectRatio);
+	void setSmoothTransform(bool smoothTransform);
+	void zoomIn();
+	void zoomOut();
+	void zoomSet(int viewZoom);
+	void zoomReset();
+
+	void toggleInsertMode();
+
+private:
+	enum { m_MaxRecentFiles = 10 };
+	const float aspectRatioHorizontalScaling[4] = { 0.6, 0.6, 0.8, 0.5 };
+
+	void init();
+	void createActions();
+	void createStatusBar();
+	void readSettings();
+	void writeSettings();
+	bool maybeSave();
+	void openFile(const QString &fileName);
+	void loadFile(const QString &fileName);
+	static bool hasRecentFiles();
+	void prependToRecentFiles(const QString &fileName);
+	void setRecentFilesVisible(bool visible);
+	bool saveFile(const QString &fileName);
+	void setCurrentFile(const QString &fileName);
+	static QString strippedName(const QString &fullFileName);
+	MainWindow *findMainWindow(const QString &fileName) const;
+
+	TeletextWidget *m_textWidget;
+	LevelOneScene *m_textScene;
+	QGraphicsView *m_textView;
+
+	int m_viewBorder, m_viewAspectRatio, m_viewZoom;
+	bool m_viewSmoothTransform;
+	PageOptionsDockWidget *m_pageOptionsDockWidget;
+	PageEnhancementsDockWidget *m_pageEnhancementsDockWidget;
+	X26DockWidget *m_x26DockWidget;
+	PaletteDockWidget *m_paletteDockWidget;
+	PageComposeLinksDockWidget *m_pageComposeLinksDockWidget;
+
+	QAction *m_recentFileActs[m_MaxRecentFiles];
+	QAction *m_recentFileSeparator;
+	QAction *m_recentFileSubMenuAct;
+	QAction *m_exportAutoAct;
+	QAction *m_deleteSubPageAction;
+	QAction *m_borderActs[3];
+	QAction *m_aspectRatioActs[4];
+	QAction *m_smoothTransformAction;
+
+	QLabel *m_subPageLabel, *m_cursorPositionLabel;
+	QToolButton *m_previousSubPageButton, *m_nextSubPageButton;
+	QSlider *m_zoomSlider;
+	QPushButton *m_insertModePushButton;
+	QRadioButton *m_levelRadioButton[4];
+
+	QString m_curFile, m_exportAutoFileName;
+	bool m_isUntitled;
+};
+
+#endif

src/qteletextmaker/pagecomposelinksdockwidget.cpp

@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QCheckBox>
+#include <QComboBox>
+#include <QGridLayout>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMap>
+#include <QPair>
+#include <QRegularExpressionValidator>
+#include <QString>
+
+#include "pagecomposelinksdockwidget.h"
+
+PageComposeLinksDockWidget::PageComposeLinksDockWidget(TeletextWidget *parent): QDockWidget(parent)
+{
+	QVBoxLayout *pageComposeLinksLayout = new QVBoxLayout;
+	QWidget *pageComposeLinksWidget = new QWidget;
+
+	m_parentMainWidget = parent;
+
+	this->setObjectName("PageComposeLinksDockWidget");
+	this->setWindowTitle("Compositional links");
+
+	QGridLayout *x27Layout = new QGridLayout;
+
+	QLabel *levelAllLabel = new QLabel(tr("Levels 2.5 and 3.5"));
+	levelAllLabel->setAlignment(Qt::AlignCenter);
+	x27Layout->addWidget(levelAllLabel, 0, 0, 1, 5);
+
+	// Link functions
+	x27Layout->addWidget(new QLabel(tr("GPOP")),  2, 0, 1, 1);
+	x27Layout->addWidget(new QLabel(tr("POP")),   3, 0, 1, 1);
+	x27Layout->addWidget(new QLabel(tr("GDRCS")), 4, 0, 1, 1);
+	x27Layout->addWidget(new QLabel(tr("DRCS")),  5, 0, 1, 1);
+
+	// Labels across the top
+	x27Layout->addWidget(new QLabel(tr("L2.5")), 1, 1, 1, 1);
+	x27Layout->addWidget(new QLabel(tr("L3.5")),  1, 2, 1, 1);
+	x27Layout->addWidget(new QLabel(tr("Page no")), 1, 3, 1, 1);
+	x27Layout->addWidget(new QLabel(tr("Sub pages required")), 1, 4, 1, 1);
+
+	QLabel *level3p5OnlyLabel = new QLabel(tr("Level 3.5 only"));
+	level3p5OnlyLabel->setAlignment(Qt::AlignCenter);
+	x27Layout->addWidget(level3p5OnlyLabel, 6, 0, 1, 5);
+
+	m_pageNumberValidator = new QRegularExpressionValidator(QRegularExpression("[1-8][0-9A-Fa-f][0-9A-Fa-f]"), this);
+
+	for (int i=0; i<8; i++) {
+		if (i < 4) {
+			// Required at which Levels
+			m_composeLinkLevelCheckbox[i][0] = new QCheckBox(this);
+			x27Layout->addWidget(m_composeLinkLevelCheckbox[i][0], i+2, 1, 1, 1);
+			connect(m_composeLinkLevelCheckbox[i][0], &QCheckBox::stateChanged, [=](bool active) { m_parentMainWidget->document()->currentSubPage()->setComposeLinkLevel2p5(i, active); });
+			m_composeLinkLevelCheckbox[i][1] = new QCheckBox(this);
+			x27Layout->addWidget(m_composeLinkLevelCheckbox[i][1], i+2, 2, 1, 1);
+			connect(m_composeLinkLevelCheckbox[i][1], &QCheckBox::stateChanged, [=](bool active) { m_parentMainWidget->document()->currentSubPage()->setComposeLinkLevel3p5(i, active); });
+		} else {
+			// Selectable link functions for Level 3.5
+			m_composeLinkFunctionComboBox[i-4] = new QComboBox;
+			m_composeLinkFunctionComboBox[i-4]->addItem("GPOP");
+			m_composeLinkFunctionComboBox[i-4]->addItem("POP");
+			m_composeLinkFunctionComboBox[i-4]->addItem("GDRCS");
+			m_composeLinkFunctionComboBox[i-4]->addItem("DRCS");
+			x27Layout->addWidget(m_composeLinkFunctionComboBox[i-4], i+3, 0, 1, 1, Qt::AlignTop);
+			connect(m_composeLinkFunctionComboBox[i-4], QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index) { m_parentMainWidget->document()->currentSubPage()->setComposeLinkFunction(i, index); } );
+		}
+		// Page link
+		m_composeLinkPageNumberLineEdit[i] = new QLineEdit("100");
+		m_composeLinkPageNumberLineEdit[i]->setMaxLength(3);
+		m_composeLinkPageNumberLineEdit[i]->setInputMask(">DHH");
+		m_composeLinkPageNumberLineEdit[i]->setValidator(m_pageNumberValidator);
+		x27Layout->addWidget(m_composeLinkPageNumberLineEdit[i], i+(i<4 ? 2 : 3), 3, 1, 1);
+		connect(m_composeLinkPageNumberLineEdit[i], &QLineEdit::textEdited, [=](QString value) { setComposeLinkPageNumber(i, value); } );
+
+		// Sub page numbers required
+		m_composeLinkSubPageNumbersLineEdit[i] = new QLineEdit(this);
+		x27Layout->addWidget(m_composeLinkSubPageNumbersLineEdit[i], i+(i<4 ? 2 : 3), 4, 1, 1);
+		connect(m_composeLinkSubPageNumbersLineEdit[i], &QLineEdit::textEdited, [=](QString value) { setComposeLinkSubPageNumbers(i, value); } );
+	}
+
+	pageComposeLinksLayout->addLayout(x27Layout);
+
+	pageComposeLinksLayout->addStretch(1);
+
+	pageComposeLinksWidget->setLayout(pageComposeLinksLayout);
+	this->setWidget(pageComposeLinksWidget);
+}
+
+void PageComposeLinksDockWidget::setComposeLinkPageNumber(int linkNumber, const QString &newPageNumberString)
+{
+	// The LineEdit should check if a valid hex number was entered, but just in case...
+	bool newPageNumberOk;
+	int newPageNumberRead = newPageNumberString.toInt(&newPageNumberOk, 16);
+	if ((!newPageNumberOk) || newPageNumberRead < 0x100 || newPageNumberRead > 0x8ff)
+		return;
+
+	// Stored as page link with relative magazine number, convert from absolute page number that was entered
+	newPageNumberRead ^= (m_parentMainWidget->document()->pageNumber() & 0x700);
+	m_parentMainWidget->document()->currentSubPage()->setComposeLinkPageNumber(linkNumber, newPageNumberRead);
+}
+
+void PageComposeLinksDockWidget::setComposeLinkSubPageNumbers(int linkNumber, const QString &newSubPagesString)
+{
+	int newSubPageCodes = 0x0000;
+
+	if (!newSubPagesString.isEmpty()) {
+		// Turn user-entered comma separated subpages and subpage-ranges into bits
+		// First we do the "comma separated"
+		const QStringList items = newSubPagesString.split(QLatin1Char(','), Qt::SkipEmptyParts);
+		// Now see if there's valid single numbers or ranges between the commas
+		for (const QString &item : items) {
+			if (item.isEmpty())
+				return;
+			if (item.contains(QLatin1Char('-'))) {
+				// Dash found, should be a range of subpages: check for two things either side of dash
+				const QStringList rangeItems = item.split('-');
+				if (rangeItems.count() != 2)
+					return;
+				// Now check if the two things are valid numbers 0-15, with first number less than second
+				bool ok1, ok2;
+				const int number1 = rangeItems[0].toInt(&ok1);
+				const int number2 = rangeItems[1].toInt(&ok2);
+				if (!ok1 || !ok2 || number1 < 0 || number2 < 0 || number1 > 15 || number2 > 15 || number2 < number1)
+					return;
+				// Yes, it is a valid range. Apply it to the result
+				for (int i=number1; i<=number2; i++)
+					newSubPageCodes |= (1 << i);
+			} else {
+				// A single thing (maybe extracted between commas): check if the thing is a number 0-15
+				bool ok;
+				const int number = item.toInt(&ok);
+				if (!ok || number < 0 || number > 15)
+					return;
+				// Yes, it is a valid number. Apply it to the result
+				newSubPageCodes |= (1 << number);
+			}
+		}
+	}
+
+	m_parentMainWidget->document()->currentSubPage()->setComposeLinkSubPageCodes(linkNumber, newSubPageCodes);
+}
+
+void PageComposeLinksDockWidget::updateWidgets()
+{
+	for (int i=0; i<8; i++) {
+		if (i >= 4) {
+			m_composeLinkFunctionComboBox[i-4]->blockSignals(true);
+			m_composeLinkFunctionComboBox[i-4]->setCurrentIndex(m_parentMainWidget->document()->currentSubPage()->composeLinkFunction(i));
+			m_composeLinkFunctionComboBox[i-4]->blockSignals(false);
+		} else {
+			m_composeLinkLevelCheckbox[i][0]->blockSignals(true);
+			m_composeLinkLevelCheckbox[i][0]->setChecked(m_parentMainWidget->document()->currentSubPage()->composeLinkLevel2p5(i));
+			m_composeLinkLevelCheckbox[i][0]->blockSignals(false);
+			m_composeLinkLevelCheckbox[i][1]->blockSignals(true);
+			m_composeLinkLevelCheckbox[i][1]->setChecked(m_parentMainWidget->document()->currentSubPage()->composeLinkLevel3p5(i));
+			m_composeLinkLevelCheckbox[i][1]->blockSignals(false);
+		}
+		// Stored as page link with relative magazine number, convert to absolute page number for display
+		int absoluteLinkPageNumber = m_parentMainWidget->document()->currentSubPage()->composeLinkPageNumber(i) ^ (m_parentMainWidget->document()->pageNumber() & 0x700);
+		// Fix magazine 0 to 8
+		if ((absoluteLinkPageNumber & 0x700) == 0x000)
+			absoluteLinkPageNumber |= 0x800;
+		m_composeLinkPageNumberLineEdit[i]->blockSignals(true);
+		m_composeLinkPageNumberLineEdit[i]->setText(QString::number(absoluteLinkPageNumber, 16).toUpper());
+		m_composeLinkPageNumberLineEdit[i]->blockSignals(false);
+
+		// Turn subpage bits into user-friendly comma separated numbers and number-ranges
+		QString rangeString;
+
+		if (m_parentMainWidget->document()->currentSubPage()->composeLinkSubPageCodes(i) != 0x0000) {
+			// First build a list of consecutive ranges seen
+			// The "b-index" is based on https://codereview.stackexchange.com/a/90074
+			QMap<int, QPair<int, int>> ranges;
+			int index = 0;
+			for (int b=0; b<16; b++)
+				if ((m_parentMainWidget->document()->currentSubPage()->composeLinkSubPageCodes(i) >> b) & 0x01) {
+					if (!ranges.contains(b-index))
+						ranges.insert(b-index, qMakePair(b, b));
+					else
+						ranges[b-index].second = b;
+					index++;
+				}
+			// Now go through the list and add single numbers or ranges as appropriate
+			QPair<int, int> range;
+			foreach (range, ranges) {
+				// For second and subsequent entries only, append a comma first
+				if (!rangeString.isEmpty())
+					rangeString.append(',');
+				// Append the single number or the first number of the range
+				rangeString.append(QString("%1").arg(range.first));
+				// If that was part of a range and not a single orphaned number
+				if (range.first != range.second) {
+					// Ranges of 3 or more use a dash. A range of 2 can make do with a comma
+					rangeString.append((range.first+1 == range.second) ? ',' : '-');
+					// Append the second number of the range
+					rangeString.append(QString("%1").arg(range.second));
+				}
+			}
+		}
+		m_composeLinkSubPageNumbersLineEdit[i]->blockSignals(true);
+		m_composeLinkSubPageNumbersLineEdit[i]->setText(rangeString);
+		m_composeLinkSubPageNumbersLineEdit[i]->blockSignals(false);
+	}
+}

src/qteletextmaker/pagecomposelinksdockwidget.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PAGECOMPOSELINKSDOCKWIDGET_H
+#define PAGECOMPOSELINKSDOCKWIDGET_H
+
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDockWidget>
+#include <QLineEdit>
+#include <QRegularExpressionValidator>
+#include <QString>
+
+#include "mainwidget.h"
+
+class PageComposeLinksDockWidget : public QDockWidget
+{
+	Q_OBJECT
+
+public:
+	PageComposeLinksDockWidget(TeletextWidget *parent);
+	void updateWidgets();
+
+private:
+	void setComposeLinkPageNumber(int linkNumber, const QString &newPageNumberString);
+	void setComposeLinkSubPageNumbers(int linkNumber, const QString &newSubPagesString);
+
+	TeletextWidget *m_parentMainWidget;
+	QCheckBox *m_composeLinkLevelCheckbox[4][2]; // For links 0-3
+	QComboBox *m_composeLinkFunctionComboBox[4]; // For links 4-7; remember to subtract 4!
+	QLineEdit *m_composeLinkPageNumberLineEdit[8], *m_composeLinkSubPageNumbersLineEdit[8];
+
+	QRegularExpressionValidator *m_pageNumberValidator;
+};
+
+#endif

src/qteletextmaker/pageenhancementsdockwidget.cpp

@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QCheckBox>
+#include <QComboBox>
+#include <QGridLayout>
+#include <QGroupBox>
+#include <QLabel>
+#include <QSpinBox>
+
+#include "pageenhancementsdockwidget.h"
+
+#include "x28commands.h"
+
+PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent): QDockWidget(parent)
+{
+	QVBoxLayout *pageEnhancementsLayout = new QVBoxLayout;
+	QWidget *pageEnhancementsWidget = new QWidget;
+
+	m_parentMainWidget = parent;
+
+	this->setObjectName("PageEnhancementsDockWidget");
+	this->setWindowTitle("X/28 page enhancements");
+
+	// Colour group box and layout
+	QGroupBox *colourGroupBox = new QGroupBox(tr("Colours"));
+	QGridLayout *colourLayout = new QGridLayout;
+
+	// Default screen and default row colours
+	colourLayout->addWidget(new QLabel(tr("Default screen colour")), 0, 0, 1, 1);
+	colourLayout->addWidget(new QLabel(tr("Default row colour")), 1, 0, 1, 1);
+	m_defaultScreenColourCombo = new QComboBox;
+	m_defaultScreenColourCombo->setModel(m_parentMainWidget->document()->clutModel());
+	m_defaultRowColourCombo = new QComboBox;
+	m_defaultRowColourCombo->setModel(m_parentMainWidget->document()->clutModel());
+	colourLayout->addWidget(m_defaultScreenColourCombo, 0, 1, 1, 1, Qt::AlignTop);
+	connect(m_defaultScreenColourCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->document()->undoStack()->push(new SetFullScreenColourCommand(m_parentMainWidget->document(), index)); });
+	colourLayout->addWidget(m_defaultRowColourCombo, 1, 1, 1, 1, Qt::AlignTop);
+	connect(m_defaultRowColourCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->document()->undoStack()->push(new SetFullRowColourCommand(m_parentMainWidget->document(), index)); });
+
+	// CLUT remapping
+	colourLayout->addWidget(new QLabel(tr("CLUT remapping")), 2, 0, 1, 1);
+	m_colourTableCombo = new QComboBox;
+	m_colourTableCombo->addItem("Fore 0  Back 0");
+	m_colourTableCombo->addItem("Fore 0  Back 1");
+	m_colourTableCombo->addItem("Fore 0  Back 2");
+	m_colourTableCombo->addItem("Fore 1  Back 1");
+	m_colourTableCombo->addItem("Fore 1  Back 2");
+	m_colourTableCombo->addItem("Fore 2  Back 1");
+	m_colourTableCombo->addItem("Fore 2  Back 2");
+	m_colourTableCombo->addItem("Fore 2  Back 3");
+	colourLayout->addWidget(m_colourTableCombo, 2, 1, 1, 1, Qt::AlignTop);
+	connect(m_colourTableCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->document()->undoStack()->push(new SetCLUTRemapCommand(m_parentMainWidget->document(), index)); });
+
+	// Black background colour substitution
+	m_blackBackgroundSubstAct = new QCheckBox("Black background colour substitution");
+	colourLayout->addWidget(m_blackBackgroundSubstAct, 3, 0, 1, 2, Qt::AlignTop);
+	connect(m_blackBackgroundSubstAct, &QCheckBox::stateChanged, [=](int state){ m_parentMainWidget->document()->undoStack()->push(new SetBlackBackgroundSubstCommand(m_parentMainWidget->document(), state)); });
+
+	// Add group box to the main layout
+	colourGroupBox->setLayout(colourLayout);
+	pageEnhancementsLayout->addWidget(colourGroupBox);
+
+
+	// Side panels group box and layout
+	QGroupBox *sidePanelsGroupBox = new QGroupBox(tr("Side panels"));
+	QGridLayout *sidePanelsLayout = new QGridLayout;
+
+	// Side panel columns
+	sidePanelsLayout->addWidget(new QLabel(tr("Left side panel columns")), 0, 0, 1, 1);
+	m_leftSidePanelSpinBox = new QSpinBox(this);
+	m_leftSidePanelSpinBox->setMaximum(16);
+	sidePanelsLayout->addWidget(m_leftSidePanelSpinBox, 0, 1, 1, 1, Qt::AlignTop);
+	connect(m_leftSidePanelSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [=](int index){ setLeftSidePanelWidth(index); });
+
+	sidePanelsLayout->addWidget(new QLabel(tr("Right side panel columns")), 1, 0, 1, 1);
+	m_rightSidePanelSpinBox = new QSpinBox(this);
+	m_rightSidePanelSpinBox->setMaximum(16);
+	sidePanelsLayout->addWidget(m_rightSidePanelSpinBox, 1, 1, 1, 1, Qt::AlignTop);
+	connect(m_rightSidePanelSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [=](int index){ setRightSidePanelWidth(index); });
+
+	// Side panels status
+	m_sidePanelStatusAct = new QCheckBox("Side panels at level 3.5 only");
+	sidePanelsLayout->addWidget(m_sidePanelStatusAct, 2, 0, 1, 2, Qt::AlignTop);
+	connect(m_sidePanelStatusAct, &QCheckBox::stateChanged, m_parentMainWidget, &TeletextWidget::setSidePanelAtL35Only);
+
+	// Add group box to the main layout
+	sidePanelsGroupBox->setLayout(sidePanelsLayout);
+	pageEnhancementsLayout->addWidget(sidePanelsGroupBox);
+
+	pageEnhancementsLayout->addStretch(1);
+
+	pageEnhancementsWidget->setLayout(pageEnhancementsLayout);
+	this->setWidget(pageEnhancementsWidget);
+}
+
+void PageEnhancementsDockWidget::setLeftSidePanelWidth(int newLeftPanelSize)
+{
+	if (newLeftPanelSize && m_rightSidePanelSpinBox->value()) {
+		int newRightPanelSize = 16-newLeftPanelSize;
+		m_rightSidePanelSpinBox->blockSignals(true);
+		m_rightSidePanelSpinBox->setValue(newRightPanelSize);
+		m_rightSidePanelSpinBox->blockSignals(false);
+	}
+	m_parentMainWidget->setSidePanelWidths(newLeftPanelSize, m_rightSidePanelSpinBox->value());
+}
+
+void PageEnhancementsDockWidget::setRightSidePanelWidth(int newRightPanelSize)
+{
+	if (newRightPanelSize && m_leftSidePanelSpinBox->value()) {
+		int newLeftPanelSize = 16-newRightPanelSize;
+		m_leftSidePanelSpinBox->blockSignals(true);
+		m_leftSidePanelSpinBox->setValue(newLeftPanelSize);
+		m_leftSidePanelSpinBox->blockSignals(false);
+	}
+	m_parentMainWidget->setSidePanelWidths(m_leftSidePanelSpinBox->value(), newRightPanelSize);
+}
+
+void PageEnhancementsDockWidget::updateWidgets()
+{
+	int leftSidePanelColumnsResult = 0;
+	int rightSidePanelColumnsResult = 0;
+
+	m_defaultScreenColourCombo->blockSignals(true);
+	m_defaultScreenColourCombo->setCurrentIndex(m_parentMainWidget->document()->currentSubPage()->defaultScreenColour());
+	m_defaultScreenColourCombo->blockSignals(false);
+	m_defaultRowColourCombo->blockSignals(true);
+	m_defaultRowColourCombo->setCurrentIndex(m_parentMainWidget->document()->currentSubPage()->defaultRowColour());
+	m_defaultRowColourCombo->blockSignals(false);
+	m_colourTableCombo->blockSignals(true);
+	m_colourTableCombo->setCurrentIndex(m_parentMainWidget->document()->currentSubPage()->colourTableRemap());
+	m_colourTableCombo->blockSignals(false);
+	m_blackBackgroundSubstAct->blockSignals(true);
+	m_blackBackgroundSubstAct->setChecked(m_parentMainWidget->document()->currentSubPage()->blackBackgroundSubst());
+	m_blackBackgroundSubstAct->blockSignals(false);
+
+	if (m_parentMainWidget->document()->currentSubPage()->leftSidePanelDisplayed())
+		leftSidePanelColumnsResult = (m_parentMainWidget->document()->currentSubPage()->sidePanelColumns() == 0) ? 16 : m_parentMainWidget->document()->currentSubPage()->sidePanelColumns();
+
+	if (m_parentMainWidget->document()->currentSubPage()->rightSidePanelDisplayed())
+		rightSidePanelColumnsResult = 16-m_parentMainWidget->document()->currentSubPage()->sidePanelColumns();
+
+	m_leftSidePanelSpinBox->blockSignals(true);
+	m_leftSidePanelSpinBox->setValue(leftSidePanelColumnsResult);
+	m_leftSidePanelSpinBox->blockSignals(false);
+	m_rightSidePanelSpinBox->blockSignals(true);
+	m_rightSidePanelSpinBox->setValue(rightSidePanelColumnsResult);
+	m_rightSidePanelSpinBox->blockSignals(false);
+	m_sidePanelStatusAct->blockSignals(true);
+	m_sidePanelStatusAct->setChecked(!m_parentMainWidget->document()->currentSubPage()->sidePanelStatusL25());
+	m_sidePanelStatusAct->blockSignals(false);
+}

src/qteletextmaker/pageenhancementsdockwidget.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PAGEENHANCEMENTSDOCKWIDGET_H
+#define PAGEENHANCEMENTSDOCKWIDGET_H
+
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDockWidget>
+#include <QSpinBox>
+
+#include "mainwidget.h"
+
+class PageEnhancementsDockWidget : public QDockWidget
+{
+	Q_OBJECT
+
+public:
+	PageEnhancementsDockWidget(TeletextWidget *parent);
+	void updateWidgets();
+
+private:
+	void setLeftSidePanelWidth(int newLeftPanelSize);
+	void setRightSidePanelWidth(int newRightPanelSize);
+
+	TeletextWidget *m_parentMainWidget;
+	QComboBox *m_defaultScreenColourCombo, *m_defaultRowColourCombo, *m_colourTableCombo;
+	QCheckBox *m_blackBackgroundSubstAct, *m_sidePanelStatusAct;
+	QSpinBox *m_leftSidePanelSpinBox, *m_rightSidePanelSpinBox;
+};
+
+#endif

src/qteletextmaker/pageoptionsdockwidget.cpp

@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QCheckBox>
+#include <QComboBox>
+#include <QGridLayout>
+#include <QGroupBox>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QLineEdit>
+#include <QRegularExpressionValidator>
+#include <QSpinBox>
+#include <QVBoxLayout>
+
+#include "pageoptionsdockwidget.h"
+
+PageOptionsDockWidget::PageOptionsDockWidget(TeletextWidget *parent): QDockWidget(parent)
+{
+	QVBoxLayout *pageOptionsLayout = new QVBoxLayout;
+	QWidget *pageOptionsWidget = new QWidget;
+
+	m_parentMainWidget = parent;
+
+	this->setObjectName("PageOptionsDockWidget");
+	this->setWindowTitle("Page options");
+
+	// Page number
+	m_pageNumberValidator = new QRegularExpressionValidator(QRegularExpression("[1-8][0-9A-Fa-f][0-9A-Fa-f]"), this);
+
+	QHBoxLayout *pageNumberLayout = new QHBoxLayout;
+	pageNumberLayout->addWidget(new QLabel(tr("Page number")));
+	m_pageNumberEdit = new QLineEdit("100");
+	m_pageNumberEdit->setMaxLength(3);
+	m_pageNumberEdit->setInputMask(">DHH");
+	m_pageNumberEdit->setValidator(m_pageNumberValidator);
+	pageNumberLayout->addWidget(m_pageNumberEdit);
+	connect(m_pageNumberEdit, &QLineEdit::textEdited, m_parentMainWidget->document(), &TeletextDocument::setPageNumberFromString);
+
+	pageOptionsLayout->addLayout(pageNumberLayout);
+
+	// Page description
+	m_pageDescriptionEdit = new QLineEdit();
+	m_pageDescriptionEdit->setPlaceholderText("Page description");
+	connect(m_pageDescriptionEdit, &QLineEdit::textEdited, m_parentMainWidget->document(), &TeletextDocument::setDescription);
+
+	pageOptionsLayout->addWidget(m_pageDescriptionEdit);
+
+	// FastText links
+	QGridLayout *fastTextLayout = new QGridLayout;
+	for (int i=0; i<6; i++) {
+		const char *fastTextLabel[] = { "Red", "Green", "Yellow" ,"Blue", "Next", "Index" };
+
+		fastTextLayout->addWidget(new QLabel(fastTextLabel[i]), 0, i, 1, 1, Qt::AlignCenter);
+		m_fastTextEdit[i] = new QLineEdit;
+		m_fastTextEdit[i]->setMaxLength(3);
+		m_fastTextEdit[i]->setInputMask(">DHH");
+		m_fastTextEdit[i]->setValidator(m_pageNumberValidator);
+		fastTextLayout->addWidget(m_fastTextEdit[i], 1, i, 1, 1);
+		connect(m_fastTextEdit[i], &QLineEdit::textEdited, [=](QString value) { setFastTextLinkPageNumber(i, value); } );
+	}
+
+	pageOptionsLayout->addLayout(fastTextLayout);
+
+	QGroupBox *subPageGroupBox = new QGroupBox(tr("Subpage options"));
+	QVBoxLayout *subPageOptionsLayout = new QVBoxLayout;
+
+	// Cycle
+	QHBoxLayout *pageCycleLayout = new QHBoxLayout;
+	pageCycleLayout->addWidget(new QLabel(tr("Page cycle")));
+	m_cycleValueSpinBox = new QSpinBox;
+	m_cycleValueSpinBox->setRange(1, 99);
+	m_cycleValueSpinBox->setWrapping(true);
+	pageCycleLayout->addWidget(m_cycleValueSpinBox);
+	// Since TeletextPage doesn't inherit from QObject (so we can copy construct it) it doesn't have a slot
+	// to connect to, so we need to use a lambda
+	connect(m_cycleValueSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [=](int index) { m_parentMainWidget->document()->currentSubPage()->setCycleValue(index); } );
+	m_cycleTypeCombo = new QComboBox;
+	m_cycleTypeCombo->addItem("cycles");
+	m_cycleTypeCombo->addItem("seconds");
+	pageCycleLayout->addWidget(m_cycleTypeCombo);
+	connect(m_cycleTypeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index) { m_parentMainWidget->document()->currentSubPage()->setCycleType(index == 0 ? LevelOnePage::CTcycles : LevelOnePage::CTseconds); } );
+
+	subPageOptionsLayout->addLayout(pageCycleLayout);
+
+	// Page status bits
+	for (int i=0; i<=7; i++) {
+		const char *controlBitsLabel[] = { "C4 Erase page", "C5 Newsflash", "C6 Subtitle", "C7 Suppress header", "C8 Update page", "C9 Page not in sequence", "C10 Inhibit display", "C11 Serial magazine" };
+
+		m_controlBitsAct[i] = new QCheckBox(controlBitsLabel[i]);
+		subPageOptionsLayout->addWidget(m_controlBitsAct[i]);
+		connect(m_controlBitsAct[i], &QCheckBox::stateChanged, [=](bool active) { m_parentMainWidget->setControlBit(i, active); });
+	}
+
+	// Region and language
+	QGridLayout *regionLayout = new QGridLayout;
+	regionLayout->addWidget(new QLabel(tr("Region")), 0, 0, 1, 1);
+	m_defaultRegionCombo = new QComboBox;
+	addRegionList(m_defaultRegionCombo);
+
+	regionLayout->addWidget(m_defaultRegionCombo, 0, 1, 1, 1, Qt::AlignTop);
+	connect(m_defaultRegionCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=]{ setDefaultRegion(); });
+
+	m_defaultNOSCombo = new QComboBox;
+	regionLayout->addWidget(m_defaultNOSCombo, 0, 2, 1, 1, Qt::AlignTop);
+	connect(m_defaultNOSCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=]{ setDefaultNOS(); });
+
+	regionLayout->addWidget(new QLabel(tr("2nd region")), 1, 0, 1, 1);
+	m_secondRegionCombo = new QComboBox;
+	m_secondRegionCombo->addItem("Not needed", 15);
+	addRegionList(m_secondRegionCombo);
+	regionLayout->addWidget(m_secondRegionCombo, 1, 1, 1, 1, Qt::AlignTop);
+	connect(m_secondRegionCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=]{ setSecondRegion(); });
+
+	m_secondNOSCombo = new QComboBox;
+	regionLayout->addWidget(m_secondNOSCombo, 1, 2, 1, 1, Qt::AlignTop);
+	connect(m_secondNOSCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=]{ setSecondNOS(); });
+
+	subPageOptionsLayout->addLayout(regionLayout);
+
+	subPageGroupBox->setLayout(subPageOptionsLayout);
+	pageOptionsLayout->addWidget(subPageGroupBox);
+
+	pageOptionsLayout->addStretch(1);
+
+	pageOptionsWidget->setLayout(pageOptionsLayout);
+	this->setWidget(pageOptionsWidget);
+
+}
+
+void PageOptionsDockWidget::addRegionList(QComboBox *regionCombo)
+{
+	regionCombo->addItem("0", 0);
+	regionCombo->addItem("1", 1);
+	regionCombo->addItem("2", 2);
+	regionCombo->addItem("3", 3);
+	regionCombo->addItem("4", 4);
+	regionCombo->addItem("6", 6);
+	regionCombo->addItem("8", 8);
+	regionCombo->addItem("10", 10);
+}
+
+void PageOptionsDockWidget::updateWidgets()
+{
+	m_pageNumberEdit->blockSignals(true);
+	m_pageNumberEdit->setText(QString::number(m_parentMainWidget->document()->pageNumber(), 16).toUpper());
+	m_pageNumberEdit->blockSignals(false);
+	m_pageDescriptionEdit->blockSignals(true);
+	m_pageDescriptionEdit->setText(m_parentMainWidget->document()->description());
+	m_pageDescriptionEdit->blockSignals(false);
+	for (int i=0; i<6; i++) {
+		// Stored as page link with relative magazine number, convert to absolute page number for display
+		int absoluteLinkPageNumber = m_parentMainWidget->document()->currentSubPage()->fastTextLinkPageNumber(i) ^ (m_parentMainWidget->document()->pageNumber() & 0x700);
+		// Fix magazine 0 to 8
+		if ((absoluteLinkPageNumber & 0x700) == 0x000)
+			absoluteLinkPageNumber |= 0x800;
+		m_fastTextEdit[i]->blockSignals(true);
+		m_fastTextEdit[i]->setText(QString::number(absoluteLinkPageNumber, 16).toUpper());
+		m_fastTextEdit[i]->blockSignals(false);
+	}
+	m_cycleValueSpinBox->blockSignals(true);
+	m_cycleValueSpinBox->setValue(m_parentMainWidget->document()->currentSubPage()->cycleValue());
+	m_cycleValueSpinBox->blockSignals(false);
+	m_cycleTypeCombo->blockSignals(true);
+	m_cycleTypeCombo->setCurrentIndex(m_parentMainWidget->document()->currentSubPage()->cycleType() == LevelOnePage::CTseconds);
+	m_cycleTypeCombo->blockSignals(false);
+	for (int i=0; i<=7; i++) {
+		m_controlBitsAct[i]->blockSignals(true);
+		m_controlBitsAct[i]->setChecked(m_parentMainWidget->document()->currentSubPage()->controlBit(i));
+		m_controlBitsAct[i]->blockSignals(false);
+	}
+	m_defaultRegionCombo->blockSignals(true);
+	m_defaultRegionCombo->setCurrentText(QString::number(m_parentMainWidget->document()->currentSubPage()->defaultCharSet()));
+	m_defaultRegionCombo->blockSignals(false);
+	m_defaultNOSCombo->blockSignals(true);
+	updateDefaultNOSOptions();
+	m_defaultNOSCombo->setCurrentIndex(m_defaultNOSCombo->findData((m_parentMainWidget->document()->currentSubPage()->defaultCharSet() << 3) | m_parentMainWidget->document()->currentSubPage()->defaultNOS()));
+	m_defaultNOSCombo->blockSignals(false);
+	m_secondRegionCombo->blockSignals(true);
+	if (m_parentMainWidget->document()->currentSubPage()->secondCharSet() == 15)
+		m_secondRegionCombo->setCurrentIndex(0);
+	else
+		m_secondRegionCombo->setCurrentText(QString::number(m_parentMainWidget->document()->currentSubPage()->secondCharSet()));
+	m_secondRegionCombo->blockSignals(false);
+	m_secondNOSCombo->blockSignals(true);
+	updateSecondNOSOptions();
+	m_secondNOSCombo->setCurrentIndex(m_secondNOSCombo->findData((m_parentMainWidget->document()->currentSubPage()->secondCharSet() << 3) | m_parentMainWidget->document()->currentSubPage()->secondNOS()));
+	m_secondNOSCombo->blockSignals(false);
+}
+
+void PageOptionsDockWidget::setFastTextLinkPageNumber(int linkNumber, const QString &pageNumberString)
+{
+	// The LineEdit should check if a valid hex number was entered, but just in case...
+	bool pageNumberOk;
+	int pageNumberRead = pageNumberString.toInt(&pageNumberOk, 16);
+	if ((!pageNumberOk) || pageNumberRead < 0x100 || pageNumberRead > 0x8ff)
+		return;
+
+	// Stored as page link with relative magazine number, convert from absolute page number that was entered
+	pageNumberRead ^= (m_parentMainWidget->document()->pageNumber() & 0x700);
+	pageNumberRead &= 0x7ff; // Fixes magazine 8 to 0
+
+	// TODO bring in option to allow different FastText links per subpage
+//	m_parentMainWidget->document()->currentSubPage()->setFastTextLinkPageNumber(linkNumber, pageNumberRead);
+	m_parentMainWidget->document()->setFastTextLinkPageNumberOnAllSubPages(linkNumber, pageNumberRead);
+}
+
+void PageOptionsDockWidget::updateDefaultNOSOptions()
+{
+	while (m_defaultNOSCombo->count() > 0)
+		m_defaultNOSCombo->removeItem(0);
+	for (int i=0; i<languageComboBoxItemCount; i++)
+		if ((languageComboBoxItems[i].bits >> 3) == m_parentMainWidget->document()->currentSubPage()->defaultCharSet())
+			m_defaultNOSCombo->addItem(languageComboBoxItems[i].name, languageComboBoxItems[i].bits);
+}
+
+void PageOptionsDockWidget::updateSecondNOSOptions()
+{
+	while (m_secondNOSCombo->count() > 0)
+		m_secondNOSCombo->removeItem(0);
+	for (int i=0; i<languageComboBoxItemCount; i++)
+		if ((languageComboBoxItems[i].bits >> 3) == m_parentMainWidget->document()->currentSubPage()->secondCharSet())
+			m_secondNOSCombo->addItem(languageComboBoxItems[i].name, languageComboBoxItems[i].bits);
+}
+
+void PageOptionsDockWidget::setDefaultRegion()
+{
+	m_parentMainWidget->document()->currentSubPage()->setDefaultCharSet(m_defaultRegionCombo->currentData().toInt());
+	m_defaultNOSCombo->blockSignals(true);
+	updateDefaultNOSOptions();
+	setDefaultNOS();
+	m_defaultNOSCombo->blockSignals(false);
+	m_parentMainWidget->refreshPage();
+}
+
+void PageOptionsDockWidget::setDefaultNOS()
+{
+	m_parentMainWidget->document()->currentSubPage()->setDefaultNOS(m_defaultNOSCombo->currentData().toInt() & 0x07);
+	m_parentMainWidget->refreshPage();
+}
+
+void PageOptionsDockWidget::setSecondRegion()
+{
+	m_parentMainWidget->document()->currentSubPage()->setSecondCharSet(m_secondRegionCombo->currentData().toInt());
+	m_secondNOSCombo->blockSignals(true);
+	updateSecondNOSOptions();
+	setSecondNOS();
+	m_secondNOSCombo->blockSignals(false);
+	m_parentMainWidget->refreshPage();
+}
+
+void PageOptionsDockWidget::setSecondNOS()
+{
+	m_parentMainWidget->document()->currentSubPage()->setSecondNOS(m_secondNOSCombo->currentData().toInt() & 0x07);
+	m_parentMainWidget->refreshPage();
+}

src/qteletextmaker/pageoptionsdockwidget.h

@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PAGEOPTIONSDOCKWIDGET_H
+#define PAGEOPTIONSDOCKWIDGET_H
+
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDockWidget>
+#include <QLineEdit>
+#include <QRegularExpressionValidator>
+#include <QSpinBox>
+
+#include "mainwidget.h"
+
+class PageOptionsDockWidget : public QDockWidget
+{
+	Q_OBJECT
+
+public:
+	PageOptionsDockWidget(TeletextWidget *parent);
+	void updateWidgets();
+
+private:
+	TeletextWidget *m_parentMainWidget;
+	QLineEdit *m_pageNumberEdit, *m_pageDescriptionEdit;
+	QSpinBox *m_cycleValueSpinBox;
+	QComboBox *m_cycleTypeCombo;
+	QCheckBox *m_controlBitsAct[8];
+	QComboBox *m_defaultRegionCombo, *m_defaultNOSCombo, *m_secondRegionCombo, *m_secondNOSCombo;
+	QLineEdit *m_fastTextEdit[6];
+
+	QRegularExpressionValidator *m_pageNumberValidator;
+
+	void addRegionList(QComboBox *regionCombo);
+	void setFastTextLinkPageNumber(int linkNumber, const QString &pageNumberString);
+	void setDefaultRegion();
+	void setDefaultNOS();
+	void setSecondRegion();
+	void setSecondNOS();
+	void updateDefaultNOSOptions();
+	void updateSecondNOSOptions();
+};
+
+struct languageComboBoxItem {
+	QString name;
+	int bits;
+};
+
+static const int languageComboBoxItemCount = 36;
+
+static const languageComboBoxItem languageComboBoxItems[languageComboBoxItemCount] {
+	{ "English", 0x00 } ,
+	{ "German", 0x01 } ,
+	{ "Swedish/Finnish/Hungarian", 0x02 } ,
+	{ "Italian", 0x03 } ,
+	{ "French", 0x04 } ,
+	{ "Portuguese/Spanish", 0x05 } ,
+	{ "Czech/Slovak", 0x06 } ,
+
+	{ "Polish", 0x08 } ,
+	{ "German", 0x09 } ,
+	{ "Swedish/Finnish/Hungarian", 0x0a } ,
+	{ "Italian", 0x0b } ,
+	{ "French", 0x0c } ,
+	{ "Czech/Slovak", 0x0e } ,
+
+	{ "English", 0x10 } ,
+	{ "German", 0x11 } ,
+	{ "Swedish/Finnish/Hungarian", 0x12 } ,
+	{ "Italian", 0x13 } ,
+	{ "French", 0x14 } ,
+	{ "Portuguese/Spanish", 0x15 } ,
+	{ "Turkish", 0x16 } ,
+
+	{ "Serbian/Croatian/Slovenian", 0x1d } ,
+	{ "Rumanian", 0x1f } ,
+
+	{ "Serbian/Croatian", 0x20 } ,
+	{ "German", 0x21 } ,
+	{ "Estonian", 0x22 } ,
+	{ "Lettish/Lithuanian", 0x23 } ,
+	{ "Russian/Bulgarian", 0x24 } ,
+	{ "Ukrainian", 0x25 } ,
+	{ "Czech/Slovak", 0x26 } ,
+
+	{ "Turkish", 0x36 } ,
+	{ "Greek", 0x37 } ,
+
+	{ "English", 0x40 } ,
+	{ "French", 0x44 } ,
+	{ "Arabic", 0x47 } ,
+
+	{ "Hebrew", 0x55 } ,
+	{ "Arabic", 0x57 } ,
+};
+
+#endif

src/qteletextmaker/palettedockwidget.cpp

@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QCheckBox>
+#include <QColorDialog>
+#include <QDialog>
+#include <QGridLayout>
+#include <QLabel>
+#include <QPushButton>
+#include <QUndoCommand>
+#include <math.h>
+
+#include "palettedockwidget.h"
+
+#include "x28commands.h"
+#include "document.h"
+#include "mainwidget.h"
+
+PaletteDockWidget::PaletteDockWidget(TeletextWidget *parent): QDockWidget(parent)
+{
+	QGridLayout *paletteGridLayout = new QGridLayout;
+	QWidget *paletteGridWidget = new QWidget;
+
+	m_parentMainWidget = parent;
+
+	m_level3p5Accepted = false; // true when Level 3.5 radio button is checked in main window
+	m_level3p5Seen = false;     // true when CLUT 0 or 1 is redefined
+
+	this->setObjectName("PaletteDockWidget");
+	this->setWindowTitle("Palette");
+	for (int c=0; c<=7; c++)
+		paletteGridLayout->addWidget(new QLabel(QString("%1").arg(c)), 0, c+1, 1, 1, Qt::AlignHCenter);
+	for (int r=0, i=0; r<=3; r++) {
+		paletteGridLayout->addWidget(new QLabel(tr("CLUT %1").arg(r)), r+1, 0);
+		m_resetButton[r] = new QPushButton(tr("Reset"));
+		paletteGridLayout->addWidget(m_resetButton[r], r+1, 9);
+		connect(m_resetButton[r], &QAbstractButton::clicked, [=]() { resetCLUT(r); });
+		for (int c=0; c<=7; c++, i++) {
+			if (i == 8)
+				continue;
+			m_colourButton[i] = new QPushButton();
+			m_colourButton[i]->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
+			paletteGridLayout->addWidget(m_colourButton[i], r+1, c+1);
+			connect(m_colourButton[i], &QAbstractButton::clicked, [=]() { selectColour(i); });
+		}
+	}
+
+	updateLevel3p5Cursor();
+
+	m_showHexValuesCheckBox = new QCheckBox(tr("Show colour hex values"));
+	paletteGridLayout->addWidget(m_showHexValuesCheckBox, 5, 1, 1, 8);
+	connect(m_showHexValuesCheckBox, &QCheckBox::stateChanged, this, &PaletteDockWidget::updateAllColourButtons);
+
+	paletteGridWidget->setLayout(paletteGridLayout);
+	this->setWidget(paletteGridWidget);
+	connect(m_parentMainWidget->document(), &TeletextDocument::colourChanged, this, &PaletteDockWidget::updateColourButton);
+}
+
+void PaletteDockWidget::updateColourButton(int colourIndex)
+{
+	if (colourIndex == 8)
+		return;
+
+	QString colourString = QString("%1").arg(m_parentMainWidget->document()->currentSubPage()->CLUT(colourIndex), 3, 16, QChar('0'));
+	if (m_showHexValuesCheckBox->isChecked())
+		m_colourButton[colourIndex]->setText(colourString);
+	else
+		m_colourButton[colourIndex]->setText(nullptr);
+
+	int r = m_parentMainWidget->document()->currentSubPage()->CLUT(colourIndex) >> 8;
+	int g = (m_parentMainWidget->document()->currentSubPage()->CLUT(colourIndex) >> 4) & 0xf;
+	int b = m_parentMainWidget->document()->currentSubPage()->CLUT(colourIndex) & 0xf;
+	// Set text itself to black or white so it can be seen over background colour - http://alienryderflex.com/hsp.html
+	char blackOrWhite = (sqrt(r*r*0.299 + g*g*0.587 + b*b*0.114) > 7.647) ? '0' : 'f';
+
+	QString qss = QString("background-color: #%1; color: #%2%2%2; border: none").arg(colourString).arg(blackOrWhite);
+	m_colourButton[colourIndex]->setStyleSheet(qss);
+
+	if (m_parentMainWidget->document()->currentSubPage()->isPaletteDefault(colourIndex)) {
+		// Default colour was set, disable Reset button if all colours in a CLUT row are default as well
+		m_resetButton[colourIndex >> 3]->setEnabled(!m_parentMainWidget->document()->currentSubPage()->isPaletteDefault(colourIndex & 0x18, colourIndex | 0x07));
+		// Check if CLUTs 0 and 1 are all default if necessary
+		if (colourIndex < 16 && m_parentMainWidget->document()->currentSubPage()->isPaletteDefault(0, 15))
+			setLevel3p5Seen(false);
+	} else {
+		// Custom colour was set, enable Reset button for that CLUT
+		m_resetButton[colourIndex >> 3]->setEnabled(true);
+		if (colourIndex < 16)
+			setLevel3p5Seen(true);
+	}
+}
+
+void PaletteDockWidget::updateAllColourButtons()
+{
+	for (int i=0; i<32; i++)
+		updateColourButton(i);
+}
+
+void PaletteDockWidget::setLevel3p5Accepted(bool b)
+{
+	if (b == m_level3p5Accepted)
+		return;
+
+	m_level3p5Accepted = b;
+
+	updateLevel3p5Cursor();
+}
+
+void PaletteDockWidget::setLevel3p5Seen(bool b)
+{
+	if (b == m_level3p5Seen)
+		return;
+
+	m_level3p5Seen = b;
+
+	updateLevel3p5Cursor();
+}
+
+void PaletteDockWidget::updateLevel3p5Cursor()
+{
+	const Qt::CursorShape cursor = (m_level3p5Accepted || m_level3p5Seen) ? Qt::ArrowCursor : Qt::ForbiddenCursor;
+
+	if (m_colourButton[0]->cursor() == cursor)
+		return;
+
+	for (int i=0; i<16; i++) {
+		if (i == 8)
+			continue;
+
+		m_colourButton[i]->setCursor(cursor);
+	}
+}
+
+void PaletteDockWidget::showEvent(QShowEvent *event)
+{
+	Q_UNUSED(event);
+	updateAllColourButtons();
+}
+
+void PaletteDockWidget::selectColour(int colourIndex)
+{
+	if (colourIndex < 16 && !m_level3p5Accepted && !m_level3p5Seen)
+		return;
+
+    const QColor newColour = QColorDialog::getColor(m_parentMainWidget->document()->currentSubPage()->CLUTtoQColor(colourIndex), this, "Select Colour");
+
+	if (newColour.isValid())
+		m_parentMainWidget->document()->undoStack()->push(new SetColourCommand(m_parentMainWidget->document(), colourIndex, ((newColour.red() & 0xf0) << 4) | (newColour.green() & 0xf0) | ((newColour.blue() & 0xf0) >> 4)));
+}
+
+void PaletteDockWidget::resetCLUT(int colourTable)
+{
+	m_parentMainWidget->document()->undoStack()->push(new ResetCLUTCommand(m_parentMainWidget->document(), colourTable));
+}

src/qteletextmaker/palettedockwidget.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PALETTEDOCKWIDGET_H
+#define PALETTEDOCKWIDGET_H
+
+#include <QCheckBox>
+#include <QDockWidget>
+#include <QPushButton>
+
+#include "mainwidget.h"
+
+class PaletteDockWidget : public QDockWidget
+{
+	Q_OBJECT
+
+public:
+	PaletteDockWidget(TeletextWidget *parent);
+	void updateAllColourButtons();
+
+public slots:
+	void updateColourButton(int colourIndex);
+	void setLevel3p5Accepted(bool b);
+
+protected:
+	void showEvent(QShowEvent *event);
+
+private slots:
+	void selectColour(int colourIndex);
+	void setLevel3p5Seen(bool b);
+	void updateLevel3p5Cursor();
+
+private:
+	void resetCLUT(int colourTable);
+
+	QPushButton *m_colourButton[32], *m_resetButton[4];
+	QCheckBox *m_showHexValuesCheckBox;
+	bool m_level3p5Accepted, m_level3p5Seen;
+
+	TeletextWidget *m_parentMainWidget;
+};
+
+#endif

src/qteletextmaker/x26commands.cpp

@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "x26commands.h"
+
+#include <QUndoCommand>
+
+#include "document.h"
+#include "x26model.h"
+#include "x26triplets.h"
+
+InsertTripletCommand::InsertTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int count, X26Triplet newTriplet, QUndoCommand *parent) : QUndoCommand(parent)
+{
+	m_teletextDocument = teletextDocument;
+	m_subPageIndex = teletextDocument->currentSubPageIndex();
+	m_x26Model = x26Model;
+	m_row = row;
+	m_count = count;
+	m_insertedTriplet = newTriplet;
+	setText(QString("insert triplet d%1 t%2").arg(m_row / 13).arg(m_row % 13));;
+	m_firstDo = true;
+}
+
+void InsertTripletCommand::redo()
+{
+	bool changingSubPage = (m_teletextDocument->currentSubPageIndex() != m_subPageIndex);
+
+	if (changingSubPage) {
+		m_teletextDocument->emit aboutToChangeSubPage();
+		m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	} else
+		m_x26Model->beginInsertRows(QModelIndex(), m_row, m_row+m_count-1);
+
+	for (int i=0; i<m_count; i++)
+		m_teletextDocument->currentSubPage()->enhancements()->insert(m_row+i, m_insertedTriplet);
+
+	if (!changingSubPage)
+		m_x26Model->endInsertRows();
+
+	// Preserve pointers to local object definitions that have moved
+	for (int i=0; i<m_teletextDocument->currentSubPage()->enhancements()->size(); i++) {
+		X26Triplet triplet = m_teletextDocument->currentSubPage()->enhancements()->at(i);
+
+		if (triplet.modeExt() >= 0x11 && triplet.modeExt() <= 0x13 && ((triplet.address() & 0x18) == 0x08) && triplet.objectLocalIndex() >= m_row) {
+			triplet.setObjectLocalIndex(triplet.objectLocalIndex() + m_count);
+			m_teletextDocument->currentSubPage()->enhancements()->replace(i, triplet);
+			if (!changingSubPage)
+				m_x26Model->emit dataChanged(m_x26Model->createIndex(i, 0), m_x26Model->createIndex(i, 3));
+		}
+	}
+
+	if (changingSubPage)
+		m_teletextDocument->emit subPageSelected();
+	else
+		m_teletextDocument->emit contentsChanged();
+
+	if (m_firstDo)
+		m_firstDo = false;
+
+	m_teletextDocument->emit tripletCommandHighlight(m_row);
+}
+
+void InsertTripletCommand::undo()
+{
+	bool changingSubPage = (m_teletextDocument->currentSubPageIndex() != m_subPageIndex);
+
+	if (changingSubPage) {
+		m_teletextDocument->emit aboutToChangeSubPage();
+		m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	} else
+		m_x26Model->beginRemoveRows(QModelIndex(), m_row, m_row+m_count-1);
+
+	for (int i=0; i<m_count; i++)
+		m_teletextDocument->currentSubPage()->enhancements()->removeAt(m_row);
+
+	if (!changingSubPage)
+		m_x26Model->endRemoveRows();
+
+	// Preserve pointers to local object definitions that have moved
+	for (int i=0; i<m_teletextDocument->currentSubPage()->enhancements()->size(); i++) {
+		X26Triplet triplet = m_teletextDocument->currentSubPage()->enhancements()->at(i);
+
+		if (triplet.modeExt() >= 0x11 && triplet.modeExt() <= 0x13 && ((triplet.address() & 0x18) == 0x08) && triplet.objectLocalIndex() >= m_row) {
+			triplet.setObjectLocalIndex(triplet.objectLocalIndex() - m_count);
+			m_teletextDocument->currentSubPage()->enhancements()->replace(i, triplet);
+			if (!changingSubPage)
+				m_x26Model->emit dataChanged(m_x26Model->createIndex(i, 0), m_x26Model->createIndex(i, 3));
+		}
+	}
+
+	if (changingSubPage)
+		m_teletextDocument->emit subPageSelected();
+	else
+		m_teletextDocument->emit contentsChanged();
+}
+
+
+DeleteTripletCommand::DeleteTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int count, QUndoCommand *parent) : QUndoCommand(parent)
+{
+	m_teletextDocument = teletextDocument;
+	m_subPageIndex = teletextDocument->currentSubPageIndex();
+	m_x26Model = x26Model;
+	m_row = row;
+	m_count = count;
+	m_deletedTriplet = m_teletextDocument->subPage(m_subPageIndex)->enhancements()->at(m_row);
+	setText(QString("delete triplet d%1 t%2").arg(m_row / 13).arg(m_row % 13));;
+	// BUG we only store one of the deleted triplets
+	if (m_count > 1)
+		qDebug("More than one triplet row deleted, undo won't put the lost triplets back!");
+}
+
+void DeleteTripletCommand::redo()
+{
+	bool changingSubPage = (m_teletextDocument->currentSubPageIndex() != m_subPageIndex);
+
+	if (changingSubPage) {
+		m_teletextDocument->emit aboutToChangeSubPage();
+		m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	} else
+		m_x26Model->beginRemoveRows(QModelIndex(), m_row, m_row+m_count-1);
+
+	for (int i=0; i<m_count; i++)
+		m_teletextDocument->currentSubPage()->enhancements()->removeAt(m_row);
+
+	if (!changingSubPage)
+		m_x26Model->endRemoveRows();
+
+	// Preserve pointers to local object definitions that have moved
+	for (int i=0; i<m_teletextDocument->currentSubPage()->enhancements()->size(); i++) {
+		X26Triplet triplet = m_teletextDocument->currentSubPage()->enhancements()->at(i);
+
+		if (triplet.modeExt() >= 0x11 && triplet.modeExt() <= 0x13 && ((triplet.address() & 0x18) == 0x08) && triplet.objectLocalIndex() >= m_row) {
+			triplet.setObjectLocalIndex(triplet.objectLocalIndex() - m_count);
+			m_teletextDocument->currentSubPage()->enhancements()->replace(i, triplet);
+			m_x26Model->emit dataChanged(m_x26Model->createIndex(i, 0), m_x26Model->createIndex(i, 3));
+		}
+	}
+
+	if (changingSubPage)
+		m_teletextDocument->emit subPageSelected();
+	else
+		m_teletextDocument->emit contentsChanged();
+}
+
+void DeleteTripletCommand::undo()
+{
+	bool changingSubPage = (m_teletextDocument->currentSubPageIndex() != m_subPageIndex);
+
+	if (changingSubPage) {
+		m_teletextDocument->emit aboutToChangeSubPage();
+		m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	} else
+		m_x26Model->beginInsertRows(QModelIndex(), m_row, m_row+m_count-1);
+
+	for (int i=0; i<m_count; i++)
+		m_teletextDocument->currentSubPage()->enhancements()->insert(m_row+i, m_deletedTriplet);
+
+	if (!changingSubPage)
+		m_x26Model->endInsertRows();
+
+	// Preserve pointers to local object definitions that have moved
+	for (int i=0; i<m_teletextDocument->currentSubPage()->enhancements()->size(); i++) {
+		X26Triplet triplet = m_teletextDocument->currentSubPage()->enhancements()->at(i);
+
+		if (triplet.modeExt() >= 0x11 && triplet.modeExt() <= 0x13 && ((triplet.address() & 0x18) == 0x08) && triplet.objectLocalIndex() >= m_row) {
+			triplet.setObjectLocalIndex(triplet.objectLocalIndex() + m_count);
+			m_teletextDocument->currentSubPage()->enhancements()->replace(i, triplet);
+			if (!changingSubPage)
+				m_x26Model->emit dataChanged(m_x26Model->createIndex(i, 0), m_x26Model->createIndex(i, 3));
+		}
+	}
+
+	if (changingSubPage)
+		m_teletextDocument->emit subPageSelected();
+	else
+		m_teletextDocument->emit contentsChanged();
+
+	m_teletextDocument->emit tripletCommandHighlight(m_row);
+}
+
+
+EditTripletCommand::EditTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int tripletPart, int bitsToKeep, int newValue, int role, QUndoCommand *parent) : QUndoCommand(parent)
+{
+	m_teletextDocument = teletextDocument;
+	m_subPageIndex = teletextDocument->currentSubPageIndex();
+	m_x26Model = x26Model;
+	m_row = row;
+	m_role = role;
+	m_oldTriplet = m_newTriplet = teletextDocument->currentSubPage()->enhancements()->at(m_row);
+	setText(QString("edit triplet d%1 t%2").arg(m_row / 13).arg(m_row % 13));;
+	switch (tripletPart) {
+		case ETaddress:
+			m_newTriplet.setAddress((m_newTriplet.address() & bitsToKeep) | newValue);
+			break;
+		case ETmode:
+			m_newTriplet.setMode((m_newTriplet.mode() & bitsToKeep) | newValue);
+			break;
+		case ETdata:
+			m_newTriplet.setData((m_newTriplet.data() & bitsToKeep) | newValue);
+			break;
+	};
+	m_firstDo = true;
+}
+
+void EditTripletCommand::redo()
+{
+	if (m_teletextDocument->currentSubPageIndex() != m_subPageIndex)
+		m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
+
+	m_teletextDocument->currentSubPage()->enhancements()->replace(m_row, m_newTriplet);
+	m_x26Model->emit dataChanged(m_x26Model->createIndex(m_row, 0), m_x26Model->createIndex(m_row, 3), {m_role});
+	m_teletextDocument->emit contentsChanged();
+
+	if (m_firstDo)
+		m_firstDo = false;
+	else
+		m_teletextDocument->emit tripletCommandHighlight(m_row);
+}
+
+void EditTripletCommand::undo()
+{
+	if (m_teletextDocument->currentSubPageIndex() != m_subPageIndex)
+		m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
+
+	m_teletextDocument->currentSubPage()->enhancements()->replace(m_row, m_oldTriplet);
+	m_x26Model->emit dataChanged(m_x26Model->createIndex(m_row, 0), m_x26Model->createIndex(m_row, 3), {m_role});
+	m_teletextDocument->emit contentsChanged();
+	m_teletextDocument->emit tripletCommandHighlight(m_row);
+}
+
+bool EditTripletCommand::mergeWith(const QUndoCommand *command)
+{
+	const EditTripletCommand *newerCommand = static_cast<const EditTripletCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex || m_row != newerCommand->m_row)
+		return false;
+
+	m_newTriplet = newerCommand->m_newTriplet;
+	return true;
+}

src/qteletextmaker/x26commands.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef X26COMMANDS_H
+#define X26COMMANDS_H
+
+#include <QUndoCommand>
+
+#include "document.h"
+#include "x26model.h"
+#include "x26triplets.h"
+
+class InsertTripletCommand : public QUndoCommand
+{
+public:
+	InsertTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int count, const X26Triplet newTriplet, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	TeletextDocument *m_teletextDocument;
+	X26Model *m_x26Model;
+	int m_subPageIndex, m_row, m_count;
+	X26Triplet m_insertedTriplet;
+	bool m_firstDo;
+};
+
+class DeleteTripletCommand : public QUndoCommand
+{
+public:
+	DeleteTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int count, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	TeletextDocument *m_teletextDocument;
+	X26Model *m_x26Model;
+	int m_subPageIndex, m_row, m_count;
+	X26Triplet m_deletedTriplet;
+};
+
+class EditTripletCommand : public QUndoCommand
+{
+public:
+	enum { Id = 201 };
+	enum EditTripletEnum { ETaddress, ETmode, ETdata };
+
+	EditTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int tripletPart, int bitsToKeep, int newValue, int role, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *) override;
+	int id() const override { return Id; }
+
+private:
+	TeletextDocument *m_teletextDocument;
+	X26Model *m_x26Model;
+	int m_subPageIndex, m_row, m_role;
+	X26Triplet m_oldTriplet, m_newTriplet;
+	bool m_firstDo;
+};
+
+#endif

src/qteletextmaker/x26dockwidget.h

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef X26DOCKWIDGET_H
+#define X26DOCKWIDGET_H
+
+#include <QAbstractListModel>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDockWidget>
+#include <QGroupBox>
+#include <QLabel>
+#include <QMenu>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QSpinBox>
+#include <QStackedLayout>
+#include <QTableView>
+
+#include "mainwidget.h"
+#include "render.h"
+#include "x26menus.h"
+#include "x26model.h"
+
+class CharacterListModel : public QAbstractListModel
+{
+	Q_OBJECT
+
+public:
+	CharacterListModel(QObject *parent = 0);
+
+	int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+	QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+	void setCharacterSet(int characterSet);
+	void setG1AndBlastCharacterSet(int characterSet);
+
+private:
+	TeletextFontBitmap m_fontBitmap;
+	int m_characterSet;
+	bool m_mosaic;
+};
+
+class X26DockWidget : public QDockWidget
+{
+	Q_OBJECT
+
+public:
+	X26DockWidget(TeletextWidget *parent);
+
+public slots:
+	void insertTriplet(int modeExt, bool after);
+	void insertTriplet(int modeExt, int row = -1);
+	void insertTripletCopy();
+	void deleteTriplet();
+	void customMenuRequested(QPoint pos);
+	void loadX26List();
+	void unloadX26List();
+	void rowSelected(const QModelIndex &current, const QModelIndex &previous);
+	void updateAllRawTripletSpinBoxes(const QModelIndex &index);
+	void updateRawTripletDataSpinBox(const QModelIndex &index);
+	void updateAllCookedTripletWidgets(const QModelIndex & index);
+	void rawTripletAddressSpinBoxChanged(int value);
+	void rawTripletModeSpinBoxChanged(int value);
+	void rawTripletDataSpinBoxChanged(int value);
+	void cookedRowSpinBoxChanged(const int value);
+	void cookedColumnSpinBoxChanged(const int value);
+	void cookedModeMenuSelected(const int value);
+	void updateModelFromCookedWidget(const int value, const int role);
+	void selectX26ListRow(int row);
+
+protected:
+	void keyPressEvent(QKeyEvent *event) override;
+	CharacterListModel m_characterListModel;
+
+private:
+	QTableView *m_x26View;
+	X26Model *m_x26Model;
+	QSpinBox *m_cookedRowSpinBox, *m_cookedColumnSpinBox;
+	QMenu *m_cookedModeMenu, *m_insertBeforeMenu, *m_insertAfterMenu;
+	QPushButton *m_cookedModePushButton;
+	QSpinBox *m_rawTripletAddressSpinBox, *m_rawTripletModeSpinBox, *m_rawTripletDataSpinBox;
+	QStackedLayout *m_rawOrCookedStackedLayout;
+	QComboBox *m_colourComboBox;
+	QRadioButton *m_fullRowColourThisRowOnlyRadioButton, *m_fullRowColourDownToBottomRadioButton;
+	QComboBox *m_characterCodeComboBox;
+	QComboBox *m_flashModeComboBox, *m_flashRateComboBox;
+	QComboBox *m_textSizeComboBox;
+	QCheckBox *m_displayAttributeBoxingCheckBox, *m_displayAttributeConcealCheckBox, *m_displayAttributeInvertCheckBox, *m_displayAttributeUnderlineCheckBox;
+	QComboBox *m_objectSourceComboBox, *m_objectRequiredAtLevelsComboBox;
+	QLabel *m_invokeLocalObjectDesignationCodeLabel, *m_invokeLocalObjectTripletNumberLabel;
+	QSpinBox *m_invokeLocalObjectDesignationCodeSpinBox, *m_invokeLocalObjectTripletNumberSpinBox;
+	QSpinBox *m_invokePOPSubPageSpinBox, *m_invokePOPPacketNumberSpinBox;
+	QComboBox *m_invokePOPTripletNumberComboBox, *m_invokePOPPointerBitsComboBox;
+	QStackedLayout *m_invokeObjectSourceStackedLayout, *m_tripletParameterStackedLayout;
+	QComboBox *m_DRCSModeRequiredAtLevelsComboBox;
+	QRadioButton *m_DRCSModeGlobalRadioButton, *m_DRCSModeNormalRadioButton;
+	QSpinBox *m_DRCSModeSubPageSpinBox;
+	QRadioButton *m_DRCSCharacterGlobalRadioButton, *m_DRCSCharacterNormalRadioButton;
+	QSpinBox *m_DRCSCharacterCodeSpinBox;
+	QCheckBox *m_fontStyleProportionalCheckBox, *m_fontStyleBoldCheckBox, *m_fontStyleItalicCheckBox;
+	QSpinBox *m_fontStyleRowsSpinBox;
+	QSpinBox *m_reservedPDCSpinBox;
+	QComboBox *m_terminationMarkerPageTypeComboBox;
+	QCheckBox *m_terminationMarkerMoreFollowsCheckBox;
+	QPushButton *m_insertBeforePushButton, *m_insertAfterPushButton, *m_insertCopyPushButton, *m_deletePushButton;
+
+	ModeTripletNames m_modeTripletNames;
+
+	TeletextWidget *m_parentMainWidget;
+
+	void disableTripletWidgets();
+
+};
+
+#endif

src/qteletextmaker/x26menus.cpp

@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "x26menus.h"
+
+#include <QActionGroup>
+#include <QColor>
+#include <QIcon>
+#include <QMenu>
+#include <QPixmap>
+#include <QString>
+
+#include "render.h"
+
+TripletModeQMenu::TripletModeQMenu(QWidget *parent): QMenu(parent)
+{
+	addModeAction(this, 0x04);
+
+	QMenu *rowTripletSubMenu = this->addMenu(tr("Row triplet"));
+	addModeAction(rowTripletSubMenu, 0x00);
+	addModeAction(rowTripletSubMenu, 0x01);
+	addModeAction(rowTripletSubMenu, 0x07);
+	addModeAction(rowTripletSubMenu, 0x18);
+
+	QMenu *columnTripletSubMenu = this->addMenu(tr("Column triplet"));
+	addModeAction(columnTripletSubMenu, 0x20);
+	addModeAction(columnTripletSubMenu, 0x23);
+	addModeAction(columnTripletSubMenu, 0x27);
+	addModeAction(columnTripletSubMenu, 0x2c);
+	addModeAction(columnTripletSubMenu, 0x2e);
+	addModeAction(columnTripletSubMenu, 0x28);
+	columnTripletSubMenu->addSeparator();
+	addModeAction(columnTripletSubMenu, 0x29);
+	addModeAction(columnTripletSubMenu, 0x2f);
+	addModeAction(columnTripletSubMenu, 0x21);
+	addModeAction(columnTripletSubMenu, 0x22);
+	addModeAction(columnTripletSubMenu, 0x2b);
+	addModeAction(columnTripletSubMenu, 0x2d);
+
+	QMenu *diacriticalSubMenu = columnTripletSubMenu->addMenu(tr("G0 diacritical"));
+	for (int i=0; i<16; i++)
+		addModeAction(diacriticalSubMenu, 0x30 + i);
+
+	QMenu *objectSubMenu = this->addMenu(tr("Object"));
+	addModeAction(objectSubMenu, 0x10);
+	addModeAction(objectSubMenu, 0x11);
+	addModeAction(objectSubMenu, 0x12);
+	addModeAction(objectSubMenu, 0x13);
+	addModeAction(objectSubMenu, 0x15);
+	addModeAction(objectSubMenu, 0x16);
+	addModeAction(objectSubMenu, 0x17);
+	addModeAction(this, 0x1f);
+	this->addSeparator();
+
+	QMenu *pdcSubMenu = this->addMenu(tr("PDC/reserved"));
+	addModeAction(pdcSubMenu, 0x08);
+	addModeAction(pdcSubMenu, 0x09);
+	addModeAction(pdcSubMenu, 0x0a);
+	addModeAction(pdcSubMenu, 0x0b);
+	addModeAction(pdcSubMenu, 0x0c);
+	addModeAction(pdcSubMenu, 0x0d);
+	addModeAction(pdcSubMenu, 0x26);
+
+	QMenu *reservedRowSubMenu = pdcSubMenu->addMenu(tr("Reserved row"));
+	addModeAction(reservedRowSubMenu, 0x02);
+	addModeAction(reservedRowSubMenu, 0x03);
+	addModeAction(reservedRowSubMenu, 0x05);
+	addModeAction(reservedRowSubMenu, 0x06);
+	addModeAction(reservedRowSubMenu, 0x0e);
+	addModeAction(reservedRowSubMenu, 0x0f);
+	addModeAction(reservedRowSubMenu, 0x14);
+	addModeAction(reservedRowSubMenu, 0x19);
+	addModeAction(reservedRowSubMenu, 0x1a);
+	addModeAction(reservedRowSubMenu, 0x1b);
+	addModeAction(reservedRowSubMenu, 0x1c);
+	addModeAction(reservedRowSubMenu, 0x1d);
+	addModeAction(reservedRowSubMenu, 0x1e);
+
+	QMenu *reservedColumnSubMenu = pdcSubMenu->addMenu(tr("Reserved column"));
+	addModeAction(reservedColumnSubMenu, 0x24);
+	addModeAction(reservedColumnSubMenu, 0x25);
+	addModeAction(reservedColumnSubMenu, 0x2a);
+}
+
+void TripletModeQMenu::addModeAction(QMenu *menu, int mode)
+{
+	m_actions[mode] = menu->addAction(m_modeTripletNames.modeName(mode));
+}
+
+
+TripletCLUTQMenu::TripletCLUTQMenu(bool rows, QWidget *parent): QMenu(parent)
+{
+	QMenu *clut[4];
+
+	for (int c=0; c<4; c++) {
+		clut[c] = this->addMenu(QString("CLUT %1").arg(c));
+
+		for (int e=0; e<8; e++)
+			m_actions[c*8+e] = clut[c]->addAction(QString("CLUT %1:%2").arg(c).arg(e));
+	}
+
+	if (rows) {
+		m_actions[32] = this->addAction(tr("This row only"));
+		m_actions[33] = this->addAction(tr("Down to bottom"));
+	}
+}
+
+void TripletCLUTQMenu::setColour(int i, QColor c)
+{
+	QPixmap menuColour(32, 32); // Should get downscaled to the menu text size
+
+	menuColour.fill(c);
+	m_actions[i]->setIcon(QIcon(menuColour));
+}
+
+
+TripletCharacterQMenu::TripletCharacterQMenu(int charSet, bool mosaic, QWidget *parent): QMenu(parent)
+{
+	QMenu *charRange[6];
+
+	for (int r=0; r<6; r++) {
+		charRange[r] = this->addMenu(QString("0x%010-0x%01f").arg(r+2));
+
+		const int charSetInColumn = (mosaic && ((r & 0x2) == 0)) ? 24 : charSet;
+
+		for (int c=0; c<16; c++)
+			m_actions[r*16+c] = charRange[r]->addAction(QIcon(m_fontBitmap.charBitmap(r*16+c+32, charSetInColumn)), QString("0x%1").arg(r*16+c+32, 2, 16, QChar('0')));
+	}
+}
+
+
+TripletFlashQMenu::TripletFlashQMenu(QWidget *parent): QMenu(parent)
+{
+	QMenu *flashModeMenu = this->addMenu(tr("Flash mode"));
+	m_actions[0] = flashModeMenu->addAction(tr("Steady"));
+	m_actions[1] = flashModeMenu->addAction(tr("Normal"));
+	m_actions[2] = flashModeMenu->addAction(tr("Invert"));
+	m_actions[3] = flashModeMenu->addAction(tr("Adjacent CLUT"));
+	m_modeActionGroup = new QActionGroup(this);
+	for (int i=0; i<4; i++) {
+		m_actions[i]->setCheckable(true);
+		m_modeActionGroup->addAction(m_actions[i]);
+	}
+
+	QMenu *flashRatePhaseMenu = this->addMenu(tr("Flash rate/phase"));
+	m_actions[4] = flashRatePhaseMenu->addAction(tr("Slow 1Hz"));
+	m_actions[5] = flashRatePhaseMenu->addAction(tr("Fast 2Hz phase 1"));
+	m_actions[6] = flashRatePhaseMenu->addAction(tr("Fast 2Hz phase 2"));
+	m_actions[7] = flashRatePhaseMenu->addAction(tr("Fast 2Hz phase 3"));
+	m_actions[8] = flashRatePhaseMenu->addAction(tr("Fast 2Hz inc/right"));
+	m_actions[9] = flashRatePhaseMenu->addAction(tr("Fast 2Hz dec/left"));
+	m_ratePhaseActionGroup = new QActionGroup(this);
+	for (int i=4; i<10; i++) {
+		m_actions[i]->setCheckable(true);
+		m_ratePhaseActionGroup->addAction(m_actions[i]);
+	}
+}
+
+void TripletFlashQMenu::setModeChecked(int n)
+{
+	m_actions[n]->setChecked(true);
+}
+
+void TripletFlashQMenu::setRatePhaseChecked(int n)
+{
+	m_actions[n+4]->setChecked(true);
+}
+
+
+TripletDisplayAttrsQMenu::TripletDisplayAttrsQMenu(QWidget *parent): QMenu(parent)
+{
+	QMenu *sizeMenu = this->addMenu(tr("Text size"));
+	m_actions[0] = sizeMenu->addAction(tr("Normal size"));
+	m_actions[1] = sizeMenu->addAction(tr("Double height"));
+	m_actions[2] = sizeMenu->addAction(tr("Double width"));
+	m_actions[3] = sizeMenu->addAction(tr("Double size"));
+	m_sizeActionGroup = new QActionGroup(this);
+	for (int i=0; i<4; i++) {
+		m_actions[i]->setCheckable(true);
+		m_sizeActionGroup->addAction(m_actions[i]);
+	}
+
+	m_actions[4] = this->addAction(tr("Boxing/Window"));
+	m_actions[5] = this->addAction(tr("Conceal"));
+	m_actions[6] = this->addAction(tr("Invert"));
+	m_actions[7] = this->addAction(tr("Underline/Separated"));
+	m_otherActionGroup = new QActionGroup(this);
+	m_otherActionGroup->setExclusive(false);
+	for (int i=4; i<8; i++) {
+		m_actions[i]->setCheckable(true);
+		m_otherActionGroup->addAction(m_actions[i]);
+	}
+}
+
+void TripletDisplayAttrsQMenu::setTextSizeChecked(int n)
+{
+	m_actions[n]->setChecked(true);
+}
+
+void TripletDisplayAttrsQMenu::setOtherAttrChecked(int n, bool b)
+{
+	m_actions[n+4]->setChecked(b);
+}
+
+
+TripletFontStyleQMenu::TripletFontStyleQMenu(QWidget *parent): QMenu(parent)
+{
+	m_actions[0] = this->addAction(tr("Proportional"));
+	m_actions[1] = this->addAction(tr("Bold"));
+	m_actions[2] = this->addAction(tr("Italic"));
+	m_styleActionGroup = new QActionGroup(this);
+	m_styleActionGroup->setExclusive(false);
+	for (int i=0; i<3; i++) {
+		m_actions[i]->setCheckable(true);
+		m_styleActionGroup->addAction(m_actions[i]);
+	}
+
+	QMenu *rowsMenu = this->addMenu(tr("Next rows"));
+	m_rowsActionGroup = new QActionGroup(this);
+	for (int i=3; i<11; i++) {
+		m_actions[i] = rowsMenu->addAction(QString("%1").arg(i-3));
+		m_actions[i]->setCheckable(true);
+		m_rowsActionGroup->addAction(m_actions[i]);
+	}
+}
+
+void TripletFontStyleQMenu::setStyleChecked(int n, bool b)
+{
+	m_actions[n]->setChecked(b);
+}
+
+void TripletFontStyleQMenu::setRowsChecked(int n)
+{
+	m_actions[n+3]->setChecked(true);
+}

src/qteletextmaker/x26menus.h

@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef X26MENUS_H
+#define X26MENUS_H
+
+#include <QActionGroup>
+#include <QColor>
+#include <QMenu>
+#include <QString>
+
+#include "render.h"
+
+class ModeTripletNames
+{
+public:
+	static const QString modeName(int i) { return m_modeTripletName[i]; }
+
+private:
+	static inline const QString m_modeTripletName[64] {
+		// Row triplet modes
+		"Full screen colour",
+		"Full row colour",
+		"Reserved 0x02",
+		"Reserved 0x03",
+
+		"Set Active Position",
+		"Reserved 0x05",
+		"Reserved 0x06",
+		"Address row 0",
+
+		"PDC origin, source",
+		"PDC month and day",
+		"PDC cursor and start hour",
+		"PDC cursor and end hour",
+
+		"PDC cursor local offset",
+		"PDC series ID and code",
+		"Reserved 0x0e",
+		"Reserved 0x0f",
+
+		"Origin modifier",
+		"Invoke active object",
+		"Invoke adaptive object",
+		"Invoke passive object",
+
+		"Reserved 0x14",
+		"Define active object",
+		"Define adaptive object",
+		"Define passive object",
+
+		"DRCS mode",
+		"Reserved 0x19",
+		"Reserved 0x1a",
+		"Reserved 0x1b",
+
+		"Reserved 0x1c",
+		"Reserved 0x1d",
+		"Reserved 0x1e",
+		"Termination marker",
+
+		// Column triplet modes
+		"Foreground colour",
+		"G1 block mosaic",
+		"G3 smooth mosaic, level 1.5",
+		"Background colour",
+
+		"Reserved 0x04",
+		"Reserved 0x05",
+		"PDC cursor, start end min",
+		"Additional flash functions",
+
+		"Modified G0/G2 character set",
+		"G0 character",
+		"Reserved 0x0a",
+		"G3 smooth mosaic, level 2.5",
+
+		"Display attributes",
+		"DRCS character",
+		"Font style, level 3.5",
+		"G2 supplementary character",
+
+		"G0 character no diacritical",
+		"G0 character diacritical 1",
+		"G0 character diacritical 2",
+		"G0 character diacritical 3",
+		"G0 character diacritical 4",
+		"G0 character diacritical 5",
+		"G0 character diacritical 6",
+		"G0 character diacritical 7",
+		"G0 character diacritical 8",
+		"G0 character diacritical 9",
+		"G0 character diacritical A",
+		"G0 character diacritical B",
+		"G0 character diacritical C",
+		"G0 character diacritical D",
+		"G0 character diacritical E",
+		"G0 character diacritical F"
+	};
+};
+
+class TripletModeQMenu : public QMenu
+{
+	Q_OBJECT
+
+public:
+	TripletModeQMenu(QWidget *parent = nullptr);
+	QAction *action(int n) const { return m_actions[n]; };
+
+private:
+	void addModeAction(QMenu *menu, int mode);
+
+	QAction *m_actions[64];
+	ModeTripletNames m_modeTripletNames;
+};
+
+class TripletCLUTQMenu : public QMenu
+{
+	Q_OBJECT
+
+public:
+	TripletCLUTQMenu(bool rows, QWidget *parent = nullptr);
+	QAction *action(int n) const { return m_actions[n]; };
+	void setColour(int i, QColor c);
+
+private:
+	QAction *m_actions[34];
+};
+
+class TripletCharacterQMenu : public QMenu
+{
+	Q_OBJECT
+
+public:
+	TripletCharacterQMenu(int charSet, bool mosaic, QWidget *parent = nullptr);
+	QAction *action(int n) const { return m_actions[n]; };
+
+private:
+	QAction *m_actions[96];
+	TeletextFontBitmap m_fontBitmap;
+};
+
+class TripletFlashQMenu : public QMenu
+{
+	Q_OBJECT
+
+public:
+	TripletFlashQMenu(QWidget *parent = nullptr);
+	QAction *modeAction(int n) const { return m_actions[n]; };
+	QAction *ratePhaseAction(int n) const { return m_actions[n+4]; };
+	void setModeChecked(int n);
+	void setRatePhaseChecked(int n);
+
+private:
+	QAction *m_actions[10];
+	QActionGroup *m_modeActionGroup, *m_ratePhaseActionGroup;
+};
+
+class TripletDisplayAttrsQMenu : public QMenu
+{
+	Q_OBJECT
+
+public:
+	TripletDisplayAttrsQMenu(QWidget *parent = nullptr);
+	QAction *textSizeAction(int n) const { return m_actions[n]; };
+	QAction *otherAttrAction(int n) const { return m_actions[n+4]; };
+	void setTextSizeChecked(int n);
+	void setOtherAttrChecked(int n, bool b);
+
+private:
+	QAction *m_actions[8];
+	QActionGroup *m_sizeActionGroup, *m_otherActionGroup;
+};
+
+class TripletFontStyleQMenu : public QMenu
+{
+	Q_OBJECT
+
+public:
+	TripletFontStyleQMenu(QWidget *parent = nullptr);
+	QAction *styleAction(int n) const { return m_actions[n]; };
+	QAction *rowsAction(int n) const { return m_actions[n+3]; };
+	void setStyleChecked(int n, bool b);
+	void setRowsChecked(int n);
+
+private:
+	QAction *m_actions[11];
+	QActionGroup *m_styleActionGroup, *m_rowsActionGroup;
+};
+
+#endif

src/qteletextmaker/x26model.cpp

@@ -0,0 +1,928 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "x26model.h"
+
+#include <QIcon>
+#include <QList>
+
+#include "x26commands.h"
+#include "x26menus.h"
+
+X26Model::X26Model(TeletextWidget *parent): QAbstractListModel(parent)
+{
+	m_parentMainWidget = parent;
+	m_listLoaded = true;
+}
+
+void X26Model::setX26ListLoaded(bool newListLoaded)
+{
+	beginResetModel();
+	m_listLoaded = newListLoaded;
+	endResetModel();
+}
+
+int X26Model::rowCount(const QModelIndex & /*parent*/) const
+{
+	return m_listLoaded ? m_parentMainWidget->document()->currentSubPage()->enhancements()->size() : 0;
+}
+
+int X26Model::columnCount(const QModelIndex & /*parent*/) const
+{
+	return 4;
+}
+
+QVariant X26Model::data(const QModelIndex &index, int role) const
+{
+	const X26Triplet triplet = m_parentMainWidget->document()->currentSubPage()->enhancements()->at(index.row());
+
+	// Qt::UserRole will always return the raw values
+	if (role == Qt::UserRole)
+		switch (index.column()) {
+			case 0:
+				return triplet.address();
+			case 1:
+				return triplet.mode();
+			case 2:
+				return triplet.data();
+			default:
+				return QVariant();
+		}
+
+	// Error colours from KDE Plasma Breeze (light) theme
+	if (role == Qt::ForegroundRole) {
+		if (triplet.error() != X26Triplet::NoError && index.column() == m_tripletErrors[triplet.error()].columnHighlight)
+			return QColor(252, 252, 252);
+		else if ((index.column() == 2 && triplet.reservedMode()) || (index.column() == 3 && triplet.reservedData()))
+			return QColor(35, 38, 39);
+	}
+
+	if (role == Qt::BackgroundRole) {
+		if (triplet.error() != X26Triplet::NoError && index.column() == m_tripletErrors[triplet.error()].columnHighlight)
+			return QColor(218, 68, 63);
+		else if ((index.column() == 2 && triplet.reservedMode()) || (index.column() == 3 && triplet.reservedData()))
+			return QColor(246, 116, 0);
+	}
+
+	if (role == Qt::ToolTipRole && triplet.error() != X26Triplet::NoError)
+		return m_tripletErrors[triplet.error()].message;
+
+	if (role == Qt::DisplayRole || role == Qt::EditRole)
+		switch (index.column()) {
+			case 0:
+				// Show row number only if address part of triplet actually represents a row:
+				// Full row colour, Set Active Position and Origin Modifier
+				// For Origin Modifier address of 40 refers to same row, so show it as 0
+				if (triplet.modeExt() == 0x10) {
+					if (triplet.address() == 40)
+						return "+0";
+					else
+						return QString("+%1").arg(triplet.addressRow());
+				}
+				if (triplet.modeExt() == 0x01 || triplet.modeExt() == 0x04)
+					return triplet.addressRow();
+				else
+					return QVariant();
+			case 1:
+				if (!triplet.isRowTriplet())
+					return triplet.addressColumn();
+				// For Set Active Position and Origin Modifier, data is the column
+				else if (triplet.modeExt() == 0x04)
+					return triplet.data();
+				else if (triplet.modeExt() == 0x10)
+					return QString("+%1").arg(triplet.data());
+				else
+					return QVariant();
+		}
+
+	QString result;
+
+	if (role == Qt::DisplayRole) {
+		if (index.column() == 2)
+			return (m_modeTripletNames.modeName(triplet.modeExt()));
+		// Column 3 - describe effects of data/address triplet parameters in plain English
+		switch (triplet.modeExt()) {
+			case 0x01: // Full row colour
+			case 0x07: // Address row 0
+				if ((triplet.data() & 0x60) == 0x60)
+					result = ", down to bottom";
+				else if ((triplet.data() & 0x60) == 0x00)
+					result = ", this row only";
+				// fall-through
+			case 0x00: // Full screen colour
+				if (!(result.isEmpty()) || (triplet.data() & 0x60) == 0x00) {
+					result.prepend(QString("CLUT %1:%2").arg((triplet.data() & 0x18) >> 3).arg(triplet.data() & 0x07));
+					return result;
+				}
+				break;
+			case 0x04: // Set Active Position
+			case 0x10: // Origin Modifier
+				// For Set Active Position and Origin Modifier, data is the column, so return blank
+				return QVariant();
+			case 0x11: // Invoke Active Object
+			case 0x12: // Invoke Adaptive Object
+			case 0x13: // Invoke Passive Object
+				switch (triplet.address() & 0x18) {
+					case 0x08:
+						return QString("Local: d%1 t%2").arg((triplet.data() >> 4) | ((triplet.address() & 0x01) << 3)).arg(triplet.data() & 0x0f);
+					case 0x10:
+						result = "POP";
+						break;
+					case 0x18:
+						result = "GPOP";
+						break;
+					// case 0x00: shouldn't happen since that would make a column triplet, not a row triplet
+				}
+				result.append(QString(": subpage %1 pkt %2 trplt %3 bits ").arg(triplet.data() & 0x0f).arg((triplet.address() & 0x03) + 1).arg(((triplet.data() & 0x60) >> 5) * 3 + (triplet.modeExt() & 0x03)));
+				if (triplet.data() & 0x10)
+					result.append("10-18");
+				else
+					result.append("1-9");
+				return result;
+			case 0x15: // Define Active Object
+			case 0x16: // Define Adaptive Object
+			case 0x17: // Define Passive Object
+				switch (triplet.address() & 0x18) {
+					case 0x08:
+						return "Local: L2.5 only";
+						break;
+					case 0x10:
+						return "Local: L3.5 only";
+						break;
+					case 0x18:
+						return "Local: L2.5 and 3.5";
+						break;
+					// case 0x00: shouldn't happen since that would make a column triplet, not a row triplet
+				}
+				break;
+			case 0x18: // DRCS mode
+				result = (triplet.data() & 0x40) == 0x40 ? "Normal" : "Global";
+				result.append(QString(": subpage %1, ").arg(triplet.data() & 0x0f));
+				switch (triplet.data() & 0x30) {
+					case 0x10:
+						result.append("L2.5 only");
+						break;
+					case 0x20:
+						result.append("L3.5 only");
+						break;
+					case 0x30:
+						result.append("L2.5 and 3.5");
+						break;
+					case 0x00:
+						result.append("Reserved");
+						break;
+				}
+				return result;
+			case 0x1f: // Termination
+				switch (triplet.data() & 0x07) {
+					case 0x00:
+						return "Intermed (G)POP subpage. End of object, more follows";
+						break;
+					case 0x01:
+						return "Intermed (G)POP subpage. End of last object on page";
+						break;
+					case 0x02:
+						return "Last (G)POP subpage. End of object, more follows";
+						break;
+					case 0x03:
+						return "Last (G)POP subpage. End of last object on page";
+						break;
+					case 0x04:
+						return "Local object definitions. End of object, more follows";
+						break;
+					case 0x05:
+						return "Local object definitions. End of last object on page";
+						break;
+					case 0x06:
+						return "End of local enhance data. Local objects follow";
+						break;
+					case 0x07:
+						return "End of local enhance data. No local objects";
+						break;
+				}
+				break;
+			case 0x08: // PDC country of origin & programme source
+			case 0x09: // PDC month & day
+			case 0x0a: // PDC cursor row & announced start hour
+			case 0x0b: // PDC cursor row & announced finish hour
+			case 0x0c: // PDC cursor row & local time offset
+			case 0x0d: // PDC series ID & series code
+				return QString("0x%1").arg(triplet.data(), 2, 16, QChar('0'));
+			case 0x20: // Foreground colour
+			case 0x23: // Background colour
+				if (!(triplet.data() & 0x60))
+					return QString("CLUT %1:%2").arg((triplet.data() & 0x18) >> 3).arg(triplet.data() & 0x07);
+				break;
+			case 0x21: // G1 mosaic character
+			case 0x22: // G3 mosaic character at level 1.5
+			case 0x29: // G0 character
+			case 0x2b: // G3 mosaic character at level >=2.5
+			case 0x2f: // G2 character
+				if (triplet.data() >= 0x20)
+					return QString("0x%1").arg(triplet.data(), 2, 16);
+				break;
+			case 0x27: // Flash functions
+				if (triplet.data() < 0x18) {
+					switch (triplet.data() & 0x03) {
+						case 0x00:
+							result = "Steady";
+							break;
+						case 0x01:
+							result = "Normal";
+							break;
+						case 0x02:
+							result = "Invert";
+							break;
+						case 0x03:
+							result = "Adj CLUT";
+							break;
+					}
+					switch (triplet.data() & 0x1c) {
+						case 0x00:
+							result.append(", 1Hz");
+							break;
+						case 0x04:
+							result.append(", 2Hz ph 1");
+							break;
+						case 0x08:
+							result.append(", 2Hz ph 2");
+							break;
+						case 0x0c:
+							result.append(", 2Hz ph 3");
+							break;
+						case 0x10:
+							result.append(", 2Hz inc");
+							break;
+						case 0x14:
+							result.append(", 2Hz dec");
+							break;
+					}
+					return result;
+				}
+				break;
+			case 0x28: // Modified G0 and G2 character set
+				switch (triplet.data()) {
+					case 0x20:
+						return QString("0x20 Cyrillic 1 Serbian/Croatian");
+					case 0x24:
+						return QString("0x24 Cyrillic 2 Russian/Bulgarian");
+					case 0x25:
+						return QString("0x25 Cyrillic 3 Ukranian");
+					case 0x36:
+						return QString("0x36 Latin");
+					case 0x37:
+						return QString("0x37 Greek");
+					case 0x40:
+					case 0x44:
+						return QString("0x%1 G0 Latin, G2 Arabic").arg(triplet.data(), 2, 16);
+					case 0x47:
+					case 0x57:
+						return QString("0x%1 Arabic").arg(triplet.data(), 2, 16);
+					case 0x55:
+						return QString("0x55 G0 Hebrew, G2 Arabic");
+				}
+				if (triplet.data() < 0x27)
+					return QString("0x%1 Latin").arg(triplet.data(), 2, 16, QChar('0'));
+				break;
+			case 0x2c: // Display attributes
+				if (triplet.data() & 0x02)
+					result.append("Boxing ");
+				if (triplet.data() & 0x04)
+					result.append("Conceal ");
+				if (triplet.data() & 0x10)
+					result.append("Invert ");
+				if (triplet.data() & 0x20)
+					result.append("Underline ");
+				if (result.isEmpty())
+					result = "None";
+				else
+					// Chop off the last space
+					result.chop(1);
+				switch (triplet.data() & 0x41) {
+					case 0x00:
+						result.append(", normal size");
+						break;
+					case 0x01:
+						result.append(", double height");
+						break;
+					case 0x40:
+						result.append(", double width");
+						break;
+					case 0x41:
+						result.append(", double size");
+						break;
+				}
+				return result;
+			case 0x2d: // DRCS character
+				result = (triplet.data() & 0x40) == 0x40 ? "Normal" : "Global";
+				result.append(QString(": %1").arg(triplet.data() & 0x3f));
+				return result;
+			case 0x2e: // Font style
+				if (triplet.data() & 0x01)
+					result.append("Proportional ");
+				if (triplet.data() & 0x02)
+					result.append("Bold ");
+				if (triplet.data() & 0x04)
+					result.append("Italic ");
+				if (result.isEmpty())
+					result = "None";
+				else
+					// Chop off the last space
+					result.chop(1);
+				result.append(QString(", %1 row(s)").arg(triplet.data() >> 4));
+				return result;
+			case 0x26: // PDC
+				return QString("0x%1").arg(triplet.data(), 2, 16, QChar('0'));
+			default:
+				if (triplet.modeExt() >= 0x30 && triplet.modeExt() <= 0x3f && triplet.data() >= 0x20)
+					// G0 with diacritical
+					return QString("0x%1").arg(triplet.data(), 2, 16);
+				else
+					// Reserved
+					return QString("Reserved 0x%1").arg(triplet.data(), 2, 16, QChar('0'));
+		}
+		// Reserved mode or data
+		return QString("Reserved 0x%1").arg(triplet.data(), 2, 16, QChar('0'));
+	}
+
+	if (role == Qt::DecorationRole && index.column() == 3)
+		switch (triplet.modeExt()) {
+			case 0x00: // Full screen colour
+			case 0x20: // Foreground colour
+			case 0x23: // Background colour
+				if (!(triplet.data() & 0x60))
+					return m_parentMainWidget->document()->currentSubPage()->CLUTtoQColor(triplet.data());
+				break;
+			case 0x01: // Full row colour
+			case 0x07: // Address row 0
+				if (((triplet.data() & 0x60) == 0x00) || ((triplet.data() & 0x60) == 0x60))
+					return m_parentMainWidget->document()->currentSubPage()->CLUTtoQColor(triplet.data() & 0x1f);
+				break;
+			case 0x21: // G1 mosaic character
+				if (triplet.data() & 0x20)
+					return m_fontBitmap.charIcon(triplet.data(), 24);
+				else if (triplet.data() >= 0x20)
+					// Blast-through
+					return m_fontBitmap.charIcon(triplet.data(), m_parentMainWidget->pageDecode()->cellG0CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn()));
+				break;
+			case 0x22: // G3 mosaic character at level 1.5
+			case 0x2b: // G3 mosaic character at level >=2.5
+				if (triplet.data() >= 0x20)
+					return m_fontBitmap.charIcon(triplet.data(), 26);
+				break;
+			case 0x2f: // G2 character
+				if (triplet.data() >= 0x20)
+					return m_fontBitmap.charIcon(triplet.data(), m_parentMainWidget->pageDecode()->cellG2CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn()));
+				break;
+			default:
+				if (triplet.modeExt() == 0x29 || (triplet.modeExt() >= 0x30 && triplet.modeExt() <= 0x3f))
+					// G0 character or G0 diacritical mark
+					if (triplet.data() >= 0x20)
+						return m_fontBitmap.charIcon(triplet.data(), m_parentMainWidget->pageDecode()->cellG0CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn()));
+		}
+
+	if (role == Qt::EditRole && index.column() == 2)
+		return triplet.modeExt();
+
+	if (role < Qt::UserRole)
+		return QVariant();
+
+	switch (triplet.modeExt()) {
+		case 0x01: // Full row colour
+		case 0x07: // Address row 0
+			if (role == Qt::UserRole+2) // "this row only" or "down to bottom"
+				return (triplet.data() & 0x60) == 0x60;
+			// fall-through
+		case 0x00: // Full screen colour
+		case 0x20: // Foreground colour
+		case 0x23: // Background colour
+			if (role == Qt::UserRole+1) // Colour index
+				return triplet.data() & 0x1f;
+			break;
+		case 0x11: // Invoke Active Object
+		case 0x12: // Invoke Adaptive Object
+		case 0x13: // Invoke Passive Object
+			switch (role) {
+				case Qt::UserRole+1: // Object source: Local, POP or GPOP
+					return ((triplet.address() & 0x18) >> 3) - 1;
+				case Qt::UserRole+2:
+					if ((triplet.address() & 0x18) == 0x08)
+						// Local object: Designation code
+						return ((triplet.address() & 0x01) << 3) | ((triplet.data() & 0x70) >> 4);
+					else
+						// (G)POP object: Subpage
+						return triplet.data() & 0x0f;
+				case Qt::UserRole+3:
+					if ((triplet.address() & 0x08) == 0x08)
+						// Local object: Triplet number
+						return triplet.data() & 0x0f;
+					else
+						// (G)POP object: Pointer location
+						return (triplet.address() & 0x03) + 1;
+				case Qt::UserRole+4: // (G)POP object: Triplet number
+					return triplet.data() >> 5;
+				case Qt::UserRole+5: // (G)POP object: Pointer position
+					return (triplet.data() & 0x10) >> 4;
+			}
+			break;
+		case 0x15: // Define Active Object
+		case 0x16: // Define Adaptive Object
+		case 0x17: // Define Passive Object
+			switch (role) {
+				case Qt::UserRole+1: // Required at which levels
+					return ((triplet.address() & 0x18) >> 3) - 1;
+				case Qt::UserRole+2: // Local object: Designation code
+					return ((triplet.address() & 0x01) << 3) | ((triplet.data() & 0x70) >> 4);
+				case Qt::UserRole+3: // Local object: Triplet number
+					return triplet.data() & 0x0f;
+			}
+			break;
+		case 0x18: // DRCS mode
+			switch (role) {
+				case Qt::UserRole+1: // Required at which levels
+					return ((triplet.data() & 0x30) >> 4) - 1;
+				case Qt::UserRole+3: // Normal or Global
+					return (triplet.data() & 0x40) == 0x40;
+				case Qt::UserRole+4: // Subpage
+					return triplet.data() & 0x0f;
+			}
+			break;
+		case 0x1f: // Termination
+			switch (role) {
+				case Qt::UserRole+1: // Intermed POP subpage|Last POP subpage|Local Object|Local enhance
+					return ((triplet.data() & 0x06) >> 1);
+				case Qt::UserRole+2: // More follows/Last
+					return (triplet.data() & 0x01) == 0x01;
+			}
+			break;
+		case 0x21: // G1 character
+			// Qt::UserRole+1 is character number, returned by default below
+			switch (role) {
+				case Qt::UserRole+2: // G1 character set
+					return 24;
+				case Qt::UserRole+3: // G0 character set for blast-through
+					return m_parentMainWidget->pageDecode()->cellG0CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn());
+			}
+			break;
+		case 0x22: // G3 character at Level 1.5
+		case 0x2b: // G3 character at Level 2.5
+			// Qt::UserRole+1 is character number, returned by default below
+			if (role == Qt::UserRole+2) // G3 character set
+				return 26;
+			break;
+		case 0x27: // Flash functions
+			switch (role) {
+				case Qt::UserRole+1: // Flash mode
+					return triplet.data() & 0x03;
+				case Qt::UserRole+2: // Flash rate and phase
+					return triplet.data() >> 2;
+			}
+			break;
+		case 0x2c: // Display attributes
+			switch (role) {
+				case Qt::UserRole+1: // Text size
+					return (triplet.data() & 0x01) | ((triplet.data() & 0x40) >> 5);
+				case Qt::UserRole+2: // Boxing/window
+					return (triplet.data() & 0x02) == 0x02;
+				case Qt::UserRole+3: // Conceal
+					return (triplet.data() & 0x04) == 0x04;
+				case Qt::UserRole+4: // Invert
+					return (triplet.data() & 0x10) == 0x10;
+				case Qt::UserRole+5: // Underline/Separated
+					return (triplet.data() & 0x20) == 0x20;
+			}
+			break;
+		case 0x2d: // DRCS character
+			switch (role) {
+				case Qt::UserRole+1: // Normal or Global
+					return (triplet.data() & 0x40) == 0x40;
+				case Qt::UserRole+2: // Character number
+					return triplet.data() & 0x3f;
+			}
+			break;
+		case 0x2e: // Font style
+			switch (role) {
+				case Qt::UserRole+1: // Proportional
+					return (triplet.data() & 0x01) == 0x01;
+				case Qt::UserRole+2: // Bold
+					return (triplet.data() & 0x02) == 0x02;
+				case Qt::UserRole+3: // Italic
+					return (triplet.data() & 0x04) == 0x04;
+				case Qt::UserRole+4: // Number of rows
+					return triplet.data() >> 4;
+			}
+			break;
+		case 0x2f: // G2 character
+			// Qt::UserRole+1 is character number, returned by default below
+			if (role == Qt::UserRole+2) // Character set
+				return m_parentMainWidget->pageDecode()->cellG2CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn());
+			break;
+		default:
+			if (triplet.modeExt() == 0x29 || (triplet.modeExt() >= 0x30 && triplet.modeExt() <= 0x3f))
+				// G0 character or G0 diacritical mark
+				// Qt::UserRole+1 is character number, returned by default below
+				if (role == Qt::UserRole+2) // Character set
+					return m_parentMainWidget->pageDecode()->cellG0CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn());
+	};
+
+	// For characters and other triplet modes, return the complete data value
+	if (role == Qt::UserRole+1)
+		return triplet.data();
+
+	return QVariant();
+}
+
+bool X26Model::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+	if (!index.isValid())
+		return false;
+
+	if (!value.canConvert<int>())
+		return false;
+
+	const int intValue = value.toInt();
+
+	if (intValue < 0)
+		return false;
+
+	// Raw address, mode and data values
+	if (role == Qt::UserRole && index.column() <= 2) {
+		m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), index.column(), 0x00, intValue, role));
+
+		return true;
+	}
+
+	const X26Triplet triplet = m_parentMainWidget->document()->currentSubPage()->enhancements()->at(index.row());
+
+	// Cooked row, column and triplet mode
+	if (role == Qt::EditRole) {
+		switch (index.column()) {
+			case 0: // Cooked row
+				// Maximum row is 24
+				if (intValue > 24)
+					return false;
+				// Set Active Position and Full Row Colour can't select row 0
+				if (((triplet.modeExt() == 0x04) || (triplet.modeExt() == 0x01)) && intValue == 0)
+					return false;
+				// For Origin Modifier address of 40 refers to same row
+				if (triplet.modeExt() == 0x10 && intValue == 24) {
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x00, 40, role));
+					return true;
+				}
+				// Others use address 40 for row 24
+				m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x00, (intValue == 24) ? 40 : intValue+40, role));
+				return true;
+
+			case 1: // Cooked column
+				// Origin modifier allows columns up to 71
+				if (intValue > (triplet.modeExt() == 0x10 ? 71 : 39))
+					return false;
+				// For Set Active Position and Origin Modifier, data is the column
+				if (triplet.modeExt() == 0x04 || triplet.modeExt() == 0x10)
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x00, intValue, role));
+				else
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x00, intValue, role));
+				return true;
+
+			case 2: // Cooked triplet mode
+				if (intValue < 0x20 && !triplet.isRowTriplet()) {
+					// Changing mode from column triplet to row triplet
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x00, 41, role));
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x00, 0, role));
+				}
+				if (intValue >= 0x20 && triplet.isRowTriplet()) {
+					// Changing mode from row triplet to column triplet
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x00, 0, role));
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x00, 0, role));
+				}
+				m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETmode, 0x00, intValue & 0x1f, role));
+
+				// Now set data values to avoid reserved bits if we need to
+				// FIXME this can rather messily push multiple EditTripletCommands
+				// that rely on mergeWith to tidy them up afterwards
+				// Also this just flips bits, where we could use default values
+				switch (intValue) {
+					case 0x00: // Full screen colour
+					case 0x20: // Foreground colour
+					case 0x23: // Background colour
+						// Both S1 and S0 reserved bits must be clear
+						if (triplet.data() & 0x60)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x1f, 0x00, role));
+						break;
+					case 0x07: // Address row 0
+						// Address locked to 63
+						if (triplet.address() != 63)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x00, 63, role));
+						// fall-through
+					case 0x01: // Full row colour
+						// S1 and S0 bits need to be the same
+						if ((triplet.data() & 0x60) != 0x00 && (triplet.data() & 0x60) != 0x60)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x1f, 0x00, role));
+						break;
+					case 0x04: // Set Active Position
+						// Data range 0-39
+						if (triplet.data() >= 40)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x00, 0, role));
+						break;
+					case 0x10: // Origin modifier
+						// Data range 0-71
+						if (triplet.data() >= 72)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x00, 0, role));
+						break;
+					case 0x11: // Invoke Active Object
+					case 0x12: // Invoke Adaptive Object
+					case 0x13: // Invoke Passive Object
+					case 0x15: // Define Active Object
+					case 0x16: // Define Adaptive Object
+					case 0x17: // Define Passive Object
+						// Bit 3 of Address is reserved
+						if ((triplet.address() & 0x04) == 0x04)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x7b, 0x00, role));
+						// BUG we're only dealing with Local Object Definitions at the moment!
+						// If source is Local, triplet number must be in range 0-12
+						if (((triplet.address() & 0x18) == 0x08) && ((triplet.data() & 0x0f) >= 12))
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x70, 0x00, role));
+						break;
+					case 0x18: // DRCS mode
+						// At least one of the L1 and L0 bits must be set
+						if ((triplet.data() & 0x30) == 0x00)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x4f, 0x30, role));
+						break;
+					case 0x1f: // Termination marker
+						// Address locked to 63
+						if (triplet.address() != 63)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x00, 63, role));
+						// Clear reserved bits D6-D3
+						if (triplet.data() & 0x78)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x07, 0x00, role));
+						break;
+					case 0x27: // Additional flash functions
+						// D6 and D5 must be clear, D4 and D3 set is reserved phase
+						if (triplet.data() >= 0x18)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x00, 0, role));
+						break;
+					case 0x2c: // Display attributes
+					case 0x2e: // Font style
+						// Clear reserved bit D3
+						if (triplet.data() & 0x08)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x77, 0x00, role));
+						break;
+					case 0x2d: // DRCS character
+						// D5-D0 range 0-47
+						if ((triplet.data() & 0x3f) >= 48)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x40, 0x77, role));
+						break;
+					case 0x21: // G1 mosaic character
+					case 0x22: // G3 mosaic character at level 1.5
+					case 0x29: // G0 character
+					case 0x2b: // G3 mosaic character at level >=2.5
+					case 0x2f: // G2 character
+						// Data range 0x20-0x7f
+						if (triplet.data() < 0x20)
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x00, 0x20, role));
+						break;
+					default:
+						if (intValue >= 0x30 && intValue <= 0x3f && triplet.data() < 0x20)
+						// G0 diacritical mark
+						// Data range 0x20-0x7f
+							m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x00, 0x20, role));
+				}
+				return true;
+		}
+		return false;
+	}
+
+	if (role < Qt::UserRole)
+		return false;
+
+	switch (triplet.modeExt()) {
+		case 0x01: // Full row colour
+		case 0x07: // Address row 0
+			switch (role) {
+				case Qt::UserRole+1: // Colour index
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x60, intValue, role));
+					return true;
+				case Qt::UserRole+2: // "this row only" or "down to bottom"
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x1f, intValue * 0x60, role));
+					break;
+			}
+			break;
+		case 0x11: // Invoke Active Object
+		case 0x12: // Invoke Adaptive Object
+		case 0x13: // Invoke Passive Object
+			switch (role) {
+				case Qt::UserRole+1: // Object source: Local, POP or GPOP
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x27, (intValue+1) << 3, role));
+					return true;
+				case Qt::UserRole+2:
+					if ((triplet.address() & 0x18) == 0x08) {
+						// Local object: Designation code
+						m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x0f, (intValue & 0x07) << 4, role));
+						m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x38, intValue >> 3, role));
+					} else
+						// (G)POP object: Subpage
+						m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x30, intValue, role));
+					return true;
+				case Qt::UserRole+3: // Invoke object
+					if ((triplet.address() & 0x18) == 0x08)
+						// Local object: triplet number
+						m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x70, intValue, role));
+					else
+						// (G)POP object: Pointer location
+						m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x7c, intValue - 1, role));
+					return true;
+				case Qt::UserRole+4: // (G)POP object: Triplet number
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x1f, intValue << 5, role));
+					return true;
+				case Qt::UserRole+5: // (G)POP object: Pointer position
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x6f, intValue << 4, role));
+					return true;
+			}
+			break;
+		case 0x15: // Define Active Object
+		case 0x16: // Define Adaptive Object
+		case 0x17: // Define Passive Object
+			switch (role) {
+				case Qt::UserRole+1: // Required at which levels
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x27, (intValue+1) << 3, role));
+					return true;
+				case Qt::UserRole+2: // Local object: Designation code
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x0f, (intValue & 0x07) << 4, role));
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETaddress, 0x38, intValue >> 3, role));
+					return true;
+				case Qt::UserRole+3: // Local object: triplet number
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x70, intValue, role));
+					break;
+			}
+			break;
+		case 0x18: // DRCS Mode
+			switch (role) {
+				case Qt::UserRole+1: // Required at which levels
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x4f, (intValue+1) << 4, role));
+					return true;
+				case Qt::UserRole+3: // Normal or Global
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x3f, intValue << 6, role));
+					return true;
+				case Qt::UserRole+4: // Subpage
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x70, intValue, role));
+					return true;
+			}
+			break;
+		case 0x1f: // Termination
+			switch (role) {
+				case Qt::UserRole+1: // Intermed POP subpage|Last POP subpage|Local Object|Local enhance
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x01, intValue << 1, role));
+					return true;
+				case Qt::UserRole+2: // More follows/Last
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x06, intValue, role));
+					return true;
+			}
+			break;
+		case 0x27: // Flash functions
+			switch (role) {
+				case Qt::UserRole+1: // Flash mode
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x1c, intValue, role));
+					return true;
+				case Qt::UserRole+2: // Flash rate and phase
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x03, intValue << 2, role));
+					break;
+			}
+			break;
+		case 0x2c: // Display attributes
+			switch (role) {
+				case Qt::UserRole+1: // Text size
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x36, ((intValue & 0x02) << 5) | (intValue & 0x01), role));
+					return true;
+				case Qt::UserRole+2: // Boxing/window
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x7d, intValue << 1, role));
+					return true;
+				case Qt::UserRole+3: // Conceal
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x7b, intValue << 2, role));
+					return true;
+				case Qt::UserRole+4: // Invert
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x6f, intValue << 4, role));
+					return true;
+				case Qt::UserRole+5: // Underline/Separated
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x5f, intValue << 5, role));
+					return true;
+			}
+			break;
+		case 0x2d: // DRCS character
+			switch (role) {
+				case Qt::UserRole+1: // Normal or Global
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x3f, intValue << 6, role));
+					return true;
+				case Qt::UserRole+2: // Character number
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x40, intValue, role));
+					break;
+			}
+			break;
+		case 0x2e: // Font style
+			switch (role) {
+				case Qt::UserRole+1: // Proportional
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x7e, intValue, role));
+					return true;
+				case Qt::UserRole+2: // Bold
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x7d, intValue << 1, role));
+					return true;
+				case Qt::UserRole+3: // Italic
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x7b, intValue << 2, role));
+					return true;
+				case Qt::UserRole+4: // Number of rows
+					m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x07, intValue << 4, role));
+					return true;
+			}
+			break;
+	}
+
+	// Fpr other triplet modes, set the complete data value
+	if (role == Qt::UserRole+1) {
+		m_parentMainWidget->document()->undoStack()->push(new EditTripletCommand(m_parentMainWidget->document(), this, index.row(), EditTripletCommand::ETdata, 0x00, intValue, role));
+		return true;
+	}
+
+	return false;
+}
+
+QVariant X26Model::headerData(int section, Qt::Orientation orientation, int role) const
+{
+	if (role == Qt::DisplayRole) {
+		if (orientation == Qt::Horizontal) {
+			switch (section) {
+				case 0:
+					return tr("Row");
+				case 1:
+					return tr("Col");
+				case 2:
+					return tr("Mode");
+				case 3:
+					return tr("Data");
+				default:
+					return QVariant();
+			}
+		} else if (orientation == Qt::Vertical)
+			return QString("d%1 t%2").arg(section / 13).arg(section % 13);
+	}
+	return QVariant();
+}
+
+bool X26Model::insertRows(int row, int count, const QModelIndex &parent)
+{
+	Q_UNUSED(parent);
+
+	if (m_parentMainWidget->document()->currentSubPage()->enhancements()->size() + count > m_parentMainWidget->document()->currentSubPage()->maxEnhancements())
+		return false;
+
+	m_parentMainWidget->document()->undoStack()->push(new InsertTripletCommand(m_parentMainWidget->document(), this, row, count, m_parentMainWidget->document()->currentSubPage()->enhancements()->at(row)));
+	return true;
+}
+
+bool X26Model::insertRows(int row, int count, const QModelIndex &parent, X26Triplet triplet)
+{
+	Q_UNUSED(parent);
+
+	if (m_parentMainWidget->document()->currentSubPage()->enhancements()->size() + count > m_parentMainWidget->document()->currentSubPage()->maxEnhancements())
+		return false;
+
+	m_parentMainWidget->document()->undoStack()->push(new InsertTripletCommand(m_parentMainWidget->document(), this, row, count, triplet));
+	return true;
+}
+
+bool X26Model::removeRows(int row, int count, const QModelIndex &index)
+{
+	Q_UNUSED(index);
+
+	m_parentMainWidget->document()->undoStack()->push(new DeleteTripletCommand(m_parentMainWidget->document(), this, row, count));
+	return true;
+}
+
+/*
+Qt::ItemFlags X26Model::flags(const QModelIndex &index) const
+{
+	if (!index.isValid())
+		return QAbstractItemModel::flags(index);
+
+	if (index.column() <= 1)
+		return QAbstractItemModel::flags(index);
+	if (index.column() >= 2)
+		return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
+
+	return QAbstractItemModel::flags(index);
+}
+*/

src/qteletextmaker/x26model.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef X26MODEL_H
+#define X26MODEL_H
+
+#include <QAbstractListModel>
+
+#include "mainwidget.h"
+#include "x26menus.h"
+
+class X26Model : public QAbstractListModel
+{
+	Q_OBJECT
+
+public:
+	X26Model(TeletextWidget *parent);
+	void setX26ListLoaded(bool newListLoaded);
+	int rowCount(const QModelIndex &parent = QModelIndex()) const override ;
+	int columnCount(const QModelIndex &parent = QModelIndex()) const override;
+	QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+	bool setData(const QModelIndex &index, const QVariant &value, int role);
+	QVariant headerData(int section, Qt::Orientation orientation, int role) const;
+	bool insertRows(int position, int rows, const QModelIndex &parent);
+	bool insertRows(int position, int rows, const QModelIndex &parent, X26Triplet triplet);
+	bool removeRows(int position, int rows, const QModelIndex &index);
+//	Qt::ItemFlags flags(const QModelIndex &index) const;
+
+	// The x26commands classes manipulate the model but beginInsertRows and endInsertRows
+	// are protected methods, so we need to friend them
+	friend class InsertTripletCommand;
+	friend class DeleteTripletCommand;
+	friend class EditTripletCommand;
+
+private:
+	TeletextWidget *m_parentMainWidget;
+	bool m_listLoaded;
+	TeletextFontBitmap m_fontBitmap;
+	ModeTripletNames m_modeTripletNames;
+
+	struct tripletErrorShow {
+		QString message;
+		int columnHighlight;
+	};
+
+	// Needs to be in the same order as enum X26TripletError in x26triplets.h
+	const tripletErrorShow m_tripletErrors[6] {
+		{ "", 0 }, // No error
+		{ "Active Position can't move up", 0 },
+		{ "Active Position can't move left within row", 1 },
+		{ "Invocation not pointing to Object Definition", 3 },
+		{ "Invoked and Defined Object types don't match", 2 },
+		{ "Origin Modifier not followed by Object Invocation", 2 }
+	};
+};
+
+#endif

src/qteletextmaker/x28commands.cpp

@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "x28commands.h"
+
+#include "document.h"
+
+X28Command::X28Command(TeletextDocument *teletextDocument, QUndoCommand *parent) : QUndoCommand(parent)
+{
+	m_teletextDocument = teletextDocument;
+	m_subPageIndex = teletextDocument->currentSubPageIndex();
+}
+
+
+SetFullScreenColourCommand::SetFullScreenColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent) : X28Command(teletextDocument, parent)
+{
+	m_oldColour = teletextDocument->currentSubPage()->defaultScreenColour();
+	m_newColour = newColour;
+
+	setText(QObject::tr("full screen colour"));
+}
+
+void SetFullScreenColourCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setDefaultScreenColour(m_newColour);
+
+	emit m_teletextDocument->contentsChanged();
+	emit m_teletextDocument->pageOptionsChanged();
+}
+
+void SetFullScreenColourCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setDefaultScreenColour(m_oldColour);
+
+	emit m_teletextDocument->contentsChanged();
+	emit m_teletextDocument->pageOptionsChanged();
+}
+
+bool SetFullScreenColourCommand::mergeWith(const QUndoCommand *command)
+{
+	const SetFullScreenColourCommand *newerCommand = static_cast<const SetFullScreenColourCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex)
+		return false;
+
+	m_newColour = newerCommand->m_newColour;
+
+	return true;
+}
+
+
+SetFullRowColourCommand::SetFullRowColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent) : X28Command(teletextDocument, parent)
+{
+	m_oldColour = teletextDocument->currentSubPage()->defaultRowColour();
+	m_newColour = newColour;
+
+	setText(QObject::tr("full row colour"));
+}
+
+void SetFullRowColourCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setDefaultRowColour(m_newColour);
+
+	emit m_teletextDocument->contentsChanged();
+	emit m_teletextDocument->pageOptionsChanged();
+}
+
+void SetFullRowColourCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setDefaultRowColour(m_oldColour);
+
+	emit m_teletextDocument->contentsChanged();
+	emit m_teletextDocument->pageOptionsChanged();
+}
+
+bool SetFullRowColourCommand::mergeWith(const QUndoCommand *command)
+{
+	const SetFullRowColourCommand *newerCommand = static_cast<const SetFullRowColourCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex)
+		return false;
+
+	m_newColour = newerCommand->m_newColour;
+
+	return true;
+}
+
+
+SetCLUTRemapCommand::SetCLUTRemapCommand(TeletextDocument *teletextDocument, int newMap, QUndoCommand *parent) : X28Command(teletextDocument, parent)
+{
+	m_oldMap = teletextDocument->currentSubPage()->colourTableRemap();
+	m_newMap = newMap;
+
+	setText(QObject::tr("CLUT remapping"));
+}
+
+void SetCLUTRemapCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setColourTableRemap(m_newMap);
+
+	emit m_teletextDocument->contentsChanged();
+	emit m_teletextDocument->pageOptionsChanged();
+}
+
+void SetCLUTRemapCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setColourTableRemap(m_oldMap);
+
+	emit m_teletextDocument->contentsChanged();
+	emit m_teletextDocument->pageOptionsChanged();
+}
+
+bool SetCLUTRemapCommand::mergeWith(const QUndoCommand *command)
+{
+	const SetCLUTRemapCommand *newerCommand = static_cast<const SetCLUTRemapCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex)
+		return false;
+
+	m_newMap = newerCommand->m_newMap;
+
+	return true;
+}
+
+
+SetBlackBackgroundSubstCommand::SetBlackBackgroundSubstCommand(TeletextDocument *teletextDocument, bool newSub, QUndoCommand *parent) : X28Command(teletextDocument, parent)
+{
+	m_oldSub = teletextDocument->currentSubPage()->blackBackgroundSubst();
+	m_newSub = newSub;
+
+	setText(QObject::tr("black background substitution"));
+}
+
+void SetBlackBackgroundSubstCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setBlackBackgroundSubst(m_newSub);
+
+	emit m_teletextDocument->contentsChanged();
+	emit m_teletextDocument->pageOptionsChanged();
+}
+
+void SetBlackBackgroundSubstCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setBlackBackgroundSubst(m_oldSub);
+
+	emit m_teletextDocument->contentsChanged();
+	emit m_teletextDocument->pageOptionsChanged();
+}
+
+bool SetBlackBackgroundSubstCommand::mergeWith(const QUndoCommand *command)
+{
+	const SetBlackBackgroundSubstCommand *newerCommand = static_cast<const SetBlackBackgroundSubstCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex)
+		return false;
+
+	setObsolete(true);
+	return true;
+}
+
+
+SetColourCommand::SetColourCommand(TeletextDocument *teletextDocument, int colourIndex, int newColour, QUndoCommand *parent) : X28Command(teletextDocument, parent)
+{
+	m_colourIndex = colourIndex;
+	m_oldColour = teletextDocument->currentSubPage()->CLUT(colourIndex);
+	m_newColour = newColour;
+
+	setText(QObject::tr("colour change"));
+}
+
+void SetColourCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setCLUT(m_colourIndex, m_newColour);
+
+	emit m_teletextDocument->colourChanged(m_colourIndex);
+	emit m_teletextDocument->contentsChanged();
+}
+
+void SetColourCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	m_teletextDocument->currentSubPage()->setCLUT(m_colourIndex, m_oldColour);
+
+	emit m_teletextDocument->colourChanged(m_colourIndex);
+	emit m_teletextDocument->contentsChanged();
+}
+
+
+ResetCLUTCommand::ResetCLUTCommand(TeletextDocument *teletextDocument, int colourTable, QUndoCommand *parent) : X28Command(teletextDocument, parent)
+{
+	m_colourTable = colourTable;
+	for (int i=m_colourTable*8; i<m_colourTable*8+8; i++)
+		m_oldColourEntry[i&7] = teletextDocument->currentSubPage()->CLUT(i);
+
+	setText(QObject::tr("CLUT %1 reset").arg(m_colourTable));
+}
+
+void ResetCLUTCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	for (int i=m_colourTable*8; i<m_colourTable*8+8; i++) {
+		m_teletextDocument->currentSubPage()->setCLUT(i, m_teletextDocument->currentSubPage()->CLUT(i, 0));
+		emit m_teletextDocument->colourChanged(i);
+	}
+
+	emit m_teletextDocument->contentsChanged();
+}
+
+void ResetCLUTCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	for (int i=m_colourTable*8; i<m_colourTable*8+8; i++) {
+		m_teletextDocument->currentSubPage()->setCLUT(i, m_oldColourEntry[i&7]);
+		emit m_teletextDocument->colourChanged(i);
+	}
+
+	emit m_teletextDocument->contentsChanged();
+}

src/qteletextmaker/x28commands.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2020-2024 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker 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.
+ *
+ * QTeletextMaker 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 QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef X28COMMANDS_H
+#define X28COMMANDS_H
+
+#include <QUndoCommand>
+
+#include "document.h"
+
+class X28Command : public QUndoCommand
+{
+public:
+	X28Command(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+protected:
+	TeletextDocument *m_teletextDocument;
+	int m_subPageIndex;
+};
+
+class SetFullScreenColourCommand : public X28Command
+{
+public:
+	enum { Id = 301 };
+
+	SetFullScreenColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	int m_oldColour, m_newColour;
+};
+
+class SetFullRowColourCommand : public X28Command
+{
+public:
+	enum { Id = 302 };
+
+	SetFullRowColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	int m_oldColour, m_newColour;
+};
+
+class SetCLUTRemapCommand : public X28Command
+{
+public:
+	enum { Id = 303 };
+
+	SetCLUTRemapCommand(TeletextDocument *teletextDocument, int newMap, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	int m_oldMap, m_newMap;
+};
+
+class SetBlackBackgroundSubstCommand : public X28Command
+{
+public:
+	enum { Id = 304 };
+
+	SetBlackBackgroundSubstCommand(TeletextDocument *teletextDocument, bool newSub, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	int m_oldSub, m_newSub;
+};
+
+class SetColourCommand : public X28Command
+{
+public:
+	SetColourCommand(TeletextDocument *teletextDocument, int colourIndex, int newColour, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	int m_colourIndex, m_oldColour, m_newColour;
+};
+
+class ResetCLUTCommand : public X28Command
+{
+public:
+	ResetCLUTCommand(TeletextDocument *teletextDocument, int colourTable, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	int m_colourTable;
+	int m_oldColourEntry[8];
+};
+
+#endif