Tag version 0.5.5-alpha

This should fix palettes not updating when switching in and out of
Level 3.5

README.md

@@ -5,19 +5,24 @@ Features
 - Load and save teletext pages in .tti format.
 - Rendering of teletext pages in Levels 1, 1.5, 2.5 and 3.5
 - Rendering of Local Objects and side panels.
+- Import and export of single pages in .t42 format.
+- Export PNG images of teletext pages.
+- Undo and redo of editing actions.
 - Interactive X/26 Local Enhancement Data triplet editor.
 - Editing of X/27/4 and X/27/5 compositional links to enhancement data pages.
 - Palette editor.
 - Configurable zoom.
 - View teletext pages in 4:3, 16:9 pillar-box and 16:9 stretch aspect ratios.
 
-Although designed on and developed for Linux, the Qt 5 libraries are cross platform so a Windows executable can be built. A Windows executable can be found within the "Releases" link, compiled on a Linux host using [MXE](https://github.com/mxe/mxe) based on [these instructions](https://blog.8bitbuddhism.com/2018/08/22/cross-compiling-windows-applications-with-mxe/). After MXE is installed `make qtbase` will be enough to build QTeletextMaker.
+Although designed on and developed for Linux, the Qt 5 libraries are cross platform so a Windows executable can be built. A Windows executable can be found within the "Releases" link, compiled on a Linux host using [MXE](https://github.com/mxe/mxe) based on [these instructions](https://blog.8bitbuddhism.com/2018/08/22/cross-compiling-windows-applications-with-mxe/). After MXE is installed `make qtbase` should build and install the required dependencies to build QTeletextMaker.
 
 ## Building
 ### Linux
-Install the QtCore, QtGui and QtWidgets libraries and build headers, along with the qmake tool. Then type `qmake && make -j3` in a terminal, you can replace -j3 with the number of processor cores used for the compile process.
+Install the QtCore, QtGui and QtWidgets libraries and build headers, along with the qmake tool. Depending on how qmake is installed, type `qmake && make -j3` or `qmake5 && make -j3` in a terminal to build, you can replace -j3 with the number of processor cores used for the compile process.
 
-The above will place the qteletextmaker executable in the same directory as the source, type `./qteletextmaker` in the terminal to launch. Optionally, type `make install` afterwards to place the executable into /usr/local/bin.
+The above should place the qteletextmaker executable in the same directory as the source, type `./qteletextmaker` in the terminal to launch. Some Qt installs may place the executable into a "release" directory.
+
+Optionally, type `make install` afterwards to place the executable into /usr/local/bin.
 
 ## Current limitations
 The following X/26 enhancement triplets are not rendered by the editor, although the list is fully aware of them.
@@ -28,7 +33,7 @@ The following X/26 enhancement triplets are not rendered by the editor, although
 - Level 3.5 font style: bold, italic and proportional spacing.
 
 ## Using the X/26 triplet editor
-The X/26 triplet editor sorts all the triplet modes available into categories selected by the triplet *type* dropdown on the left. The categories are:
+The X/26 triplet editor sorts all the triplet modes available into categories, which are:
 - Set Active Position
 - Row triplet - full screen and full row colours, address row 0 and DRCS mode
 - Column triplet - non-spacing attributes and overwriting characters
@@ -36,9 +41,9 @@ The X/26 triplet editor sorts all the triplet modes available into categories se
 - Terminator
 - PDC/reserved
 
-Selecting "Set Active Position" or "Terminator" will change the triplet mode immediately, other selections will activate the triplet *mode* dropdown on the right which can be used to then change the triplet mode. Most triplet modes will present varying widgets below which can be used to alter the parameters of the currently selected triplet (e.g. colour or character).
+After selecting the triplet mode the Row and Column spinboxes can then be used to place the Active Position of the selected triplet, whether or not each spinbox can be altered depends on the mode of the selected triplet. As well as the explicit "Set Active Position" triplet that can set both the row and the column, all column triplets can simultaneously set the column of the Active Position. Additionally the Full Row Colour triplet can set the row of the Active Position, with the column always set to 0.
 
-Between the two dropdowns are the Row and Column spinboxes that are used to place the Active Position of the selected triplet, whether or not each spinbox can be altered depends on the mode of the selected triplet. As well as the explicit "Set Active Position" triplet that can set both the row and the column, all column triplets can simultaneously set the column of the Active Position. Additionally the Full Row Colour triplet can set the row of the Active Position, with the column always set to 0.
+Most triplet modes will present varying widgets below which can be used to alter the parameters of the currently selected triplet e.g. colour or character.
 
 By checking "raw values" it is also possible to view and edit the raw Address, Mode and Data numbers of the triplets. When editing triplets this way, remember that address values 0-39 select a column triplet which has one set of modes and address values 40-63 select a row triplet which has a different set of modes.
 
@@ -49,11 +54,7 @@ The Active Position, whether set explicitly by a "Set Active Position" triplet o
 - The Active Position can never be moved up to a lesser numbered row.
 - The Active Position can never be moved left *within the same row* to a lesser numbered column, but it can be moved left at the same time as it is moved down to a greater numbered row.
 
-If this rule is not followed then triplets in earlier screen addresses will be ignored.
+If this rule is not followed then triplets in earlier screen addresses will be ignored. Triplets that break this rule will be highlighted red in the X/26 triplet editor.
 
 ### Objects
-"Define ... Object" triplets need to declare that they are in the correct place in the triplet list e.g. if the Define Object triplet is at `d1 t3` in the list then the data field must show `Local: d1 t3`, otherwise the Object won't appear.
-
-Insert and deleting triplets from the list will upset the Object pointers on both "Define" and "Invoke" triplets and will need to be corrected afterwards. A future version of the editor may adjust these pointers automatically.
-
 "Invoke ... Object" triplets must point to a "Define ... Object" of the same type e.g. "Invoke *Active* Object" must point to a "Define *Active* Object", otherwise the Object won't appear.

decode.cpp

@@ -0,0 +1,998 @@
+/*
+ * Copyright (C) 2020-2022 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 <QMultiMap>
+//#include <QTime>
+#include <QPair>
+#include <algorithm>
+#include <vector>
+
+#include "decode.h"
+
+TeletextPageDecode::TeletextPageDecode()
+{
+	m_level = 0;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<72; c++)
+			m_refresh[r][c] = true;
+
+	m_finalFullScreenColour = 0;
+	m_finalFullScreenQColor.setRgb(0, 0, 0);
+	for (int r=0; r<25; r++) {
+		m_fullRowColour[r] = 0;
+		m_fullRowQColor[r].setRgb(0, 0, 0);
+	}
+	m_leftSidePanelColumns = m_rightSidePanelColumns = 0;
+	m_textLayer.push_back(&m_level1Layer);
+	m_textLayer.push_back(new EnhanceLayer);
+}
+
+TeletextPageDecode::~TeletextPageDecode()
+{
+	while (m_textLayer.size()>1) {
+		delete m_textLayer.back();
+		m_textLayer.pop_back();
+	}
+}
+
+void TeletextPageDecode::setRefresh(int r, int c, bool refresh)
+{
+	m_refresh[r][c] = refresh;
+}
+
+void TeletextPageDecode::setTeletextPage(LevelOnePage *newCurrentPage)
+{
+	m_levelOnePage = newCurrentPage;
+	m_level1Layer.setTeletextPage(newCurrentPage);
+	updateSidePanels();
+}
+
+void TeletextPageDecode::setLevel(int level)
+{
+	if (level == m_level)
+		return;
+
+	m_level = level;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<72; c++)
+			m_refresh[r][c] = true;
+
+	decodePage();
+}
+
+void TeletextPageDecode::updateSidePanels()
+{
+	int oldLeftSidePanelColumns = m_leftSidePanelColumns;
+	int oldRightSidePanelColumns = m_rightSidePanelColumns;
+
+	if (m_level >= (3-m_levelOnePage->sidePanelStatusL25()) && m_levelOnePage->leftSidePanelDisplayed())
+		m_leftSidePanelColumns = (m_levelOnePage->sidePanelColumns() == 0) ? 16 : m_levelOnePage->sidePanelColumns();
+	else
+		m_leftSidePanelColumns = 0;
+
+	if (m_level >= (3-m_levelOnePage->sidePanelStatusL25()) && m_levelOnePage->rightSidePanelDisplayed())
+		m_rightSidePanelColumns = 16-m_levelOnePage->sidePanelColumns();
+	else
+		m_rightSidePanelColumns = 0;
+
+	if (m_leftSidePanelColumns != oldLeftSidePanelColumns || m_rightSidePanelColumns != oldRightSidePanelColumns) {
+		emit sidePanelsChanged();
+		decodePage();
+	}
+}
+
+void TeletextPageDecode::buildEnhanceMap(TextLayer *enhanceLayer, int tripletNumber)
+{
+	bool terminatorFound=false;
+	ActivePosition activePosition;
+	const X26Triplet *x26Triplet;
+	int originModifierR=0;
+	int originModifierC=0;
+
+	do {
+		x26Triplet = &m_levelOnePage->enhancements()->at(tripletNumber);
+		if (x26Triplet->isRowTriplet())
+			// Row address group
+			switch (x26Triplet->mode()) {
+				case 0x00: // Full screen colour
+					if (m_level >= 2 && ((x26Triplet->data() & 0x60) == 0x00) && !activePosition.isDeployed())
+						enhanceLayer->setFullScreenColour(x26Triplet->data());
+					break;
+				case 0x01: // Full row colour
+					if (m_level >= 2 && activePosition.setRow(x26Triplet->addressRow()) && ((x26Triplet->data() & 0x60) == 0x00 || (x26Triplet->data() & 0x60) == 0x60))
+						enhanceLayer->setFullRowColour(activePosition.row(), x26Triplet->data() & 0x1f, (x26Triplet->data() & 0x60) == 0x60);
+					break;
+				case 0x04: // Set active position
+					if (activePosition.setRow(x26Triplet->addressRow()) && m_level >= 2 && x26Triplet->data() < 40)
+						activePosition.setColumn(x26Triplet->data());
+					break;
+				case 0x07: // Address row 0
+					if (x26Triplet->address() == 0x3f && !activePosition.isDeployed()) {
+						activePosition.setRow(0);
+						activePosition.setColumn(8);
+						if (m_level >= 2 && ((x26Triplet->data() & 0x60) == 0x00 || (x26Triplet->data() & 0x60) == 0x60))
+							enhanceLayer->setFullRowColour(0, x26Triplet->data() & 0x1f, (x26Triplet->data() & 0x60) == 0x60);
+					}
+					break;
+				case 0x10: // Origin modifier
+					if (m_level >= 2 && (tripletNumber+1) < m_levelOnePage->enhancements()->size() && m_levelOnePage->enhancements()->at(tripletNumber+1).mode() >= 0x11 && m_levelOnePage->enhancements()->at(tripletNumber+1).mode() <= 0x13 && x26Triplet->address() >= 40 && x26Triplet->data() < 72) {
+						originModifierR = x26Triplet->address()-40;
+						originModifierC = x26Triplet->data();
+					}
+					break;
+				case 0x11 ... 0x13: // Invoke Object
+					if (m_level >= 2) {
+						if ((x26Triplet->address() & 0x18) == 0x08) {
+							// Local Object
+							// Check if the pointer in the Invocation triplet is valid
+							// Can't point to triplets 13-15; only triplets 0-12 per packet
+							if ((x26Triplet->data() & 0x0f) > 12)
+								break;
+							int tripletPointer = ((x26Triplet->data() >> 4) | ((x26Triplet->address() & 1) << 3)) * 13 + (x26Triplet->data() & 0x0f);
+							// Can't point to triplet beyond the end of the Local Enhancement Data
+							if ((tripletPointer+1) >= m_levelOnePage->enhancements()->size())
+								break;
+							// Check if we're pointing to an actual Object Definition of the same type
+							if ((x26Triplet->mode() | 0x04) != m_levelOnePage->enhancements()->at(tripletPointer).mode())
+								break;
+							// The Object Definition can't declare it's at triplet 13-15; only triplets 0-12 per packet
+							if ((m_levelOnePage->enhancements()->at(tripletPointer).data() & 0x0f) > 12)
+								break;
+							// Check if the Object Definition triplet is where it declares it is
+							if ((((m_levelOnePage->enhancements()->at(tripletPointer).data() >> 4) | ((m_levelOnePage->enhancements()->at(tripletPointer).address() & 1) << 3)) * 13 + (m_levelOnePage->enhancements()->at(tripletPointer).data() & 0x0f)) != tripletPointer)
+								break;
+							// Check if (sub)Object type can be invoked by Object type we're within
+							if (enhanceLayer->objectType() >= (x26Triplet->mode() & 0x03))
+								break;
+							// Is the object required at the current presentation Level?
+							if (m_level == 2 && (m_levelOnePage->enhancements()->at(tripletPointer).address() & 0x08) == 0x00)
+								break;
+							if (m_level == 3 && (m_levelOnePage->enhancements()->at(tripletPointer).address() & 0x10) == 0x00)
+								break;
+							EnhanceLayer *newLayer = new EnhanceLayer;
+							m_textLayer.push_back(newLayer);
+							newLayer->setObjectType(x26Triplet->mode() & 0x03);
+							newLayer->setOrigin(enhanceLayer->originR() + activePosition.row() + originModifierR, enhanceLayer->originC() + activePosition.column() + originModifierC);
+							buildEnhanceMap(newLayer, tripletPointer+1);
+						} else
+							qDebug("POP or GPOP");
+						originModifierR = originModifierC = 0;
+					}
+					break;
+				case 0x15 ... 0x17: // Define Object, also used as terminator
+					terminatorFound = true;
+					break;
+				case 0x1f: // Terminator
+					if (x26Triplet->address() == 63)
+						terminatorFound = true;
+					break;
+			}
+		else {
+			// Column address group
+			bool columnTripletActioned = true;
+			switch (x26Triplet->mode()) {
+				// First we deal with column triplets that are also valid at Level 1.5
+				case 0x0b: // G3 mosaic character at Level 2.5
+					if (m_level <= 1)
+						break;
+					// fall-through
+				case 0x02: // G3 mosaic character at Level 1.5
+				case 0x0f: // G2 character
+				case 0x10 ... 0x1f: // Diacritical mark
+					if (activePosition.setColumn(x26Triplet->addressColumn()) && x26Triplet->data() >= 0x20)
+						enhanceLayer->enhanceMap.insert(qMakePair(activePosition.row(), activePosition.column()), qMakePair(x26Triplet->mode() | 0x20, x26Triplet->data()));
+					break;
+				// Make sure that PDC and reserved triplets don't affect the Active Position
+				case 0x04 ... 0x06: // 0x04 and 0x05 are reserved, 0x06 for PDC
+				case 0x0a: // Reserved
+					break;
+				default:
+					columnTripletActioned = false;
+			}
+			// All remaining possible column triplets at Level 2.5 affect the Active Position
+			if (m_level >= 2 && !columnTripletActioned && activePosition.setColumn(x26Triplet->addressColumn()))
+				enhanceLayer->enhanceMap.insert(qMakePair(activePosition.row(), activePosition.column()), qMakePair(x26Triplet->mode() | 0x20, x26Triplet->data()));
+		}
+		tripletNumber++;
+	} while (!terminatorFound && tripletNumber < m_levelOnePage->enhancements()->size());
+}
+
+void TeletextPageDecode::decodePage()
+{
+	int currentFullRowColour, downwardsFullRowColour;
+	int renderedFullScreenColour;
+	struct {
+		bool operator() (TextLayer *i, TextLayer *j) { return (i->objectType() < j->objectType()); }
+	} compareLayer;
+
+//	QTime renderPageTime;
+
+//	renderPageTime.start();
+
+	updateSidePanels();
+
+	while (m_textLayer.size()>2) {
+		delete m_textLayer.back();
+		m_textLayer.pop_back();
+	}
+
+	renderedFullScreenColour = (m_level >= 2) ? m_levelOnePage->defaultScreenColour() : 0;
+	downwardsFullRowColour = (m_level >= 2) ? m_levelOnePage->defaultRowColour() : 0;
+	setFullScreenColour(renderedFullScreenColour);
+	for (int r=0; r<25; r++)
+		setFullRowColour(r, downwardsFullRowColour);
+
+	m_textLayer[1]->enhanceMap.clear();
+
+	if (m_level > 0 && !m_levelOnePage->enhancements()->isEmpty()) {
+		m_textLayer[1]->setFullScreenColour(-1);
+		for (int r=0; r<25; r++)
+			m_textLayer[1]->setFullRowColour(r, -1, false);
+		buildEnhanceMap(m_textLayer[1]);
+
+		if (m_textLayer.size() > 2)
+			std::stable_sort(m_textLayer.begin()+2, m_textLayer.end(), compareLayer);
+
+		if (m_level >= 2) {
+			if (m_textLayer[1]->fullScreenColour() != -1)
+				downwardsFullRowColour = m_textLayer[1]->fullScreenColour();
+			for (int r=0; r<25; r++) {
+				for (int l=0; l<2; l++) {
+					if (r == 0 && m_textLayer[l]->fullScreenColour() != - 1)
+						renderedFullScreenColour = m_textLayer[l]->fullScreenColour();
+					if (m_textLayer[l]->fullRowColour(r) == - 1)
+						currentFullRowColour = downwardsFullRowColour;
+					else {
+						currentFullRowColour = m_textLayer[l]->fullRowColour(r);
+						if (m_textLayer[l]->fullRowDownwards(r))
+							downwardsFullRowColour = currentFullRowColour;
+					}
+				}
+				setFullRowColour(r ,currentFullRowColour);
+			}
+			setFullScreenColour(renderedFullScreenColour);
+		}
+	}
+
+	for (int r=0; r<25; r++)
+		decodeRow(r);
+//	qDebug("Full page render: %d ms", renderPageTime.elapsed());
+}
+
+void TeletextPageDecode::decodeRow(int r)
+{
+	int c;
+	int phaseNumberRender = 0;
+	bool decodeNextRow = false;
+	bool applyRightHalf = false;
+	bool previouslyDoubleHeight, previouslyBottomHalf, underlined;
+	bool doubleHeightFound = false;
+	textCharacter resultCharacter, layerCharacter;
+	applyAttributes layerApplyAttributes;
+	textAttributes underlyingAttributes, resultAttributes;
+	int level1CharSet;
+
+	for (c=0; c<72; c++) {
+		textCell oldTextCell = m_cell[r][c];
+
+		resultAttributes = underlyingAttributes;
+		for (int l=0; l<m_textLayer.size(); l++) {
+			layerCharacter = m_textLayer[l]->character(r, c);
+			if (layerCharacter.code != 0x00)
+				resultCharacter = layerCharacter;
+			if (l == 0) {
+//				m_cell[r][c].level1Mosaic = (resultCharacter.set == 24 || resultCharacter.set == 25) && m_levelOnePage->character(r, c) >= 0x20;
+				m_cell[r][c].level1Mosaic = (resultCharacter.set == 24 || resultCharacter.set == 25);
+				if (!m_cell[r][c].level1Mosaic)
+					level1CharSet = resultCharacter.set;
+				m_cell[r][c].level1CharSet = level1CharSet;
+			}
+
+			layerApplyAttributes = { false, false, false, false, false, false, false, false };
+			m_textLayer[l]->attributes(r, c, &layerApplyAttributes);
+			if (layerApplyAttributes.copyAboveAttributes) {
+				resultAttributes = m_cell[r-1][c].attribute;
+				layerApplyAttributes.copyAboveAttributes = false;
+				break;
+			}
+			if (layerApplyAttributes.applyForeColour) {
+				resultAttributes.foreColour = layerApplyAttributes.attribute.foreColour;
+				if (l == 0 && m_level >= 2)
+					resultAttributes.foreColour |= m_foregroundRemap[m_levelOnePage->colourTableRemap()];
+			}
+			if (layerApplyAttributes.applyBackColour) {
+				resultAttributes.backColour = layerApplyAttributes.attribute.backColour;
+				if (l == 0) {
+					if (m_level >= 2)
+						if (resultAttributes.backColour == 0x20)
+							resultAttributes.backColour = (c > 39 || m_levelOnePage->blackBackgroundSubst()) ? m_fullRowColour[r] : m_backgroundRemap[m_levelOnePage->colourTableRemap()];
+						else
+							resultAttributes.backColour |= m_backgroundRemap[m_levelOnePage->colourTableRemap()];
+					else
+						if (resultAttributes.backColour == 0x20)
+							resultAttributes.backColour = 0x00;
+				}
+			}
+
+			if (layerApplyAttributes.applyFlash) {
+				//BUG Adaptive Objects disrupt inc/dec flash
+				resultAttributes.flash = layerApplyAttributes.attribute.flash;
+				if (resultAttributes.flash.mode != 0)
+					phaseNumberRender = (resultAttributes.flash.ratePhase == 4 || resultAttributes.flash.ratePhase == 5) ? 1 : resultAttributes.flash.ratePhase;
+			}
+			if (layerApplyAttributes.applyDisplayAttributes)
+				resultAttributes.display = layerApplyAttributes.attribute.display;
+			else {
+				// Selecting contiguous mosaics wih a triplet will override an earlier Level 1 separated mosaics attribute until a further Level 1 contiguous mosaic attribute is encountered
+				resultAttributes.display.forceContiguous = (layerApplyAttributes.applyContiguousOnly) ? false : underlyingAttributes.display.forceContiguous;
+				if (layerApplyAttributes.applyTextSizeOnly) {
+					resultAttributes.display.doubleHeight = layerApplyAttributes.attribute.display.doubleHeight;
+					resultAttributes.display.doubleWidth = layerApplyAttributes.attribute.display.doubleWidth;
+				}
+				if (layerApplyAttributes.applyBoxingOnly)
+					resultAttributes.display.boxingWindow = layerApplyAttributes.attribute.display.boxingWindow;
+				if (layerApplyAttributes.applyConcealOnly || layerApplyAttributes.applyForeColour)
+					resultAttributes.display.conceal = layerApplyAttributes.attribute.display.conceal;
+			}
+			if (m_textLayer[l]->objectType() <= 1)
+				underlyingAttributes = resultAttributes;
+
+			if (m_level == 0)
+				break;
+		}
+
+		underlined = false;
+		if (resultAttributes.display.underlineSeparated) {
+			if (resultCharacter.set == 24)
+				resultCharacter.set = 25;
+			else
+				underlined = resultCharacter.set < 24;
+		}
+		if (resultAttributes.display.forceContiguous && resultCharacter.set == 25)
+			resultCharacter.set = 24;
+
+		resultAttributes.flash.phaseNumber = phaseNumberRender;
+
+		previouslyDoubleHeight = m_cell[r][c].attribute.display.doubleHeight;
+		previouslyBottomHalf = m_cell[r][c].bottomHalf;
+
+		m_cell[r][c].character = resultCharacter;
+		m_cell[r][c].attribute = resultAttributes;
+
+		if (m_cell[r][c] != oldTextCell) {
+			m_refresh[r][c] = true;
+
+			if (static_cast<Level1Layer *>(m_textLayer[0])->rowHeight(r) == Level1Layer::TopHalf) {
+				m_refresh[r+1][c] = true;
+				decodeNextRow = true;
+			}
+
+			if ((m_cell[r][c].attribute.display.doubleHeight || oldTextCell.attribute.display.doubleHeight) && r < 25)
+				m_refresh[r+1][c] = true;
+			if ((m_cell[r][c].attribute.display.doubleWidth || oldTextCell.attribute.display.doubleWidth) && c < 72)
+				m_refresh[r][c+1] = true;
+			if (((m_cell[r][c].attribute.display.doubleHeight && m_cell[r][c].attribute.display.doubleWidth) || (oldTextCell.attribute.display.doubleHeight && oldTextCell.attribute.display.doubleWidth)) && r < 25 && c < 72)
+				m_refresh[r+1][c+1] = true;
+		}
+
+		if (resultAttributes.flash.ratePhase == 4 && ++phaseNumberRender == 4)
+			phaseNumberRender = 1;
+		if (resultAttributes.flash.ratePhase == 5 && --phaseNumberRender == 0)
+			phaseNumberRender = 3;
+
+		if (r > 0)
+			m_cell[r][c].bottomHalf = m_cell[r-1][c].attribute.display.doubleHeight && !m_cell[r-1][c].bottomHalf;
+		if ((resultAttributes.display.doubleHeight != previouslyDoubleHeight) || (m_cell[r][c].bottomHalf != previouslyBottomHalf))
+			decodeNextRow = true;
+		m_cell[r][c].rightHalf = applyRightHalf;
+
+		if (resultAttributes.display.doubleHeight)
+			doubleHeightFound = true;
+		if (resultAttributes.display.doubleWidth || (m_cell[r][c].bottomHalf && c > 0 && m_cell[r-1][c-1].rightHalf))
+			applyRightHalf ^= true;
+		else
+			applyRightHalf = false;
+	}
+
+	if (decodeNextRow && r<24)
+		decodeRow(r+1);
+}
+
+textCell& TeletextPageDecode::cellAtCharacterOrigin(int r, int c)
+{
+/*	if (m_cell[r][c].bottomHalf && r > 0) {
+		if (m_cell[r][c].rightHalf && c > 0)
+			// Double size
+			return m_cell[r-1][c-1];
+		else
+			// Double height
+			return m_cell[r-1][c];
+	} else {
+		if (m_cell[r][c].rightHalf && c > 0)
+			// Double width
+			return m_cell[r][c-1];
+		else
+			// Normal size
+			return m_cell[r][c];
+	}*/
+	switch (cellCharacterFragment(r, c)) {
+		case TeletextPageDecode::DoubleHeightBottomHalf:
+		case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
+			return m_cell[r-1][c];
+		case TeletextPageDecode::DoubleWidthRightHalf:
+		case TeletextPageDecode::DoubleSizeTopRightQuarter:
+			return m_cell[r][c-1];
+		case TeletextPageDecode::DoubleSizeBottomRightQuarter:
+			return m_cell[r-1][c-1];
+		default:
+			return m_cell[r][c];
+	}
+}
+
+QColor TeletextPageDecode::cellQColor(int r, int c, ColourPart colourPart)
+{
+	const textCell& cell = cellAtCharacterOrigin(r, c);
+	const bool newsFlashOrSubtitle = m_levelOnePage->controlBit(PageBase::C5Newsflash) || m_levelOnePage->controlBit(PageBase::C6Subtitle);
+	int resultCLUT;
+
+	switch (colourPart) {
+		case Foreground:
+			if (!cell.attribute.display.invert)
+				resultCLUT = cell.attribute.foreColour;
+			else
+				resultCLUT = cell.attribute.backColour;
+			break;
+		case Background:
+			if (!cell.attribute.display.invert)
+				resultCLUT = cell.attribute.backColour;
+			else
+				resultCLUT = cell.attribute.foreColour;
+			break;
+		case FlashForeground:
+			if (!cell.attribute.display.invert)
+				resultCLUT = cell.attribute.foreColour ^ 8;
+			else
+				resultCLUT = cell.attribute.backColour ^ 8;
+			break;
+	}
+
+	if (resultCLUT == 8) {
+		// Transparent CLUT - either Full Row Colour or Video
+		// Logic of table C.1 in spec implemented to find out which it is
+		if (cell.attribute.display.boxingWindow != newsFlashOrSubtitle)
+			return QColor(Qt::transparent);
+
+		int rowColour;
+
+		if (cellCharacterFragment(r, c) == TeletextPageDecode::DoubleHeightBottomHalf ||
+		    cellCharacterFragment(r, c) == TeletextPageDecode::DoubleSizeBottomLeftQuarter ||
+		    cellCharacterFragment(r, c) == TeletextPageDecode::DoubleSizeBottomRightQuarter)
+			rowColour = m_fullRowColour[r-1];
+		else
+			rowColour = m_fullRowColour[r];
+
+		if (rowColour == 8)
+			return QColor(Qt::transparent);
+		else
+			return m_levelOnePage->CLUTtoQColor(rowColour, m_level);
+	} else if (!cell.attribute.display.boxingWindow && newsFlashOrSubtitle)
+		return QColor(Qt::transparent);
+
+	return m_levelOnePage->CLUTtoQColor(resultCLUT, m_level);
+}
+
+QColor TeletextPageDecode::cellForegroundQColor(int r, int c)
+{
+	return cellQColor(r, c, Foreground);
+}
+
+QColor TeletextPageDecode::cellBackgroundQColor(int r, int c)
+{
+	return cellQColor(r, c, Background);
+}
+
+QColor TeletextPageDecode::cellFlashForegroundQColor(int r, int c)
+{
+	return cellQColor(r, c, FlashForeground);
+}
+
+TeletextPageDecode::CharacterFragment TeletextPageDecode::cellCharacterFragment(int r, int c) const
+{
+	if (m_cell[r][c].bottomHalf && r > 0) {
+		if (m_cell[r][c].rightHalf && c > 0)
+			return CharacterFragment::DoubleSizeBottomRightQuarter;
+		else if (m_cell[r-1][c].attribute.display.doubleWidth)
+			return CharacterFragment::DoubleSizeBottomLeftQuarter;
+		else
+			return CharacterFragment::DoubleHeightBottomHalf;
+	} else if (m_cell[r][c].rightHalf && c > 0) {
+		if (m_cell[r][c-1].attribute.display.doubleHeight)
+			return CharacterFragment::DoubleSizeTopRightQuarter;
+		else
+			return CharacterFragment::DoubleWidthRightHalf;
+	}
+
+	if (m_cell[r][c].attribute.display.doubleHeight) {
+		if (m_cell[r][c].attribute.display.doubleWidth)
+			return CharacterFragment::DoubleSizeTopLeftQuarter;
+		else
+			return CharacterFragment::DoubleHeightTopHalf;
+	} else if (m_cell[r][c].attribute.display.doubleWidth)
+		return CharacterFragment::DoubleWidthLeftHalf;
+
+	return CharacterFragment::NormalSize;
+}
+
+inline void TeletextPageDecode::setFullScreenColour(int newColour)
+{
+	if (newColour == 8 || m_levelOnePage->controlBit(PageBase::C5Newsflash) || m_levelOnePage->controlBit(PageBase::C6Subtitle)) {
+		m_finalFullScreenQColor = QColor(0, 0, 0, 0);
+		emit fullScreenColourChanged(QColor(0, 0, 0, 0));
+		return;
+	}
+	QColor newFullScreenQColor = m_levelOnePage->CLUTtoQColor(newColour, m_level);
+	m_finalFullScreenColour = newColour;
+	if (m_finalFullScreenQColor != newFullScreenQColor) {
+		m_finalFullScreenQColor = newFullScreenQColor;
+		emit fullScreenColourChanged(m_finalFullScreenQColor);
+	}
+}
+
+inline void TeletextPageDecode::setFullRowColour(int row, int newColour)
+{
+	m_fullRowColour[row] = newColour;
+
+	if (newColour == 8 || m_levelOnePage->controlBit(PageBase::C5Newsflash) || m_levelOnePage->controlBit(PageBase::C6Subtitle)) {
+		m_fullRowQColor[row] = QColor(0, 0, 0, 0);
+		emit fullRowColourChanged(row, QColor(0, 0, 0, 0));
+		return;
+	}
+	QColor newFullRowQColor = m_levelOnePage->CLUTtoQColor(newColour, m_level);
+	if (m_fullRowQColor[row] != newFullRowQColor) {
+		for (int c=0; c<72; c++) {
+			if (m_cell[row][c].attribute.foreColour == 8 || m_cell[row][c].attribute.backColour == 8)
+				setRefresh(row, c, true);
+		}
+		m_fullRowQColor[row] = newFullRowQColor;
+		emit fullRowColourChanged(row, m_fullRowQColor[row]);
+	}
+}
+
+void TextLayer::setTeletextPage(LevelOnePage *newCurrentPage) { m_levelOnePage = newCurrentPage; }
+void TextLayer::setFullScreenColour(int newColour) { m_layerFullScreenColour = newColour; }
+
+void TextLayer::setFullRowColour(int r, int newColour, bool newDownwards)
+{
+	m_layerFullRowColour[r] = newColour;
+	m_layerFullRowDownwards[r] = newDownwards;
+}
+
+void EnhanceLayer::setObjectType(int newObjectType) { m_objectType = newObjectType; }
+
+void EnhanceLayer::setOrigin(int r, int c)
+{
+	m_originR = r;
+	m_originC = c;
+}
+
+Level1Layer::Level1Layer()
+{
+	for (int r=0; r<25; r++) {
+		m_rowHasDoubleHeightAttr[r] = false;
+		m_rowHeight[r] = Normal;
+	}
+}
+
+EnhanceLayer::EnhanceLayer()
+{
+	for (int r=0; r<25; r++) {
+		m_layerFullRowColour[r] = -1;
+		m_layerFullRowDownwards[r] = false;
+	}
+}
+
+textCharacter EnhanceLayer::character(int r, int c)
+{
+	r -= m_originR;
+	c -= m_originC;
+	if (r < 0 || c < 0)
+		return { 0, 0 };
+
+	// QPair.first is triplet mode, QPair.second is triplet data
+	QList<QPair<int, int>> enhancements = enhanceMap.values(qMakePair(r, c));
+
+	if (enhancements.size() > 0)
+		for (int i=0; i<enhancements.size(); i++)
+			switch (enhancements.at(i).first) {
+				case 0x2b: // G3 mosaic character at Level 2.5
+				case 0x22: // G3 mosaic character at Level 1.5
+					return { enhancements.at(i).second, 26 };
+				case 0x29: // G0 character at Level 2.5
+					return { enhancements.at(i).second, 0 };
+				case 0x2f: // G2 character
+					return { enhancements.at(i).second, 7 };
+				case 0x30 ... 0x3f: // Diacritical
+					// Deal with @ symbol replacing * symbol - clause 15.6.1 note 3 in spec
+					if (enhancements.at(i).first == 0x30 && enhancements.at(i).second == 0x2a)
+						return { 0x40, 0 };
+					else
+						return { enhancements.at(i).second, 0, enhancements.at(i).first & 0x0f };
+				case 0x21: // G1 character
+					if ((enhancements.at(i).second) >= 0x20)
+						return { enhancements.at(i).second, (enhancements.at(i).second & 0x20) ? 24 : 0 };
+			}
+	return { 0, 0 };
+}
+
+void EnhanceLayer::attributes(int r, int c, applyAttributes *layerApplyAttributes)
+{
+	r -= m_originR;
+	c -= m_originC;
+	if (r < 0 || c < 0)
+		return;
+	if (m_objectType == 2) {
+		// Adaptive Object - find rightmost column addressed on this row if we haven't already
+		if (r != m_rowCached) {
+			m_rightMostColumn[r] = 0;
+			m_rowCached = r;
+			for (int cc=39; cc>0; cc--)
+				if (enhanceMap.contains(qMakePair(r, cc))) {
+					m_rightMostColumn[r] = cc;
+					break;
+				}
+		}
+		// On new row, default to attributes already on page
+		// At end of rightmost column, let go of all attributes
+		if (c == 0 || c == m_rightMostColumn[r]+1)
+			m_applyAttributes = { false, false, false, false, false, false, false, false };
+		else {
+			// Re-apply attributes that Object has defined previously on this row
+			if (m_applyAttributes.applyForeColour) {
+				layerApplyAttributes->applyForeColour = true;
+				layerApplyAttributes->attribute.foreColour = m_applyAttributes.attribute.foreColour;
+			}
+			if (m_applyAttributes.applyBackColour) {
+				layerApplyAttributes->applyBackColour = true;
+				layerApplyAttributes->attribute.backColour = m_applyAttributes.attribute.backColour;
+			}
+			//BUG Adaptive Objects disrupt inc/dec flash
+			if (m_applyAttributes.applyFlash) {
+				layerApplyAttributes->applyFlash = true;
+				layerApplyAttributes->attribute.flash.mode = m_applyAttributes.attribute.flash.mode;
+				layerApplyAttributes->attribute.flash.ratePhase = m_applyAttributes.attribute.flash.ratePhase;
+			}
+			if (m_applyAttributes.applyDisplayAttributes) {
+				layerApplyAttributes->applyDisplayAttributes = true;
+				layerApplyAttributes->attribute.display = m_applyAttributes.attribute.display;
+			}
+		}
+	}
+	if (m_objectType == 3) {
+		if (r == 0 && c == 0) {
+			// Passive Objects always start with all these default attributes
+			m_applyAttributes.applyForeColour = true;
+			m_applyAttributes.attribute.foreColour = 0x07;
+			m_applyAttributes.applyBackColour = true;
+			m_applyAttributes.attribute.backColour = 0x00;
+			m_applyAttributes.applyDisplayAttributes = true;
+			m_applyAttributes.applyFlash = true;
+			m_applyAttributes.attribute.flash.mode = 0;
+			m_applyAttributes.attribute.flash.ratePhase = 0;
+			m_applyAttributes.attribute.display.doubleHeight = false;
+			m_applyAttributes.attribute.display.doubleWidth = false;
+			m_applyAttributes.attribute.display.boxingWindow = false;
+			m_applyAttributes.attribute.display.conceal = false;
+			m_applyAttributes.attribute.display.invert = false;
+			m_applyAttributes.attribute.display.underlineSeparated = false;
+			m_applyAttributes.attribute.display.forceContiguous = false;
+		}
+		if (character(r+m_originR, c+m_originC).code == 0x00)
+			// Passive Object attributes only apply where it also defines a character
+			// In this case, wrench the pointer-parameter to alter only the attributes of the Object
+			layerApplyAttributes = &m_applyAttributes;
+		else
+			*layerApplyAttributes = m_applyAttributes;
+	}
+
+	// QPair.first is triplet mode, QPair.second is triplet data
+	QList<QPair<int, int>> enhancements = enhanceMap.values(qMakePair(r, c));
+
+	for (int i=0; i<enhancements.size(); i++)
+		switch (enhancements.at(i).first) {
+			case 0x20: // Foreground colour
+				if ((enhancements.at(i).second & 0x60) == 0) {
+					layerApplyAttributes->applyForeColour = true;
+					layerApplyAttributes->attribute.foreColour = enhancements.at(i).second;
+				}
+				break;
+			case 0x23: // Background colour
+				if ((enhancements.at(i).second & 0x60) == 0) {
+					layerApplyAttributes->applyBackColour = true;
+					layerApplyAttributes->attribute.backColour = enhancements.at(i).second;
+				}
+				break;
+			case 0x27: // Additional flash functions
+				if ((enhancements.at(i).second & 0x60) == 0 && (enhancements.at(i).second & 0x18) != 0x18) { // Avoid reserved rate/phase
+					layerApplyAttributes->applyFlash = true;
+					layerApplyAttributes->attribute.flash.mode = enhancements.at(i).second & 0x03;
+					layerApplyAttributes->attribute.flash.ratePhase = (enhancements.at(i).second >> 2) & 0x07;
+				}
+				break;
+			case 0x2c: // Display attributes
+				layerApplyAttributes->applyDisplayAttributes = true;
+				layerApplyAttributes->attribute.display.doubleHeight = enhancements.at(i).second & 0x01;
+				layerApplyAttributes->attribute.display.boxingWindow = enhancements.at(i).second & 0x02;
+				layerApplyAttributes->attribute.display.conceal = enhancements.at(i).second & 0x04;
+				layerApplyAttributes->attribute.display.invert = enhancements.at(i).second & 0x10;
+				layerApplyAttributes->attribute.display.underlineSeparated = enhancements.at(i).second & 0x20;
+				// Selecting contiguous mosaics wih a triplet will override an earlier Level 1 separated mosaics attribute
+				layerApplyAttributes->attribute.display.forceContiguous = !layerApplyAttributes->attribute.display.underlineSeparated;
+				layerApplyAttributes->attribute.display.doubleWidth = enhancements.at(i).second & 0x40;
+				break;
+		}
+	if (m_objectType >= 2)
+		m_applyAttributes = *layerApplyAttributes;
+}
+
+
+void Level1Layer::updateRowCache(int r)
+{
+	level1CacheAttributes buildCacheAttributes;
+	bool doubleHeightAttrFound = false;
+
+	for (int c=0; c<40; c++) {
+		unsigned char charCode = m_levelOnePage->character(r, c);
+		// Set at spacing attributes
+		switch (charCode) {
+			case 0x0c: // Normal size
+				if (buildCacheAttributes.sizeCode != 0x0c) // Size CHANGE resets held mosaic to space
+					buildCacheAttributes.holdChar = 0x20;
+				buildCacheAttributes.sizeCode = 0x0c;
+				break;
+			case 0x19: // Contiguous mosaics
+				buildCacheAttributes.separated = false;
+				break;
+			case 0x1a: // Separated mosaics
+				buildCacheAttributes.separated = true;
+				break;
+			case 0x1c: // Black background
+				buildCacheAttributes.backColour = 0x00;
+				break;
+			case 0x1d: // New background
+				buildCacheAttributes.backColour = buildCacheAttributes.foreColour & 0x07;
+				break;
+			case 0x1e: // Hold mosaics
+				buildCacheAttributes.held = true;
+				break;
+		}
+
+		if (buildCacheAttributes.mosaics && (charCode & 0x20)) {
+			buildCacheAttributes.holdChar = charCode;
+			buildCacheAttributes.holdSeparated = buildCacheAttributes.separated;
+		}
+
+		m_attributeCache[c] = buildCacheAttributes;
+
+		// Set-after spacing attributes
+		switch (charCode) {
+			case 0x00 ... 0x07: // Alphanumeric + foreground colour
+				buildCacheAttributes.foreColour = charCode;
+				buildCacheAttributes.mosaics = false;
+				buildCacheAttributes.holdChar = 0x20; // Switch from mosaics to alpha resets held mosaic
+				buildCacheAttributes.holdSeparated = false;
+				break;
+			case 0x10 ... 0x17: // Mosaic + foreground colour
+				buildCacheAttributes.foreColour = charCode & 0x07;
+				buildCacheAttributes.mosaics = true;
+				break;
+			case 0x0d: // Double height
+			case 0x0f: // Double size
+				doubleHeightAttrFound = true;
+				// fall-through
+			case 0x0e: // Double width
+				if (buildCacheAttributes.sizeCode != charCode) // Size CHANGE resets held mosaic to space
+					buildCacheAttributes.holdChar = 0x20;
+				buildCacheAttributes.sizeCode = charCode;
+				break;
+			case 0x1b: // ESC/switch
+				buildCacheAttributes.escSwitch ^= true;
+				break;
+			case 0x1f: // Release mosaics
+				buildCacheAttributes.held = false;
+				break;
+		}
+	}
+
+	if (doubleHeightAttrFound != m_rowHasDoubleHeightAttr[r]) {
+		m_rowHasDoubleHeightAttr[r] = doubleHeightAttrFound;
+		for (int dr=r; dr<24; dr++)
+			if (m_rowHasDoubleHeightAttr[dr]) {
+				m_rowHeight[dr] = TopHalf;
+				m_rowHeight[++dr] = BottomHalf;
+			} else
+				m_rowHeight[dr] = Normal;
+	}
+}
+
+textCharacter Level1Layer::character(int r, int c)
+{
+	textCharacter result;
+
+	if (r != m_rowCached)
+		updateRowCache(r);
+	if (c > 39 || m_rowHeight[r] == BottomHalf)
+		return { 0x20, 0 };
+	result.code = m_levelOnePage->character(r, c);
+	if (m_levelOnePage->secondCharSet() != 0xf && m_attributeCache[c].escSwitch)
+		result.set = g0CharacterMap.value(((m_levelOnePage->secondCharSet() << 3) | m_levelOnePage->secondNOS()), 0);
+	else
+		result.set = g0CharacterMap.value(((m_levelOnePage->defaultCharSet() << 3) | m_levelOnePage->defaultNOS()), 0);
+	if (result.code < 0x20) {
+		result.code = m_attributeCache[c].held ? m_attributeCache[c].holdChar : 0x20;
+		if (m_attributeCache[c].held && c > 0)
+			result.set = 24+m_attributeCache[c].holdSeparated;
+//		else
+//			result.set = m_attributeCache[c].mosaics*24;
+	} else if (m_attributeCache[c].mosaics && (result.code & 0x20))
+		result.set = 24+m_attributeCache[c].separated;
+	return result;
+}
+
+void Level1Layer::attributes(int r, int c, applyAttributes *layerApplyAttributes)
+{
+	unsigned char characterCode;
+
+	if (m_rowHeight[r] == BottomHalf) {
+		layerApplyAttributes->copyAboveAttributes = true;
+		return;
+	}
+	if (r != m_rowCached)
+		updateRowCache(r);
+	if (c == 0 || c == 40 || c == 56) {
+		// Start of row default conditions, also when crossing into side panels
+		layerApplyAttributes->applyForeColour = true;
+		layerApplyAttributes->attribute.foreColour = 0x07;
+		layerApplyAttributes->applyBackColour = true;
+		layerApplyAttributes->attribute.backColour = 0x20;
+		layerApplyAttributes->applyDisplayAttributes = true;
+		layerApplyAttributes->applyFlash = true;
+		layerApplyAttributes->attribute.flash.mode = 0;
+		layerApplyAttributes->attribute.flash.ratePhase = 0;
+		layerApplyAttributes->attribute.display.doubleHeight = false;
+		layerApplyAttributes->attribute.display.doubleWidth = false;
+		layerApplyAttributes->attribute.display.boxingWindow = false;
+		layerApplyAttributes->attribute.display.conceal = false;
+		layerApplyAttributes->attribute.display.invert = false;
+		layerApplyAttributes->attribute.display.underlineSeparated = false;
+		layerApplyAttributes->attribute.display.forceContiguous = false;
+		//TODO fontstyle
+	}
+	if (c > 39)
+		return;
+	if (c > 0) {
+		// Set-after
+		characterCode = m_levelOnePage->character(r, c-1);
+		switch (characterCode) {
+			case 0x00 ... 0x07: // Alphanumeric + Foreground colour
+			case 0x10 ... 0x17: // Mosaic + Foreground colour
+				layerApplyAttributes->applyForeColour = true;
+				layerApplyAttributes->attribute.foreColour = characterCode & 0x07;
+				layerApplyAttributes->attribute.display.conceal = false;
+				break;
+			case 0x08: // Flashing
+				layerApplyAttributes->applyFlash = true;
+				layerApplyAttributes->attribute.flash.mode = 1;
+				layerApplyAttributes->attribute.flash.ratePhase = 0;
+				break;
+			case 0x0a: // End box
+				if (m_levelOnePage->character(r, c) == 0x0a) {
+					layerApplyAttributes->applyBoxingOnly = true;
+					layerApplyAttributes->attribute.display.boxingWindow = false;
+				}
+				break;
+			case 0x0b: // Start box
+				if (m_levelOnePage->character(r, c) == 0x0b) {
+					layerApplyAttributes->applyBoxingOnly = true;
+					layerApplyAttributes->attribute.display.boxingWindow = true;
+				}
+				break;
+			case 0x0d: // Double height
+				layerApplyAttributes->applyTextSizeOnly = true;
+				layerApplyAttributes->attribute.display.doubleHeight = true;
+				layerApplyAttributes->attribute.display.doubleWidth = false;
+				break;
+			case 0x0e: // Double width
+				layerApplyAttributes->applyTextSizeOnly = true;
+				layerApplyAttributes->attribute.display.doubleHeight = false;
+				layerApplyAttributes->attribute.display.doubleWidth = true;
+				break;
+			case 0x0f: // Double size
+				layerApplyAttributes->applyTextSizeOnly = true;
+				layerApplyAttributes->attribute.display.doubleHeight = true;
+				layerApplyAttributes->attribute.display.doubleWidth = true;
+				break;
+		}
+	}
+	// Set-at
+	characterCode = m_levelOnePage->character(r, c);
+	switch (characterCode) {
+		case 0x09: // Steady
+			layerApplyAttributes->applyFlash = true;
+			layerApplyAttributes->attribute.flash.mode = 0;
+			layerApplyAttributes->attribute.flash.ratePhase = 0;
+			break;
+		case 0x0c: // Normal size
+			layerApplyAttributes->applyTextSizeOnly = true;
+			layerApplyAttributes->attribute.display.doubleHeight = false;
+			layerApplyAttributes->attribute.display.doubleWidth = false;
+			break;
+		case 0x18: // Conceal
+			layerApplyAttributes->applyConcealOnly = true;
+			layerApplyAttributes->attribute.display.conceal = true;
+			break;
+		case 0x19: // Contiguous mosaics
+			layerApplyAttributes->applyContiguousOnly = true;
+			break;
+		case 0x1c: // Black background
+			layerApplyAttributes->applyBackColour = true;
+			layerApplyAttributes->attribute.backColour = 0x20;
+			break;
+		case 0x1d: // New background
+			layerApplyAttributes->applyBackColour = true;
+			layerApplyAttributes->attribute.backColour = m_attributeCache[c].backColour;
+			break;
+	}
+}
+
+
+ActivePosition::ActivePosition()
+{
+	m_row = m_column = -1;
+}
+
+bool ActivePosition::setRow(int newRow)
+{
+	if (newRow < m_row)
+		return false;
+	if (newRow > m_row) {
+		m_row = newRow;
+		m_column = -1;
+	}
+	return true;
+}
+
+bool ActivePosition::setColumn(int newColumn)
+{
+	if (newColumn < m_column)
+		return false;
+	if (m_row == -1)
+		m_row = 0;
+	m_column = newColumn;
+	return true;
+}
+/*
+bool ActivePosition::setRowAndColumn(int newRow, int newColumn)
+{
+	if (!setRow(newRow))
+		return false;
+	return setColumn(newColumn);
+}
+*/

decode.h

@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2020-2022 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 <QMap>
+#include <QMultiMap>
+#include <QPair>
+#include <vector>
+
+#include "levelonepage.h"
+
+struct textCharacter {
+	unsigned char code=0x20;
+	int set=0;
+	int diacritical=0;
+};
+
+inline bool operator!=(const textCharacter &lhs, const textCharacter &rhs)
+{
+	return lhs.code        != rhs.code         ||
+	       lhs.set         != rhs.set          ||
+	       lhs.diacritical != rhs.diacritical;
+}
+
+struct displayAttributes {
+	bool doubleHeight=false;
+	bool doubleWidth=false;
+	bool boxingWindow=false;
+	bool conceal=false;
+	bool invert=false;
+	bool underlineSeparated=false;
+	bool forceContiguous=false;
+};
+
+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 ||
+	       lhs.forceContiguous    != rhs.forceContiguous;
+}
+
+struct textAttributes {
+	int foreColour=0x07;
+	int backColour=0x00;
+	struct flashFunctions {
+		int mode=0;
+		int ratePhase=0;
+		int phaseNumber=0;
+	} flash;
+	displayAttributes display;
+	/* font style */
+};
+
+inline bool operator!=(const textAttributes &lhs, const textAttributes &rhs)
+{
+	return lhs.foreColour        != rhs.foreColour        ||
+	       lhs.backColour        != rhs.backColour        ||
+	       lhs.flash.mode        != rhs.flash.mode        ||
+	       lhs.flash.ratePhase   != rhs.flash.ratePhase   ||
+	       lhs.flash.phaseNumber != rhs.flash.phaseNumber ||
+	       lhs.display           != rhs.display;
+}
+
+struct textCell {
+	textCharacter character;
+	textAttributes attribute;
+	bool bottomHalf=false;
+	bool rightHalf=false;
+	bool level1Mosaic=false;
+	int level1CharSet=0;
+};
+
+inline bool operator!=(const textCell &lhs, const textCell &rhs)
+{
+	return lhs.character     != rhs.character    ||
+	       lhs.attribute     != rhs.attribute    ||
+	       lhs.bottomHalf    != rhs.bottomHalf   ||
+	       lhs.rightHalf     != rhs.rightHalf    ||
+	       lhs.level1Mosaic  != rhs.level1Mosaic ||
+	       lhs.level1CharSet != rhs.level1CharSet;
+}
+
+struct applyAttributes {
+	bool applyForeColour=false;
+	bool applyBackColour=false;
+	bool applyFlash=false;
+	bool applyDisplayAttributes=false;
+	bool applyTextSizeOnly=false;
+	bool applyBoxingOnly=false;
+	bool applyConcealOnly=false;
+	bool applyContiguousOnly=false;
+	bool copyAboveAttributes=false;
+	textAttributes attribute;
+};
+
+class ActivePosition
+{
+public:
+	ActivePosition();
+	int row() const { return (m_row == -1) ? 0 : m_row; }
+	int column() const { return (m_column == -1) ? 0 : 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;
+};
+
+
+class TextLayer
+{
+public:
+//	TextLayer(TeletextPage* thePage) : currentPage(thePage) { };
+	virtual ~TextLayer() = default;
+	void setTeletextPage(LevelOnePage *);
+	virtual textCharacter character(int, int) =0;
+	virtual void attributes(int, int, applyAttributes *) =0;
+	virtual int fullScreenColour() const =0;
+	virtual int fullRowColour(int) const =0;
+	virtual bool fullRowDownwards(int) const =0;
+	virtual int objectType() const =0;
+	virtual int originR() const { return 0; };
+	virtual int originC() const { return 0; };
+	void setFullScreenColour(int);
+	void setFullRowColour(int, int, bool);
+
+	// Key QPair is row and column, value QPair is triplet mode and data
+	QMultiMap<QPair<int, int>, QPair<int, int>> enhanceMap;
+
+protected:
+	LevelOnePage* m_levelOnePage;
+	int m_layerFullScreenColour=-1;
+	int m_layerFullRowColour[25];
+	bool m_layerFullRowDownwards[25];
+	applyAttributes m_applyAttributes;
+};
+
+class EnhanceLayer: public TextLayer
+{
+public:
+	EnhanceLayer();
+	textCharacter character(int, int);
+	void attributes(int, int, applyAttributes *);
+	int fullScreenColour() const { return m_layerFullScreenColour; };
+	int fullRowColour(int r) const { return m_layerFullRowColour[r]; };
+	bool fullRowDownwards(int r) const { return m_layerFullRowDownwards[r]; };
+	int objectType() const { return m_objectType; };
+	int originR() const { return m_originR; };
+	int originC() const { return m_originC; };
+	void setObjectType(int);
+	void setOrigin(int, int);
+
+protected:
+	int m_objectType=0;
+	int m_originR=0;
+	int m_originC=0;
+	int m_rowCached=-1;
+	int m_rightMostColumn[25];
+};
+
+class Level1Layer: public TextLayer
+{
+public:
+	enum RowHeight { Normal=-1, TopHalf, BottomHalf };
+
+//	Level1Layer(TeletextPage *thePage) : TextLayer(thePage) { };
+	Level1Layer();
+	textCharacter character(int, int);
+	void attributes(int, int, applyAttributes *);
+	int fullScreenColour() const { return -1; };
+	int fullRowColour(int) const { return -1; };
+	bool fullRowDownwards(int) const { return false; };
+	int objectType() const { return 0; }
+	RowHeight rowHeight(int r) const { return m_rowHeight[r]; };
+
+private:
+	void updateRowCache(int);
+
+	struct level1CacheAttributes {
+		int foreColour=0x07;
+		int backColour=0x00;
+		unsigned char sizeCode=0x0c;
+		bool mosaics=false;
+		bool separated=false;
+		bool held=false;
+		bool escSwitch=false;
+		unsigned char holdChar=0x20;
+		bool holdSeparated=false;
+	};
+	level1CacheAttributes m_attributeCache[40];
+	int m_rowCached=-1;
+	bool m_rowHasDoubleHeightAttr[25];
+	RowHeight m_rowHeight[25];
+};
+
+class TeletextPageDecode : public QObject
+{
+	Q_OBJECT
+
+public:
+	enum CharacterFragment { NormalSize, DoubleHeightTopHalf, DoubleHeightBottomHalf, DoubleWidthLeftHalf, DoubleWidthRightHalf, DoubleSizeTopLeftQuarter, DoubleSizeTopRightQuarter, DoubleSizeBottomLeftQuarter, DoubleSizeBottomRightQuarter };
+
+	TeletextPageDecode();
+	~TeletextPageDecode();
+	bool refresh(int r, int c) const { return m_refresh[r][c]; }
+	void setRefresh(int, int, bool);
+	void decodePage();
+	void decodeRow(int r);
+	LevelOnePage *teletextPage() const { return m_levelOnePage; };
+	void setTeletextPage(LevelOnePage *);
+	void updateSidePanels();
+	void buildEnhanceMap(TextLayer *, int=0);
+
+	unsigned char cellCharacterCode(int r, int c) { return cellAtCharacterOrigin(r, c).character.code; };
+	int cellCharacterSet(int r, int c) { return cellAtCharacterOrigin(r, c).character.set; };
+	int cellCharacterDiacritical(int r, int c) { return cellAtCharacterOrigin(r, c).character.diacritical; };
+	int cellForegroundCLUT(int r, int c) { return cellAtCharacterOrigin(r, c).attribute.foreColour; };
+	int cellBackgroundCLUT(int r, int c) { return cellAtCharacterOrigin(r, c).attribute.backColour; };
+	QColor cellForegroundQColor(int, int);
+	QColor cellBackgroundQColor(int, int);
+	QColor cellFlashForegroundQColor(int, int);
+	int cellFlashMode(int r, int c) { return cellAtCharacterOrigin(r, c).attribute.flash.mode; };
+	int cellFlashRatePhase(int r, int c) { return cellAtCharacterOrigin(r, c).attribute.flash.ratePhase; };
+	int cellFlash2HzPhaseNumber(int r, int c) { return cellAtCharacterOrigin(r, c).attribute.flash.phaseNumber; };
+	CharacterFragment cellCharacterFragment(int, int) const;
+	bool cellBoxed(int r, int c) { return cellAtCharacterOrigin(r, c).attribute.display.boxingWindow; };
+	bool cellConceal(int r, int c) { return cellAtCharacterOrigin(r, c).attribute.display.conceal; };
+	bool cellUnderlined(int r, int c) { return cellAtCharacterOrigin(r, c).attribute.display.underlineSeparated && cellAtCharacterOrigin(r, c).character.set < 24; };
+
+	bool level1MosaicAttribute(int r, int c) const { return m_cell[r][c].level1Mosaic; };
+	int level1CharSet(int r, int c) const { return m_cell[r][c].level1CharSet; };
+
+	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);
+
+signals:
+	void fullScreenColourChanged(QColor);
+	void fullRowColourChanged(int, QColor);
+	void sidePanelsChanged();
+
+protected:
+	inline void setFullScreenColour(int);
+	inline void setFullRowColour(int, int);
+	textCell& cellAtCharacterOrigin(int, int);
+
+	int m_finalFullScreenColour, m_level;
+	QColor m_finalFullScreenQColor;
+	int m_leftSidePanelColumns, m_rightSidePanelColumns;
+	Level1Layer m_level1Layer;
+	std::vector<TextLayer *> m_textLayer;
+	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:
+	enum ColourPart { Foreground, Background, FlashForeground };
+
+	QColor cellQColor(int, int, ColourPart);
+
+	textCell m_cell[25][72];
+	bool m_refresh[25][72];
+	LevelOnePage* m_levelOnePage;
+	int m_fullRowColour[25];
+	QColor m_fullRowQColor[25];
+};
+
+static const QMap<int, int> g0CharacterMap {
+	{ 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 }
+};
+
+#endif

document.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -17,12 +17,46 @@
  * 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;
@@ -34,11 +68,17 @@ TeletextDocument::TeletextDocument()
 	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)
@@ -54,6 +94,25 @@ bool TeletextDocument::isEmpty() const
 	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)
 {
@@ -71,8 +130,12 @@ 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;
 	}
 }
@@ -81,8 +144,12 @@ 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();
 	}
 }
 
@@ -90,8 +157,12 @@ void TeletextDocument::selectSubPagePrevious()
 {
 	if (m_currentSubPageIndex > 0) {
 		emit aboutToChangeSubPage();
+
 		m_currentSubPageIndex--;
+
+		m_clutModel->setSubPage(m_subPages[m_currentSubPageIndex]);
 		emit subPageSelected();
+		emit selectionMoved();
 	}
 }
 
@@ -112,6 +183,8 @@ void TeletextDocument::insertSubPage(int beforeSubPageIndex, bool copySubPage)
 
 void TeletextDocument::deleteSubPage(int subPageToDelete)
 {
+	m_clutModel->setSubPage(nullptr);
+
 	delete(m_subPages[subPageToDelete]);
 	m_subPages.erase(m_subPages.begin()+subPageToDelete);
 }
@@ -128,17 +201,12 @@ void TeletextDocument::unDeleteSubPageFromRecycle(int subPage)
 	m_recycleSubPages.pop_back();
 }
 
-void TeletextDocument::setPageNumber(QString pageNumberString)
+void TeletextDocument::setPageNumber(int pageNumber)
 {
-	bool pageNumberOk;
-	int pageNumberRead = pageNumberString.toInt(&pageNumberOk, 16);
-	if ((!pageNumberOk) || pageNumberRead < 0x100 || pageNumberRead > 0x8ff)
-		return;
-
 	// 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 = (pageNumberRead & 0xf00);
+	int newMagazine = (pageNumber & 0xf00);
 	// Fix magazine 0 to 8
 	if (oldMagazine == 0x800)
 		oldMagazine = 0x000;
@@ -146,7 +214,7 @@ void TeletextDocument::setPageNumber(QString pageNumberString)
 		newMagazine = 0x000;
 	int magazineFlip = oldMagazine ^ newMagazine;
 
-	m_pageNumber = pageNumberRead;
+	m_pageNumber = pageNumber;
 
 	for (auto &subPage : m_subPages)
 		if (magazineFlip) {
@@ -157,6 +225,17 @@ void TeletextDocument::setPageNumber(QString pageNumberString)
 	}
 }
 
+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;
@@ -168,62 +247,124 @@ void TeletextDocument::setFastTextLinkPageNumberOnAllSubPages(int linkNumber, in
 		subPage->setFastTextLinkPageNumber(linkNumber, pageNumber);
 }
 
-void TeletextDocument::cursorUp()
+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()
+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()
+void TeletextDocument::cursorLeft(bool shiftKey)
 {
+	if (shiftKey && !selectionActive())
+		setSelectionCorner(m_cursorRow, m_cursorColumn);
+
 	if (--m_cursorColumn == -1) {
 		m_cursorColumn = 39;
-		cursorUp();
+		cursorUp(shiftKey);
 	}
+
+	if (shiftKey)
+		emit selectionMoved();
+	else
+		cancelSelection();
+
 	emit cursorMoved();
 }
 
-void TeletextDocument::cursorRight()
+void TeletextDocument::cursorRight(bool shiftKey)
 {
+	if (shiftKey && !selectionActive())
+		setSelectionCorner(m_cursorRow, m_cursorColumn);
+
 	if (++m_cursorColumn == 40) {
 		m_cursorColumn = 0;
-		cursorDown();
+		cursorDown(shiftKey);
 	}
+
+	if (shiftKey)
+		emit selectionMoved();
+	else
+		cancelSelection();
+
 	emit cursorMoved();
 }
 
-void TeletextDocument::moveCursor(int cursorRow, int cursorColumn)
+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 (m_selectionTopRow != topRow || m_selectionBottomRow != bottomRow || m_selectionLeftColumn != leftColumn || m_selectionRightColumn != rightColumn) {
+	if (selectionTopRow() != topRow || selectionBottomRow() != bottomRow || selectionLeftColumn() != leftColumn || selectionRightColumn() != rightColumn) {
 		m_selectionSubPage = currentSubPage();
-		m_selectionTopRow = topRow;
-		m_selectionBottomRow = bottomRow;
-		m_selectionLeftColumn = leftColumn;
-		m_selectionRightColumn = rightColumn;
+		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

document.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -20,11 +20,28 @@
 #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
@@ -39,6 +56,7 @@ public:
 	~TeletextDocument();
 
 	bool isEmpty() const;
+	void clear();
 
 	PageFunctionEnum pageFunction() const { return m_pageFunction; }
 //	void setPageFunction(PageFunctionEnum);
@@ -57,25 +75,30 @@ public:
 	void deleteSubPageToRecycle(int);
 	void unDeleteSubPageFromRecycle(int);
 	int pageNumber() const { return m_pageNumber; }
-	void setPageNumber(QString);
+	void setPageNumber(int);
+	void setPageNumberFromString(QString);
 	QString description() const { return m_description; }
 	void setDescription(QString);
 	void setFastTextLinkPageNumberOnAllSubPages(int, int);
 	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();
-	void cursorDown();
-	void cursorLeft();
-	void cursorRight();
-	void moveCursor(int, int);
-	int selectionTopRow() const { return m_selectionTopRow; }
-	int selectionBottomRow() const { return m_selectionBottomRow; }
-	int selectionLeftColumn() const { return m_selectionLeftColumn; }
-	int selectionRightColumn() const { return m_selectionRightColumn; }
-	int selectionWidth() const { return m_selectionRightColumn - m_selectionLeftColumn + 1; }
-	int selectionHeight() const { return m_selectionBottomRow - m_selectionTopRow + 1; }
+	void cursorUp(bool shiftKey=false);
+	void cursorDown(bool shiftKey=false);
+	void cursorLeft(bool shiftKey=false);
+	void cursorRight(bool shiftKey=false);
+	void moveCursor(int, int, 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, int);
 	void setSelection(int, int, int, int);
 	void cancelSelection();
 	int levelRequired() const;
@@ -99,8 +122,9 @@ private:
 	std::vector<LevelOnePage *> m_subPages;
 	std::vector<LevelOnePage *> m_recycleSubPages;
 	QUndoStack *m_undoStack;
-	int m_cursorRow, m_cursorColumn, m_selectionTopRow, m_selectionBottomRow, m_selectionLeftColumn, m_selectionRightColumn;
+	int m_cursorRow, m_cursorColumn, m_selectionCornerRow, m_selectionCornerColumn;
 	LevelOnePage *m_selectionSubPage;
+	ClutModel *m_clutModel;
 };
 
 #endif

examples/Level1p5-Defcon.tti

@@ -0,0 +1,23 @@
+PN,11600
+SC,0000
+PS,8000
+CT,8,T
+OL,26,@lD@Ib\UbTXb\ZbT]b\`B]mD@HB{VBsWB{[Bs\B{
+OL,26,AaBRnD@`BraB]oD@HBXVBPWBX[BP\BX`B}pD@Iby
+OL,26,BUbqXbyZbq]byaBruD@KBYLBSRbTVb\ZbT^b\cbY
+OL,26,CdBSvD@JBYKBSLBywD@Fb\JBTKByLBsVB^ZbX[bU
+OL,26,D\bS^bxxD@[bx\bu]bsyD@BbqFbyRbqVbyCC
+OL,3,W    <,,,,,,,,,,,,,,,,,,,,,,,,,,,,,l    
+OL,4,W    5t   xt xt 5 j    
+OL,5,W    5 "         !"/ !"  j    
+OL,6,W    5              j5j    
+OL,7,W    5 `         0`| 0`  j    
+OL,8,W    5'      +' +'  jj    
+OL,9,W    -,,,,,,,,,,,,,,,,,,,,,,,,,,,,,.    
+OL,12,V<,,,,,lR<,,,,,lS<,,,,,lQ<,,,,,lW<,,,,,l
+OL,13,V5jR5 `5jS5xtjQ5xtjW5 `~5 j
+OL,14,V55   jR5 ~75jS5/% jjQ5/% jjW5 #5 j
+OL,15,V5tjR5z? 5jS5 j5jQ5`x~/jW5  5 j
+OL,16,V5|4 jjR5jS5|4 jjQ5?#  jW5  5 j
+OL,17,V5+'jR5   5jS5+'jQ5jW5  5 j
+OL,18,V-,,,,,.R-,,,,,.S-,,,,,.Q-,,,,,.W-,,,,,.

examples/SidePanels-PriceChop.tti

@@ -0,0 +1,33 @@
+PN,13200
+SC,0000
+PS,8000
+CT,8,T
+OL,28,@@@|H@p_@|wsA@@AfUrLs_w}ww]_}_wM@p
+OL,26,@rD@Ab|BBpKBxLbtsD@BB{CbqJbyKBstD@Db|EBp
+OL,26,AHBxIbtuD@EB{FbqGbyHBswD@AbqLbyxD@Bb|CBp
+OL,26,BJBxKbtyD@CB{DbqIbyJBszD@Eb|FBpGBxHbt{D@
+OL,26,CFB{GBs}aJ@cJhPThr]hP`hre~aI@cI_Cxv]@It
+OL,26,DAipBitCIwGi\iD@@@H@irAiyBIzCirDIyxve@Iy
+OL,26,EAIqCiqDItEipFitGIwiD@@@HAisBIvCipDiyEis
+OL,26,FFiwGi{BBBBBBBBBBB
+OL,1, calls cost #5  WZ`p0ppb`p0pp `p0up`p0pp
+OL,2, 0909 879 0100  WZjp55"jj 1=.(j 15jj 5uz
+OL,3, GB  #9.99 p&p  WZ*  ! ""#!## "#!!""#!% 
+OL,4,                                W Zn,h h
+OL,5,C]Dstart #89 \                  W Zjp"d&
+OL,6,S############                           
+OL,7,                                    LIVE
+OL,8,E]G now at   \                          
+OL,9,Ussssssssssss                           
+OL,10,U+'                           
+OL,11,U^"o]G#3U?\!                            
+OL,12,U   +'                              
+OL,13,U    "o?!                               
+OL,14,Spppppppppppp                           
+OL,15,S+]D^leftS\'                           
+OL,16,S^"o]D24S?\!                            
+OL,17,S   +'                              
+OL,18,S    "o?!                               
+OL,19,S                                       
+OL,21,E]G9ct gold curb chain   9ct gold curb c
+OL,22,C]DNEW BUYER   JOHN london   JANET manch

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

keymap.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *

levelonecommands.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -17,16 +17,29 @@
  * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+#include <QApplication>
+#include <QByteArray>
+#include <QByteArrayList>
+#include <QClipboard>
+#include <QMimeData>
+
 #include "levelonecommands.h"
 
 #include "document.h"
+#include "keymap.h"
 
-TypeCharacterCommand::TypeCharacterCommand(TeletextDocument *teletextDocument, unsigned char newCharacter, bool insertMode, QUndoCommand *parent) : QUndoCommand(parent)
+LevelOneCommand::LevelOneCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : QUndoCommand(parent)
 {
 	m_teletextDocument = teletextDocument;
 	m_subPageIndex = teletextDocument->currentSubPageIndex();
 	m_row = teletextDocument->cursorRow();
-	m_columnStart = m_columnEnd = teletextDocument->cursorColumn();
+	m_column = teletextDocument->cursorColumn();
+	m_firstDo = true;
+}
+
+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;
 
@@ -37,7 +50,6 @@ TypeCharacterCommand::TypeCharacterCommand(TeletextDocument *teletextDocument, u
 		setText(QObject::tr("insert character"));
 	else
 		setText(QObject::tr("overwrite character"));
-	m_firstDo = true;
 }
 
 void TypeCharacterCommand::redo()
@@ -89,12 +101,8 @@ bool TypeCharacterCommand::mergeWith(const QUndoCommand *command)
 }
 
 
-ToggleMosaicBitCommand::ToggleMosaicBitCommand(TeletextDocument *teletextDocument, unsigned char bitToToggle, QUndoCommand *parent) : QUndoCommand(parent)
+ToggleMosaicBitCommand::ToggleMosaicBitCommand(TeletextDocument *teletextDocument, unsigned char bitToToggle, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-	m_teletextDocument = teletextDocument;
-	m_subPageIndex = teletextDocument->currentSubPageIndex();
-	m_row = teletextDocument->cursorRow();
-	m_column = teletextDocument->cursorColumn();
 	m_oldCharacter = teletextDocument->currentSubPage()->character(m_row, m_column);
 	if (bitToToggle == 0x20 || bitToToggle == 0x7f)
 		m_newCharacter = bitToToggle;
@@ -134,12 +142,10 @@ bool ToggleMosaicBitCommand::mergeWith(const QUndoCommand *command)
 }
 
 
-BackspaceKeyCommand::BackspaceKeyCommand(TeletextDocument *teletextDocument, bool insertMode, QUndoCommand *parent) : QUndoCommand(parent)
+BackspaceKeyCommand::BackspaceKeyCommand(TeletextDocument *teletextDocument, bool insertMode, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-	m_teletextDocument = teletextDocument;
-	m_subPageIndex = teletextDocument->currentSubPageIndex();
-	m_row = teletextDocument->cursorRow();
-	m_columnStart = teletextDocument->cursorColumn()-1;
+	m_columnStart = m_column - 1;
+
 	if (m_columnStart == -1) {
 		m_columnStart = 39;
 		if (--m_row == 0)
@@ -152,7 +158,6 @@ BackspaceKeyCommand::BackspaceKeyCommand(TeletextDocument *teletextDocument, boo
 		m_oldRowContents[c] = m_newRowContents[c] = m_teletextDocument->currentSubPage()->character(m_row, c);
 
 	setText(QObject::tr("backspace"));
-	m_firstDo = true;
 }
 
 void BackspaceKeyCommand::redo()
@@ -208,13 +213,8 @@ bool BackspaceKeyCommand::mergeWith(const QUndoCommand *command)
 }
 
 
-DeleteKeyCommand::DeleteKeyCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : QUndoCommand(parent)
+DeleteKeyCommand::DeleteKeyCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-	m_teletextDocument = teletextDocument;
-	m_subPageIndex = teletextDocument->currentSubPageIndex();
-	m_row = teletextDocument->cursorRow();
-	m_column = teletextDocument->cursorColumn();
-
 	for (int c=0; c<40; c++)
 		m_oldRowContents[c] = m_newRowContents[c] = m_teletextDocument->currentSubPage()->character(m_row, c);
 
@@ -262,11 +262,8 @@ bool DeleteKeyCommand::mergeWith(const QUndoCommand *command)
 }
 
 
-InsertRowCommand::InsertRowCommand(TeletextDocument *teletextDocument, bool copyRow, QUndoCommand *parent) : QUndoCommand(parent)
+InsertRowCommand::InsertRowCommand(TeletextDocument *teletextDocument, bool copyRow, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-	m_teletextDocument = teletextDocument;
-	m_subPageIndex = teletextDocument->currentSubPageIndex();
-	m_row = teletextDocument->cursorRow();
 	m_copyRow = copyRow;
 
 	if (m_copyRow)
@@ -310,12 +307,8 @@ void InsertRowCommand::undo()
 }
 
 
-DeleteRowCommand::DeleteRowCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : QUndoCommand(parent)
+DeleteRowCommand::DeleteRowCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-	m_teletextDocument = teletextDocument;
-	m_subPageIndex = teletextDocument->currentSubPageIndex();
-	m_row = teletextDocument->cursorRow();
-
 	setText(QObject::tr("delete row"));
 }
 
@@ -354,10 +347,233 @@ void DeleteRowCommand::undo()
 }
 
 
-InsertSubPageCommand::InsertSubPageCommand(TeletextDocument *teletextDocument, bool afterCurrentSubPage, bool copySubPage, QUndoCommand *parent) : QUndoCommand(parent)
+#ifndef QT_NO_CLIPBOARD
+CutCommand::CutCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-	m_teletextDocument = teletextDocument;
-	m_newSubPageIndex = teletextDocument->currentSubPageIndex()+afterCurrentSubPage;
+	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();
+
+	// Store copy of the characters that we're about to blank
+	for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++) {
+		QByteArray rowArray;
+
+		for (int c=m_selectionLeftColumn; c<=m_selectionRightColumn; c++)
+			rowArray.append(m_teletextDocument->currentSubPage()->character(r, c));
+
+		m_deletedCharacters.append(rowArray);
+	}
+
+	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->contentsChange(r);
+	}
+}
+
+void CutCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+
+	int arrayR = 0;
+	int arrayC;
+
+	for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++) {
+		arrayC = 0;
+		for (int c=m_selectionLeftColumn; c<=m_selectionRightColumn; c++)
+			m_teletextDocument->currentSubPage()->setCharacter(r, c, m_deletedCharacters[arrayR].at(arrayC++));
+
+		emit m_teletextDocument->contentsChange(r);
+		arrayR++;
+	}
+
+	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_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_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;
+	} else if (mimeData->hasText()) {
+		// Plain text
+		QStringList plainTextData = mimeData->text().split(QRegExp("\n|\r\n|\r"));
+
+		m_clipboardDataHeight = plainTextData.size();
+		m_clipboardDataWidth = 0;
+
+		for (int r=0; r<m_clipboardDataHeight; r++) {
+			m_pastingCharacters.append(QByteArray());
+			for (int c=0; c<plainTextData.at(r).size(); c++) {
+				// Try to map the unicode character to the current Level 1 character set of this page
+
+				char convertedChar;
+				const QChar charToConvert = plainTextData.at(r).at(c);
+
+				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 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_clipboardDataWidth == 0 || m_clipboardDataHeight == 0)
+		return;
+
+	if (m_selectionActive) {
+		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_pasteBottomRow = m_row + m_clipboardDataHeight - 1;
+		m_pasteLeftColumn = m_column;
+		m_pasteRightColumn = m_column + m_clipboardDataWidth - 1;
+	}
+
+	// Store copy of the characters that we're about to overwrite
+	for (int r=m_pasteTopRow; r<=m_pasteBottomRow; r++) {
+		QByteArray rowArray;
+
+		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)
+				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);
+
+		m_deletedCharacters.append(rowArray);
+	}
+
+	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) {
+				m_teletextDocument->currentSubPage()->setCharacter(r, c, m_pastingCharacters[arrayR].at(arrayC++));
+
+				// If paste area is wider than clipboard data, repeat the pattern
+				if (arrayC == m_clipboardDataWidth)
+					arrayC = 0;
+			}
+
+		if (r < 25)
+			emit m_teletextDocument->contentsChange(r);
+
+		arrayR++;
+		// If paste area is taller than clipboard data, repeat the pattern
+		if (arrayR == m_clipboardDataHeight)
+			arrayR = 0;
+	}
+
+	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);
+
+	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)
+				m_teletextDocument->currentSubPage()->setCharacter(r, c, m_deletedCharacters[arrayR].at(arrayC++));
+
+		if (r < 25)
+			emit m_teletextDocument->contentsChange(r);
+
+		arrayR++;
+	}
+
+	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"));
@@ -380,30 +596,26 @@ void InsertSubPageCommand::undo()
 }
 
 
-DeleteSubPageCommand::DeleteSubPageCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : QUndoCommand(parent)
+DeleteSubPageCommand::DeleteSubPageCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-	m_teletextDocument = teletextDocument;
-	m_subPageToDelete = teletextDocument->currentSubPageIndex();
 	setText(QObject::tr("delete subpage"));
 }
 
 void DeleteSubPageCommand::redo()
 {
-	m_teletextDocument->deleteSubPageToRecycle(m_subPageToDelete);
-	m_teletextDocument->selectSubPageIndex(qMin(m_subPageToDelete, m_teletextDocument->numberOfSubPages()-1), true);
+	m_teletextDocument->deleteSubPageToRecycle(m_subPageIndex);
+	m_teletextDocument->selectSubPageIndex(qMin(m_subPageIndex, m_teletextDocument->numberOfSubPages()-1), true);
 }
 
 void DeleteSubPageCommand::undo()
 {
-	m_teletextDocument->unDeleteSubPageFromRecycle(m_subPageToDelete);
-	m_teletextDocument->selectSubPageIndex(m_subPageToDelete, true);
+	m_teletextDocument->unDeleteSubPageFromRecycle(m_subPageIndex);
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
 }
 
 
-SetColourCommand::SetColourCommand(TeletextDocument *teletextDocument, int colourIndex, int newColour, QUndoCommand *parent) : QUndoCommand(parent)
+SetColourCommand::SetColourCommand(TeletextDocument *teletextDocument, int colourIndex, int newColour, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-	m_teletextDocument = teletextDocument;
-	m_subPageIndex = teletextDocument->currentSubPageIndex();
 	m_colourIndex = colourIndex;
 	m_oldColour = teletextDocument->currentSubPage()->CLUT(colourIndex);
 	m_newColour = newColour;
@@ -431,10 +643,8 @@ void SetColourCommand::undo()
 }
 
 
-ResetCLUTCommand::ResetCLUTCommand(TeletextDocument *teletextDocument, int colourTable, QUndoCommand *parent) : QUndoCommand(parent)
+ResetCLUTCommand::ResetCLUTCommand(TeletextDocument *teletextDocument, int colourTable, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-	m_teletextDocument = teletextDocument;
-	m_subPageIndex = teletextDocument->currentSubPageIndex();
 	m_colourTable = colourTable;
 	for (int i=m_colourTable*8; i<m_colourTable*8+8; i++)
 		m_oldColourEntry[i&7] = teletextDocument->currentSubPage()->CLUT(i);

levelonecommands.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -20,11 +20,23 @@
 #ifndef LEVELONECOMMANDS_H
 #define LEVELONECOMMANDS_H
 
+#include <QByteArrayList>
 #include <QUndoCommand>
 
 #include "document.h"
 
-class TypeCharacterCommand : public QUndoCommand
+class LevelOneCommand : public QUndoCommand
+{
+public:
+	LevelOneCommand(TeletextDocument *, QUndoCommand *parent = 0);
+
+protected:
+	TeletextDocument *m_teletextDocument;
+	int m_subPageIndex, m_row, m_column;
+	bool m_firstDo;
+};
+
+class TypeCharacterCommand : public LevelOneCommand
 {
 public:
 	enum { Id = 101 };
@@ -37,13 +49,12 @@ public:
 	int id() const override { return Id; }
 
 private:
-	TeletextDocument *m_teletextDocument;
 	unsigned char m_newCharacter, m_oldRowContents[40], m_newRowContents[40];
-	int m_subPageIndex, m_row, m_columnStart, m_columnEnd;
-	bool m_firstDo, m_insertMode;
+	int m_columnStart, m_columnEnd;
+	bool m_insertMode;
 };
 
-class ToggleMosaicBitCommand : public QUndoCommand
+class ToggleMosaicBitCommand : public LevelOneCommand
 {
 public:
 	enum { Id = 102 };
@@ -56,12 +67,10 @@ public:
 	int id() const override { return Id; }
 
 private:
-	TeletextDocument *m_teletextDocument;
 	unsigned char m_oldCharacter, m_newCharacter;
-	int m_subPageIndex, m_row, m_column;
 };
 
-class BackspaceKeyCommand : public QUndoCommand
+class BackspaceKeyCommand : public LevelOneCommand
 {
 public:
 	enum { Id = 103 };
@@ -74,13 +83,12 @@ public:
 	int id() const override { return Id; }
 
 private:
-	TeletextDocument *m_teletextDocument;
 	unsigned char m_oldRowContents[40], m_newRowContents[40];
-	int m_subPageIndex, m_row, m_columnStart, m_columnEnd;
-	bool m_firstDo, m_insertMode;
+	int m_columnStart, m_columnEnd;
+	bool m_insertMode;
 };
 
-class DeleteKeyCommand : public QUndoCommand
+class DeleteKeyCommand : public LevelOneCommand
 {
 public:
 	enum { Id = 104 };
@@ -93,12 +101,10 @@ public:
 	int id() const override { return Id; }
 
 private:
-	TeletextDocument *m_teletextDocument;
 	unsigned char m_oldRowContents[40], m_newRowContents[40];
-	int m_subPageIndex, m_row, m_column;
 };
 
-class InsertSubPageCommand : public QUndoCommand
+class InsertSubPageCommand : public LevelOneCommand
 {
 public:
 	InsertSubPageCommand(TeletextDocument *, bool, bool, QUndoCommand *parent = 0);
@@ -107,25 +113,20 @@ public:
 	void undo() override;
 
 private:
-	TeletextDocument *m_teletextDocument;
 	int m_newSubPageIndex;
 	bool m_copySubPage;
 };
 
-class DeleteSubPageCommand : public QUndoCommand
+class DeleteSubPageCommand : public LevelOneCommand
 {
 public:
 	DeleteSubPageCommand(TeletextDocument *, QUndoCommand *parent = 0);
 
 	void redo() override;
 	void undo() override;
-
-private:
-	TeletextDocument *m_teletextDocument;
-	int m_subPageToDelete;
 };
 
-class InsertRowCommand : public QUndoCommand
+class InsertRowCommand : public LevelOneCommand
 {
 public:
 	InsertRowCommand(TeletextDocument *, bool, QUndoCommand *parent = 0);
@@ -134,13 +135,11 @@ public:
 	void undo() override;
 
 private:
-	TeletextDocument *m_teletextDocument;
-	int m_subPageIndex, m_row;
 	bool m_copyRow;
 	unsigned char m_deletedBottomRow[40];
 };
 
-class DeleteRowCommand : public QUndoCommand
+class DeleteRowCommand : public LevelOneCommand
 {
 public:
 	DeleteRowCommand(TeletextDocument *, QUndoCommand *parent = 0);
@@ -149,12 +148,42 @@ public:
 	void undo() override;
 
 private:
-	TeletextDocument *m_teletextDocument;
-	int m_subPageIndex, m_row;
 	unsigned char m_deletedRow[40];
 };
 
-class SetColourCommand : public QUndoCommand
+#ifndef QT_NO_CLIPBOARD
+class CutCommand : public LevelOneCommand
+{
+public:
+	CutCommand(TeletextDocument *, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	QByteArrayList m_deletedCharacters;
+	int m_selectionTopRow, m_selectionBottomRow, m_selectionLeftColumn, m_selectionRightColumn;
+	int m_selectionCornerRow, m_selectionCornerColumn;
+};
+
+class PasteCommand : public LevelOneCommand
+{
+public:
+	PasteCommand(TeletextDocument *, int, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	QByteArrayList m_deletedCharacters, m_pastingCharacters;
+	int m_pasteTopRow, m_pasteBottomRow, m_pasteLeftColumn, m_pasteRightColumn;
+	int m_clipboardDataHeight, m_clipboardDataWidth;
+	int m_selectionCornerRow, m_selectionCornerColumn;
+	bool m_selectionActive;
+};
+#endif // !QT_NO_CLIPBOARD
+
+class SetColourCommand : public LevelOneCommand
 {
 public:
 	SetColourCommand(TeletextDocument *, int, int, QUndoCommand *parent = 0);
@@ -163,11 +192,10 @@ public:
 	void undo() override;
 
 private:
-	TeletextDocument *m_teletextDocument;
-	int m_subPageIndex, m_colourIndex, m_oldColour, m_newColour;
+	int m_colourIndex, m_oldColour, m_newColour;
 };
 
-class ResetCLUTCommand : public QUndoCommand
+class ResetCLUTCommand : public LevelOneCommand
 {
 public:
 	ResetCLUTCommand(TeletextDocument *, int, QUndoCommand *parent = 0);
@@ -176,8 +204,7 @@ public:
 	void undo() override;
 
 private:
-	TeletextDocument *m_teletextDocument;
-	int m_subPageIndex, m_colourTable;
+	int m_colourTable;
 	int m_oldColourEntry[8];
 };
 

levelonepage.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -25,23 +25,25 @@
 
 #include "levelonepage.h"
 
+#include "x26triplets.h"
+
 LevelOnePage::LevelOnePage()
 {
-	m_enhancements.reserve(208);
+	m_enhancements.reserve(maxEnhancements());
 	clearPage();
 }
 
 LevelOnePage::LevelOnePage(const PageBase &other)
 {
-	m_enhancements.reserve(208);
+	m_enhancements.reserve(maxEnhancements());
 	clearPage();
 
 	for (int i=0; i<26; i++)
-		if (other.packetNeeded(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.packetNeeded(i, j))
+			if (other.packetExists(i, j))
 				setPacket(i, j, other.packet(i));
 
 	for (int i=PageBase::C4ErasePage; i<=PageBase::C14NOS; i++)
@@ -125,12 +127,12 @@ QByteArray LevelOnePage::packet(int packetNumber, int designationCode) const
 			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) >> 8);
+			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[43] = 0xf;
-		result[44] = result[45] = 0;
+		result[37] = 0xf;
+		result[38] = result[39] = 0;
 
 		return result;
 	}
@@ -254,7 +256,7 @@ bool LevelOnePage::setPacket(int packetNumber, int designationCode, QByteArray p
 	return PageBase::setPacket(packetNumber, designationCode, packetContents);
 }
 
-bool LevelOnePage::packetNeeded(int packetNumber) const
+bool LevelOnePage::packetExists(int packetNumber) const
 {
 	if (packetNumber <= 24) {
 		for (int c=0; c<40; c++)
@@ -263,10 +265,10 @@ bool LevelOnePage::packetNeeded(int packetNumber) const
 		return false;
 	}
 
-	return PageBase::packetNeeded(packetNumber);
+	return PageBase::packetExists(packetNumber);
 }
 
-bool LevelOnePage::packetNeeded(int packetNumber, int designationCode) const
+bool LevelOnePage::packetExists(int packetNumber, int designationCode) const
 {
 	if (packetNumber == 26)
 		return packetFromEnhancementListNeeded(designationCode);
@@ -298,7 +300,7 @@ bool LevelOnePage::packetNeeded(int packetNumber, int designationCode) const
 			return !isPaletteDefault(0,15);
 	}
 
-	return PageBase::packetNeeded(packetNumber, designationCode);
+	return PageBase::packetExists(packetNumber, designationCode);
 }
 
 bool LevelOnePage::controlBit(int bitNumber) const
@@ -381,6 +383,9 @@ 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);
 }
 
@@ -400,17 +405,21 @@ bool LevelOnePage::isPaletteDefault(int fromColour, int toColour) const
 
 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;
 
@@ -423,9 +432,10 @@ int LevelOnePage::levelRequired() const
 				case 0x22: // G3 character @ Level 1.5
 				case 0x2f: // G2 character
 				case 0x30 ... 0x3f: // G0 character with diacritical
-					levelSeen = qMax(levelSeen, 1);
+					levelSeen = 1;
 					break;
 			}
+
 		if (levelSeen < 2)
 			switch (m_enhancements.at(i).modeExt()) {
 				// Check for Level 2.5 triplets
@@ -433,25 +443,26 @@ int LevelOnePage::levelRequired() const
 				case 0x01: // Full row colour
 				case 0x10 ... 0x13: // Origin Modifer and Object Invocation
 				case 0x15 ... 0x17: // Object Definition
-					// Check if Object Defition is required only at Level 3.5
-					if ((m_enhancements.at(i).address() & 0x18) == 0x10)
-						return 3;
-					else
-						levelSeen = qMax(levelSeen, 2);
-					break;
 				case 0x18: // DRCS Mode
-					// Check if DRCS is required only at Level 3.5
-					if ((m_enhancements.at(i).data() & 0x30) == 0x20)
-						return 3;
-					else
-						levelSeen = qMax(levelSeen, 2);
-					break;
 				case 0x20: // Foreground colour
 				case 0x21: // G1 character
 				case 0x23: // Background colour
 				case 0x27 ... 0x29: // Flash functions, G0 and G2 charset designation, G0 character @ Level 2.5
 				case 0x2b ... 0x2d: // G3 character @ Level 2.5, display attributes, DRCS character
-					levelSeen = qMax(levelSeen, 2);
+					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 ... 0x17: // Object Definition
+					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;
 			}
 	}

levelonepage.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -42,8 +42,8 @@ public:
 
 	QByteArray packet(int) const override;
 	QByteArray packet(int, int) const override;
-	bool packetNeeded(int) const override;
-	bool packetNeeded(int, int) const override;
+	bool packetExists(int) const override;
+	bool packetExists(int, int) const override;
 	bool setPacket(int, QByteArray) override;
 	bool setPacket(int, int, QByteArray) override;
 
@@ -52,6 +52,8 @@ public:
 
 	void clearPage();
 
+	int maxEnhancements() const { return 208; };
+
 /*	void setSubPageNumber(int); */
 	int cycleValue() const { return m_cycleValue; };
 	void setCycleValue(int);

loadsave.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -20,12 +20,14 @@
 #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"
 
@@ -52,7 +54,7 @@ void loadTTI(QFile *inFile, TeletextDocument *document)
 				document->insertSubPage(document->numberOfSubPages(), false);
 				loadingPage = document->subPage(document->numberOfSubPages()-1);
 			} else {
-				document->setPageNumber(inLine.mid(3,3));
+				document->setPageNumberFromString(inLine.mid(3,3));
 				firstSubPageAlreadyFound = true;
 			}
 		}
@@ -146,6 +148,12 @@ void loadTTI(QFile *inFile, TeletextDocument *document)
 					}
 					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);
 				}
 			}
@@ -160,6 +168,198 @@ void loadTTI(QFile *inFile, TeletextDocument *document)
 		}
 }
 
+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)
 {
@@ -182,7 +382,7 @@ void saveTTI(QSaveFile &file, const TeletextDocument &document)
 
 	auto write7bitPacket=[&](int packetNumber)
 	{
-		if (document.subPage(p)->packetNeeded(packetNumber)) {
+		if (document.subPage(p)->packetExists(packetNumber)) {
 			QByteArray outLine = document.subPage(p)->packet(packetNumber);
 
 			outStream << QString("OL,%1,").arg(packetNumber);
@@ -193,13 +393,17 @@ void saveTTI(QSaveFile &file, const TeletextDocument &document)
 					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)->packetNeeded(packetNumber, designationCode)) {
+		if (document.subPage(p)->packetExists(packetNumber, designationCode)) {
 			QByteArray outLine = document.subPage(p)->packet(packetNumber, designationCode);
 
 			outStream << QString("OL,%1,").arg(packetNumber);
@@ -207,14 +411,22 @@ void saveTTI(QSaveFile &file, const TeletextDocument &document)
 			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
 		}
 	};
 
 	outStream.setCodec("ISO-8859-1");
 
 	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
 
@@ -224,23 +436,50 @@ void saveTTI(QSaveFile &file, const TeletextDocument &document)
 
 	for (p=0; p<document.numberOfSubPages(); p++) {
 
-		outStream << QString("PN,%1%2").arg(document.pageNumber(), 3, 16, QChar('0')).arg(subPageNumber & 0xff, 2, 16, QChar('0')) << Qt::endl;
+		// 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, 16, QChar('0')) << Qt::endl;
+		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
+		}
 
-		outStream << QString("PS,%1").arg(0x8000 | controlBitsToPS(document.subPage(p)), 4, 16, QChar('0')) << Qt::endl;
+		// 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') << Qt::endl;
+			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()) << Qt::endl;
+			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)->packetNeeded(27,0)) {
+		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;
@@ -252,7 +491,7 @@ void saveTTI(QSaveFile &file, const TeletextDocument &document)
 				}*/
 		}
 
-		// X27 then X28 always come first
+		// 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++)
@@ -285,16 +524,204 @@ void saveTTI(QSaveFile &file, const TeletextDocument &document)
 				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
+		}
+	};
+
+	outStream.setCodec("ISO-8859-1");
+
+	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->packetNeeded(packetNumber))
+	if (subPage->packetExists(packetNumber))
 		return subPage->packet(packetNumber);
 	else
 		return QByteArray(40, ' ');
@@ -345,7 +772,7 @@ QString exportHashStringPackets(LevelOnePage *subPage)
 	const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 	QString result;
 
-	if (subPage->packetNeeded(28,0) || subPage->packetNeeded(28,4)) {
+	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;
@@ -356,9 +783,9 @@ QString exportHashStringPackets(LevelOnePage *subPage)
 
 		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->packetNeeded(28,0))
+		if (subPage->packetExists(28,0))
 			result.append(":X280=" + x28StringBegin + colourToHexString(2) + colourToHexString(3) + x28StringEnd);
-		if (subPage->packetNeeded(28,4))
+		if (subPage->packetExists(28,4))
 			result.append(":X284=" + x28StringBegin + colourToHexString(0) + colourToHexString(1) + x28StringEnd);
 	}
 

loadsave.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -30,11 +30,14 @@
 #include "levelonepage.h"
 #include "pagebase.h"
 
-void loadTTI(QFile *inFile, TeletextDocument *document);
+void loadTTI(QFile *, TeletextDocument *);
+void importT42(QFile *, TeletextDocument *);
 
 int controlBitsToPS(PageBase *);
 
 void saveTTI(QSaveFile &, const TeletextDocument &);
+void exportT42File(QSaveFile &, const TeletextDocument &);
+void exportM29File(QSaveFile &, const TeletextDocument &);
 
 QByteArray rowPacketAlways(PageBase *, int);
 

main.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -30,7 +30,7 @@ int main(int argc, char *argv[])
 	QApplication::setApplicationDisplayName(QApplication::applicationName());
 	QApplication::setOrganizationName("gkmac.co.uk");
 	QApplication::setOrganizationDomain("gkmac.co.uk");
-	QApplication::setApplicationVersion("0.1-alpha");
+	QApplication::setApplicationVersion("0.5.5-alpha");
 	QCommandLineParser parser;
 	parser.setApplicationDescription(QApplication::applicationName());
 	parser.addHelpOption();

mainwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -17,13 +17,18 @@
  * 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 <QKeyEvent>
 #include <QMenu>
+#include <QMimeData>
 #include <QPainter>
 #include <QPair>
 #include <QUndoCommand>
@@ -33,6 +38,7 @@
 
 #include "mainwidget.h"
 
+#include "decode.h"
 #include "document.h"
 #include "keymap.h"
 #include "levelonecommands.h"
@@ -47,18 +53,18 @@ TeletextWidget::TeletextWidget(QFrame *parent) : QFrame(parent)
 	this->setAttribute(Qt::WA_InputMethodEnabled, true);
 	m_teletextDocument = new TeletextDocument();
 	m_levelOnePage = m_teletextDocument->currentSubPage();
-	m_pageRender.setTeletextPage(m_levelOnePage);
+	m_pageDecode.setTeletextPage(m_levelOnePage);
+	m_pageRender.setDecoder(&m_pageDecode);
 	m_insertMode = false;
 	m_selectionInProgress = false;
-	m_grid = false;
 	setFocusPolicy(Qt::StrongFocus);
 	m_flashTiming = m_flashPhase = 0;
 	connect(&m_pageRender, &TeletextPageRender::flashChanged, this, &TeletextWidget::updateFlashTimer);
-	connect(&m_pageRender, &TeletextPageRender::sidePanelsChanged, this, &TeletextWidget::changeSize);
+	connect(&m_pageDecode, &TeletextPageDecode::sidePanelsChanged, this, &TeletextWidget::changeSize);
 	connect(m_teletextDocument, &TeletextDocument::subPageSelected, this, &TeletextWidget::subPageSelected);
 	connect(m_teletextDocument, &TeletextDocument::contentsChange, this, &TeletextWidget::refreshRow);
 	connect(m_teletextDocument, &TeletextDocument::refreshNeeded, this, &TeletextWidget::refreshPage);
-	connect(m_teletextDocument, &TeletextDocument::selectionMoved, this, QOverload<>::of(&TeletextWidget::update));
+	connect(m_teletextDocument, &TeletextDocument::colourChanged, &m_pageRender, &TeletextPageRender::colourChanged);
 }
 
 TeletextWidget::~TeletextWidget()
@@ -82,20 +88,21 @@ void TeletextWidget::inputMethodEvent(QInputMethodEvent* event)
 void TeletextWidget::subPageSelected()
 {
 	m_levelOnePage = m_teletextDocument->currentSubPage();
-	m_pageRender.setTeletextPage(m_levelOnePage);
-	refreshPage();
+	m_pageDecode.setTeletextPage(m_levelOnePage);
+	m_pageDecode.decodePage();
+	m_pageRender.renderPage(true);
+	update();
 }
 
 void TeletextWidget::refreshRow(int rowChanged)
 {
-	m_pageRender.renderPage(rowChanged);
+	m_pageDecode.decodeRow(rowChanged);
 	update();
 }
 
 void TeletextWidget::refreshPage()
 {
-	m_pageRender.decodePage();
-	m_pageRender.renderPage();
+	m_pageDecode.decodePage();
 	update();
 }
 
@@ -104,18 +111,12 @@ void TeletextWidget::paintEvent(QPaintEvent *event)
 	Q_UNUSED(event);
 	QPainter widgetPainter(this);
 
-	widgetPainter.drawPixmap(m_pageRender.leftSidePanelColumns()*12, 0, *m_pageRender.pagePixmap(m_flashPhase), 0, 0, 480, 250);
-	if (m_pageRender.leftSidePanelColumns())
-		widgetPainter.drawPixmap(0, 0, *m_pageRender.pagePixmap(m_flashPhase), 864-m_pageRender.leftSidePanelColumns()*12, 0, m_pageRender.leftSidePanelColumns()*12, 250);
-	if (m_pageRender.rightSidePanelColumns())
-		widgetPainter.drawPixmap(480+m_pageRender.leftSidePanelColumns()*12, 0, *m_pageRender.pagePixmap(m_flashPhase), 480, 0, m_pageRender.rightSidePanelColumns()*12, 250);
-	if (this->hasFocus())
-		widgetPainter.fillRect((m_teletextDocument->cursorColumn()+m_pageRender.leftSidePanelColumns())*12, m_teletextDocument->cursorRow()*10, 12, 10, QColor(128, 128, 128, 192));
-	if (m_teletextDocument->selectionActive()) {
-		widgetPainter.setPen(QPen(QColor(192, 192, 192, 224), 1, Qt::DashLine));
-		widgetPainter.setBrush(QBrush(QColor(255, 255, 255, 64)));
-		widgetPainter.drawRect((m_teletextDocument->selectionLeftColumn()+m_pageRender.leftSidePanelColumns())*12, m_teletextDocument->selectionTopRow()*10, m_teletextDocument->selectionWidth()*12-1, m_teletextDocument->selectionHeight()*10-1);
-	}
+	m_pageRender.renderPage();
+	widgetPainter.drawPixmap(m_pageDecode.leftSidePanelColumns()*12, 0, *m_pageRender.pagePixmap(m_flashPhase), 0, 0, 480, 250);
+	if (m_pageDecode.leftSidePanelColumns())
+		widgetPainter.drawPixmap(0, 0, *m_pageRender.pagePixmap(m_flashPhase), 864-m_pageDecode.leftSidePanelColumns()*12, 0, m_pageDecode.leftSidePanelColumns()*12, 250);
+	if (m_pageDecode.rightSidePanelColumns())
+		widgetPainter.drawPixmap(480+m_pageDecode.leftSidePanelColumns()*12, 0, *m_pageRender.pagePixmap(m_flashPhase), 480, 0, m_pageDecode.rightSidePanelColumns()*12, 250);
 }
 
 void TeletextWidget::updateFlashTimer(int newFlashTimer)
@@ -144,38 +145,44 @@ void TeletextWidget::timerEvent(QTimerEvent *event)
 		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::toggleReveal(bool revealOn)
+void TeletextWidget::setReveal(bool reveal)
 {
-	m_pageRender.setReveal(revealOn);
+	m_pageRender.setReveal(reveal);
 	update();
 }
 
-void TeletextWidget::toggleMix(bool mixOn)
+void TeletextWidget::setMix(bool mix)
 {
-	m_pageRender.setMix(mixOn);
+	m_pageRender.setMix(mix);
 	update();
 }
 
-void TeletextWidget::toggleGrid(bool gridOn)
+void TeletextWidget::setShowControlCodes(bool showControlCodes)
 {
-	m_grid = gridOn;
-	m_pageRender.setGrid(gridOn);
-	m_pageRender.renderPage();
+	m_pageRender.setShowControlCodes(showControlCodes);
 	update();
 }
 
 void TeletextWidget::setControlBit(int bitNumber, bool active)
 {
 	m_levelOnePage->setControlBit(bitNumber, active);
-	if (bitNumber == 1 || bitNumber == 2) {
-		m_pageRender.decodePage();
-		m_pageRender.renderPage();
-	}
+	if (bitNumber == 1 || bitNumber == 2)
+		m_pageDecode.decodePage();
 }
 
 void TeletextWidget::setDefaultCharSet(int newDefaultCharSet)
@@ -191,31 +198,27 @@ void TeletextWidget::setDefaultNOS(int newDefaultNOS)
 void TeletextWidget::setDefaultScreenColour(int newColour)
 {
 	m_levelOnePage->setDefaultScreenColour(newColour);
-	m_pageRender.decodePage();
-	m_pageRender.renderPage();
+	m_pageDecode.decodePage();
 }
 
 void TeletextWidget::setDefaultRowColour(int newColour)
 {
 	m_levelOnePage->setDefaultRowColour(newColour);
-	m_pageRender.decodePage();
-	m_pageRender.renderPage();
+	m_pageDecode.decodePage();
 	update();
 }
 
 void TeletextWidget::setColourTableRemap(int newMap)
 {
 	m_levelOnePage->setColourTableRemap(newMap);
-	m_pageRender.decodePage();
-	m_pageRender.renderPage();
+	m_pageDecode.decodePage();
 	update();
 }
 
 void TeletextWidget::setBlackBackgroundSubst(bool substOn)
 {
 	m_levelOnePage->setBlackBackgroundSubst(substOn);
-	m_pageRender.decodePage();
-	m_pageRender.renderPage();
+	m_pageDecode.decodePage();
 	update();
 }
 
@@ -227,18 +230,18 @@ void TeletextWidget::setSidePanelWidths(int newLeftSidePanelColumns, int newRigh
 		m_levelOnePage->setSidePanelColumns((newLeftSidePanelColumns == 16) ? 0 : newLeftSidePanelColumns);
 	else
 		m_levelOnePage->setSidePanelColumns((newRightSidePanelColumns == 0) ? 0 : 16-newRightSidePanelColumns);
-	m_pageRender.updateSidePanels();
+	m_pageDecode.updateSidePanels();
 }
 
 void TeletextWidget::setSidePanelAtL35Only(bool newSidePanelAtL35Only)
 {
 	m_levelOnePage->setSidePanelStatusL25(!newSidePanelAtL35Only);
-	m_pageRender.updateSidePanels();
+	m_pageDecode.updateSidePanels();
 }
 
 void TeletextWidget::changeSize()
 {
-	setFixedSize(QSize(480+(pageRender()->leftSidePanelColumns()+pageRender()->rightSidePanelColumns())*12, 250));
+	setFixedSize(QSize(480+(pageDecode()->leftSidePanelColumns()+pageDecode()->rightSidePanelColumns())*12, 250));
 	emit sizeChanged();
 }
 
@@ -247,14 +250,14 @@ 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_pageRender.level1CharSet(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn())].value(event->text().at(0), *qPrintable(event->text()));
-		if (mappedKeyPress < 0x20)
+		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_pageRender.level1MosaicAttribute(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn()) && (mappedKeyPress < 0x40 || mappedKeyPress > 0x5f)) {
+		if (m_pageDecode.level1MosaicAttribute(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_1 && event->key() <= Qt::Key_9 && event->modifiers() & Qt::KeypadModifier) {
 				switch (event->key()) {
@@ -354,32 +357,27 @@ void TeletextWidget::keyPressEvent(QKeyEvent *event)
 			break;
 
 		case Qt::Key_Up:
-			m_teletextDocument->cursorUp();
-			update();
+			m_teletextDocument->cursorUp(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Down:
-			m_teletextDocument->cursorDown();
-			update();
+			m_teletextDocument->cursorDown(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Left:
-			m_teletextDocument->cursorLeft();
-			update();
+			m_teletextDocument->cursorLeft(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Right:
-			m_teletextDocument->cursorRight();
-			update();
+			m_teletextDocument->cursorRight(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Return:
 		case Qt::Key_Enter:
 			m_teletextDocument->cursorDown();
-			// fall through
-		case Qt::Key_Home:
 			m_teletextDocument->moveCursor(m_teletextDocument->cursorRow(), 0);
-			update();
+			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);
-			update();
+			m_teletextDocument->moveCursor(m_teletextDocument->cursorRow(), 39, event->modifiers() & Qt::ShiftModifier);
 			break;
 
 		case Qt::Key_PageUp:
@@ -388,9 +386,9 @@ void TeletextWidget::keyPressEvent(QKeyEvent *event)
 		case Qt::Key_PageDown:
 			m_teletextDocument->selectSubPagePrevious();
 			break;
-		case Qt::Key_F5:
-			m_pageRender.decodePage();
-			m_pageRender.renderPage();
+		case Qt::Key_F6:
+			m_pageDecode.decodePage();
+			m_pageRender.renderPage(true);
 			update();
 			break;
 		default:
@@ -405,14 +403,68 @@ void TeletextWidget::setCharacter(unsigned char newCharacter)
 
 void TeletextWidget::toggleCharacterBit(unsigned char bitToToggle)
 {
-	QUndoCommand *toggleMosaicBitCommand = new ToggleMosaicBitCommand(m_teletextDocument, bitToToggle);
-	m_teletextDocument->undoStack()->push(toggleMosaicBitCommand);
+	m_teletextDocument->undoStack()->push(new ToggleMosaicBitCommand(m_teletextDocument, bitToToggle));
+}
+
+void TeletextWidget::selectionToClipboard()
+{
+	QByteArray nativeData;
+	QString plainTextData;
+	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), m_teletextDocument->currentSubPage()->character(r, c)));
+			else
+				plainTextData.append(' ');
+		}
+
+		plainTextData.append('\n');
+	}
+
+	QMimeData *mimeData = new QMimeData();
+	mimeData->setData("application/x-teletext", nativeData);
+	mimeData->setText(plainTextData);
+	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_pageRender.leftSidePanelColumns();
+	int column = mousePosition.x() / 12 - m_pageDecode.leftSidePanelColumns();
 	if (row < 1)
 		row = 1;
 	if (row > 24)
@@ -438,25 +490,12 @@ void TeletextWidget::mouseMoveEvent(QMouseEvent *event)
 {
 	if (event->buttons() & Qt::LeftButton) {
 		QPair<int, int> position = mouseToRowAndColumn(event->pos());
-		if (m_selectionInProgress || position.first != m_teletextDocument->cursorRow() || position.second != m_teletextDocument->cursorColumn()) {
-			int topRow, bottomRow, leftColumn, rightColumn;
-
+		if (position.first != m_teletextDocument->cursorRow() || position.second != m_teletextDocument->cursorColumn()) {
+			if (!m_selectionInProgress) {
 				m_selectionInProgress = true;
-			if (m_teletextDocument->cursorRow() < position.first) {
-				topRow = m_teletextDocument->cursorRow();
-				bottomRow = position.first;
-			} else {
-				topRow = position.first;
-				bottomRow = m_teletextDocument->cursorRow();
+				m_teletextDocument->setSelectionCorner(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn());
 			}
-			if (m_teletextDocument->cursorColumn() < position.second) {
-				leftColumn = m_teletextDocument->cursorColumn();
-				rightColumn = position.second;
-			} else {
-				leftColumn = position.second;
-				rightColumn = m_teletextDocument->cursorColumn();
-			}
-			m_teletextDocument->setSelection(topRow, leftColumn, bottomRow, rightColumn);
+			m_teletextDocument->moveCursor(position.first, position.second, true);
 		}
 	}
 }
@@ -480,7 +519,12 @@ void TeletextWidget::focusOutEvent(QFocusEvent *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)));
@@ -490,6 +534,7 @@ LevelOneScene::LevelOneScene(QWidget *levelOneWidget, QObject *parent) : QGraphi
 	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);
@@ -501,16 +546,59 @@ LevelOneScene::LevelOneScene(QWidget *levelOneWidget, QObject *parent) : QGraphi
 		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::setDimensions(int sceneWidth, int sceneHeight, int widgetWidth)
+void LevelOneScene::setBorderDimensions(int sceneWidth, int sceneHeight, int widgetWidth, int leftSidePanelColumns, int rightSidePanelColumns)
 {
 	setSceneRect(0, 0, sceneWidth, sceneHeight);
 
-	// Assume widget height is always 250
+	// 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
@@ -518,23 +606,152 @@ void LevelOneScene::setDimensions(int sceneWidth, int sceneHeight, int widgetWid
 
 	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_mainGridItemGroup->setVisible(false);
+		m_cursorRectItem->setVisible(false);
+		m_selectionRectItem->setVisible(false);
+		for (int i=0; i<32; i++)
+			if (m_sidePanelGridNeeded[i])
+				m_sidePanelGridItemGroup[i]->setVisible(false);
+	} else {
+		if (static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->selectionActive())
+			m_selectionRectItem->setVisible(true);
+
+		m_cursorRectItem->setVisible(true);
+		toggleGrid(m_grid);
+	}
+}
+
+// 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)
 {
-	m_fullScreenTopRectItem->setBrush(QBrush(newColor));
-	m_fullScreenBottomRectItem->setBrush(QBrush(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)
 {
-	m_fullRowLeftRectItem[row]->setBrush(QBrush(newColor));
-	m_fullRowRightRectItem[row]->setBrush(QBrush(newColor));
+	if (!static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageRender()->mix()) {
+		m_fullRowLeftRectItem[row]->setBrush(newColor);
+		m_fullRowRightRectItem[row]->setBrush(newColor);
+	}
 }

mainwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -22,12 +22,14 @@
 
 #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"
@@ -45,12 +47,14 @@ public:
 	void toggleCharacterBit(unsigned char);
 	bool insertMode() const { return m_insertMode; };
 	void setInsertMode(bool);
+	bool showControlCodes() const { return m_pageRender.showControlCodes(); };
 
-	QSize sizeHint() { return QSize(480+(pageRender()->leftSidePanelColumns()+pageRender()->rightSidePanelColumns())*12, 250); }
+	QSize sizeHint() { return QSize(480+(pageDecode()->leftSidePanelColumns()+pageDecode()->rightSidePanelColumns())*12, 250); }
 
 	void inputMethodEvent(QInputMethodEvent *);
 
 	TeletextDocument* document() const { return m_teletextDocument; }
+	TeletextPageDecode *pageDecode() { return &m_pageDecode; }
 	TeletextPageRender *pageRender() { return &m_pageRender; }
 
 signals:
@@ -60,10 +64,11 @@ signals:
 public slots:
 	void subPageSelected();
 	void refreshPage();
-	void toggleReveal(bool);
-	void toggleMix(bool);
-	void toggleGrid(bool);
+	void setReveal(bool);
+	void setMix(bool);
+	void setShowControlCodes(bool);
 	void updateFlashTimer(int);
+	void pauseFlash(bool);
 	void refreshRow(int);
 
 	void setControlBit(int, bool);
@@ -75,6 +80,11 @@ public slots:
 	void setBlackBackgroundSubst(bool);
 	void setSidePanelWidths(int, int);
 	void setSidePanelAtL35Only(bool);
+
+	void cut();
+	void copy();
+	void paste();
+
 	void changeSize();
 
 protected:
@@ -86,18 +96,18 @@ protected:
 	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_grid, m_selectionInProgress;
+	bool m_insertMode, m_selectionInProgress;
 	QBasicTimer m_flashTimer;
 	int m_flashTiming, m_flashPhase;
 
 	void timerEvent(QTimerEvent *event) override;
-
-	void calculateDimensions();
+	void selectionToClipboard();
 
 	QPair<int, int> mouseToRowAndColumn(const QPoint &);
 };
@@ -108,16 +118,34 @@ class LevelOneScene : public QGraphicsScene
 
 public:
 	LevelOneScene(QWidget *, QObject *parent = nullptr);
-	void setDimensions(int, int, int);
+	void setBorderDimensions(int, int, int, int, int);
+	QGraphicsRectItem *cursorRectItem() const { return m_cursorRectItem; }
 
 public slots:
+	void updateCursor();
+	void updateSelection();
+	void setMix(bool);
+	void toggleGrid(bool);
+	void hideGUIElements(bool);
 	void setFullScreenColour(const QColor &);
 	void setFullRowColour(int, const QColor &);
 
+signals:
+	void mouseZoomIn();
+	void mouseZoomOut();
+
+protected:
+	bool eventFilter(QObject *, QEvent *);
+	void keyPressEvent(QKeyEvent *);
+	void keyReleaseEvent(QKeyEvent *);
+
 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

mainwindow.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -20,11 +20,14 @@
 #include <QApplication>
 #include <QDesktopServices>
 #include <QFileDialog>
+#include <QImage>
 #include <QList>
 #include <QMenuBar>
 #include <QMessageBox>
+#include <QPainter>
 #include <QPushButton>
 #include <QRadioButton>
+#include <QRegExp>
 #include <QSaveFile>
 #include <QScreen>
 #include <QSettings>
@@ -39,6 +42,7 @@
 #include "levelonecommands.h"
 #include "loadsave.h"
 #include "mainwidget.h"
+#include "pagecomposelinksdockwidget.h"
 #include "pageenhancementsdockwidget.h"
 #include "pageoptionsdockwidget.h"
 #include "palettedockwidget.h"
@@ -106,20 +110,127 @@ void MainWindow::openFile(const QString &fileName)
 	other->show();
 }
 
+static inline bool hasTTISuffix(const QString &filename)
+{
+	return filename.endsWith(".tti", Qt::CaseInsensitive) || filename.endsWith(".ttix", Qt::CaseInsensitive);
+}
+
+static inline void changeSuffixFromTTI(QString &filename, const QString &newSuffix)
+{
+	if (filename.endsWith(".tti", Qt::CaseInsensitive)) {
+		filename.chop(4);
+		filename.append("." + newSuffix);
+	} else if (filename.endsWith(".ttix", Qt::CaseInsensitive)) {
+		filename.chop(5);
+		filename.append("." + newSuffix);
+	}
+}
+
 bool MainWindow::save()
 {
-	return m_isUntitled ? saveAs() : saveFile(m_curFile);
+	// If imported from non-.tti, force "Save As" so we don't clobber the original imported file
+	return m_isUntitled || !hasTTISuffix(m_curFile) ? saveAs() : saveFile(m_curFile);
 }
 
 bool MainWindow::saveAs()
 {
-	QString fileName = QFileDialog::getSaveFileName(this, tr("Save As"), m_curFile);
+	QString suggestedName = m_curFile;
+
+	// If imported from non-.tti, change extension so we don't clobber the original imported file
+	if (suggestedName.endsWith(".t42", Qt::CaseInsensitive)) {
+		suggestedName.chop(4);
+		suggestedName.append(".tti");
+	}
+
+	QString fileName = QFileDialog::getSaveFileName(this, tr("Save As"), suggestedName, "TTI teletext page (*.tti *.ttix)");
 	if (fileName.isEmpty())
 		return false;
 
 	return saveFile(fileName);
 }
 
+void MainWindow::reload()
+{
+	if (m_isUntitled)
+		return;
+
+	if (!m_textWidget->document()->undoStack()->isClean()) {
+		const QMessageBox::StandardButton ret = QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("The document \"%1\" has been modified.\nDo you want to discard your changes?").arg(QFileInfo(m_curFile).fileName()), QMessageBox::Discard | QMessageBox::Cancel);
+
+		if (ret != QMessageBox::Discard)
+			return;
+	} else {
+		const QMessageBox::StandardButton ret = QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Do you want to reload the document \"%1\" from disk?").arg(QFileInfo(m_curFile).fileName()), QMessageBox::Yes | QMessageBox::No);
+
+		if (ret != QMessageBox::Yes)
+			return;
+	}
+
+	int subPageIndex = m_textWidget->document()->currentSubPageIndex();
+
+	m_textWidget->document()->clear();
+	loadFile(m_curFile);
+
+	if (subPageIndex >= m_textWidget->document()->numberOfSubPages())
+		subPageIndex = m_textWidget->document()->numberOfSubPages()-1;
+
+	m_textWidget->document()->selectSubPageIndex(subPageIndex, true);
+}
+
+void MainWindow::exportPNG()
+{
+	QString exportFileName = QFileDialog::getSaveFileName(this, tr("Export PNG"), QString(), "PNG image (*.png)");
+	if (exportFileName.isEmpty())
+		return;
+
+	// Prepare widget image for extraction
+	m_textWidget->pauseFlash(true);
+	m_textScene->hideGUIElements(true);
+	bool reshowControlCodes = m_textWidget->showControlCodes();
+	if (reshowControlCodes)
+		m_textWidget->setShowControlCodes(false);
+	// Disable exporting in Mix mode as it corrupts the background
+	bool reMix = m_textWidget->pageRender()->mix();
+	if (reMix) {
+		m_textWidget->setMix(false);
+		m_textScene->setMix(false);
+	}
+
+	// Extract the image from the scene
+	QImage interImage = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
+//	This ought to make the background transparent in Mix mode, but it doesn't
+//	if (m_textWidget->pageDecode()->mix())
+//		interImage.fill(QColor(0, 0, 0, 0));
+	QPainter interPainter(&interImage);
+	m_textScene->render(&interPainter);
+
+	// Now we've extracted the image we can put the GUI things back
+	m_textScene->hideGUIElements(false);
+	if (reshowControlCodes)
+		m_textWidget->setShowControlCodes(true);
+	if (reMix) {
+		m_textWidget->setMix(true);
+		m_textScene->setMix(true);
+	}
+	m_textWidget->pauseFlash(false);
+
+	// Now scale the extracted image to the selected aspect ratio
+	// We do this in two steps so that anti-aliasing only occurs on vertical lines
+
+	// Double the vertical height first
+	const QImage doubleHeightImage = interImage.scaled(interImage.width(), interImage.height()*2, Qt::IgnoreAspectRatio, Qt::FastTransformation);
+
+	// If aspect ratio is Pixel 1:2 we're already at the correct scale
+	if (m_viewAspectRatio != 3) {
+		// Scale it horizontally to the selected aspect ratio
+		const QImage scaledImage = doubleHeightImage.scaled((int)((float)doubleHeightImage.width() * aspectRatioHorizontalScaling[m_viewAspectRatio] * 2), doubleHeightImage.height(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+
+		if (!scaledImage.save(exportFileName, "PNG"))
+			QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export file %1.").arg(QDir::toNativeSeparators(exportFileName)));
+	} else if (!doubleHeightImage.save(exportFileName, "PNG"))
+		QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export file %1.").arg(QDir::toNativeSeparators(exportFileName)));
+}
+
 void MainWindow::exportZXNet()
 {
 	QDesktopServices::openUrl(QUrl("http://zxnet.co.uk/teletext/editor/" + exportHashStringPage(m_textWidget->document()->currentSubPage()) + exportHashStringPackets(m_textWidget->document()->currentSubPage())));
@@ -132,12 +243,12 @@ void MainWindow::exportEditTF()
 
 void MainWindow::about()
 {
-	QMessageBox::about(this, tr("About QTeletextMaker"), tr("<b>QTeletextMaker</b><br>"
+	QMessageBox::about(this, tr("About"), QString("<b>%1</b><br>"
 	"An open source Level 2.5 teletext page editor.<br>"
-	"<i>Version 0.1-alpha</i><br><br>"
-	"Copyright (C) 2020, 2021 Gavin MacGregor<br><br>"
+	"<i>Version %2</i><br><br>"
+	"Copyright (C) 2020-2022 Gavin MacGregor<br><br>"
 	"Released under the GNU General Public License version 3<br>"
-	"<a href=\"https://github.com/gkthemac/qteletextmaker\">https://github.com/gkthemac/qteletextmaker</a>"));
+	"<a href=\"https://github.com/gkthemac/qteletextmaker\">https://github.com/gkthemac/qteletextmaker</a>").arg(QApplication::applicationDisplayName()).arg(QApplication::applicationVersion()));
 }
 
 void MainWindow::init()
@@ -156,36 +267,45 @@ void MainWindow::init()
 	addDockWidget(Qt::RightDockWidgetArea, m_x26DockWidget);
 	m_paletteDockWidget = new PaletteDockWidget(m_textWidget);
 	addDockWidget(Qt::RightDockWidgetArea, m_paletteDockWidget);
+	m_pageComposeLinksDockWidget = new PageComposeLinksDockWidget(m_textWidget);
+	addDockWidget(Qt::RightDockWidgetArea, m_pageComposeLinksDockWidget);
+
+	m_textScene = new LevelOneScene(m_textWidget, this);
 
 	createActions();
 	createStatusBar();
 
 	readSettings();
 
-	m_textScene = new LevelOneScene(m_textWidget, this);
-
 	m_textView = new QGraphicsView(this);
 	m_textView->setScene(m_textScene);
+	if (m_viewSmoothTransform)
 		m_textView->setRenderHints(QPainter::SmoothPixmapTransform);
 	m_textView->setBackgroundBrush(QBrush(QColor(32, 48, 96)));
 	setSceneDimensions();
 	setCentralWidget(m_textView);
 
 	connect(m_textWidget->document(), &TeletextDocument::cursorMoved, this, &MainWindow::updateCursorPosition);
+	connect(m_textWidget->document(), &TeletextDocument::selectionMoved, m_textScene, &LevelOneScene::updateSelection);
 	connect(m_textWidget->document()->undoStack(), &QUndoStack::cleanChanged, this, [=]() { setWindowModified(!m_textWidget->document()->undoStack()->isClean()); } );
 	connect(m_textWidget->document(), &TeletextDocument::aboutToChangeSubPage, m_x26DockWidget, &X26DockWidget::unloadX26List);
 	connect(m_textWidget->document(), &TeletextDocument::subPageSelected, this, &MainWindow::updatePageWidgets);
 	connect(m_textWidget, &TeletextWidget::sizeChanged, this, &MainWindow::setSceneDimensions);
-	connect(m_textWidget->pageRender(), &TeletextPageRender::fullScreenColourChanged, m_textScene, &LevelOneScene::setFullScreenColour);
-	connect(m_textWidget->pageRender(), &TeletextPageRender::fullRowColourChanged, m_textScene, &LevelOneScene::setFullRowColour);
+	connect(m_textWidget->pageDecode(), &TeletextPageDecode::fullScreenColourChanged, m_textScene, &LevelOneScene::setFullScreenColour);
+	connect(m_textWidget->pageDecode(), &TeletextPageDecode::fullRowColourChanged, m_textScene, &LevelOneScene::setFullRowColour);
 	connect(m_textWidget, &TeletextWidget::insertKeyPressed, this, &MainWindow::toggleInsertMode);
 
+	connect(m_textScene, &LevelOneScene::mouseZoomIn, this, &MainWindow::zoomIn);
+	connect(m_textScene, &LevelOneScene::mouseZoomOut, this, &MainWindow::zoomOut);
+
 	QShortcut *blockShortCut = new QShortcut(QKeySequence(Qt::Key_Escape, Qt::Key_J), m_textView);
 	connect(blockShortCut, &QShortcut::activated, [=]() { m_textWidget->setCharacter(0x7f); });
 
 	setUnifiedTitleAndToolBarOnMac(true);
 
 	updatePageWidgets();
+
+	m_textView->setFocus();
 }
 
 void MainWindow::tile(const QMainWindow *previous)
@@ -236,6 +356,11 @@ void MainWindow::createActions()
 	saveAsAct->setShortcuts(QKeySequence::SaveAs);
 	saveAsAct->setStatusTip(tr("Save the document under a new name"));
 
+	const QIcon reloadIcon = QIcon::fromTheme("document-revert");
+	QAction *reloadAct = fileMenu->addAction(reloadIcon, tr("Reload"), this, &MainWindow::reload);
+	reloadAct->setShortcuts(QKeySequence::Refresh);
+	reloadAct->setStatusTip(tr("Reload the document from disk"));
+
 	fileMenu->addSeparator();
 
 	QMenu *recentMenu = fileMenu->addMenu(tr("Recent"));
@@ -251,16 +376,28 @@ void MainWindow::createActions()
 
 	setRecentFilesVisible(MainWindow::hasRecentFiles());
 
-	QMenu *exportHashStringSubMenu = fileMenu->addMenu(tr("Export to online editor"));
+	QAction *exportT42Act = fileMenu->addAction(tr("Export subpage as t42..."));
+	exportT42Act->setStatusTip("Export this subpage as a t42 file");
+	connect(exportT42Act, &QAction::triggered, this, &MainWindow::exportT42);
+
+	QMenu *exportHashStringSubMenu = fileMenu->addMenu(tr("Export subpage to online editor"));
 
 	QAction *exportZXNetAct = exportHashStringSubMenu->addAction(tr("Open in zxnet.co.uk"));
-	exportZXNetAct->setStatusTip("Export and open page in zxnet.co.uk online editor");
+	exportZXNetAct->setStatusTip("Export and open this subpage in the zxnet.co.uk online editor");
 	connect(exportZXNetAct, &QAction::triggered, this, &MainWindow::exportZXNet);
 
 	QAction *exportEditTFAct = exportHashStringSubMenu->addAction(tr("Open in edit.tf"));
-	exportEditTFAct->setStatusTip("Export and open page in edit.tf online editor");
+	exportEditTFAct->setStatusTip("Export and open this subpage in the edit.tf online editor");
 	connect(exportEditTFAct, &QAction::triggered, this, &MainWindow::exportEditTF);
 
+	QAction *exportPNGAct = fileMenu->addAction(tr("Export subpage as PNG..."));
+	exportPNGAct->setStatusTip("Export a PNG image of this subpage");
+	connect(exportPNGAct, &QAction::triggered, this, &MainWindow::exportPNG);
+
+	QAction *exportM29Act = fileMenu->addAction(tr("Export subpage X/28 as M/29..."));
+	exportM29Act->setStatusTip("Export this subpage's X/28 packets as a tti file with M/29 packets");
+	connect(exportM29Act, &QAction::triggered, this, &MainWindow::exportM29);
+
 	fileMenu->addSeparator();
 
 	QAction *closeAct = fileMenu->addAction(tr("&Close"), this, &QWidget::close);
@@ -291,36 +428,33 @@ void MainWindow::createActions()
 	redoAction->setShortcuts(QKeySequence::Redo);
 
 	editMenu->addSeparator();
+
 #ifndef QT_NO_CLIPBOARD
-/*	const QIcon cutIcon = QIcon::fromTheme("edit-cut", QIcon(":/images/cut.png"));
+	const QIcon cutIcon = QIcon::fromTheme("edit-cut", QIcon(":/images/cut.png"));
 	QAction *cutAct = new QAction(cutIcon, tr("Cu&t"), this);
 	cutAct->setShortcuts(QKeySequence::Cut);
-	cutAct->setStatusTip(tr("Cut the current selection's contents to the "
-                            "clipboard"));
-	connect(cutAct, &QAction::triggered, textWidget, &QTextEdit::cut);
+	cutAct->setStatusTip(tr("Cut the current selection's contents to the clipboard"));
+	connect(cutAct, &QAction::triggered, m_textWidget, &TeletextWidget::cut);
 	editMenu->addAction(cutAct);
 	editToolBar->addAction(cutAct);
 
 	const QIcon copyIcon = QIcon::fromTheme("edit-copy", QIcon(":/images/copy.png"));
 	QAction *copyAct = new QAction(copyIcon, tr("&Copy"), this);
 	copyAct->setShortcuts(QKeySequence::Copy);
-	copyAct->setStatusTip(tr("Copy the current selection's contents to the "
-                             "clipboard"));
-	connect(copyAct, &QAction::triggered, textWidget, &QTextEdit::copy);
+	copyAct->setStatusTip(tr("Copy the current selection's contents to the clipboard"));
+	connect(copyAct, &QAction::triggered, m_textWidget, &TeletextWidget::copy);
 	editMenu->addAction(copyAct);
 	editToolBar->addAction(copyAct);
 
 	const QIcon pasteIcon = QIcon::fromTheme("edit-paste", QIcon(":/images/paste.png"));
 	QAction *pasteAct = new QAction(pasteIcon, tr("&Paste"), this);
 	pasteAct->setShortcuts(QKeySequence::Paste);
-	pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current "
-                              "selection"));
-	connect(pasteAct, &QAction::triggered, textWidget, &QTextEdit::paste);
+	pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current selection"));
+	connect(pasteAct, &QAction::triggered, m_textWidget, &TeletextWidget::paste);
 	editMenu->addAction(pasteAct);
 	editToolBar->addAction(pasteAct);
 
 	editMenu->addSeparator();
-*/
 #endif // !QT_NO_CLIPBOARD
 
 	QAction *insertBlankRowAct = editMenu->addAction(tr("Insert blank row"));
@@ -362,25 +496,26 @@ void MainWindow::createActions()
 	revealAct->setCheckable(true);
 	revealAct->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_R));
 	revealAct->setStatusTip(tr("Toggle reveal"));
-	connect(revealAct, &QAction::toggled, m_textWidget, &TeletextWidget::toggleReveal);
+	connect(revealAct, &QAction::toggled, m_textWidget, &TeletextWidget::setReveal);
 
 	QAction *mixAct = viewMenu->addAction(tr("&Mix"));
 	mixAct->setCheckable(true);
 	mixAct->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
 	mixAct->setStatusTip(tr("Toggle mix"));
-	connect(mixAct, &QAction::toggled, m_textWidget, &TeletextWidget::toggleMix);
+	connect(mixAct, &QAction::toggled, m_textWidget, &TeletextWidget::setMix);
+	connect(mixAct, &QAction::toggled, m_textScene, &LevelOneScene::setMix);
 
 	QAction *gridAct = viewMenu->addAction(tr("&Grid"));
 	gridAct->setCheckable(true);
 	gridAct->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_G));
 	gridAct->setStatusTip(tr("Toggle the text grid"));
-	connect(gridAct, &QAction::toggled, m_textWidget, &TeletextWidget::toggleGrid);
+	connect(gridAct, &QAction::toggled, m_textScene, &LevelOneScene::toggleGrid);
 
-	QAction *showCodesAct = viewMenu->addAction(tr("Show codes"));
-	showCodesAct->setCheckable(true);
-	showCodesAct->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_T));
-	showCodesAct->setStatusTip(tr("Toggle showing of control codes"));
-	connect(showCodesAct, &QAction::toggled, m_textWidget->pageRender(), &TeletextPageRender::setShowCodes);
+	QAction *showControlCodesAct = viewMenu->addAction(tr("Show control codes"));
+	showControlCodesAct->setCheckable(true);
+	showControlCodesAct->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_T));
+	showControlCodesAct->setStatusTip(tr("Toggle showing of control codes"));
+	connect(showControlCodesAct, &QAction::toggled, m_textWidget, &TeletextWidget::setShowControlCodes);
 
 	viewMenu->addSeparator();
 
@@ -415,6 +550,13 @@ void MainWindow::createActions()
 		borderGroup->addAction(m_borderActs[i]);
 	}
 
+	viewMenu->addSeparator();
+
+	m_smoothTransformAction = viewMenu->addAction(tr("Smooth font scaling"));
+	m_smoothTransformAction->setCheckable(true);
+	m_smoothTransformAction->setStatusTip(tr("Toggle smooth font scaling"));
+	connect(m_smoothTransformAction, &QAction::toggled, this, &MainWindow::setSmoothTransform);
+
 	QAction *zoomInAct = viewMenu->addAction(tr("Zoom In"));
 	zoomInAct->setShortcuts(QKeySequence::ZoomIn);
 	zoomInAct->setStatusTip(tr("Zoom in"));
@@ -532,6 +674,7 @@ void MainWindow::createActions()
 	toolsMenu->addAction(m_x26DockWidget->toggleViewAction());
 	toolsMenu->addAction(m_pageEnhancementsDockWidget->toggleViewAction());
 	toolsMenu->addAction(m_paletteDockWidget->toggleViewAction());
+	toolsMenu->addAction(m_pageComposeLinksDockWidget->toggleViewAction());
 
 	//FIXME is this main menubar separator to put help menu towards the right?
 	menuBar()->addSeparator();
@@ -552,7 +695,6 @@ void MainWindow::createActions()
 
 void MainWindow::setSceneDimensions()
 {
-	const float aspectRatioHorizontalScaling[4] = { 0.6, 0.6, 0.8, 0.5 };
 	const int topBottomBorders[3] = { 0, 10, 19 };
 	const int pillarBoxSizes[3] = { 672, 720, 854 };
 	const int leftRightBorders[3] = { 0, 24, 77 };
@@ -568,7 +710,7 @@ void MainWindow::setSceneDimensions()
 	else
 		newSceneWidth = m_textWidget->width() + leftRightBorders[m_viewBorder]*2;
 
-	m_textScene->setDimensions(newSceneWidth, 250+topBottomBorders[m_viewBorder]*2, m_textWidget->width());
+	m_textScene->setBorderDimensions(newSceneWidth, 250+topBottomBorders[m_viewBorder]*2, m_textWidget->width(), m_textWidget->pageDecode()->leftSidePanelColumns(), m_textWidget->pageDecode()->rightSidePanelColumns());
 	m_textView->setTransform(QTransform((1+(float)m_viewZoom/2)*aspectRatioHorizontalScaling[m_viewAspectRatio], 0, 0, 1+(float)m_viewZoom/2, 0, 0));
 }
 
@@ -576,20 +718,17 @@ void MainWindow::insertRow(bool copyRow)
 {
 	if (m_textWidget->document()->cursorRow() == 24)
 		return;
-	QUndoCommand *insertRowCommand = new InsertRowCommand(m_textWidget->document(), copyRow);
-	m_textWidget->document()->undoStack()->push(insertRowCommand);
+	m_textWidget->document()->undoStack()->push(new InsertRowCommand(m_textWidget->document(), copyRow));
 }
 
 void MainWindow::deleteRow()
 {
-	QUndoCommand *deleteRowCommand = new DeleteRowCommand(m_textWidget->document());
-	m_textWidget->document()->undoStack()->push(deleteRowCommand);
+	m_textWidget->document()->undoStack()->push(new DeleteRowCommand(m_textWidget->document()));
 }
 
 void MainWindow::insertSubPage(bool afterCurrentSubPage, bool copyCurrentSubPage)
 {
-	QUndoCommand *insertSubPageCommand = new InsertSubPageCommand(m_textWidget->document(), afterCurrentSubPage, copyCurrentSubPage);
-	m_textWidget->document()->undoStack()->push(insertSubPageCommand);
+	m_textWidget->document()->undoStack()->push(new InsertSubPageCommand(m_textWidget->document(), afterCurrentSubPage, copyCurrentSubPage));
 }
 
 void MainWindow::deleteSubPage()
@@ -612,16 +751,29 @@ void MainWindow::setAspectRatio(int newViewAspectRatio)
 	setSceneDimensions();
 }
 
+void MainWindow::setSmoothTransform(bool smoothTransform)
+{
+	m_viewSmoothTransform = smoothTransform;
+	if (smoothTransform)
+		m_textView->setRenderHints(QPainter::SmoothPixmapTransform);
+	else
+		m_textView->setRenderHints({ });
+}
+
 void MainWindow::zoomIn()
 {
 	if (m_viewZoom < 4)
 		m_viewZoom++;
+	else if (m_viewZoom < 12)
+		m_viewZoom += 2;
 	setSceneDimensions();
 }
 
 void MainWindow::zoomOut()
 {
-	if (m_viewZoom > 0)
+	if (m_viewZoom > 4)
+		m_viewZoom -= 2;
+	else if (m_viewZoom > 0)
 		m_viewZoom--;
 	setSceneDimensions();
 }
@@ -643,30 +795,27 @@ void MainWindow::toggleInsertMode()
 
 void MainWindow::createStatusBar()
 {
-	QLabel *subPageLabel = new QLabel("Subpage");
-	statusBar()->insertWidget(0, subPageLabel);
-
 	m_previousSubPageButton = new QToolButton;
-	m_previousSubPageButton->setMinimumSize(subPageLabel->height(), subPageLabel->height());
-	m_previousSubPageButton->setMaximumSize(subPageLabel->height(), subPageLabel->height());
 	m_previousSubPageButton->setAutoRaise(true);
 	m_previousSubPageButton->setArrowType(Qt::LeftArrow);
-	statusBar()->insertWidget(1, m_previousSubPageButton);
+	statusBar()->insertWidget(0, m_previousSubPageButton);
 	connect(m_previousSubPageButton, &QToolButton::clicked, m_textWidget->document(), &TeletextDocument::selectSubPagePrevious);
 
 	m_subPageLabel = new QLabel("1/1");
-	statusBar()->insertWidget(2, m_subPageLabel);
+	statusBar()->insertWidget(1, m_subPageLabel);
 
 	m_nextSubPageButton = new QToolButton;
-	m_nextSubPageButton->setMinimumSize(subPageLabel->height(), subPageLabel->height());
-	m_nextSubPageButton->setMaximumSize(subPageLabel->height(), subPageLabel->height());
+	m_previousSubPageButton->setMinimumSize(m_subPageLabel->height(), m_subPageLabel->height());
+	m_previousSubPageButton->setMaximumSize(m_subPageLabel->height(), m_subPageLabel->height());
+	m_nextSubPageButton->setMinimumSize(m_subPageLabel->height(), m_subPageLabel->height());
+	m_nextSubPageButton->setMaximumSize(m_subPageLabel->height(), m_subPageLabel->height());
 	m_nextSubPageButton->setAutoRaise(true);
 	m_nextSubPageButton->setArrowType(Qt::RightArrow);
-	statusBar()->insertWidget(3, m_nextSubPageButton);
+	statusBar()->insertWidget(2, m_nextSubPageButton);
 	connect(m_nextSubPageButton, &QToolButton::clicked, m_textWidget->document(), &TeletextDocument::selectSubPageNext);
 
-	m_cursorPositionLabel = new QLabel("Row 1 Column 1");
-	statusBar()->insertWidget(4, m_cursorPositionLabel);
+	m_cursorPositionLabel = new QLabel("1, 1");
+	statusBar()->insertWidget(3, m_cursorPositionLabel);
 
 	m_insertModePushButton = new QPushButton("OVERWRITE");
 	m_insertModePushButton->setFlat(true);
@@ -685,10 +834,10 @@ void MainWindow::createStatusBar()
 		statusBar()->addPermanentWidget(m_levelRadioButton[i]);
 	}
 	m_levelRadioButton[0]->toggle();
-	connect(m_levelRadioButton[0], &QAbstractButton::clicked, [=]() { m_textWidget->pageRender()->setRenderLevel(0); m_textWidget->update(); });
-	connect(m_levelRadioButton[1], &QAbstractButton::clicked, [=]() { m_textWidget->pageRender()->setRenderLevel(1); m_textWidget->update(); });
-	connect(m_levelRadioButton[2], &QAbstractButton::clicked, [=]() { m_textWidget->pageRender()->setRenderLevel(2); m_textWidget->update(); });
-	connect(m_levelRadioButton[3], &QAbstractButton::clicked, [=]() { m_textWidget->pageRender()->setRenderLevel(3); m_textWidget->update(); });
+	connect(m_levelRadioButton[0], &QAbstractButton::clicked, [=]() { m_textWidget->pageDecode()->setLevel(0); m_textWidget->update(); });
+	connect(m_levelRadioButton[1], &QAbstractButton::clicked, [=]() { m_textWidget->pageDecode()->setLevel(1); m_textWidget->update(); });
+	connect(m_levelRadioButton[2], &QAbstractButton::clicked, [=]() { m_textWidget->pageDecode()->setLevel(2); m_textWidget->update(); });
+	connect(m_levelRadioButton[3], &QAbstractButton::clicked, [=]() { m_textWidget->pageDecode()->setLevel(3); m_textWidget->update(); });
 	statusBar()->showMessage(tr("Ready"));
 }
 
@@ -705,8 +854,12 @@ void MainWindow::readSettings()
 	m_viewAspectRatio = settings.value("aspectratio", 0).toInt();
 	m_viewAspectRatio = (m_viewAspectRatio < 0 || m_viewAspectRatio > 2) ? 0 : m_viewAspectRatio;
 	m_aspectRatioActs[m_viewAspectRatio]->setChecked(true);
+	m_viewSmoothTransform = settings.value("smoothTransform", 0).toBool();
+	m_smoothTransformAction->blockSignals(true);
+	m_smoothTransformAction->setChecked(m_viewSmoothTransform);
+	m_smoothTransformAction->blockSignals(false);
 	m_viewZoom = settings.value("zoom", 2).toInt();
-	m_viewZoom = (m_viewZoom < 0 || m_viewZoom > 4) ? 2 : m_viewZoom;
+	m_viewZoom = (m_viewZoom < 0 || m_viewZoom > 12) ? 2 : m_viewZoom;
 
 	// zoom 0 = 420,426px, 1 = 620,570px, 2 = 780,720px
 	if (geometry.isEmpty()) {
@@ -732,6 +885,8 @@ void MainWindow::readSettings()
 		m_x26DockWidget->setFloating(true);
 		m_paletteDockWidget->hide();
 		m_paletteDockWidget->setFloating(true);
+		m_pageComposeLinksDockWidget->hide();
+		m_pageComposeLinksDockWidget->setFloating(true);
 	} else
 		restoreState(windowState);
 }
@@ -743,6 +898,7 @@ void MainWindow::writeSettings()
 	settings.setValue("windowState", saveState());
 	settings.setValue("border", m_viewBorder);
 	settings.setValue("aspectratio", m_viewAspectRatio);
+	settings.setValue("smoothTransform", m_viewSmoothTransform);
 	settings.setValue("zoom", m_viewZoom);
 }
 
@@ -750,7 +906,7 @@ bool MainWindow::maybeSave()
 {
 	if (m_textWidget->document()->undoStack()->isClean())
 		return true;
-	const QMessageBox::StandardButton ret = QMessageBox::warning(this, tr("QTeletextMaker"), tr("The document has been modified.\nDo you want to save your changes?"), QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
+	const QMessageBox::StandardButton ret = QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("The document \"%1\" has been modified.\nDo you want to save your changes or discard them?").arg(QFileInfo(m_curFile).fileName()), QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
 	switch (ret) {
 		case QMessageBox::Save:
 			return save();
@@ -767,17 +923,30 @@ void MainWindow::loadFile(const QString &fileName)
 	int levelSeen;
 
 	QFile file(fileName);
-	if (!file.open(QFile::ReadOnly | QFile::Text)) {
-		QMessageBox::warning(this, tr("QTeletextMaker"), tr("Cannot read file %1:\n%2.").arg(QDir::toNativeSeparators(fileName), file.errorString()));
+	const QFileInfo fileInfo(file);
+	QIODevice::OpenMode fileOpenMode;
+
+	if (fileInfo.suffix() == "t42")
+		fileOpenMode = QFile::ReadOnly;
+	else
+		fileOpenMode = QFile::ReadOnly | QFile::Text;
+
+	if (!file.open(fileOpenMode)) {
+		QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot read file %1:\n%2.").arg(QDir::toNativeSeparators(fileName), file.errorString()));
 		setCurrentFile(QString());
 		return;
 	}
 
 	QApplication::setOverrideCursor(Qt::WaitCursor);
+
+	if (fileInfo.suffix() == "t42")
+		importT42(&file, m_textWidget->document());
+	else
 		loadTTI(&file, m_textWidget->document());
+
 	levelSeen = m_textWidget->document()->levelRequired();
 	m_levelRadioButton[levelSeen]->toggle();
-	m_textWidget->pageRender()->setRenderLevel(levelSeen);
+	m_textWidget->pageDecode()->setLevel(levelSeen);
 	updatePageWidgets();
 
 	QApplication::restoreOverrideCursor();
@@ -872,13 +1041,13 @@ bool MainWindow::saveFile(const QString &fileName)
 	if (file.open(QFile::WriteOnly | QFile::Text)) {
 		saveTTI(file, *m_textWidget->document());
 		if (!file.commit())
-			errorMessage = tr("Cannot write file %1:\n%2.") .arg(QDir::toNativeSeparators(fileName), file.errorString());
+			errorMessage = tr("Cannot write file %1:\n%2.").arg(QDir::toNativeSeparators(fileName), file.errorString());
 	} else
 		errorMessage = tr("Cannot open file %1 for writing:\n%2.").arg(QDir::toNativeSeparators(fileName), file.errorString());
 	QApplication::restoreOverrideCursor();
 
 	if (!errorMessage.isEmpty()) {
-		QMessageBox::warning(this, tr("QTeletextMaker"), errorMessage);
+		QMessageBox::warning(this, QApplication::applicationDisplayName(), errorMessage);
 		return false;
 	}
 
@@ -887,6 +1056,82 @@ bool MainWindow::saveFile(const QString &fileName)
 	return true;
 }
 
+void MainWindow::exportT42()
+{
+	QString errorMessage;
+	QString exportFileName = m_curFile;
+
+	changeSuffixFromTTI(exportFileName, "t42");
+
+	exportFileName = QFileDialog::getSaveFileName(this, tr("Export t42"), exportFileName, "t42 stream (*.t42)");
+	if (exportFileName.isEmpty())
+		return;
+
+	QApplication::setOverrideCursor(Qt::WaitCursor);
+	QSaveFile file(exportFileName);
+	if (file.open(QFile::WriteOnly)) {
+		exportT42File(file, *m_textWidget->document());
+		if (!file.commit())
+			errorMessage = tr("Cannot write file %1:\n%2.").arg(QDir::toNativeSeparators(exportFileName), file.errorString());
+	} else
+		errorMessage = tr("Cannot open file %1 for writing:\n%2.").arg(QDir::toNativeSeparators(exportFileName), file.errorString());
+	QApplication::restoreOverrideCursor();
+
+	if (!errorMessage.isEmpty())
+		QMessageBox::warning(this, QApplication::applicationDisplayName(), errorMessage);
+}
+
+void MainWindow::exportM29()
+{
+	QString errorMessage;
+	QString exportFileName = m_curFile;
+
+	if (m_isUntitled || !QFileInfo(m_curFile).exists())
+		exportFileName = QString("P%1FF.tti").arg(m_textWidget->document()->pageNumber() >> 8, 1, 16);
+	else {
+		exportFileName = QFileInfo(m_curFile).fileName();
+		// Suggest a new filename to avoid clobbering the original file
+		if (QRegExp(("^[Pp]?[1-8][0-9A-Fa-f][0-9A-Fa-f]")).indexIn(exportFileName) != -1) {
+			// Page number forms start of file name, change it to xFF
+			if (exportFileName.at(0) == 'P' || exportFileName.at(0) == 'p') {
+				exportFileName[2] = 'F';
+				exportFileName[3] = 'F';
+			} else {
+				exportFileName[1] = 'F';
+				exportFileName[2] = 'F';
+			}
+		// No page number at start of file name. Try to insert "-m29" while preserving .tti(x) suffix
+		} else if (exportFileName.endsWith(".tti", Qt::CaseInsensitive)) {
+			exportFileName.chop(4);
+			exportFileName.append("-m29.tti");
+		} else if (exportFileName.endsWith(".ttix", Qt::CaseInsensitive)) {
+			exportFileName.chop(5);
+			exportFileName.append("-m29.ttix");
+		} else
+			// Shouldn't get here, bit of a messy escape but still better than clobbering the original file
+			exportFileName.append("-m29.tti");
+
+		exportFileName = QDir(QFileInfo(m_curFile).absoluteDir()).filePath(exportFileName);
+	}
+
+	exportFileName = QFileDialog::getSaveFileName(this, tr("Export M/29 tti"), exportFileName, "TTI teletext page (*.tti *.ttix)");
+	if (exportFileName.isEmpty())
+		return;
+
+	QApplication::setOverrideCursor(Qt::WaitCursor);
+	QSaveFile file(exportFileName);
+	if (file.open(QFile::WriteOnly | QFile::Text)) {
+		exportM29File(file, *m_textWidget->document());
+		if (!file.commit())
+			errorMessage = tr("Cannot write file %1:\n%2.").arg(QDir::toNativeSeparators(exportFileName), file.errorString());
+	} else
+		errorMessage = tr("Cannot open file %1 for writing:\n%2.").arg(QDir::toNativeSeparators(exportFileName), file.errorString());
+	QApplication::restoreOverrideCursor();
+
+	if (!errorMessage.isEmpty())
+		QMessageBox::warning(this, QApplication::applicationDisplayName(), errorMessage);
+}
+
 void MainWindow::setCurrentFile(const QString &fileName)
 {
 	static int sequenceNumber = 1;
@@ -925,7 +1170,22 @@ MainWindow *MainWindow::findMainWindow(const QString &fileName) const
 
 void MainWindow::updateCursorPosition()
 {
-	m_cursorPositionLabel->setText(QString("Row %1 Column %2").arg(m_textWidget->document()->cursorRow()).arg(m_textWidget->document()->cursorColumn()));
+	QString result;
+	result.reserve(19);
+
+	if (m_textWidget->document()->cursorRow() == 0)
+		result = QString("Header, %1").arg(m_textWidget->document()->cursorColumn());
+	else if (m_textWidget->document()->cursorRow() == 24)
+		result = QString("FLOF, %1").arg(m_textWidget->document()->cursorColumn());
+	else
+		result = QString("%1, %2").arg(m_textWidget->document()->cursorRow()).arg(m_textWidget->document()->cursorColumn());
+
+	if (m_textWidget->document()->selectionActive())
+		result.append(QString(" (%1, %2)").arg(m_textWidget->document()->selectionHeight()).arg(m_textWidget->document()->selectionWidth()));
+
+	m_cursorPositionLabel->setText(result);
+	m_textScene->updateCursor();
+	m_textView->ensureVisible(m_textScene->cursorRectItem(), 16, 24);
 }
 
 void MainWindow::updatePageWidgets()
@@ -933,9 +1193,11 @@ void MainWindow::updatePageWidgets()
 	m_subPageLabel->setText(QString("%1/%2").arg(m_textWidget->document()->currentSubPageIndex()+1).arg(m_textWidget->document()->numberOfSubPages()));
 	m_previousSubPageButton->setEnabled(!(m_textWidget->document()->currentSubPageIndex() == 0));
 	m_nextSubPageButton->setEnabled(!(m_textWidget->document()->currentSubPageIndex() == (m_textWidget->document()->numberOfSubPages()) - 1));
+	updateCursorPosition();
 	m_deleteSubPageAction->setEnabled(m_textWidget->document()->numberOfSubPages() > 1);
 	m_pageOptionsDockWidget->updateWidgets();
 	m_pageEnhancementsDockWidget->updateWidgets();
 	m_x26DockWidget->loadX26List();
 	m_paletteDockWidget->updateAllColourButtons();
+	m_pageComposeLinksDockWidget->updateWidgets();
 }

mainwindow.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -31,6 +31,7 @@
 #include <QToolButton>
 
 #include "mainwidget.h"
+#include "pagecomposelinksdockwidget.h"
 #include "pageenhancementsdockwidget.h"
 #include "pageoptionsdockwidget.h"
 #include "palettedockwidget.h"
@@ -58,8 +59,12 @@ private slots:
 	void open();
 	bool save();
 	bool saveAs();
+	void reload();
+	void exportT42();
 	void exportZXNet();
 	void exportEditTF();
+	void exportPNG();
+	void exportM29();
 	void updateRecentFileActions();
 	void openRecentFile();
 	void about();
@@ -74,6 +79,7 @@ private slots:
 	void setSceneDimensions();
 	void setBorder(int);
 	void setAspectRatio(int);
+	void setSmoothTransform(bool);
 	void zoomIn();
 	void zoomOut();
 	void zoomReset();
@@ -82,6 +88,7 @@ private slots:
 
 private:
 	enum { m_MaxRecentFiles = 10 };
+	const float aspectRatioHorizontalScaling[4] = { 0.6, 0.6, 0.8, 0.5 };
 
 	void init();
 	void createActions();
@@ -104,10 +111,12 @@ private:
 	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;
@@ -115,6 +124,7 @@ private:
 	QAction *m_deleteSubPageAction;
 	QAction *m_borderActs[3];
 	QAction *m_aspectRatioActs[4];
+	QAction *m_smoothTransformAction;
 
 	QLabel *m_subPageLabel, *m_cursorPositionLabel;
 	QToolButton *m_previousSubPageButton, *m_nextSubPageButton;

pagebase.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *

pagebase.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -37,8 +37,8 @@ public:
 
 	virtual QByteArray packet(int) const;
 	virtual QByteArray packet(int, int) const;
-	virtual bool packetNeeded(int i) const { return m_displayPackets[i] != nullptr; }
-	virtual bool packetNeeded(int i, int j) const { return m_designationPackets[i-26][j] != nullptr; }
+	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, QByteArray);
 	virtual bool setPacket(int, int, QByteArray);
 //	bool deletePacket(int);

pagecomposelinksdockwidget.cpp

@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2020-2022 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 <QRegExpValidator>
+#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 QRegExpValidator(QRegExp("[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(','), QString::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);
+	}
+}

pagecomposelinksdockwidget.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2020-2022 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 <QRegExpValidator>
+#include <QString>
+
+#include "mainwidget.h"
+
+class PageComposeLinksDockWidget : public QDockWidget
+{
+	Q_OBJECT
+
+public:
+	PageComposeLinksDockWidget(TeletextWidget *parent);
+	void updateWidgets();
+
+private:
+	void setComposeLinkPageNumber(int, const QString &);
+	void setComposeLinkSubPageNumbers(int, const QString &);
+
+	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];
+
+	QRegExpValidator *m_pageNumberValidator;
+};
+
+#endif

pageenhancementsdockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -22,11 +22,7 @@
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QLabel>
-#include <QLineEdit>
-#include <QMap>
-#include <QPair>
 #include <QSpinBox>
-#include <QString>
 
 #include "pageenhancementsdockwidget.h"
 
@@ -38,28 +34,26 @@ PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent):
 	m_parentMainWidget = parent;
 
 	this->setObjectName("PageEnhancementsDockWidget");
-	this->setWindowTitle("Page enhancements");
+	this->setWindowTitle("X/28 page enhancements");
 
-	QGroupBox *x28GroupBox = new QGroupBox(tr("X/28 enhancements"));
-	QGridLayout *x28Layout = new QGridLayout;
+	// Colour group box and layout
+	QGroupBox *colourGroupBox = new QGroupBox(tr("Colours"));
+	QGridLayout *colourLayout = new QGridLayout;
 
 	// Default screen and default row colours
-	x28Layout->addWidget(new QLabel(tr("Default screen colour")), 0, 0, 1, 1);
-	x28Layout->addWidget(new QLabel(tr("Default row colour")), 1, 0, 1, 1);
+	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;
-	for (int r=0; r<=3; r++)
-		for (int c=0; c<=7; c++) {
-			m_defaultScreenColourCombo->addItem(tr("CLUT %1:%2").arg(r).arg(c));
-			m_defaultRowColourCombo->addItem(tr("CLUT %1:%2").arg(r).arg(c));
-		}
-	x28Layout->addWidget(m_defaultScreenColourCombo, 0, 1, 1, 1, Qt::AlignTop);
+	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->setDefaultScreenColour(index); });
-	x28Layout->addWidget(m_defaultRowColourCombo, 1, 1, 1, 1, Qt::AlignTop);
+	colourLayout->addWidget(m_defaultRowColourCombo, 1, 1, 1, 1, Qt::AlignTop);
 	connect(m_defaultRowColourCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->setDefaultRowColour(index); });
 
 	// CLUT remapping
-	x28Layout->addWidget(new QLabel(tr("CLUT remapping")), 2, 0, 1, 1);
+	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");
@@ -69,89 +63,44 @@ PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent):
 	m_colourTableCombo->addItem("Fore 2  Back 1");
 	m_colourTableCombo->addItem("Fore 2  Back 2");
 	m_colourTableCombo->addItem("Fore 2  Back 3");
-	x28Layout->addWidget(m_colourTableCombo, 2, 1, 1, 1, Qt::AlignTop);
+	colourLayout->addWidget(m_colourTableCombo, 2, 1, 1, 1, Qt::AlignTop);
 	connect(m_colourTableCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->setColourTableRemap(index); });
 
 	// Black background colour substitution
 	m_blackBackgroundSubstAct = new QCheckBox("Black background colour substitution");
-	x28Layout->addWidget(m_blackBackgroundSubstAct, 3, 0, 1, 2, Qt::AlignTop);
+	colourLayout->addWidget(m_blackBackgroundSubstAct, 3, 0, 1, 2, Qt::AlignTop);
 	connect(m_blackBackgroundSubstAct, &QCheckBox::stateChanged, m_parentMainWidget, &TeletextWidget::setBlackBackgroundSubst);
 
+	// 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
-	x28Layout->addWidget(new QLabel(tr("Left side panel columns")), 4, 0, 1, 1);
+	sidePanelsLayout->addWidget(new QLabel(tr("Left side panel columns")), 0, 0, 1, 1);
 	m_leftSidePanelSpinBox = new QSpinBox(this);
 	m_leftSidePanelSpinBox->setMaximum(16);
-	x28Layout->addWidget(m_leftSidePanelSpinBox, 4, 1, 1, 1, Qt::AlignTop);
+	sidePanelsLayout->addWidget(m_leftSidePanelSpinBox, 0, 1, 1, 1, Qt::AlignTop);
 	connect(m_leftSidePanelSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [=](int index){ setLeftSidePanelWidth(index); });
 
-	x28Layout->addWidget(new QLabel(tr("Right side panel columns")), 5, 0, 1, 1);
+	sidePanelsLayout->addWidget(new QLabel(tr("Right side panel columns")), 1, 0, 1, 1);
 	m_rightSidePanelSpinBox = new QSpinBox(this);
 	m_rightSidePanelSpinBox->setMaximum(16);
-	x28Layout->addWidget(m_rightSidePanelSpinBox, 5, 1, 1, 1, Qt::AlignTop);
+	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");
-	x28Layout->addWidget(m_sidePanelStatusAct, 6, 0, 1, 2, Qt::AlignTop);
+	sidePanelsLayout->addWidget(m_sidePanelStatusAct, 2, 0, 1, 2, Qt::AlignTop);
 	connect(m_sidePanelStatusAct, &QCheckBox::stateChanged, m_parentMainWidget, &TeletextWidget::setSidePanelAtL35Only);
 
-	x28GroupBox->setLayout(x28Layout);
-	pageEnhancementsLayout->addWidget(x28GroupBox);
-
-	QGroupBox *x27GroupBox = new QGroupBox(tr("X/27 links - Level 2.5 and 3.5"));
-	QGridLayout *x27Layout = new QGridLayout;
-
-	// Link functions
-	x27Layout->addWidget(new QLabel(tr("GPOP")),  1, 0, 1, 1);
-	x27Layout->addWidget(new QLabel(tr("POP")),   2, 0, 1, 1);
-	x27Layout->addWidget(new QLabel(tr("GDRCS")), 3, 0, 1, 1);
-	x27Layout->addWidget(new QLabel(tr("DRCS")),  4, 0, 1, 1);
-
-	// Labels across the top
-	x27Layout->addWidget(new QLabel(tr("L2.5")), 0, 1, 1, 1);
-	x27Layout->addWidget(new QLabel(tr("L3.5")),  0, 2, 1, 1);
-	x27Layout->addWidget(new QLabel(tr("Page no")), 0, 3, 1, 1);
-	x27Layout->addWidget(new QLabel(tr("Sub pages required")), 0, 4, 1, 1);
-
-	QLabel *level3p5OnlyLabel = new QLabel(tr("Level 3.5 only"));
-	level3p5OnlyLabel->setAlignment(Qt::AlignCenter);
-	x27Layout->addWidget(level3p5OnlyLabel, 5, 0, 1, 5);
-
-	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+1, 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+1, 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+2, 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");
-		// TODO restrict first digit of page number to 1-8
-		x27Layout->addWidget(m_composeLinkPageNumberLineEdit[i], i+(i<4 ? 1 : 2), 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 ? 1 : 2), 4, 1, 1);
-		connect(m_composeLinkSubPageNumbersLineEdit[i], &QLineEdit::textEdited, [=](QString value) { setComposeLinkSubPageNumbers(i, value); } );
-	}
-
-	x27GroupBox->setLayout(x27Layout);
-	pageEnhancementsLayout->addWidget(x27GroupBox);
+	// Add group box to the main layout
+	sidePanelsGroupBox->setLayout(sidePanelsLayout);
+	pageEnhancementsLayout->addWidget(sidePanelsGroupBox);
 
 	pageEnhancementsLayout->addStretch(1);
 
@@ -181,60 +130,6 @@ void PageEnhancementsDockWidget::setRightSidePanelWidth(int newRightPanelSize)
 	m_parentMainWidget->setSidePanelWidths(m_leftSidePanelSpinBox->value(), newRightPanelSize);
 }
 
-void PageEnhancementsDockWidget::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 PageEnhancementsDockWidget::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(','), QString::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 PageEnhancementsDockWidget::updateWidgets()
 {
 	int leftSidePanelColumnsResult = 0;
@@ -268,64 +163,4 @@ void PageEnhancementsDockWidget::updateWidgets()
 	m_sidePanelStatusAct->blockSignals(true);
 	m_sidePanelStatusAct->setChecked(!m_parentMainWidget->document()->currentSubPage()->sidePanelStatusL25());
 	m_sidePanelStatusAct->blockSignals(false);
-
-	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);
-	}
 }

pageenhancementsdockwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -23,9 +23,7 @@
 #include <QCheckBox>
 #include <QComboBox>
 #include <QDockWidget>
-#include <QLineEdit>
 #include <QSpinBox>
-#include <QString>
 
 #include "mainwidget.h"
 
@@ -40,17 +38,11 @@ public:
 private:
 	void setLeftSidePanelWidth(int);
 	void setRightSidePanelWidth(int);
-	void setComposeLinkPageNumber(int, const QString &);
-	void setComposeLinkSubPageNumbers(int, const QString &);
 
 	TeletextWidget *m_parentMainWidget;
 	QComboBox *m_defaultScreenColourCombo, *m_defaultRowColourCombo, *m_colourTableCombo;
 	QCheckBox *m_blackBackgroundSubstAct, *m_sidePanelStatusAct;
 	QSpinBox *m_leftSidePanelSpinBox, *m_rightSidePanelSpinBox;
-
-	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];
 };
 
 #endif

pageoptionsdockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -24,6 +24,7 @@
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
+#include <QRegExpValidator>
 #include <QSpinBox>
 #include <QVBoxLayout>
 
@@ -40,14 +41,16 @@ PageOptionsDockWidget::PageOptionsDockWidget(TeletextWidget *parent): QDockWidge
 	this->setWindowTitle("Page options");
 
 	// Page number
+	m_pageNumberValidator = new QRegExpValidator(QRegExp("[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");
-	//TODO restrict first digit of page number to 1-8
+	m_pageNumberEdit->setInputMask(">DHH");
+	m_pageNumberEdit->setValidator(m_pageNumberValidator);
 	pageNumberLayout->addWidget(m_pageNumberEdit);
-	connect(m_pageNumberEdit, &QLineEdit::textEdited, m_parentMainWidget->document(), &TeletextDocument::setPageNumber);
+	connect(m_pageNumberEdit, &QLineEdit::textEdited, m_parentMainWidget->document(), &TeletextDocument::setPageNumberFromString);
 
 	pageOptionsLayout->addLayout(pageNumberLayout);
 
@@ -66,8 +69,8 @@ PageOptionsDockWidget::PageOptionsDockWidget(TeletextWidget *parent): QDockWidge
 		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");
-		//TODO restrict first digit of page number to 1-8
+		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); } );
 	}

pageoptionsdockwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -24,6 +24,7 @@
 #include <QComboBox>
 #include <QDockWidget>
 #include <QLineEdit>
+#include <QRegExpValidator>
 #include <QSpinBox>
 
 #include "mainwidget.h"
@@ -45,6 +46,8 @@ private:
 	QComboBox *m_defaultRegionCombo, *m_defaultNOSCombo, *m_secondRegionCombo, *m_secondNOSCombo;
 	QLineEdit *m_fastTextEdit[6];
 
+	QRegExpValidator *m_pageNumberValidator;
+
 	void addRegionList(QComboBox *);
 	void setFastTextLinkPageNumber(int, const QString &);
 	void setDefaultRegion();

pagex26base.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -74,7 +74,7 @@ void PageX26Base::setEnhancementListFromPacket(int packetNumber, QByteArray pack
 		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[enhanceListPointer] = newX26Triplet;
+		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

pagex26base.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -31,14 +31,15 @@ class PageX26Base : public PageBase //: public QObject
 	//Q_OBJECT
 
 public:
-	QList<X26Triplet> *enhancements() { return &m_enhancements; };
+	X26TripletList *enhancements() { return &m_enhancements; };
+	virtual int maxEnhancements() const =0;
 
 protected:
 	QByteArray packetFromEnhancementList(int) const;
 	void setEnhancementListFromPacket(int, QByteArray);
 	bool packetFromEnhancementListNeeded(int n) const { return ((m_enhancements.size()+12) / 13) > n; };
 
-	QList<X26Triplet> m_enhancements;
+	X26TripletList m_enhancements;
 	const X26Triplet m_paddingX26Triplet { 41, 0x1e, 0 };
 };
 

palettedockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -108,14 +108,11 @@ void PaletteDockWidget::selectColour(int colourIndex)
 {
     const QColor newColour = QColorDialog::getColor(m_parentMainWidget->document()->currentSubPage()->CLUTtoQColor(colourIndex), this, "Select Colour");
 
-	if (newColour.isValid()) {
-		QUndoCommand *setColourCommand = new SetColourCommand(m_parentMainWidget->document(), colourIndex, ((newColour.red() & 0xf0) << 4) | (newColour.green() & 0xf0) | ((newColour.blue() & 0xf0) >> 4));
-		m_parentMainWidget->document()->undoStack()->push(setColourCommand);
-	}
+	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)
 {
-	QUndoCommand *resetCLUTCommand = new ResetCLUTCommand(m_parentMainWidget->document(), colourTable);
-	m_parentMainWidget->document()->undoStack()->push(resetCLUTCommand);
+	m_parentMainWidget->document()->undoStack()->push(new ResetCLUTCommand(m_parentMainWidget->document(), colourTable));
 }

palettedockwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *

qteletextmaker.pro

@@ -1,7 +1,9 @@
 QT += widgets
 requires(qtConfig(filedialog))
 
-HEADERS       = document.h \
+HEADERS       = decode.h \
+                document.h \
+                hamming.h \
                 keymap.h \
                 levelonecommands.h \
                 levelonepage.h \
@@ -10,6 +12,7 @@ HEADERS       = document.h \
                 mainwindow.h \
                 pagebase.h \
                 pagex26base.h \
+                pagecomposelinksdockwidget.h \
                 pageenhancementsdockwidget.h \
                 pageoptionsdockwidget.h \
                 palettedockwidget.h \
@@ -18,7 +21,8 @@ HEADERS       = document.h \
                 x26dockwidget.h \
                 x26model.h \
                 x26triplets.h
-SOURCES       = document.cpp \
+SOURCES       = decode.cpp \
+                document.cpp \
                 levelonecommands.cpp \
                 levelonepage.cpp \
                 loadsave.cpp \
@@ -27,6 +31,7 @@ SOURCES       = document.cpp \
                 mainwindow.cpp \
                 pagebase.cpp \
                 pagex26base.cpp \
+                pagecomposelinksdockwidget.cpp \
                 pageenhancementsdockwidget.cpp \
                 pageoptionsdockwidget.cpp \
                 palettedockwidget.cpp \

render.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -21,158 +21,22 @@
 #define RENDER_H
 
 #include <QBitmap>
-#include <QMap>
-#include <QMultiMap>
-#include <QPair>
-#include <vector>
+#include <QSet>
+#include <QPixmap>
 
-#include "levelonepage.h"
+#include "decode.h"
 
-
-struct textCharacter {
-	unsigned char code=0x20;
-	int set=0;
-	int diacritical=0;
-};
-
-struct displayAttributes {
-	bool doubleHeight=false;
-	bool doubleWidth=false;
-	bool boxingWindow=false;
-	bool conceal=false;
-	bool invert=false;
-	bool underlineSeparated=false;
-	bool forceContiguous=false;
-};
-
-struct textAttributes {
-	int foreColour=0x07;
-	int backColour=0x00;
-	struct flashFunctions {
-		int mode=0;
-		int ratePhase=0;
-		int phaseNumber=0;
-	} flash;
-	displayAttributes display;
-	/* font style */
-};
-
-struct textCell {
-	textCharacter character;
-	textAttributes attribute;
-	bool bottomHalf=false;
-	bool rightHalf=false;
-	bool level1Mosaic=false;
-	int level1CharSet=0;
-};
-
-struct applyAttributes {
-	bool applyForeColour=false;
-	bool applyBackColour=false;
-	bool applyFlash=false;
-	bool applyDisplayAttributes=false;
-	bool applyTextSizeOnly=false;
-	bool applyBoxingOnly=false;
-	bool applyConcealOnly=false;
-	bool applyContiguousOnly=false;
-	bool copyAboveAttributes=false;
-	textAttributes attribute;
-};
-
-class ActivePosition
+class TeletextFontBitmap
 {
 public:
-	ActivePosition();
-	int row() const { return (m_row == -1) ? 0 : m_row; }
-	int column() const { return (m_column == -1) ? 0 : m_column; }
-	bool isDeployed() const { return m_row != -1; }
-	bool setRow(int);
-	bool setColumn(int);
-//	bool setRowAndColumn(int, int);
+	TeletextFontBitmap();
+	~TeletextFontBitmap();
+
+	QBitmap *rawBitmap() const { return s_fontBitmap; }
 
 private:
-	int m_row, m_column;
-};
-
-
-class TextLayer
-{
-public:
-//	TextLayer(TeletextPage* thePage) : currentPage(thePage) { };
-	virtual ~TextLayer() = default;
-	void setTeletextPage(LevelOnePage *);
-	virtual textCharacter character(int, int) =0;
-	virtual void attributes(int, int, applyAttributes *) =0;
-	virtual int fullScreenColour() const =0;
-	virtual int fullRowColour(int) const =0;
-	virtual bool fullRowDownwards(int) const =0;
-	virtual int objectType() const =0;
-	void setFullScreenColour(int);
-	void setFullRowColour(int, int, bool);
-
-	// Key QPair is row and column, value QPair is triplet mode and data
-	QMultiMap<QPair<int, int>, QPair<int, int>> enhanceMap;
-
-protected:
-	LevelOnePage* m_levelOnePage;
-	int m_layerFullScreenColour=-1;
-	int m_layerFullRowColour[25];
-	bool m_layerFullRowDownwards[25];
-	applyAttributes m_applyAttributes;
-};
-
-class EnhanceLayer: public TextLayer
-{
-public:
-	EnhanceLayer();
-	textCharacter character(int, int);
-	void attributes(int, int, applyAttributes *);
-	int fullScreenColour() const { return m_layerFullScreenColour; };
-	int fullRowColour(int r) const { return m_layerFullRowColour[r]; };
-	bool fullRowDownwards(int r) const { return m_layerFullRowDownwards[r]; };
-	int objectType() const { return m_objectType; };
-	void setObjectType(int);
-	void setOrigin(int, int);
-
-protected:
-	int m_objectType=0;
-	int m_originR=0;
-	int m_originC=0;
-	int m_rowCached=-1;
-	int m_rightMostColumn[25];
-};
-
-class Level1Layer: public TextLayer
-{
-public:
-//	Level1Layer(TeletextPage *thePage) : TextLayer(thePage) { };
-	Level1Layer();
-	textCharacter character(int, int);
-	void attributes(int, int, applyAttributes *);
-	int fullScreenColour() const { return -1; };
-	int fullRowColour(int) const { return -1; };
-	bool fullRowDownwards(int) const { return false; };
-	int objectType() const { return 0; }
-	bool isRowBottomHalf(int r) const { return m_rowHeight[r]==RHbottomhalf; }
-
-private:
-	void updateRowCache(int);
-
-	struct level1CacheAttributes {
-		int foreColour=0x07;
-		int backColour=0x00;
-		unsigned char sizeCode=0x0c;
-		bool mosaics=false;
-		bool separated=false;
-		bool held=false;
-		bool escSwitch=false;
-		unsigned char holdChar=0x20;
-		bool holdSeparated=false;
-	};
-	level1CacheAttributes m_attributeCache[40];
-	int m_rowCached=-1;
-	bool m_rowHasDoubleHeightAttr[25];
-	enum rowHeightEnum { RHnormal=-1, RHtophalf, RHbottomhalf } m_rowHeight[25];
+	static int s_instances;
+	static QBitmap* s_fontBitmap;
 };
 
 class TeletextPageRender : public QObject
@@ -182,66 +46,37 @@ class TeletextPageRender : public QObject
 public:
 	TeletextPageRender();
 	~TeletextPageRender();
-	void decodePage();
-	void renderPage();
-	void renderPage(int r);
-	void setTeletextPage(LevelOnePage *);
-	void updateSidePanels();
-	void buildEnhanceMap(TextLayer *, int=0);
+
 	QPixmap* pagePixmap(int i) const { return m_pagePixmap[i]; };
-	bool level1MosaicAttribute(int r, int c) const { return m_cell[r][c].level1Mosaic; };
-	int level1CharSet(int r, int c) const { return m_cell[r][c].level1CharSet; };
-	int leftSidePanelColumns() const { return m_leftSidePanelColumns; };
-	int rightSidePanelColumns() const { return m_rightSidePanelColumns; };
-	void setGrid(bool);
+	bool mix() const { return m_mix; };
+	void setDecoder(TeletextPageDecode *);
+	void renderPage(bool force=false);
+	bool showControlCodes() const { return m_showControlCodes; };
 
 public slots:
+	void colourChanged(int);
 	void setReveal(bool);
 	void setMix(bool);
-	void setShowCodes(bool);
-	void setRenderLevel(int);
+	void setShowControlCodes(bool);
 
 signals:
-	void fullScreenColourChanged(QColor);
-	void fullRowColourChanged(int, QColor);
 	void flashChanged(int);
-	void sidePanelsChanged();
 
 protected:
-	void updateFlashRequired(int);
-	inline void setFullScreenColour(int);
-	inline void setFullRowColour(int, int);
-
-	QBitmap* m_fontBitmap;
+	TeletextFontBitmap m_fontBitmap;
 	QPixmap* m_pagePixmap[6];
-	int m_finalFullScreenColour, m_renderLevel;
-	QColor m_finalFullScreenQColor;
-	int m_leftSidePanelColumns, m_rightSidePanelColumns;
-	bool m_reveal, m_mix, m_grid, m_showCodes;
-	Level1Layer m_level1Layer;
-	std::vector<TextLayer *> m_textLayer;
-	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 };
+	unsigned char m_controlCodeCache[25][40];
+	bool m_reveal, m_mix, m_showControlCodes;
+	QSet<QPair<int, int>> m_flash1HzCells;
+	QSet<QPair<int, int>> m_flash2HzCells;
+	int m_flashBuffersHz;
 
 private:
-	textCell m_cell[25][72];
-	LevelOnePage* m_levelOnePage;
-	int m_flashRequired;
-	int m_fullRowColour[25];
-	QColor m_fullRowQColor[25];
-	int m_flashRow[25];
-	bool m_concealRow[25];
-};
+	inline void drawFromFontBitmap(QPainter &, int, int, unsigned char, int, TeletextPageDecode::CharacterFragment);
+	inline void drawCharacter(QPainter &, int, int, unsigned char, int, int, TeletextPageDecode::CharacterFragment);
+	void updateFlashBuffers();
 
-static const QMap<int, int> g0CharacterMap {
-	{ 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 }
+	TeletextPageDecode *m_decoder;
 };
 
 #endif

x26commands.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -50,17 +50,30 @@ void InsertTripletCommand::redo()
 	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_x26Model->endInsertRows();
+	else
 		m_teletextDocument->emit refreshNeeded();
-	}
 
 	if (m_firstDo)
 		m_firstDo = false;
-	else
-		m_teletextDocument->emit tripletCommandHighlight(m_row+1);
+
+	m_teletextDocument->emit tripletCommandHighlight(m_row);
 }
 
 void InsertTripletCommand::undo()
@@ -76,12 +89,25 @@ void InsertTripletCommand::undo()
 	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_x26Model->endRemoveRows();
+	else
 		m_teletextDocument->emit refreshNeeded();
-	}
 }
 
 
@@ -101,15 +127,35 @@ DeleteTripletCommand::DeleteTripletCommand(TeletextDocument *teletextDocument, X
 
 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 refreshNeeded();
 }
 
 void DeleteTripletCommand::undo()
@@ -125,12 +171,25 @@ void DeleteTripletCommand::undo()
 	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_x26Model->endInsertRows();
+	else
 		m_teletextDocument->emit refreshNeeded();
-	}
 
 	m_teletextDocument->emit tripletCommandHighlight(m_row);
 }
@@ -164,7 +223,7 @@ void EditTripletCommand::redo()
 	if (m_teletextDocument->currentSubPageIndex() != m_subPageIndex)
 		m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
 
-	m_teletextDocument->currentSubPage()->enhancements()->operator[](m_row) = m_newTriplet;
+	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 refreshNeeded();
 
@@ -179,7 +238,7 @@ void EditTripletCommand::undo()
 	if (m_teletextDocument->currentSubPageIndex() != m_subPageIndex)
 		m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
 
-	m_teletextDocument->currentSubPage()->enhancements()->operator[](m_row) = m_oldTriplet;
+	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 refreshNeeded();
 	m_teletextDocument->emit tripletCommandHighlight(m_row);

x26commands.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *

x26dockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -17,6 +17,7 @@
  * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+#include <QAbstractListModel>
 #include <QActionGroup>
 #include <QButtonGroup>
 #include <QCheckBox>
@@ -34,8 +35,42 @@
 #include <QToolButton>
 #include <QVBoxLayout>
 
+#include "render.h"
 #include "x26dockwidget.h"
 
+CharacterListModel::CharacterListModel(QObject *parent): QAbstractListModel(parent)
+{
+	m_characterSet = 0;
+}
+
+int CharacterListModel::rowCount(const QModelIndex & /*parent*/) const
+{
+	return 96;
+}
+
+QVariant CharacterListModel::data(const QModelIndex &index, int role) const
+{
+	if (!index.isValid())
+		return QVariant();
+
+	if (role == Qt::DisplayRole)
+		return QString("0x%1").arg(index.row()+0x20, 2, 16);
+
+	if (role == Qt::DecorationRole)
+		return m_fontBitmap.rawBitmap()->copy(index.row()*12, m_characterSet*10, 12, 10);
+
+	return QVariant();
+}
+
+void CharacterListModel::setCharacterSet(int characterSet)
+{
+	if (characterSet != m_characterSet) {
+		m_characterSet = characterSet;
+		emit dataChanged(createIndex(0, 0), createIndex(95, 0), QVector<int>(Qt::DecorationRole));
+	}
+}
+
+
 X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 {
 	QVBoxLayout *x26Layout = new QVBoxLayout;
@@ -70,16 +105,6 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	// "Cooked" or user-friendly triplet type, row and column selection
 	QHBoxLayout *cookedTripletLayout = new QHBoxLayout;
 
-	m_cookedModeTypeComboBox = new QComboBox;
-	m_cookedModeTypeComboBox->addItem("Set Active Position");
-	m_cookedModeTypeComboBox->addItem("Row triplet");
-	m_cookedModeTypeComboBox->addItem("Column triplet");
-	m_cookedModeTypeComboBox->addItem("Object");
-	m_cookedModeTypeComboBox->addItem("Terminator");
-	m_cookedModeTypeComboBox->addItem("PDC/reserved");
-	cookedTripletLayout->addWidget(m_cookedModeTypeComboBox);
-	connect(m_cookedModeTypeComboBox, QOverload<int>::of(&QComboBox::activated), this, &X26DockWidget::updateCookedModeFromCookedType);
-
 	// Cooked row spinbox
 	QLabel *rowLabel = new QLabel(tr("Row"));
 	rowLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
@@ -102,10 +127,101 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	connect(m_cookedColumnSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), this, &X26DockWidget::cookedColumnSpinBoxChanged);
 
 	// Cooked triplet mode
-	m_cookedModeComboBox = new QComboBox;
-	m_cookedModeComboBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
-	cookedTripletLayout->addWidget(m_cookedModeComboBox);
-	connect(m_cookedModeComboBox, QOverload<int>::of(&QComboBox::activated), this, &X26DockWidget::cookedModeComboBoxChanged);
+	QLabel *modeLabel = new QLabel(tr("Mode"));
+	modeLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
+	cookedTripletLayout->addWidget(modeLabel);
+	m_cookedModePushButton = new QPushButton;
+	cookedTripletLayout->addWidget(m_cookedModePushButton);
+
+	// Cooked triplet menu
+	// We build the menus for both "Insert" buttons at the same time
+	m_cookedModeMenu = new QMenu(this);
+	m_insertBeforeMenu = new QMenu(this);
+	m_insertAfterMenu = new QMenu(this);
+
+	for (int m=0; m<3; m++) {
+		QMenu *menuToBuild;
+
+		if (m == 0)
+			menuToBuild = m_cookedModeMenu;
+		else if (m == 1)
+			menuToBuild = m_insertBeforeMenu;
+		else // if (m == 2)
+			menuToBuild = m_insertAfterMenu;
+
+		auto newModeMenuAction=[&](QMenu *menu, int mode)
+		{
+			QAction *action = menu->addAction(m_x26Model->modeTripletName(mode));
+			if (m == 0)
+				connect(action, &QAction::triggered, [=]() { cookedModeMenuSelected(mode); });
+			else if (m == 1)
+				connect(action, &QAction::triggered, [=]() { insertTriplet(mode, false); });
+			else // if (m == 2)
+				connect(action, &QAction::triggered, [=]() { insertTriplet(mode, true); });
+		};
+
+		newModeMenuAction(menuToBuild, 0x04);
+		QMenu *rowTripletSubMenu = menuToBuild->addMenu(tr("Row triplet"));
+		newModeMenuAction(rowTripletSubMenu, 0x00);
+		newModeMenuAction(rowTripletSubMenu, 0x01);
+		newModeMenuAction(rowTripletSubMenu, 0x07);
+		newModeMenuAction(rowTripletSubMenu, 0x18);
+		QMenu *columnTripletSubMenu = menuToBuild->addMenu(tr("Column triplet"));
+		newModeMenuAction(columnTripletSubMenu, 0x20);
+		newModeMenuAction(columnTripletSubMenu, 0x23);
+		newModeMenuAction(columnTripletSubMenu, 0x27);
+		newModeMenuAction(columnTripletSubMenu, 0x2c);
+		newModeMenuAction(columnTripletSubMenu, 0x2e);
+		newModeMenuAction(columnTripletSubMenu, 0x28);
+		columnTripletSubMenu->addSeparator();
+		newModeMenuAction(columnTripletSubMenu, 0x29);
+		newModeMenuAction(columnTripletSubMenu, 0x2f);
+		newModeMenuAction(columnTripletSubMenu, 0x21);
+		newModeMenuAction(columnTripletSubMenu, 0x22);
+		newModeMenuAction(columnTripletSubMenu, 0x2b);
+		newModeMenuAction(columnTripletSubMenu, 0x2d);
+		QMenu *diacriticalSubMenu = columnTripletSubMenu->addMenu(tr("G0 diacritical"));
+		for (int i=0; i<16; i++)
+			newModeMenuAction(diacriticalSubMenu, 0x30 + i);
+		QMenu *objectSubMenu = menuToBuild->addMenu(tr("Object"));
+		newModeMenuAction(objectSubMenu, 0x10);
+		newModeMenuAction(objectSubMenu, 0x11);
+		newModeMenuAction(objectSubMenu, 0x12);
+		newModeMenuAction(objectSubMenu, 0x13);
+		newModeMenuAction(objectSubMenu, 0x15);
+		newModeMenuAction(objectSubMenu, 0x16);
+		newModeMenuAction(objectSubMenu, 0x17);
+		newModeMenuAction(menuToBuild, 0x1f);
+		menuToBuild->addSeparator();
+		QMenu *pdcSubMenu = menuToBuild->addMenu(tr("PDC/reserved"));
+		newModeMenuAction(pdcSubMenu, 0x08);
+		newModeMenuAction(pdcSubMenu, 0x09);
+		newModeMenuAction(pdcSubMenu, 0x0a);
+		newModeMenuAction(pdcSubMenu, 0x0b);
+		newModeMenuAction(pdcSubMenu, 0x0c);
+		newModeMenuAction(pdcSubMenu, 0x0d);
+		newModeMenuAction(pdcSubMenu, 0x26);
+		QMenu *reservedRowSubMenu = pdcSubMenu->addMenu(tr("Reserved row"));
+		newModeMenuAction(reservedRowSubMenu, 0x02);
+		newModeMenuAction(reservedRowSubMenu, 0x03);
+		newModeMenuAction(reservedRowSubMenu, 0x05);
+		newModeMenuAction(reservedRowSubMenu, 0x06);
+		newModeMenuAction(reservedRowSubMenu, 0x0e);
+		newModeMenuAction(reservedRowSubMenu, 0x0f);
+		newModeMenuAction(reservedRowSubMenu, 0x14);
+		newModeMenuAction(reservedRowSubMenu, 0x19);
+		newModeMenuAction(reservedRowSubMenu, 0x1a);
+		newModeMenuAction(reservedRowSubMenu, 0x1b);
+		newModeMenuAction(reservedRowSubMenu, 0x1c);
+		newModeMenuAction(reservedRowSubMenu, 0x1d);
+		newModeMenuAction(reservedRowSubMenu, 0x1e);
+		QMenu *reservedColumnSubMenu = pdcSubMenu->addMenu(tr("Reserved column"));
+		newModeMenuAction(reservedColumnSubMenu, 0x24);
+		newModeMenuAction(reservedColumnSubMenu, 0x25);
+		newModeMenuAction(reservedColumnSubMenu, 0x26);
+	}
+
+	m_cookedModePushButton->setMenu(m_cookedModeMenu);
 
 	// Raw triplet values
 	QHBoxLayout *rawTripletLayout = new QHBoxLayout;
@@ -161,9 +277,7 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	QHBoxLayout *colourAndRowLayout = new QHBoxLayout;
 
 	m_colourComboBox = new QComboBox;
-	for (int c=0; c<=3; c++)
-		for (int e=0; e<=7; e++)
-			m_colourComboBox->addItem(tr("CLUT %1:%2").arg(c).arg(e));
+	m_colourComboBox->setModel(m_parentMainWidget->document()->clutModel());
 	colourAndRowLayout->addWidget(m_colourComboBox);
 	connect(m_colourComboBox, QOverload<int>::of(&QComboBox::activated), this, [=](const int value) { updateModelFromCookedWidget(value, Qt::UserRole+1); } );
 
@@ -181,8 +295,7 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	QHBoxLayout *characterCodeLayout = new QHBoxLayout;
 
 	m_characterCodeComboBox = new QComboBox;
-	for (int i=32; i<128; i++)
-		m_characterCodeComboBox->addItem(QString("0x%1").arg(i, 2, 16), i);
+	m_characterCodeComboBox->setModel(&m_characterListModel);
 	characterCodeLayout->addWidget(m_characterCodeComboBox);
 	connect(m_characterCodeComboBox, QOverload<int>::of(&QComboBox::activated), this, [=](const int value) { updateModelFromCookedWidget(value+32, Qt::UserRole+1); } );
 
@@ -240,7 +353,7 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	m_objectSourceComboBox->addItem("POP");
 	m_objectSourceComboBox->addItem("GPOP");
 	invokeObjectLayout->addWidget(m_objectSourceComboBox);
-	connect(m_objectSourceComboBox, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](const int value) { updateModelFromCookedWidget(value, Qt::UserRole+1); updateCookedTripletParameters(m_x26View->currentIndex()); } );
+	connect(m_objectSourceComboBox, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](const int value) { updateModelFromCookedWidget(value, Qt::UserRole+1); updateAllCookedTripletWidgets(m_x26View->currentIndex()); } );
 
 	// Object required at which levels
 	m_objectRequiredAtLevelsComboBox = new QComboBox;
@@ -253,13 +366,15 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	// Invoke Local Objects
 	QHBoxLayout *invokeLocalObjectLayout = new QHBoxLayout;
 
-	invokeLocalObjectLayout->addWidget(new QLabel(tr("Designation")));
+	m_invokeLocalObjectDesignationCodeLabel = new QLabel(tr("Designation"));
+	invokeLocalObjectLayout->addWidget(m_invokeLocalObjectDesignationCodeLabel);
 	m_invokeLocalObjectDesignationCodeSpinBox = new QSpinBox;
 	m_invokeLocalObjectDesignationCodeSpinBox->setMaximum(15);
 	invokeLocalObjectLayout->addWidget(m_invokeLocalObjectDesignationCodeSpinBox);
 	connect(m_invokeLocalObjectDesignationCodeSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), this, [=](const int value) { updateModelFromCookedWidget(value, Qt::UserRole+2); } );
 
-	invokeLocalObjectLayout->addWidget(new QLabel(tr("Triplet")));
+	m_invokeLocalObjectTripletNumberLabel = new QLabel(tr("Triplet"));
+	invokeLocalObjectLayout->addWidget(m_invokeLocalObjectTripletNumberLabel);
 	m_invokeLocalObjectTripletNumberSpinBox = new QSpinBox;
 	m_invokeLocalObjectTripletNumberSpinBox->setMaximum(12);
 	invokeLocalObjectLayout->addWidget(m_invokeLocalObjectTripletNumberSpinBox);
@@ -410,60 +525,70 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	m_tripletParameterStackedLayout->addWidget(blankWidget);
 
 	// Index 1
+	colourAndRowLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *colourAndRowWidget = new QWidget;
 	colourAndRowWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	colourAndRowWidget->setLayout(colourAndRowLayout);
 	m_tripletParameterStackedLayout->addWidget(colourAndRowWidget);
 
 	// Index 2
+	characterCodeLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *characterCodeWidget = new QWidget;
 	characterCodeWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	characterCodeWidget->setLayout(characterCodeLayout);
 	m_tripletParameterStackedLayout->addWidget(characterCodeWidget);
 
 	// Index 3
+	flashModeRateLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *flashModeRateWidget = new QWidget;
 	flashModeRateWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	flashModeRateWidget->setLayout(flashModeRateLayout);
 	m_tripletParameterStackedLayout->addWidget(flashModeRateWidget);
 
 	// Index 4
+	displayAttributesLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *displayAttributesWidget = new QWidget;
 	displayAttributesWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	displayAttributesWidget->setLayout(displayAttributesLayout);
 	m_tripletParameterStackedLayout->addWidget(displayAttributesWidget);
 
 	// Index 5
+	invokeObjectLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *invokeObjectWidget = new QWidget;
 	invokeObjectWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	invokeObjectWidget->setLayout(invokeObjectLayout);
 	m_tripletParameterStackedLayout->addWidget(invokeObjectWidget);
 
 	// Index 6
+	DRCSModeLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *DRCSModeWidget = new QWidget;
 	DRCSModeWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	DRCSModeWidget->setLayout(DRCSModeLayout);
 	m_tripletParameterStackedLayout->addWidget(DRCSModeWidget);
 
 	// Index 7
+	DRCSCharacterLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *DRCSCharacterWidget = new QWidget;
 	DRCSCharacterWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	DRCSCharacterWidget->setLayout(DRCSCharacterLayout);
 	m_tripletParameterStackedLayout->addWidget(DRCSCharacterWidget);
 
 	// Index 8
+	fontStyleLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *fontStyleWidget = new QWidget;
 	fontStyleWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	fontStyleWidget->setLayout(fontStyleLayout);
 	m_tripletParameterStackedLayout->addWidget(fontStyleWidget);
 
 	// Index 9
+	reservedPDCLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *reservedPDCWidget = new QWidget;
 	reservedPDCWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	reservedPDCWidget->setLayout(reservedPDCLayout);
 	m_tripletParameterStackedLayout->addWidget(reservedPDCWidget);
 
 	// Index 10
+	terminationMarkerLayout->setContentsMargins(0, 0, 0, 0);
 	QWidget *terminationMarkerWidget = new QWidget;
 	terminationMarkerWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	terminationMarkerWidget->setLayout(terminationMarkerLayout);
@@ -479,30 +604,41 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	// Insert and delete widgets
 	QHBoxLayout *insertDeleteLayout = new QHBoxLayout;
 
-	m_insertPushButton = new QPushButton(tr("Insert triplet"));
-	insertDeleteLayout->addWidget(m_insertPushButton);
-	m_deletePushButton = new QPushButton(tr("Delete triplet"));
+	m_insertBeforePushButton = new QPushButton(tr("Insert before"));
+	insertDeleteLayout->addWidget(m_insertBeforePushButton);
+	m_insertBeforePushButton->setMenu(m_insertBeforeMenu);
+
+	m_insertAfterPushButton = new QPushButton(tr("Insert after"));
+	insertDeleteLayout->addWidget(m_insertAfterPushButton);
+	m_insertAfterPushButton->setMenu(m_insertAfterMenu);
+
+	m_insertCopyPushButton = new QPushButton(tr("Insert copy"));
+	insertDeleteLayout->addWidget(m_insertCopyPushButton);
+
+	m_deletePushButton = new QPushButton(tr("Delete"));
 	insertDeleteLayout->addWidget(m_deletePushButton);
 
-	connect(m_insertPushButton, &QPushButton::clicked, this, &X26DockWidget::insertTriplet);
+	connect(m_insertCopyPushButton, &QPushButton::clicked, this, &X26DockWidget::insertTripletCopy);
 	connect(m_deletePushButton, &QPushButton::clicked, this, &X26DockWidget::deleteTriplet);
 
 	x26Layout->addLayout(insertDeleteLayout);
 
+	disableTripletWidgets();
+
 	x26Widget->setLayout(x26Layout);
 	this->setWidget(x26Widget);
 
 	m_x26View->setContextMenuPolicy(Qt::CustomContextMenu);
 	connect(m_x26View, &QWidget::customContextMenuRequested, this, &X26DockWidget::customMenuRequested);
 
-	connect(m_x26View, &QAbstractItemView::clicked, this, &X26DockWidget::rowClicked);
+	connect(m_x26View->selectionModel(), &QItemSelectionModel::currentRowChanged, this, &X26DockWidget::rowSelected);
 }
 
 void X26DockWidget::keyPressEvent(QKeyEvent *event)
 {
 	switch (event->key()) {
 		case Qt::Key_Insert:
-			insertTriplet();
+			insertTripletCopy();
 			break;
 		case Qt::Key_Delete:
 			deleteTriplet();
@@ -520,7 +656,7 @@ void X26DockWidget::selectX26ListRow(int row)
 		row = m_x26Model->rowCount() - 1;
 
 	m_x26View->selectRow(row);
-	rowClicked(m_x26View->currentIndex());
+	rowSelected(m_x26View->currentIndex(), QModelIndex());
 }
 
 void X26DockWidget::loadX26List()
@@ -536,145 +672,53 @@ void X26DockWidget::unloadX26List()
 	m_rawTripletModeSpinBox->setEnabled(false);
 }
 
-void X26DockWidget::rowClicked(const QModelIndex &index)
+void X26DockWidget::rowSelected(const QModelIndex &current, const QModelIndex &previous)
 {
-	updateAllRawTripletSpinBoxes(index);
-	updateAllCookedTripletWidgets(index);
+	Q_UNUSED(previous);
+
+	if (current.isValid()) {
+		updateAllRawTripletSpinBoxes(current);
+		updateAllCookedTripletWidgets(current);
+	} else
+		disableTripletWidgets();
+}
+
+void X26DockWidget::disableTripletWidgets()
+{
+	m_rawTripletAddressSpinBox->setEnabled(false);
+	m_rawTripletDataSpinBox->setEnabled(false);
+	m_rawTripletModeSpinBox->setEnabled(false);
+	m_rawTripletAddressSpinBox->blockSignals(true);
+	m_rawTripletModeSpinBox->blockSignals(true);
+	m_rawTripletDataSpinBox->blockSignals(true);
+	m_rawTripletAddressSpinBox->setValue(0);
+	m_rawTripletModeSpinBox->setValue(0);
+	m_rawTripletDataSpinBox->setValue(0);
+	m_rawTripletAddressSpinBox->blockSignals(false);
+	m_rawTripletModeSpinBox->blockSignals(false);
+	m_rawTripletDataSpinBox->blockSignals(false);
+
+	m_cookedRowSpinBox->setEnabled(false);
+	m_cookedColumnSpinBox->setEnabled(false);
+	m_cookedRowSpinBox->blockSignals(true);
+	m_cookedColumnSpinBox->blockSignals(true);
+	m_cookedRowSpinBox->setValue(1);
+	m_cookedColumnSpinBox->setValue(0);
+	m_cookedRowSpinBox->blockSignals(false);
+	m_cookedColumnSpinBox->blockSignals(false);
+
+	m_cookedModePushButton->setEnabled(false);
+	m_cookedModePushButton->setText(QString());
+
+	m_tripletParameterStackedLayout->setCurrentIndex(0);
 }
 
 void X26DockWidget::updateAllCookedTripletWidgets(const QModelIndex &index)
 {
 	const int modeExt = index.model()->data(index.model()->index(index.row(), 2), Qt::EditRole).toInt();
 
-	// Find which triplettype the triplet is
-	const int oldCookedModeType = m_cookedModeTypeComboBox->currentIndex();
-	switch (modeExt) {
-		case 0x04:
-			m_cookedModeTypeComboBox->setCurrentIndex(0);
-			break;
-		case 0x00:
-		case 0x01:
-		case 0x07:
-		case 0x18:
-			m_cookedModeTypeComboBox->setCurrentIndex(1);
-			break;
-		case 0x20 ... 0x23:
-		case 0x27 ... 0x29:
-		case 0x2b ... 0x3f:
-			m_cookedModeTypeComboBox->setCurrentIndex(2);
-			break;
-		case 0x10 ... 0x13:
-		case 0x15 ... 0x17:
-			m_cookedModeTypeComboBox->setCurrentIndex(3);
-			break;
-		case 0x1f:
-			m_cookedModeTypeComboBox->setCurrentIndex(4);
-			break;
-		default:
-			m_cookedModeTypeComboBox->setCurrentIndex(5);
-	}
-
-	// If the triplettype has changed, update the triplet mode combobox
-	if (oldCookedModeType != m_cookedModeTypeComboBox->currentIndex())
-		updateCookedModeFromCookedType(-1);
-	for (int i=0; i<m_cookedModeComboBox->count(); i++)
-		if (m_cookedModeComboBox->itemData(i) == modeExt) {
-			m_cookedModeComboBox->blockSignals(true);
-			m_cookedModeComboBox->setCurrentIndex(i);
-			m_cookedModeComboBox->blockSignals(false);
-			break;
-		}
-
-	updateCookedTripletParameters(index);
-}
-
-void X26DockWidget::updateCookedModeFromCookedType(const int value)
-{
-	while (m_cookedModeComboBox->count() > 0)
-		m_cookedModeComboBox->removeItem(0);
-	// When called as a slot, "value" parameter would be the same as this currentIndex
-	switch (m_cookedModeTypeComboBox->currentIndex()) {
-		case 1:
-			m_cookedModeComboBox->addItem("select...", -1);
-			m_cookedModeComboBox->addItem("Full screen colour", 0x00);
-			m_cookedModeComboBox->addItem("Full row colour", 0x01);
-			m_cookedModeComboBox->addItem("Address row 0", 0x07);
-			m_cookedModeComboBox->addItem("DRCS mode", 0x18);
-			break;
-		case 2:
-			m_cookedModeComboBox->addItem("select...", -1);
-			m_cookedModeComboBox->addItem("Foreground colour", 0x20);
-			m_cookedModeComboBox->addItem("Background colour", 0x23);
-			m_cookedModeComboBox->addItem("Flash functions", 0x27);
-			m_cookedModeComboBox->addItem("Display attrs", 0x2c);
-			m_cookedModeComboBox->addItem("Font style L 3.5", 0x2e);
-			m_cookedModeComboBox->addItem("Mod G0 and G2", 0x28);
-			m_cookedModeComboBox->addItem("G0 character", 0x29);
-			m_cookedModeComboBox->addItem("G2 character", 0x2f);
-			m_cookedModeComboBox->addItem("G1 block mosaic", 0x21);
-			m_cookedModeComboBox->addItem("G3 at L 1.5", 0x22);
-			m_cookedModeComboBox->addItem("G3 at L 2.5", 0x2b);
-			m_cookedModeComboBox->addItem("DRCS character", 0x2d);
-			for (int i=0; i<16; i++)
-				m_cookedModeComboBox->addItem(QString("G0 diactricial ")+QString("%1").arg(i, 1, 16).toUpper(), 0x30 | i);
-			break;
-		case 3:
-			m_cookedModeComboBox->addItem("select...", -1);
-			m_cookedModeComboBox->addItem("Origin modifier", 0x10);
-			m_cookedModeComboBox->addItem("Invoke active obj", 0x11);
-			m_cookedModeComboBox->addItem("Invoke adaptive obj", 0x12);
-			m_cookedModeComboBox->addItem("Invoke passive obj", 0x13);
-			m_cookedModeComboBox->addItem("Define active obj", 0x15);
-			m_cookedModeComboBox->addItem("Define adaptive obj", 0x16);
-			m_cookedModeComboBox->addItem("Define passive obj", 0x17);
-			break;
-		case 5:
-			m_cookedModeComboBox->addItem("select...", -1);
-			m_cookedModeComboBox->addItem("Origin and Source", 0x08);
-			m_cookedModeComboBox->addItem("Month and day", 0x09);
-			m_cookedModeComboBox->addItem("Row + start hours", 0x0a);
-			m_cookedModeComboBox->addItem("Row + end hours", 0x0b);
-			m_cookedModeComboBox->addItem("Row + time offset", 0x0c);
-			m_cookedModeComboBox->addItem("Series ID and code", 0x0d);
-			m_cookedModeComboBox->addItem("Col + start/end mins", 0x26);
-			m_cookedModeComboBox->addItem("Reserved row 0x02", 0x02);
-			m_cookedModeComboBox->addItem("Reserved row 0x03", 0x03);
-			m_cookedModeComboBox->addItem("Reserved row 0x05", 0x05);
-			m_cookedModeComboBox->addItem("Reserved row 0x06", 0x06);
-			m_cookedModeComboBox->addItem("Reserved row 0x0e", 0x0e);
-			m_cookedModeComboBox->addItem("Reserved row 0x0f", 0x0f);
-			m_cookedModeComboBox->addItem("Reserved row 0x14", 0x14);
-			m_cookedModeComboBox->addItem("Reserved row 0x19", 0x19);
-			m_cookedModeComboBox->addItem("Reserved row 0x1a", 0x1a);
-			m_cookedModeComboBox->addItem("Reserved row 0x1b", 0x1b);
-			m_cookedModeComboBox->addItem("Reserved row 0x1c", 0x1c);
-			m_cookedModeComboBox->addItem("Reserved row 0x1d", 0x1d);
-			m_cookedModeComboBox->addItem("Reserved row 0x1e", 0x1e);
-			m_cookedModeComboBox->addItem("Reserved col 0x04", 0x04);
-			m_cookedModeComboBox->addItem("Reserved col 0x05", 0x05);
-			m_cookedModeComboBox->addItem("Reserved col 0x0a", 0x0a);
-			break;
-		case 0:
-			// When called as a slot the user set the combobox themself, so set the triplet mode immediately
-			if (value != -1) {
-				m_x26Model->setData(m_x26Model->index(m_x26View->currentIndex().row(), 2), 4, Qt::EditRole);
-				updateAllRawTripletSpinBoxes(m_x26View->currentIndex());
-				updateCookedTripletParameters(m_x26View->currentIndex());
-			}
-			break;
-		case 4:
-			if (value != -1) {
-				m_x26Model->setData(m_x26Model->index(m_x26View->currentIndex().row(), 2), 31, Qt::EditRole);
-				updateAllRawTripletSpinBoxes(m_x26View->currentIndex());
-				updateCookedTripletParameters(m_x26View->currentIndex());
-			}
-			break;
-	}
-}
-
-void X26DockWidget::updateCookedTripletParameters(const QModelIndex &index)
-{
-	const int modeExt = index.model()->data(index.model()->index(index.row(), 2), Qt::EditRole).toInt();
+	m_cookedModePushButton->setEnabled(true);
+	m_cookedModePushButton->setText(m_x26Model->modeTripletName(modeExt));
 
 	switch (modeExt) {
 		case 0x04: // Set active position
@@ -705,7 +749,16 @@ void X26DockWidget::updateCookedTripletParameters(const QModelIndex &index)
 		case 0x29: // G0 character
 		case 0x2b: // G3 character at Level 2.5
 		case 0x2f ... 0x3f: // G2 character, G0 character with diacritical
+			// TODO non-Latin G0 and G2 character sets
 			m_characterCodeComboBox->blockSignals(true);
+			if (modeExt == 0x22 || modeExt == 0x2b)
+				m_characterListModel.setCharacterSet(26);
+			else if (modeExt == 0x2f)
+				m_characterListModel.setCharacterSet(7);
+			else if (modeExt == 0x21)
+				m_characterListModel.setCharacterSet(24);
+			else
+				m_characterListModel.setCharacterSet(0);
 			m_characterCodeComboBox->setCurrentIndex(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+1).toInt()-32);
 			m_characterCodeComboBox->blockSignals(false);
 			m_tripletParameterStackedLayout->setCurrentIndex(2);
@@ -756,14 +809,22 @@ void X26DockWidget::updateCookedTripletParameters(const QModelIndex &index)
 			// BUG we're only dealing with Local Object Definitions at the moment!
 			if (index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+1).toInt() == 0 || (index.model()->data(index.model()->index(index.row(), 1), Qt::UserRole).toInt() & 0x04)) {
 //			if (triplet.objectSource() == X26Triplet::LocalObjectSource) {
+				const bool tripletLocationWidgetsVisible = (modeExt & 0x04) != 0x04;
+
+				m_invokeLocalObjectDesignationCodeLabel->setVisible(tripletLocationWidgetsVisible);
+				m_invokeLocalObjectDesignationCodeSpinBox->setVisible(tripletLocationWidgetsVisible);
+				m_invokeLocalObjectTripletNumberLabel->setVisible(tripletLocationWidgetsVisible);
+				m_invokeLocalObjectTripletNumberSpinBox->setVisible(tripletLocationWidgetsVisible);
 				m_objectSourceComboBox->setCurrentIndex(0);
 				m_invokeObjectSourceStackedLayout->setCurrentIndex(0);
+				if (tripletLocationWidgetsVisible) {
 					m_invokeLocalObjectDesignationCodeSpinBox->blockSignals(true);
 					m_invokeLocalObjectTripletNumberSpinBox->blockSignals(true);
 					m_invokeLocalObjectDesignationCodeSpinBox->setValue(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+2).toInt());
 					m_invokeLocalObjectTripletNumberSpinBox->setValue(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+3).toInt());
 					m_invokeLocalObjectDesignationCodeSpinBox->blockSignals(false);
 					m_invokeLocalObjectTripletNumberSpinBox->blockSignals(false);
+				}
 			} else { // if (triplet.objectSource() != X26Triplet::IllegalObjectSource) {
 				m_objectSourceComboBox->setCurrentIndex(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+1).toInt());
 				m_invokeObjectSourceStackedLayout->setCurrentIndex(1);
@@ -849,28 +910,36 @@ void X26DockWidget::updateCookedTripletParameters(const QModelIndex &index)
 	// Now deal with cooked row and column spinboxes
 	m_cookedRowSpinBox->blockSignals(true);
 	m_cookedColumnSpinBox->blockSignals(true);
-	QVariant rowVariant = index.model()->data(index.model()->index(index.row(), 0), Qt::EditRole);
+	const QVariant rowVariant = index.model()->data(index.model()->index(index.row(), 0), Qt::EditRole);
 	if (rowVariant.isNull()) {
 		m_cookedRowSpinBox->setEnabled(false);
 		m_cookedRowSpinBox->setValue(0);
+		m_cookedRowSpinBox->setPrefix("");
 	} else {
 		m_cookedRowSpinBox->setEnabled(true);
-		if (index.model()->data(index.model()->index(index.row(), 2), Qt::EditRole) == 0x10)
+		if (modeExt == 0x10) {
 			m_cookedRowSpinBox->setRange(0, 23);
-		else
+			m_cookedRowSpinBox->setPrefix("+");
+		} else {
 			m_cookedRowSpinBox->setRange(1, 24);
+			m_cookedRowSpinBox->setPrefix("");
+		}
 		m_cookedRowSpinBox->setValue(rowVariant.toInt());
 	}
-	QVariant columnVariant = index.model()->data(index.model()->index(index.row(), 1), Qt::EditRole);
+	const QVariant columnVariant = index.model()->data(index.model()->index(index.row(), 1), Qt::EditRole);
 	if (columnVariant.isNull()) {
 		m_cookedColumnSpinBox->setEnabled(false);
 		m_cookedColumnSpinBox->setValue(0);
+		m_cookedColumnSpinBox->setPrefix("");
 	} else {
 		m_cookedColumnSpinBox->setEnabled(true);
-		if (index.model()->data(index.model()->index(index.row(), 2), Qt::EditRole) == 0x10)
+		if (modeExt == 0x10) {
 			m_cookedColumnSpinBox->setMaximum(71);
-		else
+			m_cookedColumnSpinBox->setPrefix("+");
+		} else {
 			m_cookedColumnSpinBox->setMaximum(39);
+			m_cookedColumnSpinBox->setPrefix("");
+		}
 		m_cookedColumnSpinBox->setValue(columnVariant.toInt());
 	}
 	m_cookedRowSpinBox->blockSignals(false);
@@ -945,35 +1014,65 @@ void X26DockWidget::cookedColumnSpinBoxChanged(const int value)
 	updateAllRawTripletSpinBoxes(m_x26View->currentIndex());
 }
 
-void X26DockWidget::cookedModeComboBoxChanged(const int value)
+void X26DockWidget::cookedModeMenuSelected(const int value)
 {
 	if (!m_x26View->currentIndex().isValid())
 		return;
 
-	// Avoid "select..."
-	if (m_cookedModeComboBox->itemData(value) == -1)
-		return;
-
-	m_x26Model->setData(m_x26Model->index(m_x26View->currentIndex().row(), 2), m_cookedModeComboBox->itemData(value).toInt(), Qt::EditRole);
+	m_x26Model->setData(m_x26Model->index(m_x26View->currentIndex().row(), 2), value, Qt::EditRole);
 
 	updateAllRawTripletSpinBoxes(m_x26View->currentIndex());
-	updateCookedTripletParameters(m_x26View->currentIndex());
+	updateAllCookedTripletWidgets(m_x26View->currentIndex());
 }
 
+
 void X26DockWidget::updateModelFromCookedWidget(const int value, const int role)
 {
 	m_x26Model->setData(m_x26Model->index(m_x26View->currentIndex().row(), 0), value, role);
 	updateAllRawTripletSpinBoxes(m_x26View->currentIndex());
 }
 
-void X26DockWidget::insertTriplet()
+void X26DockWidget::insertTriplet(int modeExt, bool after)
+{
+	QModelIndex index = m_x26View->currentIndex();
+	X26Triplet newTriplet(modeExt < 0x20 ? 41 : 0, modeExt & 0x1f, 0);
+	int row;
+
+	if (index.isValid()) {
+		// If we're inserting a column triplet next to another column triplet,
+		// duplicate the column number
+		// Avoid the PDC and reserved mode triplets
+		if (modeExt >= 0x20 && modeExt != 0x24 && modeExt != 0x25 && modeExt != 0x26 && modeExt != 0x2a) {
+			const int existingTripletModeExt = index.model()->data(index.model()->index(index.row(), 2), Qt::EditRole).toInt();
+
+			if (existingTripletModeExt >= 0x20 && existingTripletModeExt != 0x24 && existingTripletModeExt != 0x25 && existingTripletModeExt != 0x26 && existingTripletModeExt != 0x2a)
+				newTriplet.setAddress(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole).toInt());
+		}
+		row = index.row()+after;
+	} else
+		row = 0;
+
+	// For character triplets, ensure Data is not reserved
+	if (modeExt == 0x21 || modeExt == 0x22 || modeExt == 0x29 || modeExt == 0x2b || modeExt >= 0x2f)
+		newTriplet.setData(0x20);
+	// For Termination Marker, set Address and Mode
+	if (modeExt == 0x1f) {
+		newTriplet.setAddress(63);
+		newTriplet.setData(7);
+	}
+
+	m_x26Model->insertRows(row, 1, QModelIndex(), newTriplet);
+}
+
+void X26DockWidget::insertTripletCopy()
 {
 	QModelIndex index = m_x26View->currentIndex();
 
 	if (index.isValid())
 		m_x26Model->insertRow(index.row(), QModelIndex());
 	else
-		m_x26Model->insertFirstRow();
+		// No existing triplet to copy, so insert a Termination Marker
+		m_x26Model->insertRows(0, 1, QModelIndex(), X26Triplet(63, 31, 7));
 }
 
 void X26DockWidget::deleteTriplet()
@@ -989,9 +1088,9 @@ void X26DockWidget::customMenuRequested(QPoint pos)
 
 	QMenu *menu = new QMenu(this);
 
-	QAction *insertAct = new QAction("Insert triplet", this);
+	QAction *insertAct = new QAction("Insert triplet copy", this);
 	menu->addAction(insertAct);
-	connect(insertAct, &QAction::triggered, this, &X26DockWidget::insertTriplet);
+	connect(insertAct, &QAction::triggered, this, &X26DockWidget::insertTripletCopy);
 	if (index.isValid()) {
 		QAction *deleteAct = new QAction("Delete triplet", this);
 		menu->addAction(deleteAct);

x26dockwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -20,10 +20,13 @@
 #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>
@@ -31,8 +34,25 @@
 #include <QTableView>
 
 #include "mainwidget.h"
+#include "render.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);
+
+private:
+	TeletextFontBitmap m_fontBitmap;
+	int m_characterSet;
+};
+
 class X26DockWidget : public QDockWidget
 {
 	Q_OBJECT
@@ -41,35 +61,35 @@ public:
 	X26DockWidget(TeletextWidget *parent);
 
 public slots:
-	void insertTriplet();
+	void insertTriplet(int, bool);
+	void insertTripletCopy();
 	void deleteTriplet();
 	void customMenuRequested(QPoint pos);
 	void loadX26List();
 	void unloadX26List();
-	void rowClicked(const QModelIndex &);
+	void rowSelected(const QModelIndex &, const QModelIndex &);
 	void updateAllRawTripletSpinBoxes(const QModelIndex &);
 	void updateRawTripletDataSpinBox(const QModelIndex &);
 	void updateAllCookedTripletWidgets(const QModelIndex &);
-	void updateCookedModeFromCookedType(const int);
-	void updateCookedTripletParameters(const QModelIndex &);
 	void rawTripletAddressSpinBoxChanged(int);
 	void rawTripletModeSpinBoxChanged(int);
 	void rawTripletDataSpinBoxChanged(int);
 	void cookedRowSpinBoxChanged(const int);
 	void cookedColumnSpinBoxChanged(const int);
-	void cookedModeComboBoxChanged(const int);
+	void cookedModeMenuSelected(const int);
 	void updateModelFromCookedWidget(const int, const int);
 	void selectX26ListRow(int);
 
 protected:
 	void keyPressEvent(QKeyEvent *event) override;
+	CharacterListModel m_characterListModel;
 
 private:
 	QTableView *m_x26View;
 	X26Model *m_x26Model;
-	QComboBox *m_cookedModeTypeComboBox;
 	QSpinBox *m_cookedRowSpinBox, *m_cookedColumnSpinBox;
-	QComboBox *m_cookedModeComboBox;
+	QMenu *m_cookedModeMenu, *m_insertBeforeMenu, *m_insertAfterMenu;
+	QPushButton *m_cookedModePushButton;
 	QSpinBox *m_rawTripletAddressSpinBox, *m_rawTripletModeSpinBox, *m_rawTripletDataSpinBox;
 	QStackedLayout *m_rawOrCookedStackedLayout;
 	QComboBox *m_colourComboBox;
@@ -79,6 +99,7 @@ private:
 	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;
@@ -93,9 +114,12 @@ private:
 	QSpinBox *m_reservedPDCSpinBox;
 	QComboBox *m_terminationMarkerPageTypeComboBox;
 	QCheckBox *m_terminationMarkerMoreFollowsCheckBox;
-	QPushButton *m_insertPushButton, *m_deletePushButton;
+	QPushButton *m_insertBeforePushButton, *m_insertAfterPushButton, *m_insertCopyPushButton, *m_deletePushButton;
 
 	TeletextWidget *m_parentMainWidget;
+
+	void disableTripletWidgets();
+
 };
 
 #endif

x26model.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -22,6 +22,7 @@
 
 #include <QAbstractListModel>
 #include "mainwidget.h"
+#include "render.h"
 
 class X26Model : public QAbstractListModel
 {
@@ -35,11 +36,13 @@ public:
 	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 insertFirstRow();
 	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;
 
+	const QString modeTripletName(int i) const { return m_modeTripletName[i]; }
+
 	// The x26commands classes manipulate the model but beginInsertRows and endInsertRows
 	// are protected methods, so we need to friend them
 	friend class InsertTripletCommand;
@@ -49,9 +52,9 @@ public:
 private:
 	TeletextWidget *m_parentMainWidget;
 	bool m_listLoaded;
-};
+	TeletextFontBitmap m_fontBitmap;
 
-static const QString modeTripletName[64] {
+	const QString m_modeTripletName[64] {
 		// Row triplet modes
 		"Full screen colour",
 		"Full row colour",
@@ -95,8 +98,8 @@ static const QString modeTripletName[64] {
 
 		// Column triplet modes
 		"Foreground colour",
-	"G1 character",
-	"G3 character, level 1.5",
+		"G1 block mosaic",
+		"G3 smooth mosaic, level 1.5",
 		"Background colour",
 
 		"Reserved 0x04",
@@ -107,12 +110,12 @@ static const QString modeTripletName[64] {
 		"Modified G0/G2 character set",
 		"G0 character",
 		"Reserved 0x0a",
-	"G3 character, level 2.5",
+		"G3 smooth mosaic, level 2.5",
 
 		"Display attributes",
 		"DRCS character",
-	"Font style",
-	"G2 character",
+		"Font style, level 3.5",
+		"G2 supplementary character",
 
 		"G0 character no diacritical",
 		"G0 character diacritical 1",
@@ -130,6 +133,22 @@ static const QString modeTripletName[64] {
 		"G0 character diacritical D",
 		"G0 character diacritical E",
 		"G0 character diacritical F"
+	};
+
+	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

x26triplets.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -50,3 +50,201 @@ 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;
+
+	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 ... 0x13: // Invoke 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 ... 0x17: // Define Object
+					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 ... 0x0d: // PDC
+					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: // Foreground colour
+					if (triplet->m_data & 0x60)
+						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 ... 0x3f: // G2 character or G0 diacritical mark
+					if (triplet->m_data < 0x20)
+						triplet->m_reservedData = true;
+					break;
+				case 0x27: // Additional flash functions
+					if (triplet->m_data >= 0x18)
+						triplet->m_reservedData = true;
+					break;
+				case 0x2d: // DRCS character
+					if ((triplet->m_data & 0x3f) >= 48)
+						// Should really be an error?
+						triplet->m_reservedData = true;
+			}
+
+		triplet->m_activePositionRow = activePosition.row();
+		triplet->m_activePositionColumn = 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);
+}
+*/

x26triplets.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020, 2021 Gavin MacGregor
+ * Copyright (C) 2020-2022 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -20,9 +20,15 @@
 #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);
 
@@ -44,9 +50,69 @@ public:
 	void setAddressRow(int);
 	void setAddressColumn(int);
 
+	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);
+	void setObjectLocalTripletNumber(int);
+	void setObjectLocalIndex(int);
+
+	int activePositionRow() const { return m_activePositionRow; }
+	int activePositionColumn() const { return m_activePositionColumn; }
+	X26TripletError error() const { return m_error; }
+	bool reservedMode() const { return m_reservedMode; }
+	bool reservedData() const { return m_reservedData; }
+
+	friend class X26TripletList;
+
 private:
 	int m_address, m_mode, m_data;
+	int m_activePositionRow = -1;
+	int m_activePositionColumn = -1;
+	X26TripletError m_error = NoError;
+	bool m_reservedMode = false;
+	bool m_reservedData = false;
+};
 
+class X26TripletList
+{
+public:
+	void append(const X26Triplet &);
+	void insert(int, const X26Triplet &);
+	void removeAt(int);
+	void replace(int, const X26Triplet &);
+
+	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(); }
+
+private:
+	void updateInternalData();
+
+	QList<X26Triplet> m_list;
+
+	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