Tag version 0.8.2-beta

Closes GH-14 where flashing text in Mix mode would not flash to the
transparent background.

The bundled QtGifImage does not expose a way to change the DisposalMode in
giflib and thus it is fixed at 0 or DISPOSAL_UNSPECIFIED. This is a quick and
dirty change to fix it to 2 or DISPOSAL_BACKGROUND for our needs.

A proper fix would be to fork QtGifImage and add a more accessible API call
to choose the DisposalMode value.

.gitignore

@@ -1,6 +1,4 @@
-.qmake.stash
-moc_*
-qrc_*
-*.o
 Makefile
-qteletextmaker
+build*/
+cmake-build-*/
+.idea

3rdparty/QtGifImage/.gitignore

@@ -0,0 +1,45 @@
+syntax: glob
+*.pro.user*
+*.autosave
+*.app
+*.moc
+*.prl
+Makefile*
+doc/html/
+*.framework/
+*.xcodeproj/
+debug/
+release/
+qtc-gdbmacros/
+*.rej
+*.orig
+*.obj
+*.swp
+*.dll
+*.exp
+*.ilk
+*.pdb
+*.lib
+Thumbs.db
+moc_*.cpp
+qrc_*.cpp
+*.o
+*.so.*
+*.so
+*.pdb
+ui_*.h
+*~
+.qmake.cache
+lib/*
+*.orig
+*.exe
+*.vcproj
+*.vcproj.*.user
+*_resource.rc
+*.sln
+*.idb
+*.ncb
+*.suo
+
+*.zip
+*.xlsx

3rdparty/QtGifImage/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required(VERSION 3.5...3.16)
+project(QtGifImage)
+
+set(CMAKE_CXX_STANDARD 17)
+
+find_package(QT NAMES Qt6 REQUIRED COMPONENTS Core Gui)
+find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core Gui)
+
+set(LIB_LIBRARIES Qt${QT_VERSION_MAJOR}::Core Qt${QT_VERSION_MAJOR}::Gui)
+
+set(GIF_IMAGE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/gifimage)
+set(GIF_LIB_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/3rdparty/giflib)
+
+# Next line was "add_library(${PROJECT_NAME} SHARED"
+# but it breaks MXE static compilation
+add_library(${PROJECT_NAME} STATIC
+    ${GIF_IMAGE_DIR}/qgifglobal.h ${GIF_IMAGE_DIR}/qgifimage.cpp
+    ${GIF_IMAGE_DIR}/qgifimage.h  ${GIF_IMAGE_DIR}/qgifimage_p.h
+
+    ${GIF_LIB_DIR}/dgif_lib.c ${GIF_LIB_DIR}/egif_lib.c
+    ${GIF_LIB_DIR}/gif_err.c  ${GIF_LIB_DIR}/gif_font.c
+    ${GIF_LIB_DIR}/gif_hash.c ${GIF_LIB_DIR}/gif_hash.h
+    ${GIF_LIB_DIR}/gif_lib.h  ${GIF_LIB_DIR}/gif_lib_private.h
+    ${GIF_LIB_DIR}/gifalloc.c ${GIF_LIB_DIR}/quantize.c
+)
+
+add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
+
+target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/3rdparty)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE ${LIB_LIBRARIES})

3rdparty/QtGifImage/include/3rdparty/giflib/AUTHORS

@@ -0,0 +1,36 @@
+Michael Brown <michael_brown_uk[AT]hotmail.com>
+        callbacks to write data via user defined function
+
+Daniel Eisenbud <eisenbud[AT]google.com>
+	Fixes for crashes with invalid gif files and double freeing of
+	colormaps
+
+Gershon Elber <gershon[AT]cs.technion.sc.il>
+	original giflib code
+
+Marc Ewing <marc[AT]redhat.com>
+        spec file (for rpms) updates
+
+Toshio Kuratomi <toshio[AT]tiki-lounge.com>
+        uncompressed gif writing code
+        autoconf/automake process
+        former maintainer
+
+marek <marwaw[AT]users.sourceforge.net>
+	Gif initialization fix
+	windows build code
+
+Peter Mehlitz <peter[AT]transvirtual.com>
+        callbacks to read data from arbitrary sources (like libjpeg/libpng)
+
+Dick Porter <dick[AT]cymru.net>
+        int/pointer fixes for Alpha
+
+Eric Raymond <esr[AT]snark.thyrsus.com>
+        current as well as long time former maintainer of giflib code
+
+Petter Reinholdtsen <pere[AT]hungry.com>
+	Tru64 build fixs
+	
+Georg Schwarz <geos[AT]epost.de>
+	IRIX fixes

3rdparty/QtGifImage/include/3rdparty/giflib/COPYING

@@ -0,0 +1,19 @@
+The GIFLIB distribution is Copyright (c) 1997  Eric S. Raymond
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

3rdparty/QtGifImage/include/3rdparty/giflib/README

@@ -0,0 +1,27 @@
+= GIFLIB =
+
+This is the README file of GIFLIB, a library for manipulating GIF files.
+
+Latest versions of GIFLIB are currently hosted at:
+    http://sourceforge.net/projects/giflib
+
+== Overview ==
+
+GIF is a legacy format; we recommend against generating new images in
+it.  For a cleaner, more extensible design with better color support
+and compression, look up PNG.
+
+giflib provides code for reading GIF files and transforming them into 
+RGB bitmaps, and for writing RGB bitmaps as GIF files.
+
+The (permissive) open-source license is in the file COPYING.
+
+You will find build instructions in build.asc
+
+You will find full documentation of the API in doc/ and on the 
+project website.
+
+The project has a long and confusing history, described in history.asc
+
+The project to-do list is in TODO.
+

3rdparty/QtGifImage/include/3rdparty/giflib/gif_err.c

@@ -0,0 +1,67 @@
+/*****************************************************************************
+
+gif_err.c - handle error reporting for the GIF library.
+
+****************************************************************************/
+
+#include <giflib/gif_lib.h>
+
+/*****************************************************************************
+ Return a string description of  the last GIF error
+*****************************************************************************/
+char *
+GifErrorString(int ErrorCode) {
+  char *Err;
+
+  switch (ErrorCode) {
+  case E_GIF_ERR_OPEN_FAILED: Err = "Failed to open given file";
+	break;
+  case E_GIF_ERR_WRITE_FAILED: Err = "Failed to write to given file";
+	break;
+  case E_GIF_ERR_HAS_SCRN_DSCR: Err = "Screen descriptor has already been set";
+	break;
+  case E_GIF_ERR_HAS_IMAG_DSCR: Err = "Image descriptor is still active";
+	break;
+  case E_GIF_ERR_NO_COLOR_MAP: Err = "Neither global nor local color map";
+	break;
+  case E_GIF_ERR_DATA_TOO_BIG: Err = "Number of pixels bigger than width * height";
+	break;
+  case E_GIF_ERR_NOT_ENOUGH_MEM: Err = "Failed to allocate required memory";
+	break;
+  case E_GIF_ERR_DISK_IS_FULL: Err = "Write failed (disk full?)";
+	break;
+  case E_GIF_ERR_CLOSE_FAILED: Err = "Failed to close given file";
+	break;
+  case E_GIF_ERR_NOT_WRITEABLE: Err = "Given file was not opened for write";
+	break;
+  case D_GIF_ERR_OPEN_FAILED: Err = "Failed to open given file";
+	break;
+  case D_GIF_ERR_READ_FAILED: Err = "Failed to read from given file";
+	break;
+  case D_GIF_ERR_NOT_GIF_FILE: Err = "Data is not in GIF format";
+	break;
+  case D_GIF_ERR_NO_SCRN_DSCR: Err = "No screen descriptor detected";
+	break;
+  case D_GIF_ERR_NO_IMAG_DSCR: Err = "No Image Descriptor detected";
+	break;
+  case D_GIF_ERR_NO_COLOR_MAP: Err = "Neither global nor local color map";
+	break;
+  case D_GIF_ERR_WRONG_RECORD: Err = "Wrong record type detected";
+	break;
+  case D_GIF_ERR_DATA_TOO_BIG: Err = "Number of pixels bigger than width * height";
+	break;
+  case D_GIF_ERR_NOT_ENOUGH_MEM: Err = "Failed to allocate required memory";
+	break;
+  case D_GIF_ERR_CLOSE_FAILED: Err = "Failed to close given file";
+	break;
+  case D_GIF_ERR_NOT_READABLE: Err = "Given file was not opened for read";
+	break;
+  case D_GIF_ERR_IMAGE_DEFECT: Err = "Image is defective, decoding aborted";
+	break;
+  case D_GIF_ERR_EOF_TOO_SOON: Err = "Image EOF detected before image complete";
+	break;
+  default: Err = NULL;
+	break;
+  }
+  return Err;
+}

3rdparty/QtGifImage/include/3rdparty/giflib/gif_font.c

@@ -0,0 +1,246 @@
+/*****************************************************************************
+ 
+gif_font.c - utility font handling and simple drawing for the GIF library
+ 
+****************************************************************************/
+
+#include <string.h>
+
+#include <giflib/gif_lib.h>
+
+/*****************************************************************************
+ Ascii 8 by 8 regular font - only first 128 characters are supported.
+*****************************************************************************/
+
+/*
+ * Each array entry holds the bits for 8 horizontal scan lines, topmost
+ * first.  The most significant bit of each constant is the leftmost bit of
+ * the scan line.
+ */
+/*@+charint@*/
+const unsigned char GifAsciiTable8x8[][GIF_FONT_WIDTH] = {
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},    /* Ascii 0 */
+	{0x3c, 0x42, 0xa5, 0x81, 0xbd, 0x42, 0x3c, 0x00},    /* Ascii 1 */
+	{0x3c, 0x7e, 0xdb, 0xff, 0xc3, 0x7e, 0x3c, 0x00},    /* Ascii 2 */
+	{0x00, 0xee, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00},    /* Ascii 3 */
+	{0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00},    /* Ascii 4 */
+	{0x00, 0x3c, 0x18, 0xff, 0xff, 0x08, 0x18, 0x00},    /* Ascii 5 */
+	{0x10, 0x38, 0x7c, 0xfe, 0xfe, 0x10, 0x38, 0x00},    /* Ascii 6 */
+	{0x00, 0x00, 0x18, 0x3c, 0x18, 0x00, 0x00, 0x00},    /* Ascii 7 */
+	{0xff, 0xff, 0xe7, 0xc3, 0xe7, 0xff, 0xff, 0xff},    /* Ascii 8 */
+	{0x00, 0x3c, 0x42, 0x81, 0x81, 0x42, 0x3c, 0x00},    /* Ascii 9 */
+	{0xff, 0xc3, 0xbd, 0x7e, 0x7e, 0xbd, 0xc3, 0xff},    /* Ascii 10 */
+	{0x1f, 0x07, 0x0d, 0x7c, 0xc6, 0xc6, 0x7c, 0x00},    /* Ascii 11 */
+	{0x00, 0x7e, 0xc3, 0xc3, 0x7e, 0x18, 0x7e, 0x18},    /* Ascii 12 */
+	{0x04, 0x06, 0x07, 0x04, 0x04, 0xfc, 0xf8, 0x00},    /* Ascii 13 */
+	{0x0c, 0x0a, 0x0d, 0x0b, 0xf9, 0xf9, 0x1f, 0x1f},    /* Ascii 14 */
+	{0x00, 0x92, 0x7c, 0x44, 0xc6, 0x7c, 0x92, 0x00},    /* Ascii 15 */
+	{0x00, 0x00, 0x60, 0x78, 0x7e, 0x78, 0x60, 0x00},    /* Ascii 16 */
+	{0x00, 0x00, 0x06, 0x1e, 0x7e, 0x1e, 0x06, 0x00},    /* Ascii 17 */
+	{0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x18},    /* Ascii 18 */
+	{0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00},    /* Ascii 19 */
+	{0xff, 0xb6, 0x76, 0x36, 0x36, 0x36, 0x36, 0x00},    /* Ascii 20 */
+	{0x7e, 0xc1, 0xdc, 0x22, 0x22, 0x1f, 0x83, 0x7e},    /* Ascii 21 */
+	{0x00, 0x00, 0x00, 0x7e, 0x7e, 0x00, 0x00, 0x00},    /* Ascii 22 */
+	{0x18, 0x7e, 0x18, 0x18, 0x7e, 0x18, 0x00, 0xff},    /* Ascii 23 */
+	{0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00},    /* Ascii 24 */
+	{0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x00},    /* Ascii 25 */
+	{0x00, 0x04, 0x06, 0xff, 0x06, 0x04, 0x00, 0x00},    /* Ascii 26 */
+	{0x00, 0x20, 0x60, 0xff, 0x60, 0x20, 0x00, 0x00},    /* Ascii 27 */
+	{0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xff, 0x00},    /* Ascii 28 */
+	{0x00, 0x24, 0x66, 0xff, 0x66, 0x24, 0x00, 0x00},    /* Ascii 29 */
+	{0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, 0x00, 0x00},    /* Ascii 30 */
+	{0x00, 0x00, 0x00, 0xfe, 0x7c, 0x38, 0x10, 0x00},    /* Ascii 31 */
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},    /* */
+	{0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x30, 0x00},    /* ! */
+	{0x66, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},    /* " */
+	{0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00},    /* # */
+	{0x10, 0x7c, 0xd2, 0x7c, 0x86, 0x7c, 0x10, 0x00},    /* $ */
+	{0xf0, 0x96, 0xfc, 0x18, 0x3e, 0x72, 0xde, 0x00},    /* % */
+	{0x30, 0x48, 0x30, 0x78, 0xce, 0xcc, 0x78, 0x00},    /* & */
+	{0x0c, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00},    /* ' */
+	{0x10, 0x60, 0xc0, 0xc0, 0xc0, 0x60, 0x10, 0x00},    /* ( */
+	{0x10, 0x0c, 0x06, 0x06, 0x06, 0x0c, 0x10, 0x00},    /* ) */
+	{0x00, 0x54, 0x38, 0xfe, 0x38, 0x54, 0x00, 0x00},    /* * */
+	{0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00},    /* + */
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x70},    /* , */
+	{0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00},    /* - */
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00},    /* . */
+	{0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x00},    /* / */
+	{0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00},    /* 0 */
+	{0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x3c, 0x00},    /* 1 */
+	{0x7c, 0xc6, 0x06, 0x0c, 0x30, 0x60, 0xfe, 0x00},    /* 2 */
+	{0x7c, 0xc6, 0x06, 0x3c, 0x06, 0xc6, 0x7c, 0x00},    /* 3 */
+	{0x0e, 0x1e, 0x36, 0x66, 0xfe, 0x06, 0x06, 0x00},    /* 4 */
+	{0xfe, 0xc0, 0xc0, 0xfc, 0x06, 0x06, 0xfc, 0x00},    /* 5 */
+	{0x7c, 0xc6, 0xc0, 0xfc, 0xc6, 0xc6, 0x7c, 0x00},    /* 6 */
+	{0xfe, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x60, 0x00},    /* 7 */
+	{0x7c, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0x7c, 0x00},    /* 8 */
+	{0x7c, 0xc6, 0xc6, 0x7e, 0x06, 0xc6, 0x7c, 0x00},    /* 9 */
+	{0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00},    /* : */
+	{0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x20, 0x00},    /* }, */
+	{0x00, 0x1c, 0x30, 0x60, 0x30, 0x1c, 0x00, 0x00},    /* < */
+	{0x00, 0x00, 0x7e, 0x00, 0x7e, 0x00, 0x00, 0x00},    /* = */
+	{0x00, 0x70, 0x18, 0x0c, 0x18, 0x70, 0x00, 0x00},    /* > */
+	{0x7c, 0xc6, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00},    /* ? */
+	{0x7c, 0x82, 0x9a, 0xaa, 0xaa, 0x9e, 0x7c, 0x00},    /* @ */
+	{0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x00},    /* A */
+	{0xfc, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xfc, 0x00},    /* B */
+	{0x7c, 0xc6, 0xc6, 0xc0, 0xc0, 0xc6, 0x7c, 0x00},    /* C */
+	{0xf8, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 0xf8, 0x00},    /* D */
+	{0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xfe, 0x00},    /* E */
+	{0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0x00},    /* F */
+	{0x7c, 0xc6, 0xc0, 0xce, 0xc6, 0xc6, 0x7e, 0x00},    /* G */
+	{0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00},    /* H */
+	{0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00},    /* I */
+	{0x1e, 0x06, 0x06, 0x06, 0xc6, 0xc6, 0x7c, 0x00},    /* J */
+	{0xc6, 0xcc, 0xd8, 0xf0, 0xd8, 0xcc, 0xc6, 0x00},    /* K */
+	{0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0x00},    /* L */
+	{0xc6, 0xee, 0xfe, 0xd6, 0xc6, 0xc6, 0xc6, 0x00},    /* M */
+	{0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00},    /* N */
+	{0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00},    /* O */
+	{0xfc, 0xc6, 0xc6, 0xfc, 0xc0, 0xc0, 0xc0, 0x00},    /* P */
+	{0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x06},    /* Q */
+	{0xfc, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xc6, 0x00},    /* R */
+	{0x78, 0xcc, 0x60, 0x30, 0x18, 0xcc, 0x78, 0x00},    /* S */
+	{0xfc, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00},    /* T */
+	{0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00},    /* U */
+	{0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00},    /* V */
+	{0xc6, 0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x00},    /* W */
+	{0xc6, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0xc6, 0x00},    /* X */
+	{0xc3, 0xc3, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x00},    /* Y */
+	{0xfe, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xfe, 0x00},    /* Z */
+	{0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c, 0x00},    /* [ */
+	{0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x00},    /* \ */
+	{0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 0x00},    /* ] */
+	{0x00, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00},    /* ^ */
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff},    /* _ */
+	{0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00},    /* ` */
+	{0x00, 0x00, 0x7c, 0x06, 0x7e, 0xc6, 0x7e, 0x00},    /* a */
+	{0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xe6, 0xdc, 0x00},    /* b */
+	{0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0x7e, 0x00},    /* c */
+	{0x06, 0x06, 0x7e, 0xc6, 0xc6, 0xce, 0x76, 0x00},    /* d */
+	{0x00, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0x7e, 0x00},    /* e */
+	{0x1e, 0x30, 0x7c, 0x30, 0x30, 0x30, 0x30, 0x00},    /* f */
+	{0x00, 0x00, 0x7e, 0xc6, 0xce, 0x76, 0x06, 0x7c},    /* g */
+	{0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x00},    /* */
+	{0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x3c, 0x00},    /* i */
+	{0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0xf0},    /* j */
+	{0xc0, 0xc0, 0xcc, 0xd8, 0xf0, 0xd8, 0xcc, 0x00},    /* k */
+	{0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00},    /* l */
+	{0x00, 0x00, 0xcc, 0xfe, 0xd6, 0xc6, 0xc6, 0x00},    /* m */
+	{0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x00},    /* n */
+	{0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7c, 0x00},    /* o */
+	{0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xe6, 0xdc, 0xc0},    /* p */
+	{0x00, 0x00, 0x7e, 0xc6, 0xc6, 0xce, 0x76, 0x06},    /* q */
+	{0x00, 0x00, 0x6e, 0x70, 0x60, 0x60, 0x60, 0x00},    /* r */
+	{0x00, 0x00, 0x7c, 0xc0, 0x7c, 0x06, 0xfc, 0x00},    /* s */
+	{0x30, 0x30, 0x7c, 0x30, 0x30, 0x30, 0x1c, 0x00},    /* t */
+	{0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x00},    /* u */
+	{0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00},    /* v */
+	{0x00, 0x00, 0xc6, 0xc6, 0xd6, 0xfe, 0x6c, 0x00},    /* w */
+	{0x00, 0x00, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00},    /* x */
+	{0x00, 0x00, 0xc6, 0xc6, 0xce, 0x76, 0x06, 0x7c},    /* y */
+	{0x00, 0x00, 0xfc, 0x18, 0x30, 0x60, 0xfc, 0x00},    /* z */
+	{0x0e, 0x18, 0x18, 0x70, 0x18, 0x18, 0x0e, 0x00},    /* { */
+	{0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00},    /* | */
+	{0xe0, 0x30, 0x30, 0x1c, 0x30, 0x30, 0xe0, 0x00},    /* } */
+	{0x00, 0x00, 0x70, 0x9a, 0x0e, 0x00, 0x00, 0x00},    /* ~ */
+	{0x00, 0x00, 0x18, 0x3c, 0x66, 0xff, 0x00, 0x00}    /* Ascii 127 */
+};
+/*@=charint@*/
+
+void
+GifDrawText8x8(SavedImage *Image,
+			   const int x, const int y,
+			   const char *legend,
+			   const int color) {
+  int i, j;
+  int base;
+  const char *cp;
+
+  for (i = 0; i < GIF_FONT_HEIGHT; i++) {
+	base = Image->ImageDesc.Width * (y + i) + x;
+
+	for (cp = legend; *cp; cp++)
+	  for (j = 0; j < GIF_FONT_WIDTH; j++) {
+		if (GifAsciiTable8x8[(short)(*cp)][i] & (1 << (GIF_FONT_WIDTH - j)))
+		  Image->RasterBits[base] = color;
+		base++;
+	  }
+  }
+}
+
+void
+GifDrawBox(SavedImage *Image,
+		   const int x, const int y,
+		   const int w, const int d,
+		   const int color) {
+  int j, base = Image->ImageDesc.Width * y + x;
+
+  for (j = 0; j < w; j++)
+	Image->RasterBits[base + j] =
+	Image->RasterBits[base + (d * Image->ImageDesc.Width) + j] = color;
+
+  for (j = 0; j < d; j++)
+	Image->RasterBits[base + j * Image->ImageDesc.Width] =
+	Image->RasterBits[base + j * Image->ImageDesc.Width + w] = color;
+}
+
+void
+GifDrawRectangle(SavedImage *Image,
+				 const int x, const int y,
+				 const int w, const int d,
+				 const int color) {
+  unsigned char *bp = Image->RasterBits + Image->ImageDesc.Width * y + x;
+  int i;
+
+  for (i = 0; i < d; i++)
+	memset(bp + (i * Image->ImageDesc.Width), color, (size_t)w);
+}
+
+void
+GifDrawBoxedText8x8(SavedImage *Image,
+					const int x, const int y,
+					const char *legend,
+					const int border,
+					const int bg, const int fg) {
+  int i, j = 0, LineCount = 0, TextWidth = 0;
+  const char *cp;
+
+  /* compute size of text to box */
+  for (cp = legend; *cp; cp++)
+	if (*cp == '\r') {
+	  if (j > TextWidth)
+		TextWidth = j;
+	  j = 0;
+	  LineCount++;
+	} else if (*cp != '\t')
+	  ++j;
+  LineCount++;    /* count last line */
+  if (j > TextWidth)    /* last line might be longer than any previous */
+	TextWidth = j;
+
+  /* fill the box */
+  GifDrawRectangle(Image, x + 1, y + 1,
+				   border + TextWidth * GIF_FONT_WIDTH + border - 1,
+				   border + LineCount * GIF_FONT_HEIGHT + border - 1, bg);
+
+  /* draw the text */
+  i = 0;
+  cp = strtok((char *)legend, "\r\n");
+  do {
+	int leadspace = 0;
+
+	if (cp[0] == '\t')
+	  leadspace = (int)(TextWidth - strlen(++cp)) / 2;
+
+	GifDrawText8x8(Image, x + border + (leadspace * GIF_FONT_WIDTH),
+				   y + border + (GIF_FONT_HEIGHT * i++), cp, fg);
+	cp = strtok((char *)NULL, "\r\n");
+  } while (cp);
+
+  /* outline the box */
+  GifDrawBox(Image, x, y, border + TextWidth * GIF_FONT_WIDTH + border,
+			 border + LineCount * GIF_FONT_HEIGHT + border, fg);
+}

3rdparty/QtGifImage/include/3rdparty/giflib/gif_hash.c

@@ -0,0 +1,121 @@
+/*****************************************************************************
+
+gif_hash.c -- module to support the following operations:
+
+1. InitHashTable - initialize hash table.
+2. ClearHashTable - clear the hash table to an empty state.
+2. InsertHashTable - insert one item into data structure.
+3. ExistsHashTable - test if item exists in data structure.
+
+This module is used to hash the GIF codes during encoding.
+
+*****************************************************************************/
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <giflib/gif_hash.h>
+
+/* #define  DEBUG_HIT_RATE    Debug number of misses per hash Insert/Exists. */
+
+#ifdef    DEBUG_HIT_RATE
+static long NumberOfTests = 0,
+		NumberOfMisses = 0;
+#endif    /* DEBUG_HIT_RATE */
+
+static int KeyItem(uint32_t Item);
+
+/******************************************************************************
+ Initialize HashTable - allocate the memory needed and clear it.	      *
+******************************************************************************/
+GifHashTableType *_InitHashTable(void) {
+  GifHashTableType *HashTable;
+
+  if ((HashTable = (GifHashTableType *)malloc(sizeof(GifHashTableType)))
+	  == NULL)
+	return NULL;
+
+  _ClearHashTable(HashTable);
+
+  return HashTable;
+}
+
+/******************************************************************************
+ Routine to clear the HashTable to an empty state.			      *
+ This part is a little machine depended. Use the commented part otherwise.   *
+******************************************************************************/
+void _ClearHashTable(GifHashTableType *HashTable) {
+  memset(HashTable->HTable, 0xFF, HT_SIZE * sizeof(uint32_t));
+}
+
+/******************************************************************************
+ Routine to insert a new Item into the HashTable. The data is assumed to be  *
+ new one.								      *
+******************************************************************************/
+void _InsertHashTable(GifHashTableType *HashTable, uint32_t Key, int Code) {
+  int HKey = KeyItem(Key);
+  uint32_t *HTable = HashTable->HTable;
+
+#ifdef DEBUG_HIT_RATE
+  NumberOfTests++;
+	NumberOfMisses++;
+#endif /* DEBUG_HIT_RATE */
+
+  while (HT_GET_KEY(HTable[HKey]) != 0xFFFFFL) {
+#ifdef DEBUG_HIT_RATE
+	NumberOfMisses++;
+#endif /* DEBUG_HIT_RATE */
+	HKey = (HKey + 1) & HT_KEY_MASK;
+  }
+  HTable[HKey] = HT_PUT_KEY(Key) | HT_PUT_CODE(Code);
+}
+
+/******************************************************************************
+ Routine to test if given Key exists in HashTable and if so returns its code *
+ Returns the Code if key was found, -1 if not.				      *
+******************************************************************************/
+int _ExistsHashTable(GifHashTableType *HashTable, uint32_t Key) {
+  int HKey = KeyItem(Key);
+  uint32_t *HTable = HashTable->HTable, HTKey;
+
+#ifdef DEBUG_HIT_RATE
+  NumberOfTests++;
+	NumberOfMisses++;
+#endif /* DEBUG_HIT_RATE */
+
+  while ((HTKey = HT_GET_KEY(HTable[HKey])) != 0xFFFFFL) {
+#ifdef DEBUG_HIT_RATE
+	NumberOfMisses++;
+#endif /* DEBUG_HIT_RATE */
+	if (Key == HTKey)
+	  return HT_GET_CODE(HTable[HKey]);
+	HKey = (HKey + 1) & HT_KEY_MASK;
+  }
+
+  return -1;
+}
+
+/******************************************************************************
+ Routine to generate an HKey for the hashtable out of the given unique key.  *
+ The given Key is assumed to be 20 bits as follows: lower 8 bits are the     *
+ new postfix character, while the upper 12 bits are the prefix code.	      *
+ Because the average hit ratio is only 2 (2 hash references per entry),      *
+ evaluating more complex keys (such as twin prime keys) does not worth it!   *
+******************************************************************************/
+static int KeyItem(uint32_t Item) {
+  return (int)(((Item >> 12) ^ Item) & HT_KEY_MASK);
+}
+
+#ifdef    DEBUG_HIT_RATE
+/******************************************************************************
+ Debugging routine to print the hit ratio - number of times the hash table   *
+ was tested per operation. This routine was used to test the KeyItem routine *
+******************************************************************************/
+void HashTablePrintHitRatio(void)
+{
+	printf("Hash Table Hit Ratio is %ld/%ld = %ld%%.\n",
+	NumberOfMisses, NumberOfTests,
+	NumberOfMisses * 100 / NumberOfTests);
+}
+#endif    /* DEBUG_HIT_RATE */

3rdparty/QtGifImage/include/3rdparty/giflib/gif_hash.h

@@ -0,0 +1,39 @@
+/******************************************************************************
+
+gif_hash.h - magfic constants and declarations for GIF LZW
+
+******************************************************************************/
+
+#ifndef GIF_LIB_GIF_HASH_H_
+#define GIF_LIB_GIF_HASH_H_
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+#include <stdint.h>
+
+#define HT_SIZE 8192       /* 12bits = 4096 or twice as big! */
+#define HT_KEY_MASK 0x1FFF /* 13bits keys */
+#define HT_KEY_NUM_BITS 13 /* 13bits keys */
+#define HT_MAX_KEY 8191    /* 13bits - 1, maximal code possible */
+#define HT_MAX_CODE 4095   /* Biggest code possible in 12 bits. */
+
+/* The 32 bits of the long are divided into two parts for the key & code:   */
+/* 1. The code is 12 bits as our compression algorithm is limited to 12bits */
+/* 2. The key is 12 bits Prefix code + 8 bit new char or 20 bits.	    */
+/* The key is the upper 20 bits.  The code is the lower 12. */
+#define HT_GET_KEY(l) (l >> 12)
+#define HT_GET_CODE(l) (l & 0x0FFF)
+#define HT_PUT_KEY(l) (l << 12)
+#define HT_PUT_CODE(l) (l & 0x0FFF)
+
+typedef struct GifHashTableType {
+  uint32_t HTable[HT_SIZE];
+} GifHashTableType;
+
+GifHashTableType *_InitHashTable(void);
+void _ClearHashTable(GifHashTableType *HashTable);
+void _InsertHashTable(GifHashTableType *HashTable, uint32_t Key, int Code);
+int _ExistsHashTable(GifHashTableType *HashTable, uint32_t Key);
+
+#endif // GIF_LIB_GIF_HASH_H_

3rdparty/QtGifImage/include/3rdparty/giflib/gif_lib.h

@@ -0,0 +1,319 @@
+/******************************************************************************
+ 
+gif_lib.h - service library for decoding and encoding GIF images
+                                                                             
+*****************************************************************************/
+
+#ifndef GIF_LIB_GIF_LIB_H_
+#define GIF_LIB_GIF_LIB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define GIFLIB_MAJOR 5
+#define GIFLIB_MINOR 0
+#define GIFLIB_RELEASE 5
+
+#define GIF_ERROR   0
+#define GIF_OK      1
+
+#include <stddef.h>
+
+#define BOOL int
+#define TRUE 1
+#define FALSE 0
+
+//#ifdef _MSC_VER
+//#define BOOL int
+//#define TRUE 1
+//#define FALSE 0
+//#else
+//#include <stdbool.h>
+//#define BOOL int
+//#define TRUE 1
+//#define FALSE 0
+//#endif
+
+#define GIF_STAMP "GIFVER"          /* First chars in file - GIF stamp.  */
+#define GIF_STAMP_LEN sizeof(GIF_STAMP) - 1
+#define GIF_VERSION_POS 3           /* Version first character in stamp. */
+#define GIF87_STAMP "GIF87a"        /* First chars in file - GIF stamp.  */
+#define GIF89_STAMP "GIF89a"        /* First chars in file - GIF stamp.  */
+
+typedef unsigned char GifPixelType;
+typedef unsigned char *GifRowType;
+typedef unsigned char GifByteType;
+typedef unsigned int GifPrefixType;
+typedef int GifWord;
+
+typedef struct GifColorType {
+  GifByteType Red, Green, Blue;
+} GifColorType;
+
+typedef struct ColorMapObject {
+  int ColorCount;
+  int BitsPerPixel;
+  BOOL SortFlag;
+  GifColorType *Colors;    /* on malloc(3) heap */
+} ColorMapObject;
+
+typedef struct GifImageDesc {
+  GifWord Left, Top, Width, Height;   /* Current image dimensions. */
+  BOOL Interlace;                     /* Sequential/Interlaced lines. */
+  ColorMapObject *ColorMap;           /* The local color map */
+} GifImageDesc;
+
+typedef struct ExtensionBlock {
+  int ByteCount;
+  GifByteType *Bytes; /* on malloc(3) heap */
+  int Function;       /* The block function code */
+#define CONTINUE_EXT_FUNC_CODE    0x00    /* continuation subblock */
+#define COMMENT_EXT_FUNC_CODE     0xfe    /* comment */
+#define GRAPHICS_EXT_FUNC_CODE    0xf9    /* graphics control (GIF89) */
+#define PLAINTEXT_EXT_FUNC_CODE   0x01    /* plaintext */
+#define APPLICATION_EXT_FUNC_CODE 0xff    /* application block */
+} ExtensionBlock;
+
+typedef struct SavedImage {
+  GifImageDesc ImageDesc;
+  GifByteType *RasterBits;         /* on malloc(3) heap */
+  int ExtensionBlockCount;         /* Count of extensions before image */
+  ExtensionBlock *ExtensionBlocks; /* Extensions before image */
+} SavedImage;
+
+typedef struct GifFileType {
+  GifWord SWidth, SHeight;         /* Size of virtual canvas */
+  GifWord SColorResolution;        /* How many colors can we generate? */
+  GifWord SBackGroundColor;        /* Background color for virtual canvas */
+  GifByteType AspectByte;         /* Used to compute pixel aspect ratio */
+  ColorMapObject *SColorMap;       /* Global colormap, NULL if nonexistent. */
+  int ImageCount;                  /* Number of current image (both APIs) */
+  GifImageDesc Image;              /* Current image (low-level API) */
+  SavedImage *SavedImages;         /* Image sequence (high-level API) */
+  int ExtensionBlockCount;         /* Count extensions past last image */
+  ExtensionBlock *ExtensionBlocks; /* Extensions past last image */
+  int Error;                 /* Last error condition reported */
+  void *UserData;                  /* hook to attach user data (TVT) */
+  void *Private;                   /* Don't mess with this! */
+} GifFileType;
+
+#define GIF_ASPECT_RATIO(n)    ((n)+15.0/64.0)
+
+typedef enum {
+  UNDEFINED_RECORD_TYPE,
+  SCREEN_DESC_RECORD_TYPE,
+  IMAGE_DESC_RECORD_TYPE, /* Begin with ',' */
+  EXTENSION_RECORD_TYPE,  /* Begin with '!' */
+  TERMINATE_RECORD_TYPE   /* Begin with ';' */
+} GifRecordType;
+
+/* func type to read gif data from arbitrary sources (TVT) */
+typedef int (*InputFunc)(GifFileType *, GifByteType *, int);
+
+/* func type to write gif data to arbitrary targets.
+ * Returns count of bytes written. (MRB)
+ */
+typedef int (*OutputFunc)(GifFileType *, const GifByteType *, int);
+
+/******************************************************************************
+ GIF89 structures
+******************************************************************************/
+
+#define DISPOSAL_UNSPECIFIED      0       /* No disposal specified. */
+#define DISPOSE_DO_NOT            1       /* Leave image in place */
+#define DISPOSE_BACKGROUND        2       /* Set area too background color */
+#define DISPOSE_PREVIOUS          3       /* Restore to previous content */
+#define NO_TRANSPARENT_COLOR    (-1)
+
+typedef struct GraphicsControlBlock {
+  int DisposalMode;
+  BOOL UserInputFlag;      /* User confirmation required before disposal */
+  int DelayTime;           /* pre-display delay in 0.01sec units */
+  int TransparentColor;    /* Palette index for transparency, -1 if none */
+} GraphicsControlBlock;
+
+/******************************************************************************
+ GIF encoding routines
+******************************************************************************/
+
+/* Main entry points */
+GifFileType *EGifOpenFileName(const char *GifFileName,
+							  BOOL GifTestExistence, int *Error);
+GifFileType *EGifOpenFileHandle(int GifFileHandle, int *Error);
+GifFileType *EGifOpen(void *userPtr, OutputFunc writeFunc, int *Error);
+int EGifSpew(GifFileType *GifFile);
+char *EGifGetGifVersion(GifFileType *GifFile); /* new in 5.x */
+int EGifCloseFile(GifFileType *GifFile);
+int EGifCloseFile1(GifFileType *GifFile);
+
+#define E_GIF_ERR_OPEN_FAILED    1    /* And EGif possible errors. */
+#define E_GIF_ERR_WRITE_FAILED   2
+#define E_GIF_ERR_HAS_SCRN_DSCR  3
+#define E_GIF_ERR_HAS_IMAG_DSCR  4
+#define E_GIF_ERR_NO_COLOR_MAP   5
+#define E_GIF_ERR_DATA_TOO_BIG   6
+#define E_GIF_ERR_NOT_ENOUGH_MEM 7
+#define E_GIF_ERR_DISK_IS_FULL   8
+#define E_GIF_ERR_CLOSE_FAILED   9
+#define E_GIF_ERR_NOT_WRITEABLE  10
+
+/* These are legacy.  You probably do not want to call them directly */
+int EGifPutScreenDesc(GifFileType *GifFile,
+					  int GifWidth, int GifHeight,
+					  int GifColorRes, int GifBackGround,
+					  const ColorMapObject *GifColorMap);
+int EGifPutImageDesc(GifFileType *GifFile,
+					 int GifLeft, int GifTop,
+					 int GifWidth, int GifHeight,
+					 BOOL GifInterlace,
+					 const ColorMapObject *GifColorMap);
+void EGifSetGifVersion(GifFileType *GifFile, BOOL gif89);
+int EGifPutLine(GifFileType *GifFile, GifPixelType *GifLine,
+				int GifLineLen);
+int EGifPutPixel(GifFileType *GifFile, GifPixelType GifPixel);
+int EGifPutComment(GifFileType *GifFile, const char *GifComment);
+int EGifPutExtensionLeader(GifFileType *GifFile, int GifExtCode);
+int EGifPutExtensionBlock(GifFileType *GifFile,
+						  int GifExtLen, const void *GifExtension);
+int EGifPutExtensionTrailer(GifFileType *GifFile);
+int EGifPutExtension(GifFileType *GifFile, int GifExtCode,
+					 int GifExtLen,
+					 const void *GifExtension);
+int EGifPutCode(GifFileType *GifFile, const GifByteType *GifCodeBlock);
+int EGifPutCodeNext(GifFileType *GifFile,
+					const GifByteType *GifCodeBlock);
+
+/******************************************************************************
+ GIF decoding routines
+******************************************************************************/
+
+/* Main entry points */
+GifFileType *DGifOpenFileName(const char *GifFileName, int *Error);
+GifFileType *DGifOpenFileHandle(int GifFileHandle, int *Error);
+int DGifSlurp(GifFileType *GifFile);
+GifFileType *DGifOpen(void *userPtr, InputFunc readFunc, int *Error);    /* new one (TVT) */
+int DGifCloseFile(GifFileType *GifFile);
+
+#define D_GIF_ERR_OPEN_FAILED    101    /* And DGif possible errors. */
+#define D_GIF_ERR_READ_FAILED    102
+#define D_GIF_ERR_NOT_GIF_FILE   103
+#define D_GIF_ERR_NO_SCRN_DSCR   104
+#define D_GIF_ERR_NO_IMAG_DSCR   105
+#define D_GIF_ERR_NO_COLOR_MAP   106
+#define D_GIF_ERR_WRONG_RECORD   107
+#define D_GIF_ERR_DATA_TOO_BIG   108
+#define D_GIF_ERR_NOT_ENOUGH_MEM 109
+#define D_GIF_ERR_CLOSE_FAILED   110
+#define D_GIF_ERR_NOT_READABLE   111
+#define D_GIF_ERR_IMAGE_DEFECT   112
+#define D_GIF_ERR_EOF_TOO_SOON   113
+
+/* These are legacy.  You probably do not want to call them directly */
+int DGifGetScreenDesc(GifFileType *GifFile);
+int DGifGetRecordType(GifFileType *GifFile, GifRecordType *GifType);
+int DGifGetImageDesc(GifFileType *GifFile);
+int DGifGetLine(GifFileType *GifFile, GifPixelType *GifLine, int GifLineLen);
+int DGifGetPixel(GifFileType *GifFile, GifPixelType GifPixel);
+int DGifGetComment(GifFileType *GifFile, char *GifComment);
+int DGifGetExtension(GifFileType *GifFile, int *GifExtCode,
+					 GifByteType **GifExtension);
+int DGifGetExtensionNext(GifFileType *GifFile, GifByteType **GifExtension);
+int DGifGetCode(GifFileType *GifFile, int *GifCodeSize,
+				GifByteType **GifCodeBlock);
+int DGifGetCodeNext(GifFileType *GifFile, GifByteType **GifCodeBlock);
+int DGifGetLZCodes(GifFileType *GifFile, int *GifCode);
+
+/******************************************************************************
+ Color table quantization (deprecated)
+******************************************************************************/
+int GifQuantizeBuffer(unsigned int Width, unsigned int Height,
+					  int *ColorMapSize, const GifByteType *RedInput,
+					  const GifByteType *GreenInput, const GifByteType *BlueInput,
+					  GifByteType *OutputBuffer,
+					  GifColorType *OutputColorMap);
+
+/******************************************************************************
+ Error handling and reporting.
+******************************************************************************/
+extern char *GifErrorString(int ErrorCode);     /* new in 2012 - ESR */
+
+/*****************************************************************************
+ Everything below this point is new after version 1.2, supporting `slurp
+ mode' for doing I/O in two big belts with all the image-bashing in core.
+******************************************************************************/
+
+/******************************************************************************
+ Color map handling from gif_alloc.c
+******************************************************************************/
+
+extern ColorMapObject *GifMakeMapObject(int ColorCount,
+										const GifColorType *ColorMap);
+extern void GifFreeMapObject(ColorMapObject *Object);
+extern ColorMapObject *GifUnionColorMap(const ColorMapObject *ColorIn1,
+										const ColorMapObject *ColorIn2,
+										GifPixelType ColorTransIn2[]);
+extern int GifBitSize(int n);
+
+/******************************************************************************
+ Support for the in-core structures allocation (slurp mode).
+******************************************************************************/
+
+extern void GifApplyTranslation(SavedImage *Image, const GifPixelType Translation[]);
+extern int GifAddExtensionBlock(int *ExtensionBlock_Count,
+								ExtensionBlock **ExtensionBlocks,
+								int Function,
+								unsigned int Len, unsigned char ExtData[]);
+extern void GifFreeExtensions(int *ExtensionBlock_Count,
+							  ExtensionBlock **ExtensionBlocks);
+extern void FreeLastSavedImage(GifFileType *GifFile);
+extern SavedImage *GifMakeSavedImage(GifFileType *GifFile,
+									 const SavedImage *CopyFrom);
+extern void GifFreeSavedImages(GifFileType *GifFile);
+
+/******************************************************************************
+ 5.x functions for GIF89 graphics control blocks
+******************************************************************************/
+
+int DGifExtensionToGCB(size_t GifExtensionLength,
+					   const GifByteType *GifExtension,
+					   GraphicsControlBlock *GCB);
+size_t EGifGCBToExtension(const GraphicsControlBlock *GCB,
+						  GifByteType *GifExtension);
+
+int DGifSavedExtensionToGCB(GifFileType *GifFile,
+							int ImageIndex,
+							GraphicsControlBlock *GCB);
+int EGifGCBToSavedExtension(const GraphicsControlBlock *GCB,
+							GifFileType *GifFile,
+							int ImageIndex);
+
+/******************************************************************************
+ The library's internal utility font
+******************************************************************************/
+
+#define GIF_FONT_WIDTH  8
+#define GIF_FONT_HEIGHT 8
+extern const unsigned char GifAsciiTable8x8[][GIF_FONT_WIDTH];
+
+extern void GifDrawText8x8(SavedImage *Image,
+						   int x, int y,
+						   const char *legend, int color);
+
+extern void GifDrawBox(SavedImage *Image,
+					   int x, int y,
+					   int w, int d, int color);
+
+extern void GifDrawRectangle(SavedImage *Image,
+							 int x, int y,
+							 int w, int d, int color);
+
+extern void GifDrawBoxedText8x8(SavedImage *Image,
+								int x, int y,
+								const char *legend,
+								int border, int bg, int fg);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif // GIF_LIB_GIF_LIB_H_

3rdparty/QtGifImage/include/3rdparty/giflib/gif_lib_private.h

@@ -0,0 +1,59 @@
+/****************************************************************************
+
+gif_lib_private.h - internal giflib routines and structures
+
+****************************************************************************/
+
+#ifndef GIF_LIB_GIF_LIB_PRIVATE_H_
+#define GIF_LIB_GIF_LIB_PRIVATE_H_
+
+#include <stdio.h>
+
+#include <giflib/gif_lib.h>
+#include <giflib/gif_hash.h>
+
+#define EXTENSION_INTRODUCER 0x21
+#define DESCRIPTOR_INTRODUCER 0x2c
+#define TERMINATOR_INTRODUCER 0x3b
+
+#define LZ_MAX_CODE 4095 /* Biggest code possible in 12 bits. */
+#define LZ_BITS 12
+
+#define FLUSH_OUTPUT 4096 /* Impossible code, to signal flush. */
+#define FIRST_CODE 4097   /* Impossible code, to signal first. */
+#define NO_SUCH_CODE 4098 /* Impossible code, to signal empty. */
+
+#define FILE_STATE_WRITE 0x01
+#define FILE_STATE_SCREEN 0x02
+#define FILE_STATE_IMAGE 0x04
+#define FILE_STATE_READ 0x08
+
+#define IS_READABLE(Private) (Private->FileState & FILE_STATE_READ)
+#define IS_WRITEABLE(Private) (Private->FileState & FILE_STATE_WRITE)
+
+typedef struct GifFilePrivateType {
+  GifWord FileState, FileHandle, /* Where all this data goes to! */
+  BitsPerPixel, /* Bits per pixel (Codes uses at least this + 1). */
+  ClearCode,    /* The CLEAR LZ code. */
+  EOFCode,      /* The EOF LZ code. */
+  RunningCode,  /* The next code algorithm can generate. */
+  RunningBits,  /* The number of bits required to represent RunningCode. */
+  MaxCode1,     /* 1 bigger than max. possible code, in RunningBits bits. */
+  LastCode,     /* The code before the current code. */
+  CrntCode,     /* Current algorithm code. */
+  StackPtr,     /* For character stack (see below). */
+  CrntShiftState;                  /* Number of bits in CrntShiftDWord. */
+  unsigned long CrntShiftDWord;        /* For bytes decomposition into codes. */
+  unsigned long PixelCount;            /* Number of pixels in image. */
+  FILE *File;                          /* File as stream. */
+  InputFunc Read;                      /* function to read gif input (TVT) */
+  OutputFunc Write;                    /* function to write gif output (MRB) */
+  GifByteType Buf[256];                /* Compressed input is buffered here. */
+  GifByteType Stack[LZ_MAX_CODE];      /* Decoded pixels are stacked here. */
+  GifByteType Suffix[LZ_MAX_CODE + 1]; /* So we can trace the codes. */
+  GifPrefixType Prefix[LZ_MAX_CODE + 1];
+  GifHashTableType *HashTable;
+  BOOL gif89;
+} GifFilePrivateType;
+
+#endif // GIF_LIB_GIF_LIB_PRIVATE_H_

3rdparty/QtGifImage/include/3rdparty/giflib/gifalloc.c

@@ -0,0 +1,393 @@
+/*****************************************************************************
+
+ GIF construction tools
+
+****************************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <giflib/gif_lib.h>
+
+#define MAX(x, y)    (((x) > (y)) ? (x) : (y))
+
+/******************************************************************************
+ Miscellaneous utility functions
+******************************************************************************/
+
+/* return smallest bitfield size n will fit in */
+int GifBitSize(int n) {
+  register int i;
+
+  for (i = 1; i <= 8; i++)
+	if ((1 << i) >= n)
+	  break;
+  return (i);
+}
+
+/******************************************************************************
+  Color map object functions
+******************************************************************************/
+
+/*
+ * Allocate a color map of given size; initialize with contents of
+ * ColorMap if that pointer is non-NULL.
+ */
+ColorMapObject *
+GifMakeMapObject(int ColorCount, const GifColorType *ColorMap) {
+  ColorMapObject *Object;
+
+  /*** FIXME: Our ColorCount has to be a power of two.  Is it necessary to
+   * make the user know that or should we automatically round up instead? */
+  if (ColorCount != (1 << GifBitSize(ColorCount))) {
+	return NULL;
+  }
+
+  Object = (ColorMapObject *)malloc(sizeof(ColorMapObject));
+  if (Object == NULL) {
+	return NULL;
+  }
+
+  Object->Colors = (GifColorType *)calloc(ColorCount, sizeof(GifColorType));
+  if (Object->Colors == NULL) {
+	free(Object);
+	return NULL;
+  }
+
+  Object->ColorCount = ColorCount;
+  Object->BitsPerPixel = GifBitSize(ColorCount);
+
+  if (ColorMap != NULL) {
+	memcpy((char *)Object->Colors,
+		   (char *)ColorMap, ColorCount * sizeof(GifColorType));
+  }
+
+  return (Object);
+}
+
+/*******************************************************************************
+Free a color map object
+*******************************************************************************/
+void
+GifFreeMapObject(ColorMapObject *Object) {
+  if (Object != NULL && Object->Colors != NULL) {
+	free(Object->Colors);
+  }
+  if (Object) {
+	free(Object);
+  }
+}
+
+#ifdef DEBUG
+void
+DumpColorMap(ColorMapObject *Object,
+			 FILE * fp)
+{
+	if (Object != NULL) {
+		int i, j, Len = Object->ColorCount;
+
+		for (i = 0; i < Len; i += 4) {
+			for (j = 0; j < 4 && j < Len; j++) {
+				(void)fprintf(fp, "%3d: %02x %02x %02x   ", i + j,
+				  Object->Colors[i + j].Red,
+				  Object->Colors[i + j].Green,
+				  Object->Colors[i + j].Blue);
+			}
+			(void)fprintf(fp, "\n");
+		}
+	}
+}
+#endif /* DEBUG */
+
+/*******************************************************************************
+ Compute the union of two given color maps and return it.  If result can't
+ fit into 256 colors, NULL is returned, the allocated union otherwise.
+ ColorIn1 is copied as is to ColorUnion, while colors from ColorIn2 are
+ copied iff they didn't exist before.  ColorTransIn2 maps the old
+ ColorIn2 into the ColorUnion color map table./
+*******************************************************************************/
+ColorMapObject *
+GifUnionColorMap(const ColorMapObject *ColorIn1,
+				 const ColorMapObject *ColorIn2,
+				 GifPixelType ColorTransIn2[]) {
+  int i, j, CrntSlot, RoundUpTo, NewGifBitSize;
+  ColorMapObject *ColorUnion;
+
+  /*
+   * We don't worry about duplicates within either color map; if
+   * the caller wants to resolve those, he can perform unions
+   * with an empty color map.
+   */
+
+  /* Allocate table which will hold the result for sure. */
+  ColorUnion = GifMakeMapObject(MAX(ColorIn1->ColorCount,
+									ColorIn2->ColorCount) * 2, NULL);
+
+  if (ColorUnion == NULL)
+	return (NULL);
+
+  /*
+   * Copy ColorIn1 to ColorUnion.
+   */
+  for (i = 0; i < ColorIn1->ColorCount; i++)
+	ColorUnion->Colors[i] = ColorIn1->Colors[i];
+  CrntSlot = ColorIn1->ColorCount;
+
+  /*
+   * Potentially obnoxious hack:
+   *
+   * Back CrntSlot down past all contiguous {0, 0, 0} slots at the end
+   * of table 1.  This is very useful if your display is limited to
+   * 16 colors.
+   */
+  while (ColorIn1->Colors[CrntSlot - 1].Red == 0
+	  && ColorIn1->Colors[CrntSlot - 1].Green == 0
+	  && ColorIn1->Colors[CrntSlot - 1].Blue == 0)
+	CrntSlot--;
+
+  /* Copy ColorIn2 to ColorUnion (use old colors if they exist): */
+  for (i = 0; i < ColorIn2->ColorCount && CrntSlot <= 256; i++) {
+	/* Let's see if this color already exists: */
+	for (j = 0; j < ColorIn1->ColorCount; j++)
+	  if (memcmp(&ColorIn1->Colors[j], &ColorIn2->Colors[i],
+				 sizeof(GifColorType)) == 0)
+		break;
+
+	if (j < ColorIn1->ColorCount)
+	  ColorTransIn2[i] = j;    /* color exists in Color1 */
+	else {
+	  /* Color is new - copy it to a new slot: */
+	  ColorUnion->Colors[CrntSlot] = ColorIn2->Colors[i];
+	  ColorTransIn2[i] = CrntSlot++;
+	}
+  }
+
+  if (CrntSlot > 256) {
+	GifFreeMapObject(ColorUnion);
+	return NULL;
+  }
+
+  NewGifBitSize = GifBitSize(CrntSlot);
+  RoundUpTo = (1 << NewGifBitSize);
+
+  if (RoundUpTo != ColorUnion->ColorCount) {
+	register GifColorType *Map = ColorUnion->Colors;
+
+	/*
+	 * Zero out slots up to next power of 2.
+	 * We know these slots exist because of the way ColorUnion's
+	 * start dimension was computed.
+	 */
+	for (j = CrntSlot; j < RoundUpTo; j++)
+	  Map[j].Red = Map[j].Green = Map[j].Blue = 0;
+
+	/* perhaps we can shrink the map? */
+	if (RoundUpTo < ColorUnion->ColorCount)
+	  ColorUnion->Colors = (GifColorType *)realloc(Map,
+												   sizeof(GifColorType) * RoundUpTo);
+  }
+
+  ColorUnion->ColorCount = RoundUpTo;
+  ColorUnion->BitsPerPixel = NewGifBitSize;
+
+  return (ColorUnion);
+}
+
+/*******************************************************************************
+ Apply a given color translation to the raster bits of an image
+*******************************************************************************/
+void
+GifApplyTranslation(SavedImage *Image, const GifPixelType Translation[]) {
+  register int i;
+  register int RasterSize = Image->ImageDesc.Height * Image->ImageDesc.Width;
+
+  for (i = 0; i < RasterSize; i++)
+	Image->RasterBits[i] = Translation[Image->RasterBits[i]];
+}
+
+/******************************************************************************
+ Extension record functions
+******************************************************************************/
+int
+GifAddExtensionBlock(int *ExtensionBlockCount,
+					 ExtensionBlock **ExtensionBlocks,
+					 int Function,
+					 unsigned int Len,
+					 unsigned char ExtData[]) {
+  ExtensionBlock *ep;
+
+  if (*ExtensionBlocks == NULL)
+	*ExtensionBlocks = (ExtensionBlock *)malloc(sizeof(ExtensionBlock));
+  else
+	*ExtensionBlocks = (ExtensionBlock *)realloc(*ExtensionBlocks,
+												 sizeof(ExtensionBlock) *
+													 (*ExtensionBlockCount + 1));
+
+  if (*ExtensionBlocks == NULL)
+	return (GIF_ERROR);
+
+  ep = &(*ExtensionBlocks)[(*ExtensionBlockCount)++];
+
+  ep->Function = Function;
+  ep->ByteCount = (int)(Len);
+  ep->Bytes = (GifByteType *)malloc(ep->ByteCount);
+  if (ep->Bytes == NULL)
+	return (GIF_ERROR);
+
+  if (ExtData != NULL) {
+	memcpy(ep->Bytes, ExtData, Len);
+  }
+
+  return (GIF_OK);
+}
+
+void
+GifFreeExtensions(int *ExtensionBlockCount,
+				  ExtensionBlock **ExtensionBlocks) {
+  ExtensionBlock *ep;
+
+  if (*ExtensionBlocks == NULL)
+	return;
+
+  for (ep = *ExtensionBlocks;
+	   ep < (*ExtensionBlocks + *ExtensionBlockCount);
+	   ep++) {
+	free((char *)ep->Bytes);
+  }
+
+  free((char *)*ExtensionBlocks);
+  *ExtensionBlocks = NULL;
+  *ExtensionBlockCount = 0;
+}
+
+/******************************************************************************
+ Image block allocation functions
+******************************************************************************/
+
+/* Private Function:
+ * Frees the last image in the GifFile->SavedImages array
+ */
+void
+FreeLastSavedImage(GifFileType *GifFile) {
+  SavedImage *sp;
+
+  if ((GifFile == NULL) || (GifFile->SavedImages == NULL))
+	return;
+
+  /* Remove one SavedImage from the GifFile */
+  GifFile->ImageCount--;
+  sp = &GifFile->SavedImages[GifFile->ImageCount];
+
+  /* Deallocate its Colormap */
+  if (sp->ImageDesc.ColorMap != NULL) {
+	GifFreeMapObject(sp->ImageDesc.ColorMap);
+	sp->ImageDesc.ColorMap = NULL;
+  }
+
+  /* Deallocate the image data */
+  if (sp != NULL && sp->RasterBits != NULL)
+	free((char *)sp->RasterBits);
+
+  /* Deallocate any extensions */
+  GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);
+
+  /*** FIXME: We could realloc the GifFile->SavedImages structure but is
+   * there a point to it? Saves some memory but we'd have to do it every
+   * time.  If this is used in GifFreeSavedImages then it would be inefficient
+   * (The whole array is going to be deallocated.)  If we just use it when
+   * we want to free the last Image it's convenient to do it here.
+   */
+}
+
+/*
+ * Append an image block to the SavedImages array
+ */
+SavedImage *
+GifMakeSavedImage(GifFileType *GifFile, const SavedImage *CopyFrom) {
+  if (GifFile->SavedImages == NULL)
+	GifFile->SavedImages = (SavedImage *)malloc(sizeof(SavedImage));
+  else
+	GifFile->SavedImages = (SavedImage *)realloc(GifFile->SavedImages,
+												 sizeof(SavedImage) * (GifFile->ImageCount + 1));
+
+  if (GifFile->SavedImages == NULL)
+	return NULL;
+  else {
+	SavedImage *sp = &GifFile->SavedImages[GifFile->ImageCount++];
+	memset((char *)sp, '\0', sizeof(SavedImage));
+
+	if (CopyFrom != NULL) {
+	  memcpy((char *)sp, CopyFrom, sizeof(SavedImage));
+
+	  /*
+	   * Make our own allocated copies of the heap fields in the
+	   * copied record.  This guards against potential aliasing
+	   * problems.
+	   */
+
+	  /* first, the local color map */
+	  if (sp->ImageDesc.ColorMap != NULL) {
+		sp->ImageDesc.ColorMap = GifMakeMapObject(
+			CopyFrom->ImageDesc.ColorMap->ColorCount,
+			CopyFrom->ImageDesc.ColorMap->Colors);
+		if (sp->ImageDesc.ColorMap == NULL) {
+		  FreeLastSavedImage(GifFile);
+		  return NULL;
+		}
+	  }
+
+	  /* next, the raster */
+	  sp->RasterBits = (unsigned char *)malloc(sizeof(GifPixelType) *
+		  CopyFrom->ImageDesc.Height *
+		  CopyFrom->ImageDesc.Width);
+	  if (sp->RasterBits == NULL) {
+		FreeLastSavedImage(GifFile);
+		return NULL;
+	  }
+	  memcpy(sp->RasterBits, CopyFrom->RasterBits,
+			 sizeof(GifPixelType) * CopyFrom->ImageDesc.Height *
+				 CopyFrom->ImageDesc.Width);
+
+	  /* finally, the extension blocks */
+	  if (sp->ExtensionBlocks != NULL) {
+		sp->ExtensionBlocks = (ExtensionBlock *)malloc(
+			sizeof(ExtensionBlock) *
+				CopyFrom->ExtensionBlockCount);
+		if (sp->ExtensionBlocks == NULL) {
+		  FreeLastSavedImage(GifFile);
+		  return NULL;
+		}
+		memcpy(sp->ExtensionBlocks, CopyFrom->ExtensionBlocks,
+			   sizeof(ExtensionBlock) * CopyFrom->ExtensionBlockCount);
+	  }
+	}
+
+	return (sp);
+  }
+}
+
+void
+GifFreeSavedImages(GifFileType *GifFile) {
+  SavedImage *sp;
+
+  if ((GifFile == NULL) || (GifFile->SavedImages == NULL)) {
+	return;
+  }
+
+  for (sp = GifFile->SavedImages;
+	   sp < GifFile->SavedImages + GifFile->ImageCount; sp++) {
+	if (sp->ImageDesc.ColorMap != NULL) {
+	  GifFreeMapObject(sp->ImageDesc.ColorMap);
+	  sp->ImageDesc.ColorMap = NULL;
+	}
+
+	if (sp != NULL && sp->RasterBits != NULL) {
+	  free((char *)sp->RasterBits);
+	}
+
+	GifFreeExtensions(&sp->ExtensionBlockCount, &sp->ExtensionBlocks);
+  }
+
+  free((char *)GifFile->SavedImages);
+  GifFile->SavedImages = NULL;
+}

3rdparty/QtGifImage/include/3rdparty/giflib/quantize.c

@@ -0,0 +1,308 @@
+/*****************************************************************************
+
+ quantize.c - quantize a high resolution image into lower one
+
+ Based on: "Color Image Quantization for frame buffer Display", by
+ Paul Heckbert SIGGRAPH 1982 page 297-307.
+
+ This doesn't really belong in the core library, was undocumented,
+ and was removed in 4.2.  Then it turned out some client apps were
+ actually using it, so it was restored in 5.0.
+
+******************************************************************************/
+
+#include <stdlib.h>
+
+#include <giflib/gif_lib.h>
+
+#define ABS(x)    ((x) > 0 ? (x) : (-(x)))
+
+#define COLOR_ARRAY_SIZE 32768
+#define BITS_PER_PRIM_COLOR 5
+#define MAX_PRIM_COLOR      0x1f
+
+static int SortRGBAxis;
+
+typedef struct QuantizedColorType {
+  GifByteType RGB[3];
+  GifByteType NewColorIndex;
+  long Count;
+  struct QuantizedColorType *Pnext;
+} QuantizedColorType;
+
+typedef struct NewColorMapType {
+  GifByteType RGBMin[3], RGBWidth[3];
+  unsigned int NumEntries; /* # of QuantizedColorType in linked list below */
+  unsigned long Count; /* Total number of pixels in all the entries */
+  QuantizedColorType *QuantizedColors;
+} NewColorMapType;
+
+static int SubdivColorMap(NewColorMapType *NewColorSubdiv,
+						  unsigned int ColorMapSize,
+						  unsigned int *NewColorMapSize);
+static int SortCmpRtn(const void *Entry1, const void *Entry2);
+
+/******************************************************************************
+ Quantize high resolution image into lower one. Input image consists of a
+ 2D array for each of the RGB colors with size Width by Height. There is no
+ Color map for the input. Output is a quantized image with 2D array of
+ indexes into the output color map.
+   Note input image can be 24 bits at the most (8 for red/green/blue) and
+ the output has 256 colors at the most (256 entries in the color map.).
+ ColorMapSize specifies size of color map up to 256 and will be updated to
+ real size before returning.
+   Also non of the parameter are allocated by this routine.
+   This function returns GIF_OK if successful, GIF_ERROR otherwise.
+******************************************************************************/
+int
+GifQuantizeBuffer(unsigned int Width,
+				  unsigned int Height,
+				  int *ColorMapSize,
+				  const GifByteType *RedInput,
+				  const GifByteType *GreenInput,
+				  const GifByteType *BlueInput,
+				  GifByteType *OutputBuffer,
+				  GifColorType *OutputColorMap) {
+
+  unsigned int Index, NumOfEntries;
+  int i, j, MaxRGBError[3];
+  unsigned int NewColorMapSize;
+  long Red, Green, Blue;
+  NewColorMapType NewColorSubdiv[256];
+  QuantizedColorType *ColorArrayEntries, *QuantizedColor;
+
+  ColorArrayEntries = (QuantizedColorType *)malloc(
+	  sizeof(QuantizedColorType) * COLOR_ARRAY_SIZE);
+  if (ColorArrayEntries == NULL) {
+	return GIF_ERROR;
+  }
+
+  for (i = 0; i < COLOR_ARRAY_SIZE; i++) {
+	ColorArrayEntries[i].RGB[0] = i >> (2 * BITS_PER_PRIM_COLOR);
+	ColorArrayEntries[i].RGB[1] = (i >> BITS_PER_PRIM_COLOR) &
+		MAX_PRIM_COLOR;
+	ColorArrayEntries[i].RGB[2] = i & MAX_PRIM_COLOR;
+	ColorArrayEntries[i].Count = 0;
+  }
+
+  /* Sample the colors and their distribution: */
+  for (i = 0; i < (int)(Width * Height); i++) {
+	Index = ((RedInput[i] >> (8 - BITS_PER_PRIM_COLOR)) <<
+														(2 * BITS_PER_PRIM_COLOR)) +
+		((GreenInput[i] >> (8 - BITS_PER_PRIM_COLOR)) <<
+													  BITS_PER_PRIM_COLOR) +
+		(BlueInput[i] >> (8 - BITS_PER_PRIM_COLOR));
+	ColorArrayEntries[Index].Count++;
+  }
+
+  /* Put all the colors in the first entry of the color map, and call the
+   * recursive subdivision process.  */
+  for (i = 0; i < 256; i++) {
+	NewColorSubdiv[i].QuantizedColors = NULL;
+	NewColorSubdiv[i].Count = NewColorSubdiv[i].NumEntries = 0;
+	for (j = 0; j < 3; j++) {
+	  NewColorSubdiv[i].RGBMin[j] = 0;
+	  NewColorSubdiv[i].RGBWidth[j] = 255;
+	}
+  }
+
+  /* Find the non empty entries in the color table and chain them: */
+  for (i = 0; i < COLOR_ARRAY_SIZE; i++)
+	if (ColorArrayEntries[i].Count > 0)
+	  break;
+  QuantizedColor = NewColorSubdiv[0].QuantizedColors = &ColorArrayEntries[i];
+  NumOfEntries = 1;
+  while (++i < COLOR_ARRAY_SIZE)
+	if (ColorArrayEntries[i].Count > 0) {
+	  QuantizedColor->Pnext = &ColorArrayEntries[i];
+	  QuantizedColor = &ColorArrayEntries[i];
+	  NumOfEntries++;
+	}
+  QuantizedColor->Pnext = NULL;
+
+  NewColorSubdiv[0].NumEntries = NumOfEntries; /* Different sampled colors */
+  NewColorSubdiv[0].Count = ((long)Width) * Height; /* Pixels */
+  NewColorMapSize = 1;
+  if (SubdivColorMap(NewColorSubdiv, *ColorMapSize, &NewColorMapSize) !=
+	  GIF_OK) {
+	free((char *)ColorArrayEntries);
+	return GIF_ERROR;
+  }
+  if (NewColorMapSize < *ColorMapSize) {
+	/* And clear rest of color map: */
+	for (i = (int)(NewColorMapSize); i < *ColorMapSize; i++)
+	  OutputColorMap[i].Red = OutputColorMap[i].Green =
+	  OutputColorMap[i].Blue = 0;
+  }
+
+  /* Average the colors in each entry to be the color to be used in the
+   * output color map, and plug it into the output color map itself. */
+  for (i = 0; i < NewColorMapSize; i++) {
+	if ((j = (int)(NewColorSubdiv[i].NumEntries)) > 0) {
+	  QuantizedColor = NewColorSubdiv[i].QuantizedColors;
+	  Red = Green = Blue = 0;
+	  while (QuantizedColor) {
+		QuantizedColor->NewColorIndex = i;
+		Red += QuantizedColor->RGB[0];
+		Green += QuantizedColor->RGB[1];
+		Blue += QuantizedColor->RGB[2];
+		QuantizedColor = QuantizedColor->Pnext;
+	  }
+	  OutputColorMap[i].Red = (Red << (8 - BITS_PER_PRIM_COLOR)) / j;
+	  OutputColorMap[i].Green = (Green << (8 - BITS_PER_PRIM_COLOR)) / j;
+	  OutputColorMap[i].Blue = (Blue << (8 - BITS_PER_PRIM_COLOR)) / j;
+	}
+  }
+
+  /* Finally scan the input buffer again and put the mapped index in the
+   * output buffer.  */
+  MaxRGBError[0] = MaxRGBError[1] = MaxRGBError[2] = 0;
+  for (i = 0; i < (int)(Width * Height); i++) {
+	Index = ((RedInput[i] >> (8 - BITS_PER_PRIM_COLOR)) <<
+														(2 * BITS_PER_PRIM_COLOR)) +
+		((GreenInput[i] >> (8 - BITS_PER_PRIM_COLOR)) <<
+													  BITS_PER_PRIM_COLOR) +
+		(BlueInput[i] >> (8 - BITS_PER_PRIM_COLOR));
+	Index = ColorArrayEntries[Index].NewColorIndex;
+	OutputBuffer[i] = Index;
+	if (MaxRGBError[0] < ABS(OutputColorMap[Index].Red - RedInput[i]))
+	  MaxRGBError[0] = ABS(OutputColorMap[Index].Red - RedInput[i]);
+	if (MaxRGBError[1] < ABS(OutputColorMap[Index].Green - GreenInput[i]))
+	  MaxRGBError[1] = ABS(OutputColorMap[Index].Green - GreenInput[i]);
+	if (MaxRGBError[2] < ABS(OutputColorMap[Index].Blue - BlueInput[i]))
+	  MaxRGBError[2] = ABS(OutputColorMap[Index].Blue - BlueInput[i]);
+  }
+
+#ifdef DEBUG
+  fprintf(stderr,
+			"Quantization L(0) errors: Red = %d, Green = %d, Blue = %d.\n",
+			MaxRGBError[0], MaxRGBError[1], MaxRGBError[2]);
+#endif /* DEBUG */
+
+  free((char *)ColorArrayEntries);
+
+  *ColorMapSize = (int)(NewColorMapSize);
+
+  return GIF_OK;
+}
+
+/******************************************************************************
+ Routine to subdivide the RGB space recursively using median cut in each
+ axes alternatingly until ColorMapSize different cubes exists.
+ The biggest cube in one dimension is subdivide unless it has only one entry.
+ Returns GIF_ERROR if failed, otherwise GIF_OK.
+*******************************************************************************/
+static int
+SubdivColorMap(NewColorMapType *NewColorSubdiv,
+			   unsigned int ColorMapSize,
+			   unsigned int *NewColorMapSize) {
+
+  int MaxSize;
+  unsigned int i, j, Index = 0, NumEntries, MinColor, MaxColor;
+  long Sum, Count;
+  QuantizedColorType *QuantizedColor, **SortArray;
+
+  while (ColorMapSize > *NewColorMapSize) {
+	/* Find candidate for subdivision: */
+	MaxSize = -1;
+	for (i = 0; i < *NewColorMapSize; i++) {
+	  for (j = 0; j < 3; j++) {
+		if ((((int)NewColorSubdiv[i].RGBWidth[j]) > MaxSize) &&
+			(NewColorSubdiv[i].NumEntries > 1)) {
+		  MaxSize = NewColorSubdiv[i].RGBWidth[j];
+		  Index = i;
+		  SortRGBAxis = (int)(j);
+		}
+	  }
+	}
+
+	if (MaxSize == -1)
+	  return GIF_OK;
+
+	/* Split the entry Index into two along the axis SortRGBAxis: */
+
+	/* Sort all elements in that entry along the given axis and split at
+	 * the median.  */
+	SortArray = (QuantizedColorType **)malloc(
+		sizeof(QuantizedColorType *) *
+			NewColorSubdiv[Index].NumEntries);
+	if (SortArray == NULL)
+	  return GIF_ERROR;
+	for (j = 0, QuantizedColor = NewColorSubdiv[Index].QuantizedColors;
+		 j < NewColorSubdiv[Index].NumEntries && QuantizedColor != NULL;
+		 j++, QuantizedColor = QuantizedColor->Pnext)
+	  SortArray[j] = QuantizedColor;
+
+	qsort(SortArray, NewColorSubdiv[Index].NumEntries,
+		  sizeof(QuantizedColorType *), SortCmpRtn);
+
+	/* Relink the sorted list into one: */
+	for (j = 0; j < NewColorSubdiv[Index].NumEntries - 1; j++) {
+	  SortArray[j]->Pnext = SortArray[j + 1];
+	}
+
+	SortArray[NewColorSubdiv[Index].NumEntries - 1]->Pnext = NULL;
+	NewColorSubdiv[Index].QuantizedColors = QuantizedColor = SortArray[0];
+	free((char *)SortArray);
+
+	/* Now simply add the Counts until we have half of the Count: */
+	Sum = (long int)(NewColorSubdiv[Index].Count / 2 - QuantizedColor->Count);
+	NumEntries = 1;
+	Count = QuantizedColor->Count;
+	while (QuantizedColor->Pnext != NULL &&
+		(Sum -= QuantizedColor->Pnext->Count) >= 0 &&
+		QuantizedColor->Pnext->Pnext != NULL) {
+	  QuantizedColor = QuantizedColor->Pnext;
+	  NumEntries++;
+	  Count += QuantizedColor->Count;
+	}
+	/* Save the values of the last color of the first half, and first
+	 * of the second half, so we can update the Bounding Boxes later.
+	 * Also, as the colors are quantized and the BBoxes are full 0..255,
+	 * they need to be rescaled.
+	 */
+	MaxColor = QuantizedColor->RGB[SortRGBAxis]; /* Max. of first half */
+	/* coverity[var_deref_op] */
+	MinColor = QuantizedColor->Pnext->RGB[SortRGBAxis]; /* of second */
+	MaxColor <<= (8 - BITS_PER_PRIM_COLOR);
+	MinColor <<= (8 - BITS_PER_PRIM_COLOR);
+
+	/* Partition right here: */
+	NewColorSubdiv[*NewColorMapSize].QuantizedColors =
+		QuantizedColor->Pnext;
+	QuantizedColor->Pnext = NULL;
+	NewColorSubdiv[*NewColorMapSize].Count = Count;
+	NewColorSubdiv[Index].Count -= Count;
+	NewColorSubdiv[*NewColorMapSize].NumEntries =
+		NewColorSubdiv[Index].NumEntries - NumEntries;
+	NewColorSubdiv[Index].NumEntries = NumEntries;
+	for (j = 0; j < 3; j++) {
+	  NewColorSubdiv[*NewColorMapSize].RGBMin[j] =
+		  NewColorSubdiv[Index].RGBMin[j];
+	  NewColorSubdiv[*NewColorMapSize].RGBWidth[j] =
+		  NewColorSubdiv[Index].RGBWidth[j];
+	}
+	NewColorSubdiv[*NewColorMapSize].RGBWidth[SortRGBAxis] =
+		NewColorSubdiv[*NewColorMapSize].RGBMin[SortRGBAxis] +
+			NewColorSubdiv[*NewColorMapSize].RGBWidth[SortRGBAxis] - MinColor;
+	NewColorSubdiv[*NewColorMapSize].RGBMin[SortRGBAxis] = MinColor;
+
+	NewColorSubdiv[Index].RGBWidth[SortRGBAxis] =
+		MaxColor - NewColorSubdiv[Index].RGBMin[SortRGBAxis];
+
+	(*NewColorMapSize)++;
+  }
+
+  return GIF_OK;
+}
+
+/****************************************************************************
+ Routine called by qsort to compare two entries.
+*****************************************************************************/
+static int
+SortCmpRtn(const void *Entry1,
+		   const void *Entry2) {
+
+  return (*((QuantizedColorType **)Entry1))->RGB[SortRGBAxis] -
+	  (*((QuantizedColorType **)Entry2))->RGB[SortRGBAxis];
+}

3rdparty/QtGifImage/include/gifimage/qgifglobal.h

@@ -0,0 +1,40 @@
+/****************************************************************************
+** Copyright (c) 2013 Debao Zhang <hello@debao.me>
+** All right reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining
+** a copy of this software and associated documentation files (the
+** "Software"), to deal in the Software without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Software, and to
+** permit persons to whom the Software is furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**
+****************************************************************************/
+#ifndef GIF_IMAGE_Q_GIF_GLOBAL_H_
+#define GIF_IMAGE_Q_GIF_GLOBAL_H_
+
+#include <QtGlobal>
+
+#if !defined(QT_STATIC) && !defined(GIFIMAGE_NO_LIB)
+#if defined(QT_BUILD_GIFIMAGE_LIB)
+#define Q_GIFIMAGE_EXPORT Q_DECL_EXPORT
+#else
+#define Q_GIFIMAGE_EXPORT Q_DECL_IMPORT
+#endif
+#else
+#define Q_GIFIMAGE_EXPORT
+#endif
+
+#endif // GIF_IMAGE_Q_GIF_GLOBAL_H_

3rdparty/QtGifImage/include/gifimage/qgifimage.cpp

@@ -0,0 +1,668 @@
+/****************************************************************************
+** Copyright (c) 2013 Debao Zhang <hello@debao.me>
+** All right reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining
+** a copy of this software and associated documentation files (the
+** "Software"), to deal in the Software without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Software, and to
+** permit persons to whom the Software is furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**
+****************************************************************************/
+
+#include <gifimage/qgifimage.h>
+#include <gifimage/qgifimage_p.h>
+
+#include <QFile>
+#include <QImage>
+#include <QDebug>
+#include <QScopedPointer>
+
+namespace {
+
+int writeToIODevice(GifFileType *gifFile, const GifByteType *data,
+					int maxSize) {
+  return static_cast<int>(
+	  static_cast<QIODevice *>(
+		  gifFile->UserData)->write(
+		  reinterpret_cast<const char *>(data), maxSize));
+}
+
+int readFromIODevice(GifFileType *gifFile, GifByteType *data, int maxSize) {
+  return static_cast<int>(
+	  static_cast<QIODevice *>(
+		  gifFile->UserData)->read(
+		  reinterpret_cast<char *>(data), maxSize));
+}
+
+}  // namespace
+
+QGifImagePrivate::QGifImagePrivate(QGifImage *p)
+	: loopCount(0), defaultDelayTime(1000), q_ptr(p) {}
+
+QVector<QRgb> QGifImagePrivate::colorTableFromColorMapObject(
+	ColorMapObject *colorMap, int transColorIndex) const {
+  QVector<QRgb> colorTable;
+  if (colorMap) {
+	for (int idx = 0; idx < colorMap->ColorCount; ++idx) {
+	  GifColorType gifColor = colorMap->Colors[idx];
+	  QRgb color = gifColor.Blue | (gifColor.Green << 8) | (gifColor.Red << 16);
+	  // For non-transparent color, set the alpha to opaque.
+	  if (idx != transColorIndex)
+		color |= 0xff << 24;
+	  colorTable.append(color);
+	}
+  }
+  return colorTable;
+}
+
+ColorMapObject *QGifImagePrivate::colorTableToColorMapObject(
+	QVector<QRgb> colorTable) const {
+  if (colorTable.isEmpty())
+	return nullptr;
+
+  auto cmap = (ColorMapObject *)malloc(sizeof(ColorMapObject));
+  // num of colors must be a power of 2
+  int numColors = 1 << GifBitSize(static_cast<int>(colorTable.size()));
+  cmap->ColorCount = numColors;
+  // Maybe a bug of giflib, BitsPerPixel is used as size of the color table
+  // size.
+  cmap->BitsPerPixel = GifBitSize(static_cast<int>(colorTable.size()));  // Todo!
+  cmap->SortFlag = false;
+
+  auto colorValues =
+	  (GifColorType *)calloc(numColors, sizeof(GifColorType));
+  for (int idx = 0; idx < colorTable.size(); ++idx) {
+	colorValues[idx].Red = qRed(colorTable[idx]);
+	colorValues[idx].Green = qGreen(colorTable[idx]);
+	colorValues[idx].Blue = qBlue(colorTable[idx]);
+  }
+
+  cmap->Colors = colorValues;
+
+  return cmap;
+}
+
+QSize QGifImagePrivate::getCanvasSize() const {
+  // If canvasSize has been set by user.
+  if (canvasSize.isValid())
+	return canvasSize;
+
+  // Calc the right canvasSize from the frame size.
+  int width = -1;
+  int height = -1;
+	  foreach (QGifFrameInfoData info, frameInfos) {
+	  int w = info.image.width() + info.offset.x();
+	  int h = info.image.height() + info.offset.y();
+	  if (w > width)
+		width = w;
+	  if (h > height)
+		height = h;
+	}
+  return {width, height};
+}
+
+int QGifImagePrivate::getFrameTransparentColorIndex(
+	const QGifFrameInfoData &frameInfo) const {
+  int index = -1;
+
+  QColor transColor = frameInfo.transparentColor.isValid()
+					  ? frameInfo.transparentColor
+					  : defaultTransparentColor;
+
+  if (transColor.isValid()) {
+	if (!frameInfo.image.colorTable().isEmpty())
+	  index = static_cast<int>(frameInfo.image.colorTable().indexOf(transColor.rgb()));
+	else if (!globalColorTable.isEmpty())
+	  index = static_cast<int>(globalColorTable.indexOf(transColor.rgb()));
+  }
+
+  return index;
+}
+
+bool QGifImagePrivate::load(QIODevice *device) {
+  static int interlacedOffset[] = {0, 4, 2,
+								   1}; /* The way Interlaced image should. */
+  static int interlacedJumps[] = {8, 8, 4,
+								  2}; /* be read - offsets and jumps... */
+
+  int error;
+  GifFileType *gifFile = DGifOpen(device, readFromIODevice, &error);
+  if (!gifFile) {
+	char *temp = GifErrorString(error);
+	qWarning("%s", temp);
+	return false;
+  }
+
+  if (DGifSlurp(gifFile) == GIF_ERROR)
+	return false;
+
+  canvasSize.setWidth(gifFile->SWidth);
+  canvasSize.setHeight(gifFile->SHeight);
+  if (gifFile->SColorMap) {
+	globalColorTable = colorTableFromColorMapObject(gifFile->SColorMap);
+	if (gifFile->SBackGroundColor < globalColorTable.size())
+	  bgColor = QColor(globalColorTable[gifFile->SBackGroundColor]);
+  }
+
+  for (int idx = 0; idx < gifFile->ImageCount; ++idx) {
+	SavedImage gifImage = gifFile->SavedImages[idx];
+	int top = gifImage.ImageDesc.Top;
+	int left = gifImage.ImageDesc.Left;
+	int width = gifImage.ImageDesc.Width;
+	int height = gifImage.ImageDesc.Height;
+
+	QGifFrameInfoData frameInfo;
+	GraphicsControlBlock gcb;
+	DGifSavedExtensionToGCB(gifFile, idx, &gcb);
+	int transColorIndex = gcb.TransparentColor;
+
+	QVector<QRgb> colorTable;
+	if (gifImage.ImageDesc.ColorMap)
+	  colorTable = colorTableFromColorMapObject(gifImage.ImageDesc.ColorMap,
+												transColorIndex);
+	else if (transColorIndex != -1)
+	  colorTable =
+		  colorTableFromColorMapObject(gifFile->SColorMap, transColorIndex);
+	else
+	  colorTable = globalColorTable;
+
+	if (transColorIndex != -1)
+	  frameInfo.transparentColor = colorTable[transColorIndex];
+	frameInfo.delayTime = gcb.DelayTime * 10;  // convert to milliseconds
+	frameInfo.interlace = gifImage.ImageDesc.Interlace;
+	frameInfo.offset = QPoint(left, top);
+
+	QImage image(width, height, QImage::Format_Indexed8);
+	image.setOffset(QPoint(left, top));  // Maybe useful for some users.
+	image.setColorTable(colorTable);
+	if (transColorIndex != -1)
+	  image.fill(transColorIndex);
+	else if (!globalColorTable.isEmpty())
+	  image.fill(gifFile->SBackGroundColor);  //! ToDo
+
+	if (gifImage.ImageDesc.Interlace) {
+	  int line = 0;
+	  for (int i = 0; i < 4; i++) {
+		for (int row = interlacedOffset[i]; row < height;
+			 row += interlacedJumps[i]) {
+		  memcpy(image.scanLine(row), gifImage.RasterBits + line * width,
+				 width);
+		  line++;
+		}
+	  }
+	} else {
+	  for (int row = 0; row < height; row++) {
+		memcpy(image.scanLine(row), gifImage.RasterBits + row * width, width);
+	  }
+	}
+
+	// Extract other data for the image.
+	if (idx == 0) {
+	  if (gifImage.ExtensionBlockCount > 2) {
+		ExtensionBlock *extBlock = gifImage.ExtensionBlocks;
+		if (extBlock->Function == APPLICATION_EXT_FUNC_CODE &&
+			extBlock->ByteCount == 8) {
+		  if (QByteArray((char *)extBlock->Bytes) ==
+			  QByteArray("NETSCAPE2.0")) {
+			ExtensionBlock *block = gifImage.ExtensionBlocks + 1;
+			if (block->ByteCount == 3) {
+			  loopCount =
+				  uchar(block->Bytes[1]) + uchar((block->Bytes[2]) << 8);
+			}
+		  }
+		}
+	  }
+	}
+
+	frameInfo.image = image;
+	frameInfos.append(frameInfo);
+  }
+
+  DGifCloseFile(gifFile);
+  return true;
+}
+
+bool QGifImagePrivate::save(QIODevice *device) const {
+  int error;
+  GifFileType *gifFile = EGifOpen(device, writeToIODevice, &error);
+  if (!gifFile) {
+	char *temp = GifErrorString(error);
+	qWarning("%s", temp);
+	return false;
+  }
+
+  QSize _canvasSize = getCanvasSize();
+  gifFile->SWidth = _canvasSize.width();
+  gifFile->SHeight = _canvasSize.height();
+  gifFile->SColorResolution = 8;
+  if (!globalColorTable.isEmpty()) {
+	gifFile->SColorMap = colorTableToColorMapObject(globalColorTable);
+	int idx = static_cast<int>(globalColorTable.indexOf(bgColor.rgba()));
+	gifFile->SBackGroundColor = idx == -1 ? 0 : idx;
+  }
+
+  gifFile->ImageCount = static_cast<int>(frameInfos.size());
+  gifFile->SavedImages =
+	  (SavedImage *)calloc(frameInfos.size(), sizeof(SavedImage));
+  for (int idx = 0; idx < frameInfos.size(); ++idx) {
+	const QGifFrameInfoData frameInfo = frameInfos.at(idx);
+	QImage image = frameInfo.image;
+	if (image.format() != QImage::Format_Indexed8) {
+	  if (!globalColorTable.isEmpty())
+		image =
+			image.convertToFormat(QImage::Format_Indexed8, globalColorTable);
+	  else
+		image = image.convertToFormat(QImage::Format_Indexed8);
+	}
+
+	SavedImage *gifImage = gifFile->SavedImages + idx;
+
+	gifImage->ImageDesc.Left = frameInfo.offset.x();
+	gifImage->ImageDesc.Top = frameInfo.offset.y();
+	gifImage->ImageDesc.Width = image.width();
+	gifImage->ImageDesc.Height = image.height();
+	gifImage->ImageDesc.Interlace = frameInfo.interlace;
+
+	if (!image.colorTable().isEmpty() &&
+		(image.colorTable() != globalColorTable))
+	  gifImage->ImageDesc.ColorMap =
+		  colorTableToColorMapObject(image.colorTable());
+	else
+	  gifImage->ImageDesc.ColorMap = nullptr;
+
+	auto data = (GifByteType *)malloc(image.width() * image.height() *
+		sizeof(GifByteType));
+	for (int row = 0; row < image.height(); ++row) {
+	  memcpy(data + row * image.width(), image.scanLine(row), image.width());
+	}
+	gifImage->RasterBits = data;
+
+	if (idx == 0) {
+	  uchar data8[12] = "NETSCAPE2.0";
+	  GifAddExtensionBlock(&gifImage->ExtensionBlockCount,
+						   &gifImage->ExtensionBlocks,
+						   APPLICATION_EXT_FUNC_CODE, 11, data8);
+	  uchar data_char[3];
+	  data_char[0] = 0x01;
+	  data_char[1] = loopCount & 0xFF;
+	  data_char[2] = (loopCount >> 8) & 0xFF;
+	  GifAddExtensionBlock(&gifImage->ExtensionBlockCount,
+						   &gifImage->ExtensionBlocks, CONTINUE_EXT_FUNC_CODE,
+						   3, data_char);
+	}
+
+	GraphicsControlBlock gcbBlock;
+	gcbBlock.DisposalMode = 2;
+	gcbBlock.UserInputFlag = false;
+	gcbBlock.TransparentColor = getFrameTransparentColorIndex(frameInfo);
+
+	if (frameInfo.delayTime != -1)
+	  gcbBlock.DelayTime =
+		  frameInfo.delayTime / 10;  // convert from milliseconds
+	else
+	  gcbBlock.DelayTime = defaultDelayTime / 10;
+
+	EGifGCBToSavedExtension(&gcbBlock, gifFile, idx);
+  }
+  EGifSpew(gifFile);
+
+  return true;
+}
+
+/*!
+    \class QGifImage
+    \inmodule QtGifImage
+    \brief Class used to read/wirte .gif files.
+*/
+
+/*!
+    Constructs a gif image
+*/
+QGifImage::QGifImage() : d_ptr(new QGifImagePrivate(this)) {}
+
+/*!
+    Constructs a gif image and tries to load the image from the
+    file with the given \a fileName
+*/
+QGifImage::QGifImage(const QString &fileName)
+	: d_ptr(new QGifImagePrivate(this)) {
+  load(fileName);
+}
+
+/*!
+    Constructs a gif image with the given \a size
+*/
+QGifImage::QGifImage(const QSize &size) : d_ptr(new QGifImagePrivate(this)) {
+  d_ptr->canvasSize = size;
+}
+
+/*!
+    Destroys the gif image and cleans up.
+*/
+QGifImage::~QGifImage() { delete d_ptr; }
+
+/*!
+    Return global color table.
+ */
+QVector<QRgb> QGifImage::globalColorTable() const {
+  Q_D(const QGifImage);
+  return d->globalColorTable;
+}
+
+/*!
+    Return background color of the gif canvas. It only makes sense when
+    global color table is not empty.
+ */
+QColor QGifImage::backgroundColor() const {
+  Q_D(const QGifImage);
+  return d->bgColor;
+}
+
+/*!
+    Set the global color table \a colors and background color \a bgColor.
+    \a bgColor must be one the color in \a colors.
+
+    Unlike other image formats that support alpha (e.g. png), GIF does not
+    support semi-transparent pixels. So the alpha channel of the color table
+    will be ignored.
+*/
+void QGifImage::setGlobalColorTable(const QVector<QRgb> &colors,
+									const QColor &bgColor) {
+  Q_D(QGifImage);
+  d->globalColorTable = colors;
+  d->bgColor = bgColor;
+}
+
+/*!
+    Return the default delay in milliseconds. The default value is 1000 ms.
+
+    The time delay can be different for every frame.
+*/
+int QGifImage::defaultDelay() const {
+  Q_D(const QGifImage);
+  return d->defaultDelayTime;
+}
+
+/*!
+    Set the default \a delay in milliseconds.
+*/
+void QGifImage::setDefaultDelay(int delay) {
+  Q_D(QGifImage);
+  d->defaultDelayTime = delay;
+}
+
+/*!
+    Return the default transparent color.
+
+    The transparent color can be different for every frame.
+*/
+QColor QGifImage::defaultTransparentColor() const {
+  Q_D(const QGifImage);
+  return d->defaultTransparentColor;
+}
+
+/*!
+    Set the default transparent \a color.
+
+    Unlike other image formats that support alpha (e.g. png), GIF does
+    not support semi-transparent pixels. The way to achieve transparency
+    is to set a color that will be transparent when rendering the GIF.
+    So, if you set the transparent color to black, the black pixels in
+    the gif file will be transparent.
+*/
+void QGifImage::setDefaultTransparentColor(const QColor &color) {
+  Q_D(QGifImage);
+  d->defaultTransparentColor = color;
+}
+
+/*!
+    Return the loop count.
+*/
+int QGifImage::loopCount() const {
+  Q_D(const QGifImage);
+  return d->loopCount;
+}
+
+/*!
+    Set the loop count. The default value of \a loop is 0, which means loop
+   forever.
+*/
+void QGifImage::setLoopCount(int loop) {
+  Q_D(QGifImage);
+  d->loopCount = loop;
+}
+
+/*!
+    Insert the QImage object \a frame at position \a index with \a delay.
+
+    As gif file only support indexed image, so all the \a frame will be
+   converted to the QImage::Format_Indexed8 format. Global color table will be
+   used in the convertion if it has been set.
+
+    QImage::offset() will be used when insert the QImage to the gif canvas.
+*/
+void QGifImage::insertFrame(int index, const QImage &frame, int delay) {
+  Q_D(QGifImage);
+
+  QGifFrameInfoData data;
+  data.image = frame;
+  data.delayTime = delay;
+  data.offset = frame.offset();
+
+  d->frameInfos.insert(index, data);
+}
+
+/*!
+    \overload
+
+    Insert the QImage object \a frame at position \a index with the given \a
+   offset and \a delay.
+
+    As gif file only support indexed image, so all the \a frame will be
+   converted to the QImage::Format_Indexed8 format. Global color table will be
+   used in the convertion if it has been set.
+*/
+void QGifImage::insertFrame(int index, const QImage &frame,
+							const QPoint &offset, int delay) {
+  Q_D(QGifImage);
+  QGifFrameInfoData data;
+  data.image = frame;
+  data.delayTime = delay;
+  data.offset = offset;
+
+  d->frameInfos.insert(index, data);
+}
+
+/*!
+    Append the QImage object \a frame with \a delay.
+
+    As gif file only support indexed image, so all the \a frame will be
+   converted to the QImage::Format_Indexed8 format. Global color table will be
+   used in the convertion if it has been set.
+
+    QImage::offset() will be used when insert the QImage to the gif canvas.
+*/
+void QGifImage::addFrame(const QImage &frame, int delay) {
+  Q_D(QGifImage);
+
+  QGifFrameInfoData data;
+  data.image = frame;
+  data.delayTime = delay;
+  data.offset = frame.offset();
+
+  d->frameInfos.append(data);
+}
+
+/*!
+    \overload
+    Append the QImage object \a frame with the given \a offset and \a delay.
+ */
+void QGifImage::addFrame(const QImage &frame, const QPoint &offset, int delay) {
+  Q_D(QGifImage);
+
+  QGifFrameInfoData data;
+  data.image = frame;
+  data.delayTime = delay;
+  data.offset = offset;
+
+  d->frameInfos.append(data);
+}
+
+/*!
+    Return frame count contained in the gif file.
+ */
+int QGifImage::frameCount() const {
+  Q_D(const QGifImage);
+  return static_cast<int>(d->frameInfos.count());
+}
+
+/*!
+    Return the image at \a index.
+ */
+QImage QGifImage::frame(int index) const {
+  Q_D(const QGifImage);
+  if (index < 0 || index >= d->frameInfos.size())
+	return {};
+
+  return d->frameInfos[index].image;
+}
+
+/*!
+     Return the offset value of the frame at \a index
+ */
+QPoint QGifImage::frameOffset(int index) const {
+  Q_D(const QGifImage);
+  if (index < 0 || index >= d->frameInfos.size())
+	return {};
+
+  return d->frameInfos[index].offset;
+}
+
+/*!
+     Set the \a offset value for the frame at \a index
+ */
+void QGifImage::setFrameOffset(int index, const QPoint &offset) {
+  Q_D(QGifImage);
+  if (index < 0 || index >= d->frameInfos.size())
+	return;
+  d->frameInfos[index].offset = offset;
+}
+
+/*!
+     Return the delay value of the frame at \a index
+ */
+int QGifImage::frameDelay(int index) const {
+  Q_D(const QGifImage);
+  if (index < 0 || index >= d->frameInfos.size())
+	return -1;
+
+  return d->frameInfos[index].delayTime;
+}
+
+/*!
+     Set the \a delay value for the frame at \a index
+ */
+void QGifImage::setFrameDelay(int index, int delay) {
+  Q_D(QGifImage);
+  if (index < 0 || index >= d->frameInfos.size())
+	return;
+  d->frameInfos[index].delayTime = delay;
+}
+
+/*!
+     Return the transparent color of the frame at \a index
+ */
+QColor QGifImage::frameTransparentColor(int index) const {
+  Q_D(const QGifImage);
+  if (index < 0 || index >= d->frameInfos.size())
+	return {};
+
+  return d->frameInfos[index].transparentColor;
+}
+
+/*!
+    Sets the transparent \a color of the frame \a index. Unlike other image
+   formats that support alpha (e.g. PNG), GIF does not support semi-transparent
+   pixels. The way to achieve transparency is to set a color that will be
+   transparent when rendering the GIF. So, if you set the transparent color to
+   black, the black pixels in your gif file will be transparent.
+*/
+void QGifImage::setFrameTransparentColor(int index, const QColor &color) {
+  Q_D(QGifImage);
+  if (index < 0 || index >= d->frameInfos.size())
+	return;
+  d->frameInfos[index].transparentColor = color;
+}
+
+/*!
+    Saves the gif image to the file with the given \a fileName.
+    Returns \c true if the image was successfully saved; otherwise
+    returns \c false.
+*/
+bool QGifImage::save(const QString &fileName) const {
+  Q_D(const QGifImage);
+  QFile file(fileName);
+  if (file.open(QIODevice::WriteOnly)) {
+	bool res = d->save(&file);
+//      d->~QGifImagePrivate();
+//      delete d;
+	return res;
+  }
+
+  return false;
+}
+
+/*!
+    \overload
+
+    This function writes a QImage to the given \a device.
+*/
+bool QGifImage::save(QIODevice *device) const {
+  Q_D(const QGifImage);
+  if (device->openMode() | QIODevice::WriteOnly)
+	return d->save(device);
+
+  return false;
+}
+
+/*!
+    Loads an gif image from the file with the given \a fileName. Returns \c true
+   if the image was successfully loaded; otherwise invalidates the image and
+   returns \c false.
+*/
+bool QGifImage::load(const QString &fileName) {
+  Q_D(QGifImage);
+  QFile file(fileName);
+  if (file.open(QIODevice::ReadOnly))
+	return d->load(&file);
+
+  return false;
+}
+
+/*!
+    \overload
+
+    This function reads a gif image from the given \a device. This can,
+    for example, be used to load an image directly into a QByteArray.
+*/
+bool QGifImage::load(QIODevice *device) {
+  Q_D(QGifImage);
+  if (device->openMode() | QIODevice::ReadOnly)
+	return d->load(device);
+
+  return false;
+}

3rdparty/QtGifImage/include/gifimage/qgifimage.h

@@ -0,0 +1,89 @@
+/****************************************************************************
+** Copyright (c) 2013 Debao Zhang <hello@debao.me>
+** All right reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining
+** a copy of this software and associated documentation files (the
+** "Software"), to deal in the Software without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Software, and to
+** permit persons to whom the Software is furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**
+****************************************************************************/
+#ifndef GIF_IMAGE_Q_GIF_IMAGE_H_
+#define GIF_IMAGE_Q_GIF_IMAGE_H_
+
+#include <gifimage/qgifglobal.h>
+
+#include <QList>
+#include <QImage>
+#include <QColor>
+#include <QVector>
+
+class QGifImagePrivate;
+
+class QGifImage {
+  Q_DECLARE_PRIVATE(QGifImage)
+
+public:
+  QGifImage();
+  explicit QGifImage(const QString &fileName);
+  explicit QGifImage(const QSize &size);
+
+  ~QGifImage();
+
+public:
+  QVector<QRgb> globalColorTable() const;
+  QColor backgroundColor() const;
+
+  void setGlobalColorTable(const QVector<QRgb> &colors, const QColor &bgColor = QColor());
+  int defaultDelay() const;
+
+  void setDefaultDelay(int internal);
+  QColor defaultTransparentColor() const;
+  void setDefaultTransparentColor(const QColor &color);
+
+  int loopCount() const;
+  void setLoopCount(int loop);
+
+  int frameCount() const;
+  QImage frame(int index) const;
+
+  void addFrame(const QImage &frame, int delay = -1);
+  void addFrame(const QImage &frame, const QPoint &offset, int delay = -1);
+
+  void insertFrame(int index, const QImage &frame, int delay = -1);
+  void insertFrame(int index, const QImage &frame, const QPoint &offset, int delay = -1);
+
+  QPoint frameOffset(int index) const;
+  void setFrameOffset(int index, const QPoint &offset);
+
+  int frameDelay(int index) const;
+  void setFrameDelay(int index, int delay);
+
+  QColor frameTransparentColor(int index) const;
+  void setFrameTransparentColor(int index, const QColor &color);
+
+  bool load(QIODevice *device);
+  bool load(const QString &fileName);
+
+  bool save(QIODevice *device) const;
+  bool save(const QString &fileName) const;
+
+private:
+  QGifImagePrivate *const d_ptr;
+};
+
+#endif // GIF_IMAGE_Q_GIF_IMAGE_H_

3rdparty/QtGifImage/include/gifimage/qgifimage_p.h

@@ -0,0 +1,75 @@
+/****************************************************************************
+** Copyright (c) 2013 Debao Zhang <hello@debao.me>
+** All right reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining
+** a copy of this software and associated documentation files (the
+** "Software"), to deal in the Software without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Software, and to
+** permit persons to whom the Software is furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**
+****************************************************************************/
+#ifndef GIF_IMAGE_Q_GIF_IMAGE_P_H_
+#define GIF_IMAGE_Q_GIF_IMAGE_P_H_
+
+#include <giflib/gif_lib.h>
+#include <gifimage/qgifimage.h>
+
+#include <QVector>
+#include <QColor>
+
+struct QGifFrameInfoData {
+  QGifFrameInfoData() : delayTime(-1), interlace(false) {}
+
+public:
+  QImage image;
+  QPoint offset; //offset info of QImage will lost when convert from One format to another.
+  int delayTime;
+  bool interlace;
+  QColor transparentColor;
+};
+
+class QGifImagePrivate {
+  Q_DECLARE_PUBLIC(QGifImage)
+
+public:
+  explicit QGifImagePrivate(QGifImage *p);
+  ~QGifImagePrivate() = default;
+
+public:
+  bool load(QIODevice *device);
+  bool save(QIODevice *device) const;
+
+  QVector<QRgb> colorTableFromColorMapObject(ColorMapObject *object, int transColorIndex = -1) const;
+  [[nodiscard]] ColorMapObject *colorTableToColorMapObject(QVector<QRgb> colorTable) const;
+
+  [[nodiscard]] QSize getCanvasSize() const;
+  [[nodiscard]] int getFrameTransparentColorIndex(const QGifFrameInfoData &info) const;
+
+public:
+  QSize canvasSize;
+  int loopCount;
+  int defaultDelayTime;
+  QColor defaultTransparentColor;
+
+  QVector<QRgb> globalColorTable;
+  QColor bgColor;
+  QList<QGifFrameInfoData> frameInfos;
+
+  QGifImage *q_ptr;
+};
+
+#endif // GIF_IMAGE_Q_GIF_IMAGE_P_H_

CMakeLists.txt

@@ -0,0 +1,59 @@
+cmake_minimum_required(VERSION 3.16.0)
+
+project(qteletextmaker VERSION 1.0.0 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTORCC ON)
+set(CMAKE_AUTOUIC ON)
+
+find_package(Qt6 COMPONENTS Core Widgets REQUIRED)
+
+add_subdirectory(src/qteletextdecoder)
+add_subdirectory(3rdparty/QtGifImage)
+
+file (GLOB SOURCES src/qteletextmaker/*.cpp)
+add_executable(qteletextmaker ${SOURCES} src/qteletextmaker/actionicons.qrc)
+
+target_link_libraries(qteletextmaker PRIVATE QtGifImage::QtGifImage qteletextdecoder Qt::Widgets)
+
+set_target_properties(qteletextmaker PROPERTIES
+	WIN32_EXECUTABLE ON
+)
+
+if(UNIX)
+	include(GNUInstallDirs)
+
+	set(BIN_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}")
+	set(DOC_INSTALL_DIR "${CMAKE_INSTALL_DOCDIR}")
+	set(EXAMPLES_INSTALL_DIR "${DOC_INSTALL_DIR}/examples")
+else()
+	set(BIN_INSTALL_DIR ".")
+	set(DOC_INSTALL_DIR ".")
+	set(EXAMPLES_INSTALL_DIR "./examples")
+endif()
+
+install(TARGETS qteletextmaker
+	BUNDLE DESTINATION .
+	RUNTIME DESTINATION ${BIN_INSTALL_DIR}
+)
+
+install(FILES
+	${CMAKE_CURRENT_LIST_DIR}/README.md
+	${CMAKE_CURRENT_LIST_DIR}/LICENSE
+	DESTINATION ${DOC_INSTALL_DIR}
+)
+
+install(DIRECTORY
+	${CMAKE_CURRENT_LIST_DIR}/examples/
+	DESTINATION ${EXAMPLES_INSTALL_DIR}
+)
+
+if(UNIX AND NOT APPLE)
+	install(FILES
+		${CMAKE_CURRENT_LIST_DIR}/share/qteletextmaker.desktop
+		DESTINATION ${CMAKE_INSTALL_DATADIR}/applications
+	)
+endif()

README.md

@@ -1,34 +1,42 @@
 # QTeletextMaker
-QTeletextMaker is a teletext page editor in development. It is written in C++ using the Qt 5 widget libraries, and released under the GNU General Public License v3.0
+QTeletextMaker is a teletext page editor with an emphasis on Level 2.5 enhancement editing, released under the GNU General Public License v3.0
+
+It is written in C++ using the Qt 6 widget libraries.
 
 Features
-- Load and save teletext pages in .tti format.
+- Load and save pages in TTI format.
-- Rendering of teletext pages in Levels 1, 1.5, 2.5 and 3.5
+- Rendering of pages in Levels 1, 1.5, 2.5 and 3.5 including Local Objects and side panels.
-- Rendering of Local Objects and side panels.
+- Rendering of DRCS characters imported from DRCS downloading pages.
-- Import and export of single pages in .t42 format.
+- Import and export of single pages in t42, EP1 and HTT formats.
-- Export PNG images of teletext pages.
+- Export PNG and animated GIF images of 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 pages in 4:3, 16:9 pillar-box and 16:9 stretch aspect ratios with configurable zoom level.
-- View teletext pages in 4:3, 16:9 pillar-box and 16:9 stretch aspect ratios.
+- View pages in mix and attribute-less monochrome modes.
 
-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.
+Although designed on and developed for Linux, the Qt 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://web.archive.org/web/20230606021352/https://blog.8bitbuddhism.com/2018/08/22/cross-compiling-windows-applications-with-mxe/). After MXE is installed `make qt6-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. 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.
+Install version 6 of the QtCore, QtGui and QtWidgets libraries and build headers, along with CMake.
 
-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.
+Change into the source directory and run the following commands. -j8 can be replaced with the number of processor cores used for the compile process
+```
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Release ..
+make -j8
+```
 
-Optionally, type `make install` afterwards to place the executable into /usr/local/bin.
+The above should place the qteletextmaker executable into the build directory created by the above commands. Within the build directory type `./qteletextmaker` in the terminal to launch.
+
+Optionally, type `cmake --install .` to place the executable into /usr/local/bin and the example .tti files into /usr/local/share/doc/qteletextmaker.
 
 ## Current limitations
 The following X/26 enhancement triplets are not rendered by the editor, although the list is fully aware of them.
 - Invocation of Objects from POP and GPOP pages.
-- DRCS characters.
-- Modified G0 and G2 character set designation using X/26 triplets with mode 01000.
 - Proportional font spacing on Level 3.5
 
 ## Using the X/26 triplet editor
@@ -46,7 +54,7 @@ Most triplet modes will present varying widgets below which can be used to alter
 
 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.
 
-The full behaviour of X/26 enhancement triplets can be found in section 12.3 of the [Enhanced Teletext specification ETS 300 706](https://web.archive.org/web/20160326062859/https://www.phecap.nl/download/enhenced-teletext-specs.pdf).
+The full behaviour of X/26 enhancement triplets can be found in section 12.3 of the [Enhanced Teletext specification ETS 300 706](https://www.etsi.org/deliver/etsi_en/300700_300799/300706/01.02.01_60/en_300706v010201p.pdf).
 
 ### Setting the Active Position
 The Active Position, whether set explicitly by a "Set Active Position" triplet or by a row or column triplet, can only be moved in screen address order i.e. from left to right within a row and then from top to bottom across rows. In other words:

examples/Level2p5-DRCS/DRCS-CardSuits-MainPage.tti

@@ -0,0 +1,157 @@
+DE,Level 2.5 DRCS card suits demo display page
+PN,22001
+SC,0001
+PS,8000
+RE,0
+CT,20,T
+OL,27,D@}@@@A}@@@B}@@@OPhD@@H}@@@H}@@@@@@
+OL,28,@@@|gpCUC@TpK@PA`Ub{~Ls_w}ww]_}_wMPv
+OL,26,@kD@PM`Rm`TMaVmamD@JAPKKYMMuOMuQMuSMu\KQ
+OL,26,A]APnD@hS|TMtUIPoD@hS|LM`NM`PM`RM`TM`UMd
+OL,26,BVmdYMdZmdpD@hS|UMeVmeWMdXmdYMeZmeqD@hS|
+OL,26,CUMdVmdWMeXmeYMdZmdrD@hS|UMeVmeYMeZmesD@
+OL,26,DhS|UMfVmfYMfZmftD@hS|UMgVmgWMfXmfYMgZmg
+OL,26,EuD@hS|UMfVmfWMgXmgYMfZmfvD@hS|UMgVmgYMg
+OL,26,FZmg[MbwD@hS|ZIP[mtxD@JAPKK|MmuOmuQmuSmu
+OL,26,G\Kt]APzD@PMbRmbTMcVmc_CxW|JcKJ@IJaKaZ
+OL,26,HMKhOKhQKhSKh\Au]aBBBBBBB
+OL,1,R]                                G(1/4)
+OL,2,R]           Wppspppppppp               
+OL,3,R]           W]TCQHTSQD R]              
+OL,4,R]           W##s########               
+OL,5,R]       W||||||||||||||||||||          
+OL,6,R]       W]DA K Q J 10       R]         
+OL,7,R]       W]T! ! ! ! !n$  n$  R]         
+OL,8,R]       W]T         .$n$.$  R]         
+OL,9,R]       W]T         n$.$n$  R]         
+OL,10,R]       W]T         .$  .$  R]         
+OL,11,R]       W]T         l$  l$  R]         
+OL,12,R]       W]T         n$l$n$  R]         
+OL,13,R]       W]T         l$n$l$  R]         
+OL,14,R]       W]T         n$  n$` R]         
+OL,15,R]       W]D              01 R]         
+OL,16,R]       W////////////////////          
+OL,17,R]           Wppspppppppp               
+OL,18,R]           W]TCQHTSQD R]              
+OL,19,R]           W##s########               
+OL,20,R]                                      
+OL,21,R]                                      
+OL,22,R]                                      
+OL,23,R]                                      
+PN,22002
+SC,0002
+PS,8000
+RE,0
+CT,20,T
+OL,27,D@}@@@A}@@@B}@@@OPhD@@H}@@@H}@@@@@@
+OL,28,@@@|gpCUC@TpK@PA`Ub{~Ls_w}ww]_}_wMPv
+OL,26,@kD@PM`Rm`TMaVmamD@JAPKKYMMuOMuQMuSMu\KQ
+OL,26,A]APnD@hS|TMtUIPoD@hS|Lm`Nm`Pm`Rm`Tm`UMh
+OL,26,BVmhYMhZmhpD@hS|UMiVmiWMhXmhYMiZmiqD@hS|
+OL,26,CUMhVmhWMiXmiYMhZmhrD@hS|UMiVmiYMiZmisD@
+OL,26,DhS|UMjVmjYMjZmjtD@hS|UMkVmkWMjXmjYMkZmk
+OL,26,EuD@hS|UMjVmjWMkXmkYMjZmjvD@hS|UMkVmkYMk
+OL,26,FZmk[mbwD@hS|ZIP[mtxD@JAPKK|MmuOmuQmuSmu
+OL,26,G\Kt]APzD@PMbRmbTMcVmc_CxW|JcKJ@IJaKaZ
+OL,26,HMKhOKhQKhSKh\Au]aBBBBBBB
+OL,1,R]                                G(2/4)
+OL,2,R]           Wppppspppppp               
+OL,3,R]           W]TCQHTSQD R]              
+OL,4,R]           W####s######               
+OL,5,R]       W||||||||||||||||||||          
+OL,6,R]       W]AA K Q J 10       R]         
+OL,7,R]       W]Q! ! ! ! !}5  }5  R]         
+OL,8,R]       W]Q         * }5*   R]         
+OL,9,R]       W]Q         }5* }5  R]         
+OL,10,R]       W]Q         *   *   R]         
+OL,11,R]       W]Q         h   h   R]         
+OL,12,R]       W]Q         ?5h ?5  R]         
+OL,13,R]       W]Q         h ?5h   R]         
+OL,14,R]       W]Q         ?5  ?5` R]         
+OL,15,R]       W]A              01 R]         
+OL,16,R]       W////////////////////          
+OL,17,R]           Wppppspppppp               
+OL,18,R]           W]TCQHTSQD R]              
+OL,19,R]           W####s######               
+OL,20,R]                                      
+OL,21,R]                                      
+OL,22,R]                                      
+OL,23,R]                                      
+PN,22003
+SC,0003
+PS,8000
+RE,0
+CT,20,T
+OL,27,D@}@@@A}@@@B}@@@OPhD@@H}@@@H}@@@@@@
+OL,28,@@@|gpCUC@TpK@PA`Ub{~Ls_w}ww]_}_wMPv
+OL,26,@kD@PM`Rm`TMaVmamD@JAPKKYMMuOMuQMuSMu\KQ
+OL,26,A]APnD@hS|TMtUIPoD@hS|LMaNMaPMaRMaTMaUMl
+OL,26,BVmlYMlZmlpD@hS|UMmVmmWMlXmlYMmZmmqD@hS|
+OL,26,CUMlVmlWMmXmmYMlZmlrD@hS|UMmVmmYMmZmmsD@
+OL,26,DhS|UMnVmnYMnZmntD@hS|UMoVmoWMnXmnYMoZmo
+OL,26,EuD@hS|UMnVmnWMoXmoYMnZmnvD@hS|UMoVmoYMo
+OL,26,FZmo[McwD@hS|ZIP[mtxD@JAPKK|MmuOmuQmuSmu
+OL,26,G\Kt]APzD@PMbRmbTMcVmc_CxW|JcKJ@IJaKaZ
+OL,26,HMKhOKhQKhSKh\Au]aBBBBBBB
+OL,1,R]                                G(3/4)
+OL,2,R]           Wppppppspppp               
+OL,3,R]           W]TCQHTSQD R]              
+OL,4,R]           W######s####               
+OL,5,R]       W||||||||||||||||||||          
+OL,6,R]       W]DA K Q J 10       R]         
+OL,7,R]       W]T! ! ! ! !~4  ~4  R]         
+OL,8,R]       W]T         .$~4.$  R]         
+OL,9,R]       W]T         ~4.$~4  R]         
+OL,10,R]       W]T         .$  .$  R]         
+OL,11,R]       W]T         l$  l$  R]         
+OL,12,R]       W]T         o%l$o%  R]         
+OL,13,R]       W]T         l$o%l$  R]         
+OL,14,R]       W]T         o%  o%` R]         
+OL,15,R]       W]D              01 R]         
+OL,16,R]       W////////////////////          
+OL,17,R]           Wppppppspppp               
+OL,18,R]           W]TCQHTSQD R]              
+OL,19,R]           W######s####               
+OL,20,R]                                      
+OL,21,R]                                      
+OL,22,R]                                      
+OL,23,R]                                      
+PN,22004
+SC,0004
+PS,8000
+RE,0
+CT,20,T
+OL,27,D@}@@@A}@@@B}@@@OPhD@@H}@@@H}@@@@@@
+OL,28,@@@|gpCUC@TpK@PA`Ub{~Ls_w}ww]_}_wMPv
+OL,26,@kD@PM`Rm`TMaVmamD@JAPKKYMMuOMuQMuSMu\KQ
+OL,26,A]APnD@hS|TMtUIPoD@hS|LmaNmaPmaRmaTmaUMp
+OL,26,BVmpYMpZmppD@hS|UMqVmqWMpXmpYMqZmqqD@hS|
+OL,26,CUMpVmpWMqXmqYMpZmprD@hS|UMqVmqYMqZmqsD@
+OL,26,DhS|UMrVmrYMrZmrtD@hS|UMsVmsWMrXmrYMsZms
+OL,26,EuD@hS|UMrVmrWMsXmsYMrZmrvD@hS|UMsVmsYMs
+OL,26,FZms[mcwD@hS|ZIP[mtxD@JAPKK|MmuOmuQmuSmu
+OL,26,G\Kt]APzD@PMbRmbTMcVmc_CxW|JcKJ@IJaKaZ
+OL,26,HMKhOKhQKhSKh\Au]aBBBBBBB
+OL,1,R]                                G(4/4)
+OL,2,R]           Wppppppppspp               
+OL,3,R]           W]TCQHTSQD R]              
+OL,4,R]           W########s##               
+OL,5,R]       W||||||||||||||||||||          
+OL,6,R]       W]AA K Q J 10       R]         
+OL,7,R]       W]Q! ! ! ! !~4  ~4  R]         
+OL,8,R]       W]Q         +!~4+!  R]         
+OL,9,R]       W]Q         ~4+!~4  R]         
+OL,10,R]       W]Q         +!  +!  R]         
+OL,11,R]       W]Q         x0  x0  R]         
+OL,12,R]       W]Q         o%x0o%  R]         
+OL,13,R]       W]Q         x0o%x0  R]         
+OL,14,R]       W]Q         o%  o%` R]         
+OL,15,R]       W]A              01 R]         
+OL,16,R]       W////////////////////          
+OL,17,R]           Wppppppppspp               
+OL,18,R]           W]TCQHTSQD R]              
+OL,19,R]           W########s##               
+OL,20,R]                                      
+OL,21,R]                                      
+OL,22,R]                                      
+OL,23,R]                                      

examples/Level2p5-DRCS/DRCS-CardSuits-Nptus.tti

@@ -0,0 +1,27 @@
+DE,Level 2.5 DRCS card suits demo PTU page
+PN,2a000
+SC,0000
+PS,8010
+PF,5,0
+OL,1,C`GpGpC`Ox_|_|MXA@C`LX^|_|_|_|OxOxGpC`A@
+OL,2,A@C`C`GpGpOxOxEPA@C`A@C`C`GpGpOxGpC`C`A@
+OL,3,C`A@MX_|_|OxC`GpGpC`A@C`GpOxOx_|_|_|^|LX
+OL,4,C`A@EPOxOxGpGpC`C`A@A@C`C`GpOxGpGpC`C`A@
+OL,5,@G@O@_@_@_@_@O@GAwCx@|@~@~@~@~@|@x@{`p
+OL,6,GGGGC}Ay@A@C@C@@xxxxopg``@p@p@@@
+OL,7,@@@C@C@AAyC}GGGG@@p@p@`@g`opxxxx
+OL,8,CAw@G@O@_@_@_@_@O@Gp{`x@|@~@~@~@~@|@x@
+OL,9,AxC|C~GGGGGCCG`Op_pxxxxxpp
+OL,10,AA@@@_@O@G@C@A@@``@@~@|@x@p@`@@@
+OL,11,@@@A@C@G@O@_@@AA@@`@p@x@|@~@@@``
+OL,12,CCGGGGGC~C|Axppxxxxx_pOpG`
+OL,13,@A@A@C@C@G@O@_@_@@`@`@p@p@x@|@~@~@@@
+OL,14,AAAA}@y@A@A@C@G@@```o`g@`@`@p@x@@@
+OL,15,@@@G@C@A@A@yA}AAA@@x@p@`@`@g@o````
+OL,16,@@@_@_@O@G@C@C@A@A@@~@~@|@x@p@p@`@`@
+OL,17,@A@A@C@C@G@G@O@_@C`@`@p@p@x@x@|@~@@p
+OL,18,@@_@O@G@G@C@C@A@A@@@~@|@x@x@p@p@`@`@@@
+OL,19,@@@A@A@C@C@G@G@O@_@@@`@`@p@p@x@x@|@~@@
+OL,20,C@@_@O@G@G@C@C@A@Ap@~@|@x@x@p@p@`@`@
+OL,21,@@Y|[F[F[F[F[FY|@@@@@@OfXvXvXvXvXvOf@@@@
+OL,22,@@@@@@~|ysgO~_~_Ogsy|~@@@@@@

examples/Level2p5-DRCS/DRCS-Parrot-MainPage.tti

@@ -0,0 +1,21 @@
+DE,Level 2.5 DRCS parrot demo display page
+PN,21000
+SC,0000
+PS,8000
+RE,0
+CT,20,T
+OL,27,D@_|@@@A_|@@@B_|@@@OPlD@@H_|@@@H_|@@@@@@
+OL,28,@@@|gpCu_@|wKpZA`UB_wLs_w}ww]_}_wM@G
+OL,26,@rD@^C@^M`_m``MaamasD@^C@^Mb_mb`McamctD@
+OL,26,A^C@^Md_md`MeameuD@^C@^Mf_mf`MgamgvD@^C@
+OL,26,B^Mh_mh`MiamiwD@^C@^Mj_mj`MkamkCCC
+OL,7, Level 2.5 DRCS                         
+OL,9, Mode 0 characters                      
+OL,10,  12x10 pixels of                 \     
+OL,11,  1 bitplane                      \     
+OL,12,                                  \     
+OL,13,                                  \     
+OL,14, 24 DRCS characters               \     
+OL,15,  over 24 PTUs                    \     
+OL,17, 6 rows of 4 columns                    
+OL,18,  or 48x60 pixels                       

examples/Level2p5-DRCS/DRCS-Parrot-Nptus.tti

@@ -0,0 +1,17 @@
+DE,Level 2.5 DRCS parrot demo PTU page
+PN,2b000
+SC,0000
+PS,8010
+PF,5,0
+OL,1,@@@@@@@@@@@C@O@O@O@@@@@@@@@@|{
+OL,2,@@@@@@@@~@||@@@@@@@@@@@@@@@@`@p@
+OL,3,@N@N@N@N@L@M@D@@@Gp____OOC@@p
+OL,4,_Op@x@~@`xx|~~
+OL,5,@A~A{C^B~C~Sn@NB^F~xOPF@@`@@@p@@@@@@C@B
+OL,6,oD{@G@_AA@|__~nztfbr}z}z
+OL,7,F~E^E^E~GxAxCxCxCpI`@F@O@O@O@O@_@_@^@~@|
+OL,8,~yyagO~@H}xx~|v\tLt@d@@@@@@@
+OL,9,I`L@@@@@@@D@d@@C@N@\@@@@@@@HA`L@x@`@@@@@
+OL,10,p@`@P@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,11,ApC`G@N@X@p@`@@@@@@@@@@@@@@AAAA`A`AaAaA`
+OL,12,@@D@l@x@p@p@A@A@A@@@@@@@@@@@@@@@@@@@@@@@

examples/Level2p5-DRCS/README-drcs.md

@@ -0,0 +1,22 @@
+# DRCS examples
+## Viewing the examples
+Each example is in two page files: the main display page and the DRCS downloading page.
+- From the "File" menu select "Open".
+- Select the TTI file you wish to view with the `MainPage` extension.
+- From the "View" menu go to the "DRCS pages" submenu and under "Normal DRCS" select "Open file".
+- Select the TTI file with the same name but with the `Nptus` extension.
+
+## DRCS downloading pages
+A teletext page can use X/26 triplets to invoke downloaded DRCS characters, but the Pattern Transfer Units (or bitmaps) of the DRCS characters themselves are stored on a separate hidden DRCS downloading page. Any teletext page for display can reference up to two DRCS downloading pages: one "Global" table and one "Normal" table.
+
+## Viewing pages with DRCS characters in QTeletextMaker
+Since QTeletextMaker is a single page editor and does not see an entire teletext service, the DRCS downloading page(s) must be loaded manually after the main display page has been loaded in.
+
+All the examples supplied with QTeletextMaker use DRCS characters from the "Normal" table only. For other pages it is required to check whether the page invokes DRCS characters from the "Global" or "Normal" table using the X/26 triplets dockwindow. Where an enhancement triplet mode is listed as "DRCS character" the data will either say "Global" or "Normal". Some pages may use DRCS characters from *both* tables.
+
+From the "View" menu go to the "DRCS pages" submenu where there are two headings: "Global DRCS" and "Normal DRCS". Under each heading is a "Load file" option to load in the DRCS downloading page into that corresponding table, along with a "Clear" option.
+
+If a Global DRCS page is accidentally loaded into the Normal DRCS table or vice versa, the "DRCS pages" submenu has a "Swap Global and Normal" option to correct this.
+
+## Defining DRCS characters
+QTeletextMaker does not feature DRCS character bitmap *editing*. The Python script [image2drcs](https://github.com/gkthemac/image2drcs) can be used to convert small bitmaps in various image formats to DRCS downloading pages.

examples/Level3p5-CharDesignation.tti

@@ -0,0 +1,71 @@
+DE,Unlimited character sets with Level 3.5
+PN,19901
+SC,0001
+PS,8000
+CT,8,T
+OL,28,@@@|gpCu_@|wKpZA`UB_GQd^w}ww]_}_wM@D
+OL,28,D@@|g@@pC@|p@@CO|O@pA@\p]@@wAG\gYF@D
+OL,26,@laIA@Bma|mDRdo}eO~fo~gOoayA@BpawXH@Xi`
+OL,26,AYIaZia[Ib]ip^Iq_iq`IrbI~do}eO~fo~gOrA|
+OL,26,BXHPXi`YIaZia[Ib]ip^Iq_iq`IrbI~do}eO~fo~
+OL,26,CgOtawXHRXi`YIaZia[Ib]ip^Iq_iq`IrbI~do}
+OL,26,DeO~fo~gOvA|XhRXi`YIaZia[Ib]ip^Iq_iq`Ir
+OL,26,EbI~do}eO~fo~gOxawXh[Xi`YIaZia[Ib]ip^Iq
+OL,26,F_iq`IrbI~do}eO~fo~gOzA|XhjXi`YIaZia[Ib
+OL,26,G]ip^Iq_iq`IrbI~do}eO~fo~gO|awXhkXi`YIa
+OL,26,HZia[Ib]ip^Iq_iq`IrbI~do}eO~fo~gO~A|XH`
+OL,26,IXi`YIaZia[Ib]ip^Iq_iq`IrbI~do}eO~fo~gO
+OL,26,JhApCCCCCCCCCCCC
+OL,1, Level 3.5 allows unlimited char  F(1/2)
+OL,2, sets using the "Modified G0 and G2     
+OL,3, Character Set Designation" triplet.    
+OL,4,F                       `G0 lvl 1`` -G2`
+OL,5,FLevel 1 with         G ABCD abcd |     
+OL,6,F  Level 1.5 G2 chars                   
+OL,7,F`Char set```` `Bits``  `G0 X/26``` `G2`
+OL,8,FLatin        B0000xxxG                 
+OL,10,FCyrillic 1   B0100000G                 
+OL,11,F  Serbian/Croatian                     
+OL,12,FCyrillic 2   B0100100G                 
+OL,13,F  Russian/Bulgarian                    
+OL,14,FCyrillic 3   B0100101G                 
+OL,15,F  Ukranian                             
+OL,16,FGreek        B0110111G                 
+OL,18,FHebrew       B1010101G                 
+OL,20,FArabic       B1010111G                 
+OL,22,FLatin with   B1000000G                 
+OL,23,F  Arabic G2                            
+PN,19902
+SC,0002
+PS,8000
+CT,8,T
+OL,28,@@@|gpCu_@|wKpZA`UB_GQd^w}ww]_}_wM@D
+OL,28,D@@|g@@pC@|p@@CO|O@pA@\p]@@wAG\gYF@D
+OL,26,@layA@Bma|nD@Ao|BO}Co}DO~Eo~FOoayA@Bpaw
+OL,26,AhQaHH@qD@@H@rA|hQaHHPsD@@HPtawhQaHHRuD@
+OL,26,B@HRvA|hQaHhRwD@@hRxawhQaHh[yD@@h[zA|hQa
+OL,26,CHhj{D@@hj|awhQaHhk}D@@hk~A|hQaHH`D@@H`
+OL,26,DhAp_CxUaHI`Ii`JIaKiaLIbMibNIcOicPIdQid
+OL,26,ERIeSieTIfUifVIgWigXIhYihZIi[ii\Ij]ij^Ik
+OL,26,F_ik`IlailbImcimdIneinfIogioiD@Ao|BO}Co}
+OL,26,GDO~Eo~FOHIpIipJIqKiqLIrMirNIsOisPItQit
+OL,26,HRIuSiuTIvUivVIwWiwXIxYixZIy[iy\Iz]iz^I{
+OL,26,I_i{`I|ai|bI}ci}dI~ei~fIBBBBB
+OL,1, Level 3.5 allows unlimited char  F(2/2)
+OL,2, sets using the "Modified G0 and G2     
+OL,3, Character Set Designation" triplet.    
+OL,4,F`G2``` `G0 from level 1`````````` `NOS`
+OL,5,FL1.5  G@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
+OL,6,        `abcdefghijklmnopqrstuvwxyz{|}~ 
+OL,7,F`G2``` `G0 from X/26 enhancements``````
+OL,8,FLatin G                                
+OL,10,FCyr 1 CG        CG    C G   C  FGCFC F 
+OL,11,       CG        CG    C G   C  FGCFC   
+OL,12,FCyr 2 CG        CG    C G   C  FGCFC F 
+OL,13,       CG        CG    C G   C  FGCFC   
+OL,14,FCyr 3 CG        CG    C G   C  FGCFC F 
+OL,15,       CG        CG    C G   C  FGCFC   
+OL,16,FGreek G                                
+OL,18,FHebrewG                                
+OL,20,FArabicG                                
+OL,22,FL/AbG2G                                

examples/Level3p5-DRCS/Level3p5DRCS-ParrotMode1-MainPage.tti

@@ -0,0 +1,34 @@
+DE,Level 3.5 DRCS mode 1 parrot demo display page
+PN,21100
+SC,0000
+PS,8000
+RE,0
+CT,20,T
+OL,27,D@_|@@@A_|@@@B_|@@@OQlD@@H_|@@@H_|@@@@@@
+OL,28,@@@|g@@`Jq[tnIpZA`UB_wLs_w}ww]_}_wM@G
+OL,28,A@@@@@@@crI@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,26,@mD@\M`]Ma^Mb_Mc`MdaMebMfcMgdMheMinD@\Mj
+OL,26,A]Mk^Ml_Mm`MnaMobMpcMqdMreMsoD@\Mt]Mu^Mv
+OL,26,B_Mwixp`M`aMabMbcMcdMdeMepD@\Mf]Mg^Mh_Mi
+OL,26,C`MjaMkbMlcMmdMneMoqD@\Mp]Mq^Mr_Ms`MtaMu
+OL,26,DbMvcMwiXqdM`eMarD@\Mb]Mc^Md_Me`MfaMgbMh
+OL,26,EcMidMjeMksD@\Ml]Mm^Mn_Mo`MpaMqbMrcMsdMt
+OL,26,FeMutD@\Mv]Mwixq^M`_Ma`MbaMcbMdcMedMfeMg
+OL,26,GuD@\Mh]Mi^Mj_Mk`MlaMmbMncModMpeMqvD@\Mr
+OL,26,H]Ms^Mt_Mu`MvaMwiXrbM`cMadMbeMcwD@\Md]Me
+OL,26,I^Mf_Mg`MhaMibMjcMkdMleMmxD@\Mn]Mo^Mp_Mq
+OL,26,J`MraMsbMtcMudMveMwyD@ixr\M`]Ma^Mb_Mc`Md
+OL,26,KaMebMfcMgdMheMizD@\Mj]Mk^Ml_Mm`MnaMobMp
+OL,26,LcMqdMreMs{D@\Mt]Mu^Mv_MwiXs`M`aMabMbcMc
+OL,26,MdMdeMe|D@\Mf]Mg^Mh_Mi`MjaMkbMlcMmdMneMo
+OL,26,NCCCCCCCCCCCCC
+OL,6, Level 3.5 DRCS                         
+OL,8, Mode 1 characters                      
+OL,9,  12x10 pixels of                       
+OL,10,  2 bitplanes                           
+OL,11,  or 4 colours                          
+OL,13, 160 DRCS characters                    
+OL,14,  over 320 PTUs stored                  
+OL,15,  across 7 subtables                    
+OL,17, 16 rows of 10 columns                  
+OL,18,  or 120x160 pixels                     

examples/Level3p5-DRCS/Level3p5DRCS-ParrotMode1-Nptus.tti

@@ -0,0 +1,196 @@
+DE,Level 3.5 DRCS mode 1 parrot demo PTU page
+PN,2b100
+SC,0000
+PS,8010
+PF,5,0
+OL,28,CE@@aG^xaG^xaG^xaG^xaG^xaG^xaG^xaG^x@@@@
+OL,1,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,2,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,3,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,4,@@@@@@@@@@@@@@@@@@_x@@@@@@@@@@@@@@@@@@NP
+OL,5,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,6,@G@C@@@@@@@@@F@@@@@@@G@@@@@@@@@@@B@@@@@@
+OL,7,`C@@@@@@@@@@@@@@@@@@@B@@@@@@@@@@@@@@@@@@
+OL,8,@@@@@@@@AfAAA@@_@@@@@@@@AbAA@@@_
+OL,9,@@@@@A@A@@@@@@`A@A@A@@@@@@@A@@@@@@@@@A@A
+OL,10,qpyp~~_OGvG|F|F|@Qpyp|~~ONGDFxF|@|@
+OL,11,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,12,@@@@@@@@@A@B@D@@@P@P@@@@@@@@@@@A@C@O@O@O
+OL,13,@G@_AB}Br@@@@@@@@@@@C@O@O
+OL,14,owM|_@AG@A@A
+OL,15,x@acx@`
+OL,16,A|}O~_@@O
+OL,17,@`eppp}wp{@@a``p
+OL,18,@ND@F@F@`@p@p@p@~@@@ND@F@F@@@`@p@`@|@@
+OL,19,@A@A@@@@@@@@@@@@@@@@@A@@@@@@@@@@@@@@@@@@
+OL,20,|@x@@@@D@@@@@@@@@@@]|@x@@@@@@@@@@@@@@@@Y
+OL,21,@@`@p@p@`@@@@@@@@@@@@@`@p@`@@@@@@@@@@@@@
+OL,22,@P@P@Z@O@O@C@G@G@O@O@O@O@E@@@@@C@G@G@O@O
+OL,23,@@H@p@OoowOp_@_`_`_p_x_|_
+OL,24,@@G@Op~{
+PN,2b101
+SC,0001
+PS,8010
+PF,5,0
+OL,28,CE@@aG^xaG^xaG^xaG^xaG^xaG^xaG^xaG^x@@@@
+OL,1,@`@N@^@~@\|@x@xsys{q
+OL,2,_G@z@xHx@x@@@`@pG`A
+OL,3,sss_C@@C@C@@Gx`
+OL,4,`px|yx^po@A|@A`pp|~~~~
+OL,5,@\@@_@_CC@_@G@A@@@X@_@_@_AC@O@G@A@@
+OL,6,\_x^_@x|||xxL\x^_@~x||xx_x
+OL,7,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,8,@_@_@_@_@_@_@_@_@_@_@O@O@_@_@_@_@_@_@_@_
+OL,9,}|_|_|O~__O|GxG|G~_|_|_|O~_~_}GxGxGxC
+OL,10,
+OL,11,x@x@p`qApApEpG|C|@~@
+OL,12,@A@@@@x@x@y@x@`@@@@@
+OL,13,~@x@`@@@@@@@@@@@@@@@
+OL,14,@A@K@O@G@O@O@O@_@@
+OL,15,x@x@|@p|rucnG`Ax@x@x@``f
+OL,16,OY@AAAFwNH@{AAA@g
+OL,17,@@@@@@@@@@@@@@@@@@O`@@@@@@@@@@@@@@@@@@G`
+OL,18,@_@O@OHGHG@C@C@C@B@J@O@O@G@GHC@C@C@@@C@G
+OL,19,s|S}g~_~~|otg@@pAdxC{crCpJrXwDw@\@@~X
+OL,20,_GA@~@N@F@D_GA@_@O@A@C
+OL,21,~@~@x@`@@@@@@@@@@@@@
+OL,22,@@@@@@@@@@@@@@@@@@@@
+OL,23,@@@@@@@@@@@@F@GwOOryxOpOpO
+OL,24,@_@O@GHG^G~C^Ak@@@@@
+PN,2b102
+SC,0002
+PS,8010
+PF,5,0
+OL,28,CE@@aG^xaG^xaG^xaG^xaG^xaG^xaG^xaG^x@@@@
+OL,1,`ApAx@x@x@~@@~@\AL@
+OL,2,y{}SWCGGqBpGDfpbHYCpx||~
+OL,3,xx||xp~@~@~@x@px|xx`~@~@~@`@
+OL,4,@x@|A|G|GrODOl\Ht@@@@_@ACGOO_[
+OL,5,CxAC@@@@@@BFAcCsAyp}|@~|}y~\|L~FOB
+OL,6,@Xxppy_~OOo@G@G@O@O@F`@p@@@@@@@
+OL,7,@@@@`@`DPFXFlgtgw__{OyGyCXCX@@@@
+OL,8,@@@@D@F@C@K`[a}{y|t_d^B@@@@@
+OL,9,O@F@@@@@@@xBxC~G~pyG}G|Ax@@@A
+OL,10,@@@@@@@@@@@@l@|@p@@@SCO
+OL,11,@@@@@H@L@D@D@@@@@@@@ws{{
+OL,12,`Q@P@A@A@A@C@E@DXFxF~}||g|G~
+OL,13,C@pz}~~xN|DDC@_aq{xOxG~C
+OL,14,\CzCv@l@\@X@P@`@`@`q|}|yscgo___N
+OL,15,x|~]~_CCCGGCaCqc{G@A`A`|@|@|@xx|^|N\D
+OL,16,OOo@@@@@@@@@@@@@@@@@@@@
+OL,17,ooK@@@@@@@@@@@@@@@@@@@@
+OL,18,@@@@@@@@@@@@@@@@@@@@
+OL,19,|x`|@p@p@p@p@x@|@@C@G@_COOOOGC
+OL,20,@@@@@@@@@@@@@@@@@@@@
+OL,21,@@@@@@@@@@@@@`ApAq@q_~O~NN
+OL,22,pFYFYF]]]]|~O~f~f~c~ava~a~@~@~@z
+OL,23,aakO~Gw_gFggG~G|cwOG
+OL,24,@|q|}~y|s|t|dXlX|DxcC~CrApCpCcCggogo{o\
+PN,2b103
+SC,0003
+PS,8010
+PF,5,0
+OL,28,CE@@aG^xaG^xaG^xaG^xaG^xaG^xaG^xaG^x@@@@
+OL,1,cCGOOGGgGwG~G|\@|@x@p@p@x@xXzH{@x@
+OL,2,o~tx~@@@@@@@@@@@@@@@@@@@@
+OL,3,KGGOoykc@@@@@@@@@@@@@@@F@T@\
+OL,4,w~_`O`C`C@@@@@@@@@@H@A`_p_|_|
+OL,5,t||pppv|oG@K@C@C@O@O@O@I@CP@x@
+OL,6,@@@@@@@@@@@@@@@@`@@@_
+OL,7,@A@@@@A`A@A@C`C@C@C@~~_~~|_|||
+OL,8,~~~~~~~W~WzC{O{GC~@z@z@z@zhzhz|{p{xz|z
+OL,9,a`^@_P]|_~~~s~`^@_@\@\|\
+OL,10,`aq`cAC@G@G@G@F@B@B@_^^_\~|z~|y}}
+OL,11,G|g|ClC|CrCxCxGxGx|x@X@|@|@|@|@|@~@~@O@
+OL,12,__OCA@{@G@G@G@G@@@@@@@@@@@@@@@@@@@@
+OL,13,cgnN~\~H~@x@x@x@@\@X@Q@qAcAwAGGG
+OL,14,@@@@@@@@@@@@@A@@@@@A~~
+OL,15,C@CAAOAG@G@_@_@_|@@|@~@~p~xx```
+OL,16,E@E@f~~N~B|B|_n|xzzYAAqA}C}C`@Q@C@G
+OL,17,C`G`G`O`y|p~P^`|`~`~|_x_x_p_FCOAoa_C_A_A
+OL,18,C~AAwAw@@@O@_@_@_|z~s~w~ggkoo
+OL,19,|^~\~\\\|_|]|]|\|]|Y|[~[~[~[|Q|S|SxS|S
+OL,20,C@O@|AdA`A`A`C`C`C`C|pC~[~~~}}_}}
+OL,21,|wxZ~~ov~w~O@OdGdGfgvs~q~q~yy
+OL,22,@O@O@_@_@_@@@wAA@@@@@@@@@P@P@@@X@pAp
+OL,23,x@x@p@`@b@h@p@pD`F`GGGO_]WOO{_y_x
+OL,24,@A@Q@Y@Y@J@_@_AC}cy~nffu``~@|B\F
+PN,2b104
+SC,0004
+PS,8010
+PF,5,0
+OL,28,CE@@aG^xaG^xaG^xaG^xaG^xaG^xaG^xaG^x@@@@
+OL,1,D_D_DOFGD~~w{`{`{py@x@{@@@A@A@H@
+OL,2,`acg_~|~y|@_@^@\@X@`@@@@@@C@F@
+OL,3,Qo]o_hWcC`C`SDS@[C^GN@B@@@H@\@\@L@L@DC@C
+OL,4,@_p_xGHgGyGWwooOGgGCGaC|C~wgg
+OL,5,||p||~z{}}Hsps{yy_x}|||
+OL,6,PCPOPGRGSqp_Hloo}ouo}m}l]N\O~w~Sq
+OL,7,{~}_~}}~~||||_|OxNx
+OL,8,acsC`AAaa@A`A`A@@@@@@@@@@@@@a@
+OL,9,`G`O`pw~}_x_p_@O@@A@O@O@_AC
+OL,10,x~ov_~y``@G@A@I@Ap@x@|@@@`
+OL,11,BD@@@@@@`A{{qBAC}{_~@D@@@@@fBw
+OL,12,i|A|G|O||||C|C|@DV@~@x@p@@@@@@@@@@@@@
+OL,13,PG@C@N@\BXF_NONG^G]s@C@B@H@H@PBNFGNGLCUs
+OL,14,O~O~O|GxGxCxspqpx@x@G~O~OxGxGxCxapqpp@x@
+OL,15,~yOqOqyyqy}~~yOaGqpppx{|
+OL,16,_}|~~}owo_y}|_|_|K~K~
+OL,17,g_gn{kr~O}_K~Ovooa``w`wasqrspwpwxW|[
+OL,18,a_Aqqp`@COa`a`A`A`@|@_@_AO
+OL,19,}GGxOoO
+OL,20,D@coO@@
+OL,21,yCODOCw}}}}p_@G@F
+OL,22,pG@C@G^@A@@@@
+OL,23,_x|~~gOx||~~C
+OL,24,x@@@@@@@@@@@@p|X@@@@@@@@@~@@@px
+PN,2b105
+SC,0005
+PS,8010
+PF,5,0
+OL,28,CE@@aG^xaG^xaG^xaG^xaG^xaG^xaG^xaG^x@@@@
+OL,1,{~~~~_@N@@@@y~~~~~\^@N@@@@
+OL,2,{W|_|_|O~O~E@c_H^hNlNlNLO~@_@A_G_
+OL,3,qi{IXY[
+OL,4,}e~rJ@~@
+OL,5,~x`~@{@{@}`|`|x||~p~@z@b@@@@@@@@H@H
+OL,6,_@O`O`O`Gq@\_\_N@~@O@O@O`O`Fp@@_@F@@F@
+OL,7,DOY^XLx@x@p@`@@@@@`@@N@NX@X@p@p@`@@@@@@@
+OL,8,@O@O@[@[@wAwAoCfG@F@@A@A@C@C@G@G@G@B@@@@
+OL,9,`_pGx@swOOOO`_pCp@swgOOOO
+OL,10,Ow|Ocyx~Gq|_~Gcpx
+OL,11,@@x@xA|C|C|C\GXO@Op_@@X@x@|C|C|C\GHG@O`O
+OL,12,___oOOGo
+OL,13,yapx|~^|p`pxxc\CH
+OL,14,cca`@@@@@@oc@APAp@p@@@@@@@@@@@P
+OL,15,|n|_|_|O|_|~o~_~o@L@O@O@O@O@O@O@O@G@O
+OL,16,wS{_~~}}}WAsWy~~~||x
+OL,17,@@B@B@G@Oawacg}NL@@@@@@@@A@A@A`A@C@C@
+OL,18,N@\@X@x@p@h@d@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,19,O@_@_@O@G@@@@@@@@@@N@_@_@O@G@@@@@@@@@@
+OL,20,wxqpp@`@@@@@@@@@@@@@wxpp`@@@@@@@@@@@@@@@
+OL,21,|wO_|_gGO_
+OL,22,~~_~_~_~_~xx``@````
+OL,23,~ld`Ppp}x~p||AH@@@`@`@@@@@@@@@@@@
+OL,24,@o@_A_AuquqeqeQdS`S`@P@@@@@Z@z@z@z@{@@
+PN,2b106
+SC,0006
+PS,8010
+PF,5,0
+OL,28,CE@@aG^xaG^xaG^xaG^xaG^xaG^xaG^xaG^x@@@@
+OL,1,__oo@_@_@_@_@_@_A_AOAOAO
+OL,2,{{xxpdl|\||x
+OL,3,XP``aggC@C@C@B@F@FGG__~
+OL,4,@@@@@@@@`@|@@@g@Ct@@@@@@@@`@p@~@@c@C`
+OL,5,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,6,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,7,{p``@~A|A{p`@~@|A|A
+OL,8,~_~o~o~o^w_wOekKH`PPP[H[HOHGDdzf
+OL,9,|~~~~~~@@@@@@@@@@@@@@@@@@@@
+OL,10,S`C`C`G`E`g`G`G`GhGh@@@BBDDDDwDw
+OL,11,o}}_}}}AOAOAGCGCgCgCgCcCcCc
+OL,12,www}o~~zppxsxwr`p}}
+OL,13,op_pO`OpO~__^^__po`@`z~O~
+OL,14,C|A|Ax@|@~|gg|CA|Ax@x@|@|xgC|C
+OL,15,@@@@@@@@^@@@@|@x@@@@@@@@@\@~@@~@p@p@
+OL,16,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

examples/Level3p5-DRCS/Level3p5DRCS-ParrotMode2-MainPage.tti

@@ -0,0 +1,28 @@
+DE,Level 3.5 DRCS mode 2 parrot demo display page
+PN,21200
+SC,0000
+PS,8000
+RE,0
+CT,20,T
+OL,27,D@_|@@@A_|@@@B_|@@@ORlD@@H_|@@@H_|@@@@@@
+OL,28,@@@|g@@`DsIBGqXaUSUwSC^MfziDcxgUoywvOpF
+OL,28,A@@@@@@@@@@LJgtj}bszMo{ph\RkvKNkw|nC@@
+OL,26,@oD@^M`_Mb`MdaMfbMhcMjdMleMnpD@^Mp_Mr`Mt
+OL,26,AaMvixpbM`cMbdMdeMfqD@^Mh_Mj`MlaMnbMpcMr
+OL,26,BdMteMvrD@iXq^M`_Mb`MdaMfbMhcMjdMleMnsD@
+OL,26,C^Mp_Mr`MtaMvixqbM`cMbdMdeMftD@^Mh_Mj`Ml
+OL,26,DaMnbMpcMrdMteMvuD@iXr^M`_Mb`MdaMfbMhcMj
+OL,26,EdMleMnvD@^Mp_Mr`MtaMvixrbM`cMbdMdeMfwD@
+OL,26,F^Mh_Mj`MlaMnbMpcMrdMteMvxD@iXs^M`_Mb`Md
+OL,26,GaMfbMhcMjdMleMnyD@^Mp_Mr`MtaMvixsbM`cMb
+OL,26,HdMdeMfzD@^Mh_Mj`MlaMnbMpcMrdMteMvCC
+OL,7, Level 3.5 DRCS                         
+OL,9, Mode 2 characters                      
+OL,10,  12x10 pixels of                       
+OL,11,  4 bitplanes                           
+OL,12,  or 16 colours                         
+OL,14, 96 DRCS characters                     
+OL,15,  over 384 PTUs stored                  
+OL,16,  across 8 subtables                    
+OL,18, 12 rows of 8 columns                   
+OL,19,  or 96x120 pixels                      

examples/Level3p5-DRCS/Level3p5DRCS-ParrotMode2-Nptus.tti

@@ -0,0 +1,233 @@
+DE,Level 3.5 DRCS mode 2 parrot demo PTU page
+PN,2b200
+SC,0000
+PS,8010
+PF,5,0
+OL,28,CE@@b{nxnKn{b{nxnKn{b{nxnKn{b{nxnKn{@@@@
+OL,1,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,2,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,3,@@@@@@@@@@@@@@@@@@@C@@@@@@@@@@@@@@@@@@@E
+OL,4,@@@@@@@@@@@@@@@@@@@B@@@@@@@@@@@@@@@@@@@A
+OL,5,@~@xOxGx@H@@@XOop@@@@@@@@@@@@@@@@@AWO
+OL,6,@p@pOxCX@@@@@HFx_@@@@@@@@@@@@@@AO
+OL,7,H`@@L@D@@@@@@@^@n@@@@@@@@@@@@@@@`@AqA
+OL,8,@@@@D@@@@@@@@@^@~@@@@@@@@@@@@@@@`@p
+OL,9,@pD\LDH@LX@\ApCp~w|`@H@@@@@@@@@@@@@@MLS_
+OL,10,@T@LD@D@@H@X@pA`sr@H@@@@@@@@@@@@@@O|
+OL,11,HI@A@A@@B@G`EbKxwH@@@@@@@@@@@@@@B@@@H@|@
+OL,12,Os@@@@@A@AAACaCOLGxG@@@@@@@@@@@@@@@@@@|@
+OL,13,`^az@X@@A@@@A@@@@@`@@@@@@@@@@@@@@@@@@@@@
+OL,14,@L~\`~@~@@~@~@l@@@@@@@@@@@@@@@@@@@@@@@
+OL,15,@@@FPO@W@@PD@b@@A@DD@@@@F@@I@B@B@@@@@@@@
+OL,16,NxO~I{OjGgOc_@_@N@@C@@@@FD@G@@@@@@@@@@@@
+OL,17,@@@@@@@@@@@@p@p@`@@@@@@@@@@@@@@@@@@@@@@@
+OL,18,@@@@@@@@@@@@P@P@@@@@@@@@@@@@@@@@`@`@@@@@
+OL,19,@HAxA~CCCCG@oAw@S@yC~GGGGCC@
+OL,20,@O@ACCC@C@H@@A`@G@G@A@@@@@@@@@@@`Ap
+OL,21,@@@@@@`@`@pBp~ooB`{`@pBpb^xow
+OL,22,]@G____O}O_o
+OL,23,@C@@@@@@@@@@@@p@x@~@|_Y@_p`_zA
+OL,24,O}
+PN,2b201
+SC,0001
+PS,8010
+PF,5,0
+OL,28,CE@@b{nxnKn{b{nxnKn{b{nxnKn{b{nxnKn{@@@@
+OL,1,`@@@@@@@@@@@@@@@@O@B_f}t|OxB
+OL,2,p}
+OL,3,@@BM@K@B@E@O@G@@@@@@{p}pxd{pxGAy
+OL,4,|Gys{~`px|
+OL,5,@@`@@@`@`AqD[dOnCqCP@@@@@@@@@@`@pAx@|@~@
+OL,6,@@@@`@@@@@@CaBwGN|O@@@@@@@@@@`@pAx@|A~@
+OL,7,I@GCLC@K@|Pp@@@@@X@X@@@@@@@@@@@L`@~@@`
+OL,8,PGXB@@@ACOo_A@|@F@@@@@@@@@@@@`@~@@x
+OL,9,@@@@@PBPA@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,10,@@@@@`A`@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,11,A{CGs}}G}G|G|G{CzCACG~C~C~C@DtDL
+OL,12,CpCxC|G~C~G~GGC~GvAxC|C~C|G|G|G|G|GxCx
+OL,13,oOGoOwtgx_W_OGGC
+OL,14,OoO_oWOG_____O_OGG
+OL,15,~@~@|@|@x@|@|@|@@@z{]{yzP~a{CxGxGxCx@
+OL,16,}
+OL,17,@@@@@@@@@@@A@G@X@PL@p@t_`A_`FxA{G{XcPLB
+OL,18,~xgos
+OL,19,@@@@B@N@\@x@@~@\HXXQa~Az@n@\@x@@~@\HXX
+OL,20,}qcG@Acwgg
+OL,21,CFC`CbGwGoOO{_xrF|@x@y`[@_P@B@v@F^J^F
+OL,22,~C@~@fo}}|@|@}``p~~}y
+OL,23,@r@@HBB@WdGw_pH`N@O@_HAp@@@@@[@I`ODNsxqH
+OL,24,`D^LG}O_N`{b_p{q|G~w_xAp@@@@@_@_`O|NxH
+PN,2b202
+SC,0002
+PS,8010
+PF,5,0
+OL,28,CE@@b{nxnKn{b{nxnKn{b{nxnKn{b{nxnKn{@@@@
+OL,1,@@@@@C@C@A@ABA@@|Pp@@@@@@@@@@@@@@@N@C`O`
+OL,2,@@@@@@@A@@@@@@q`|@pP@@@@@@@@@@@@@@N@``
+OL,3,G}CC{`|a~q}xO^G\C~I@CBSA~A@y@NAoBGCC@I
+OL,4,GtAeBAACaEa{P]~O~_CxCxAx@x@z@DApCxG|Ov
+OL,5,_WAG_{ow~xC~ck~_xG`G@Ap@xA
+OL,6,W[~|Oxd@@H@@@P@|@GGA@_@C@A@@@@@@@@
+OL,7,@~A|CxGpGuGmgmox@AApCHGpGuGMgmo
+OL,8,wOO_w~|xxzxRXRP@@@@
+OL,9,|@hxoqgw|@hxoqgw
+OL,10,~~~^sC@W@GPNXH@@@@@@@@@@
+OL,11,Pxqayoo^OG`XH~N}_Pxqayom\|{`xH~N}_
+OL,12,q_r_cDCD_GO_oGN^F^@_@CCGwAqB`
+OL,13,_NogoegwaA{@q@QNGgNNgGaeagbw@cAA@ANGg
+OL,14,~q_x_z_x_x|~~qx@X
+OL,15,_ropbpqxq}om{~YpI|@Aaaab_p@p`}dlzvXpI|A
+OL,16,~^~^}`\~[sE{gv_a_a_OpOxC|_~M~OC
+OL,17,@ABa@C@C@GHG\NM@N@O`|@x@|C@C@BsDFioG
+OL,18,@PCADA@@|AGElkOW@R@|`|@xA|C@B@C_Gnl@
+OL,19,Oq_z^z~[y_WsaP_u_{m`o@_@_x[y_osp_u_{o
+OL,20,_}~G~f~WoA_|_|xp``@dG`@L`O`J`DP
+OL,21,~Mo`Ix\XDHg@qHp_x|_ooox~
+OL,22,~@s@X@\@D@@@`@@@@@@@@@P@P@@@@@@@@@@@@@@@
+OL,23,wwkEC@o@@HpHp`r@{ww{}
+OL,24,s}Ax@h@H@@@@@@@@@@@@@H@@@@@@@@@@@@@@@@@@
+PN,2b203
+SC,0003
+PS,8010
+PF,5,0
+OL,28,CE@@b{nxnKn{b{nxnKn{b{nxnKn{b{nxnKn{@@@@
+OL,1,}wCAA__
+OL,2,{|i|`p@@@@@@@@@@@@@A@@@@@@@@@@@@@@@@@@@@
+OL,3,
+OL,4,___^A@A@O@CO@@@@@@@@@@@@@@@@@@@@
+OL,5,sqtsqt
+OL,6,@L@N@K@@@@@@@@@@@@@@
+OL,7,~D~Fev~r|szV|WKC~E~Gftzpxp~u~B~@~@
+OL,8,__}yy{u_ykyHy@y@A{A{@^@NCNCNA^A@@
+OL,9,DKWfNT^N@OBX@pAHqqAspK`FPDlN~A|AxA[qBBn@
+OL,10,Iu[n__QAXFQGQdqMCQcpLpI\K~_~^xNxN[NC|o|
+OL,11,S~OKs~C}wikono_}SOOOo_moml_~
+OL,12,x|qlp|@XAxazYzY{~Yl@p@p@@@@@@PPPpP`P`@
+OL,13,~]MXx|x|~}v}Y`]
+OL,14,X@H@@@@@@@@@@@@@@@`@@@@@@@@@@@@@@@@@@@@@
+OL,15,@_@VDVHgPoLO@@_@~g~{scs_
+OL,16,@@@@@@@@@@@@@`@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,17,__
+OL,18,@@@@@@@@@@@@@@B@H@P@@@@@@@@@@@@@@@@@@@@@
+OL,19,
+OL,20,[@@_@@_@_@O@G@C@@@@@@@@@@@@@@@@@@@@
+OL,21,
+OL,22,yxy{{sssCc@@@@@@@@@@@@@@@@@@@@
+OL,23,{Fr@rE{A}dDaa``~Aa`dAadddf
+OL,24,qA`a@apdpaxAxE|E|E~G@~@^@^@Z@^@^@Z@Z@Z@X
+PN,2b204
+SC,0004
+PS,8010
+PF,5,0
+OL,28,CE@@b{nxnKn{b{nxnKn{b{nxnKn{b{nxnKn{@@@@
+OL,1,Ar@bAa@cCaA@HG@KSO@_x@}F|E`C@A@HAOqK@OqN
+OL,2,GcBECG_G`G@OqKMGmGOIy}}{|z`|@~@w@tp|Pppp
+OL,3,w||xznojgsgo{gXgo{{oo_iwqwu{~x~
+OL,4,wLgl|G~W~g~oojOa_a@@@@@DpD`P@THLHEDGGG
+OL,5,@sBCC`JHV@LIL@FAL@L@}||_tGhOpFp@x@xAPA
+OL,6,@@@@@@@@P@L@L@D@L@l@@@@@@@@@@@@@@@@@`@`@
+OL,7,GGGOO___OO
+OL,8,@D@D@A@A@S@_@[@{@@@@@@@@@@@@@@@@@@@@@@
+OL,9,
+OL,10,_|~qscc~CB@@@@@@@@@@@@@@@@@@@@
+OL,11,
+OL,12,@@@@@A`A`@`@`@P@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,13,}~|~|~|
+OL,14,sCaC`@@@P@HDHLH\@X@@@@@@@@@@@@@@@@@@@@@
+OL,15,`hbp|xxoxC`GPffmmpv{g{Q
+OL,16,GGnOnOoOyOtOpCxAn@X@X@Q@Q@P@F@K@O@W@q
+OL,17,ROpWXOP]DGFYDoAoACgi_IOa_A]AWA[a_~_^O\Y
+OL,18,W]OQmI}KyIyM^MAmaecwxbpfPf@f@n@da``_`_`
+OL,19,xw|w{Oom{~}xo|KGKOOnGnGzC}By@
+OL,20,_Ptxtpx}xm|b}fGgCC@C@KpOPGPGFCGCCA
+OL,21,ZBjBoGgFGIcgowdADAT@xAhA`G`O`KPC@C
+OL,22,x@zBzCVFWF_L_L_lotdd@t@t@x@x@x@x@x@x@h@
+OL,23,O__~~|~}x
+OL,24,@]A|AxBxC@C`C@@@@C@@@@@@@@@@@@@@@@@@@@@G
+PN,2b205
+SC,0005
+PS,8010
+PF,5,0
+OL,28,CE@@b{nxnKn{b{nxnKn{b{nxnKn{b{nxnKn{@@@@
+OL,1,GgSx_O
+OL,2,DB|@\@X@@A@G@G`@P@@@@@@@@@@@@@@@@@P@x@
+OL,3,xQ@
+OL,4,@@@@@@@@@@@@~XpG@@@@@@@@@@@@@@@@@@@@@@@
+OL,5,~}||{y{ygxpOpO@_A\~|||||xx@x@xAx@x@
+OL,6,@`@p@s@R@@@B@E@L@K@[@@@@@@@@@@@@@@@A@@@@
+OL,7,K`f@DB`CP@x@p@`@HBA@Q@@@`dLtIpApApAx@x@X
+OL,8,BAG[SIrO~O~O~GsE|dA@@@@dLvIpApApAx@x@X
+OL,9,CmB_@n@O@[`O`GXA@@@Llu}s_spsE@AS@sFCGgc
+OL,10,SGBD`L@OLd_`laLg|gXWorp_ppsC@GSFs@C@g`
+OL,11,~_OOowoowG}@z`K`Ipm@m`ohghCPAp
+OL,12,sE_tvoRR_PWXW|o~OO@O`O`OpopopoxgxCXAH
+OL,13,sgkw{~}\juG~Go~HGXG@G@CACcDJ@@@@PA@
+OL,14,w`g`jd~d\guC|D|PCH@X@@D@@@@`A@@@C@O@
+OL,15,}}roag_p`B~M|^\@`@@@@@@@
+OL,16,@D@l@B@m@^`LapN@p@@@@O@_A}ApCaG_
+OL,17,~@~g_}\_mCMAC@P@@@@@B@@@c`R|r@
+OL,18,n@BR@Y@M@G`@@c`R~r@|@~@@}\_l@L@
+OL,19,o|tP_MfOfo~Am}CPCKc@`rYpYP@A@~@R@B`
+OL,20,I`O`BxvYpYR@C@~@fAba@@@@]@MfOfo~AA`A@
+OL,21,G|Gxv`_p_|sWox@x@IP`@`B@@@@@@L@HP
+OL,22,A}BC``y@C@@@@|@Gp@@@@@@_@_~C@O
+OL,23,@A@@@@P@@@`@|P`x~@P@@@@@@@@P@@@@@@@@@
+OL,24,~h~ssn@v@~@C`Bp@h@@@P@@@@@@@@`@|@@p|
+PN,2b206
+SC,0006
+PS,8010
+PF,5,0
+OL,28,CE@@b{nxnKn{b{nxnKn{b{nxnKn{b{nxnKn{@@@@
+OL,1,@@@@`M@A@EpEdS@C@C@GswqwXryzXz@R@@@@@@@@
+OL,2,LONogNVVeRHjxBxBx@|\spqpxqyyXy@Q@A@A@A@A
+OL,3,O___oyAxaD`d@@@PPC^DXP``[@
+OL,4,~E~yZ_x{qoSblbX]`{@AHAD@e`G`Opy
+OL,5,~zn~|}w|@@@@@@X@`A@E@QAC@BHC
+OL,6,xXa`F@X@pA@G@]ACO~G_~x`~@|@p@
+OL,7,|g|CyAlA|a\`XphpHP@C@XC|F~_~o^o_oO_OO
+OL,8,@C@\C|I~p~P_X_P_`O@O|`|@p@@@@@@@@@@@@@
+OL,9,g_O\_Fyzn}a_@^BVBLAX@PCBAFEQB@^`~a|i|s~
+OL,10,XOSCBA^eiB}~~~|w||F@N@OBAB@|@@@@@@@@@@
+OL,11,Ud}hrJPP@H@`@E|AlCOVBCBF@D@H@Q@S@B@FPLpH
+OL,12,z@b@@@@@@@@@@A@AHCHFA`A@@@@@@@@@@@@@@@@@
+OL,13,TNLQh@P@P@p@r@`@DX@BHAP@P@`@`A@S@_@S@A@A
+OL,14,GOgOo__~~ll`@l@BL@@@@@@@@@@A@S@_@S@A@A
+OL,15,EA_@W@]@C@CAD@@@@@@B@@`wHwbsxyxx@x@
+OL,16,@@p@~@`HxHVLEFDDxDPOA@_wGwasxyxx@x@
+OL,17,PADKaOA_EcgG_@FHGHF@I@^@|AxKpO`O@
+OL,18,|xXvXox~]|_xp_`@@A@C@O@_@acGO_
+OL,19,~{ws~C|CxC|At@d@xApD@H@LA|C|G|C~S
+OL,20,|@xApG@O@SACBCDCLAL@~xp`~@|@x@p@x@
+OL,21,_|_p}|t~|vv}s`C`C@C@A@A@A@C@G@C@C
+OL,22,{zYrxz|r|f|rnrt{dd@@`@@@@@@@@@@A@C@C@C
+OL,23,HphpXSx{X{XcXsXsxs`qO_Oh_@D\LL_LoL
+OL,24,@_`_@X`x@|@|@|@|p|p|@@@@@G@G@C@C@C@C@CPC
+PN,2b207
+SC,0007
+PS,8010
+PF,5,0
+OL,28,CE@@b{nxnKn{b{nxnKn{b{nxnKn{b{nxnKn{@@@@
+OL,1,t]~QqAIIo[o{n~dKbAn@N@N@V@V@d@EAQAy
+OL,2,O`Ai@I@A@Y@Y@{@zAnAFpX~Ppp``@A~P~y
+OL,3,JfJLXLZPX`y@r@p@uB`@tXtpepa`s@V@l@|@x@x
+OL,4,HDHHXDX@H@`@@@@@FxPG@@@@@@@@P@P@p@p@p@ox
+OL,5,@AH@@H@@@@@D@@@@@@@@@@@@@@@@@@@@@@@@@@@@
+OL,6,L@@@@@@L@F@B@@@@@@x@@@@@@@@@@@@@@@@@@@@@
+OL,7,@@``@@B`@@@@@`@@@@@@p@@@@@@@@@@@@@@@@@@@
+OL,8,HXPX@x@P@@@`@@@@@@@@p@@@@@@@@@@@@@@@@@@@
+OL,9,|xp`P~@@~H|@\@hBPDpH`P@`A@@@@@@@
+OL,10,~@|CxGpO`_@oAC@A@G@O|xp`@~@~@|@x@
+OL,11,T@v@~@^@@@_@_p_`]`sQ]uTZZZOKOKW
+OL,12,l@N@f@n@o@g@g@cpqpqhX@x@X@P@P@X@X@X@HPHH
+OL,13,_wOGwGwCA@o@_@_@C`KpCxKxO|C~G___
+OL,14,t_|O|G|GxC|AX@P@@@@@C@C@C@C@G@C@G@O@_@_
+OL,15,`QHq@y@qAqIqIpC`GpK{onONGFGjGhOhOhExC~O}
+OL,16,P^x~x~xZxXxXpXzX|FpBpApAxAxeygqgygyg{q{q
+OL,17,`accgO_AyCsC{_s_w__w_
+OL,18,AFBL@D\LXHP@@H@@@@@@~y}s{csgwow
+OL,19,`H`H`LbDTNPd`Fx@p@p@p`x@p@`@`@|@f@abdx
+OL,20,@O@_GoLCxEAC}YN][Gp`x@p@@@@@|@f@abdx
+OL,21,@@@@B@@B@@Cx@x@@P@@@@@@@@@@@@@@@P@@@@@@@
+OL,22,x@|@|@~@~@|poL|o|`@@@@@@@@@@@@Pp@@@@@@
+OL,23,@@@@@@B@A@B@@@@@@@@A@@@@@@@@@@@@@@@@@@@@
+OL,24,@@@@@@@@B@@@@@@@@\@\@@@@@@@@@@@@@@@@@@@@

examples/Level3p5-DRCS/Level3p5DRCS-ParrotMode3-MainPage.tti

@@ -0,0 +1,23 @@
+DE,Level 3.5 DRCS mode 3 parrot demo display page
+PN,21300
+SC,0000
+PS,8000
+RE,0
+CT,20,T
+OL,27,D@_|@@@A_|@@@B_|@@@OSlD@@H_|@@@H_|@@@@@@
+OL,28,@@@|g@@`DsIBGqXaUSUwSC^MfziDcxgUoywvOpF
+OL,28,A@@@@@@@@@@LJgtj}bszMo{ph\RkvKNkw|nC@@
+OL,26,@qD@^M`_m``MaamabMbcmbrD@^Mc_mc`MdamdbMe
+OL,26,AcmesD@^Mf_mf`MgamgbMhcmhtD@^Mi_mi`Mjamj
+OL,26,BbMkcmkuD@^Ml_ml`MmammbMncmnvD@^Mo_mo`Mp
+OL,26,CampbMqcmqwD@^Mr_mr`MsamsbMtcmtxD@^Mu_mu
+OL,26,D`MvamvbMwcmwCCCCCCCCC
+OL,7, Level 3.5 DRCS                         
+OL,9, Mode 3 characters                      
+OL,10,  6x5 pixels of                         
+OL,11,  4 bitplanes                           
+OL,12,  or 16 colours                         
+OL,14, 48 DRCS characters                     
+OL,15,  over 48 PTUs                          
+OL,17, 8 rows of 6 columns                    
+OL,18,  or 36x40 pixels                       

examples/Level3p5-DRCS/Level3p5DRCS-ParrotMode3-Nptus.tti

@@ -0,0 +1,30 @@
+DE,Level 3.5 DRCS mode 3 parrot demo PTU page
+PN,2b300
+SC,0000
+PS,8010
+PF,5,0
+OL,28,CE@@sLsLsLsLsLsLsLsLsLsLsLsLsLsLsLsL@@@@
+OL,1,@@@@@@@@@@@@@@@@@@@@C@A@C@@@@FACpWOOxxG
+OL,2,h@@@`@@@vxFxA~@_Y@D@\@@@uHtH`_@
+OL,3,y@F@`@N@p@n@P`X`Dxpxa@o@BAM@A@L@H@A@G@@@
+OL,4,A``@@@@@K@@@@AA@@AA@}|C^Cwsssw[{s
+OL,5,`Cxsx~xy|y@@`@NAa~AA~
+OL,6,Otx|A|~~CD~C@GB@PoPC\`^p@O@tc\cHFy~
+OL,7,B@@@B@B@ApIpKpKqFbQcyEswXmPMNxp~_~`[_x`
+OL,8,|xqA_~_O@F@G@@ppO}@}@m@@@
+OL,9,GF{[Yg@@@O@lgx_WR}nZZuoXXg}}~C
+OL,10,GYvVf[e}EKvXcZdKSa^|h@p@p@uP@}wx@
+OL,11,B@@s@@c@@kw@@w@@O@@C@@@@@@@
+OL,12,@@_@_@O@~xGy||Cx}AB|}YB|}YB
+OL,13,OcRl]EcNwGgHGo_`gO{Dpp@z|x@z|rH^Lrl~hvL
+OL,14,_@@OA@O_C@O_C@o_f@|@z@z@p@p@
+OL,15,C@@@@@@@}@@|}]B~MBnFA~`G@YbMB
+OL,16,_gWhKByGyFycG|CCtOpHvLwlSl@`~qNp~qOp
+OL,17,_d@_~BA^}AFwHxG@@_C@Op`pOOp@@QnoP
+OL,18,||@@c|A@Ez@@@a^^axFyFaB|BB@}@pHLp}BB|
+OL,19,EjWhGhUjCA`CSDoCODfO@xG@l_~AQ~{DGxoP]`
+OL,20,}BC|d[W`pOs@pOs@i^BA}BfPrL|@sL|@A~}@{DCx
+OL,21,Hdc@\@G@FHA@jP@@P`@@GXxGA^b]AZdZ@@Z@B@`@
+OL,22,_hl_QP{efysINqaPW`oPo@GxG@C|C@a^a@QnQ@
+OL,23,yNrAy^bQ\{oP|~Ju}~B}sLKp^KD{~O@~^A~~~A~
+OL,24,`@@@@pLp@@~@PAo@@PoP@@@@@@@@@@@@d@@@A@b@

examples/Level3p5-Joseph.tti

@@ -0,0 +1,22 @@
+DE,The colours of Joseph's dreamcoat
+PN,19900
+SC,0000
+PS,8000
+CT,20,T
+OL,28,@@@|g`VrO@_r{kGFBooWk}M`ooGDsL`ORrs}c@@@
+OL,28,D@@|g@@pC@|p@@CH|O@pwp}]@@wAws]G@@
+OL,26,@lD@`CHnD@AcHTCI`cIpD@ACJJcEL`CTcJ`CKrD@
+OL,26,AhQRAcKTCL`cLtD@JCMTcM`cBvD@ACNTcN`cGxD@
+OL,26,BAcFTCO`cO_CpURJcDjD@ACElD@JCGBBB
+OL,2, It was...                              
+OL,4,A]GRed   C]DYellow B]DGreen  MLA]GBrown 
+OL,6,A]GScarlet\ Black  A]GOchre  MLC]DPeach 
+OL,8,E]GRuby  C]DOlive  E]GViolet MLC]DFawn  
+OL,10,E]DLilac C]DGold MLA]GChocolateE]DMauve 
+OL,12, ]DCream A]GCrimson ]DSilver MLE]GRose  
+OL,14,D]GAzure C]DLemon  A]GRusset ML \ Grey  
+OL,16,E]GPurple ]DWhite  E]DPink   MLA]GOrange
+OL,18,                            andD]GBlue!M
+OL,21,  FRose is CLUT 0:5. Gold, Cream and    
+OL,22,  FLemon are in CLUT 1 and applied with 
+OL,23,  Fa Level 3.5 only Object.             

examples/SubObjects-TeletextStoreBag.tti

@@ -0,0 +1,36 @@
+DE,Parody of Microsoft Store icon
+PN,15400
+SC,0000
+PS,8000
+CT,8,T
+OL,28,@@@|gpCu_@|wKpZA`UB_GdN`M\LXKTJPILXwM@@
+OL,26,@iD@hq]jD@hq]kD@hq]lD@hq]mD@hq]nD@hq]oD@
+OL,26,Ahq]pD@ACLN@LPbZQ`OQcOXCOXbRqD@hQarD@hQa
+OL,26,BsD@ACLJcO_COtD@hQdvD@hQdxD@hQdzD@hQd|D@
+OL,26,CACLJBp^CO^Bx}D@hq]~D@hq]D@hq]_Cxu]A@L
+OL,26,DhshXCOxUaACLhshN@LQ@LYCOxUdACL_COiD@ACL
+OL,26,E_COxwhQ`LQaR@MRaS`MSaT@NTaU`NUaV@O
+OL,26,FVaBBBBBBBBBBBB
+OL,1,Twwf$$$                
+OL,2,T==9111                
+OL,3,Twwf$$$FWelcome to the 
+OL,4,T==9111                
+OL,5,Twwf$$$WTELETEXT STORE 
+OL,6,T==9111                
+OL,7,Twwf$$$                
+OL,8,T]           ^xWV]    tW\               
+OL,9,T]           ^WT\wwf$$W               
+OL,10,T]           ^WT\==911W               
+OL,11,T]       V]W                 \        
+OL,12,T]       W]                    \        
+OL,13,T]       W]                    \        
+OL,14,T]       W]Q   RS     \        
+OL,15,T]       W]Q   RS     \        
+OL,16,T]       W]Q                   \        
+OL,17,T]       W]Q  TUV     \        
+OL,18,T]       W]Q  TUV     \        
+OL,19,T]       W]                    \        
+OL,20,T]       Wo]                ^?\         
+OL,21,Twwf$$$                
+OL,22,T==9111                
+OL,23,Twwf$$$                

examples/Template-ActivePosition.tti

@@ -0,0 +1,9 @@
+PN,19900
+SC,0000
+PS,8000
+CT,8,T
+OL,26,@iD@@kfjD@@kfkD@@kflD@@kfmD@@kfnD@@kfoD@
+OL,26,A@kfpD@@kfqD@@kfrD@@kfsD@@kftD@@kfuD@@kf
+OL,26,BvD@@kfwD@@kfxD@@kfyD@@kfzD@@kf{D@@kf|D@
+OL,26,C@kf}D@@kf~D@@kfD@@kfCCCCCC
+OL,1,  Active Position across every row      

keymap.h

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

levelonecommands.h

@@ -1,211 +0,0 @@
-/*
- * Copyright (C) 2020-2023 Gavin MacGregor
- *
- * This file is part of QTeletextMaker.
- *
- * QTeletextMaker is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * QTeletextMaker is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#ifndef LEVELONECOMMANDS_H
-#define LEVELONECOMMANDS_H
-
-#include <QByteArrayList>
-#include <QUndoCommand>
-
-#include "document.h"
-
-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 };
-
-	TypeCharacterCommand(TeletextDocument *, unsigned char, bool, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-	bool mergeWith(const QUndoCommand *) override;
-	int id() const override { return Id; }
-
-private:
-	unsigned char m_newCharacter, m_oldRowContents[40], m_newRowContents[40];
-	int m_columnStart, m_columnEnd;
-	bool m_insertMode;
-};
-
-class ToggleMosaicBitCommand : public LevelOneCommand
-{
-public:
-	enum { Id = 102 };
-
-	ToggleMosaicBitCommand(TeletextDocument *, unsigned char, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-	bool mergeWith(const QUndoCommand *) override;
-	int id() const override { return Id; }
-
-private:
-	unsigned char m_oldCharacter, m_newCharacter;
-};
-
-class BackspaceKeyCommand : public LevelOneCommand
-{
-public:
-	enum { Id = 103 };
-
-	BackspaceKeyCommand(TeletextDocument *, bool insertMode, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-	bool mergeWith(const QUndoCommand *) override;
-	int id() const override { return Id; }
-
-private:
-	unsigned char m_oldRowContents[40], m_newRowContents[40];
-	int m_columnStart, m_columnEnd;
-	bool m_insertMode;
-};
-
-class DeleteKeyCommand : public LevelOneCommand
-{
-public:
-	enum { Id = 104 };
-
-	DeleteKeyCommand(TeletextDocument *, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-	bool mergeWith(const QUndoCommand *) override;
-	int id() const override { return Id; }
-
-private:
-	unsigned char m_oldRowContents[40], m_newRowContents[40];
-};
-
-class InsertSubPageCommand : public LevelOneCommand
-{
-public:
-	InsertSubPageCommand(TeletextDocument *, bool, bool, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-
-private:
-	int m_newSubPageIndex;
-	bool m_copySubPage;
-};
-
-class DeleteSubPageCommand : public LevelOneCommand
-{
-public:
-	DeleteSubPageCommand(TeletextDocument *, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-};
-
-class InsertRowCommand : public LevelOneCommand
-{
-public:
-	InsertRowCommand(TeletextDocument *, bool, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-
-private:
-	bool m_copyRow;
-	unsigned char m_deletedBottomRow[40];
-};
-
-class DeleteRowCommand : public LevelOneCommand
-{
-public:
-	DeleteRowCommand(TeletextDocument *, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-
-private:
-	unsigned char m_deletedRow[40];
-};
-
-#ifndef QT_NO_CLIPBOARD
-class CutCommand : public LevelOneCommand
-{
-public:
-	CutCommand(TeletextDocument *, 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, m_plainText;
-};
-#endif // !QT_NO_CLIPBOARD
-
-class SetColourCommand : public LevelOneCommand
-{
-public:
-	SetColourCommand(TeletextDocument *, int, int, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-
-private:
-	int m_colourIndex, m_oldColour, m_newColour;
-};
-
-class ResetCLUTCommand : public LevelOneCommand
-{
-public:
-	ResetCLUTCommand(TeletextDocument *, int, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-
-private:
-	int m_colourTable;
-	int m_oldColourEntry[8];
-};
-
-#endif

levelonepage.cpp

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

levelonepage.h

@@ -1,134 +0,0 @@
-/*
- * Copyright (C) 2020-2023 Gavin MacGregor
- *
- * This file is part of QTeletextMaker.
- *
- * QTeletextMaker is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * QTeletextMaker is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#ifndef LEVELONEPAGE_H
-#define LEVELONEPAGE_H
-
-#include <QByteArray>
-#include <QColor>
-#include <QObject>
-#include <QString>
-
-#include "pagex26base.h"
-#include "x26triplets.h"
-
-class LevelOnePage : public PageX26Base //: public QObject
-{
-	//Q_OBJECT
-
-public:
-	enum CycleTypeEnum { CTcycles, CTseconds };
-
-	LevelOnePage();
-	LevelOnePage(const PageBase &);
-
-	bool isEmpty() const override;
-
-	QByteArray packet(int) const override;
-	QByteArray packet(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;
-
-	bool controlBit(int bitNumber) const override;
-	bool setControlBit(int, bool) override;
-
-	void clearPage();
-
-	int maxEnhancements() const { return 208; };
-
-/*	void setSubPageNumber(int); */
-	int cycleValue() const { return m_cycleValue; };
-	void setCycleValue(int);
-	CycleTypeEnum cycleType() const { return m_cycleType; };
-	void setCycleType(CycleTypeEnum);
-	int defaultCharSet() const { return m_defaultCharSet; }
-	void setDefaultCharSet(int);
-	int defaultNOS() const { return m_defaultNOS; }
-	void setDefaultNOS(int);
-	int secondCharSet() const { return m_secondCharSet; }
-	void setSecondCharSet(int);
-	int secondNOS() const { return m_secondNOS; }
-	void setSecondNOS(int);
-	unsigned char character(int row, int column) const { return m_level1Page[row][column]; }
-	void setCharacter(int, int, unsigned char);
-	int defaultScreenColour() const { return m_defaultScreenColour; }
-	void setDefaultScreenColour(int);
-	int defaultRowColour() const { return m_defaultRowColour; }
-	void setDefaultRowColour(int);
-	int colourTableRemap() const { return m_colourTableRemap; }
-	void setColourTableRemap(int);
-	bool blackBackgroundSubst() const { return m_blackBackgroundSubst; }
-	void setBlackBackgroundSubst(bool);
-	int CLUT(int index, int renderLevel=3) const;
-	void setCLUT(int, int);
-	QColor CLUTtoQColor(int index, int renderlevel=3) const;
-	bool isPaletteDefault(int) const;
-	bool isPaletteDefault(int, int) const;
-	int levelRequired() const;
-	bool leftSidePanelDisplayed() const { return m_leftSidePanelDisplayed; }
-	void setLeftSidePanelDisplayed(bool);
-	bool rightSidePanelDisplayed() const { return m_rightSidePanelDisplayed; }
-	void setRightSidePanelDisplayed(bool);
-	int sidePanelColumns() const { return m_sidePanelColumns; }
-	void setSidePanelColumns(int);
-	bool sidePanelStatusL25() const { return m_sidePanelStatusL25; }
-	void setSidePanelStatusL25(bool);
-	int fastTextLinkPageNumber(int linkNumber) const { return m_fastTextLink[linkNumber].pageNumber; }
-	void setFastTextLinkPageNumber(int, int);
-	int composeLinkFunction(int linkNumber) const { return m_composeLink[linkNumber].function; }
-	void setComposeLinkFunction(int, int);
-	bool composeLinkLevel2p5(int linkNumber) const { return m_composeLink[linkNumber].level2p5; }
-	void setComposeLinkLevel2p5(int, bool);
-	bool composeLinkLevel3p5(int linkNumber) const { return m_composeLink[linkNumber].level3p5; }
-	void setComposeLinkLevel3p5(int, bool);
-	int composeLinkPageNumber(int linkNumber) const { return m_composeLink[linkNumber].pageNumber; }
-	void setComposeLinkPageNumber(int, int);
-	int composeLinkSubPageCodes(int linkNumber) const { return m_composeLink[linkNumber].subPageCodes; }
-	void setComposeLinkSubPageCodes(int, int);
-
-private:
-	unsigned char m_level1Page[25][40];
-/*	int m_subPageNumber; */
-	int m_cycleValue;
-	CycleTypeEnum m_cycleType;
-	int m_defaultCharSet, m_defaultNOS, m_secondCharSet, m_secondNOS;
-	int m_defaultScreenColour, m_defaultRowColour, m_colourTableRemap, m_sidePanelColumns;
-	bool m_blackBackgroundSubst, m_leftSidePanelDisplayed, m_rightSidePanelDisplayed, m_sidePanelStatusL25;
-	int m_CLUT[32];
-	struct fastTextLink {
-		int pageNumber;
-		int subPageNumber;
-	} m_fastTextLink[6];
-	struct composeLink {
-		int function;
-		bool level2p5, level3p5;
-		int pageNumber, subPageCodes;
-	} m_composeLink[8];
-
-	const int m_defaultCLUT[32] = {
-		0x000, 0xf00, 0x0f0, 0xff0, 0x00f, 0xf0f, 0x0ff, 0xfff,
-		0x000, 0x700, 0x070, 0x770, 0x007, 0x707, 0x077, 0x777,
-		0xf05, 0xf70, 0x0f7, 0xffb, 0x0ca, 0x500, 0x652, 0xc77,
-		0x333, 0xf77, 0x7f7, 0xff7, 0x77f, 0xf7f, 0x7ff, 0xddd
-	};
-};
-
-#endif

loadsave.cpp

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

pagebase.cpp

@@ -1,122 +0,0 @@
-/*
- * Copyright (C) 2020-2023 Gavin MacGregor
- *
- * This file is part of QTeletextMaker.
- *
- * QTeletextMaker is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * QTeletextMaker is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include <QByteArray>
-
-#include "pagebase.h"
-
-PageBase::PageBase()
-{
-	// We use nullptrs to keep track of allocated packets, so initialise them this way
-	for (int i=0; i<26; i++)
-		m_displayPackets[i] = nullptr;
-	for (int i=0; i<4; i++)
-		for (int j=0; j<16; j++)
-			m_designationPackets[i][j] = nullptr;
-
-	for (int i=PageBase::C4ErasePage; i<=PageBase::C14NOS; i++)
-		m_controlBits[i] = false;
-}
-
-PageBase::~PageBase()
-{
-	for (int i=0; i<26; i++)
-		if (m_displayPackets[i] != nullptr)
-			delete m_displayPackets[i];
-	for (int i=0; i<4; i++)
-		for (int j=0; j<16; j++)
-			if (m_designationPackets[i][j] != nullptr)
-				delete m_designationPackets[i][j];
-}
-
-bool PageBase::isEmpty() const
-{
-	for (int i=0; i<26; i++)
-		if (m_displayPackets[i] != nullptr)
-			return false;
-	for (int i=0; i<4; i++)
-		for (int j=0; j<16; j++)
-			if (m_designationPackets[i][j] != nullptr)
-				return false;
-
-	return true;
-}
-
-QByteArray PageBase::packet(int i) const
-{
-	if (m_displayPackets[i] == nullptr)
-		return QByteArray(); // Blank result
-
-	return *m_displayPackets[i];
-}
-
-QByteArray PageBase::packet(int i, int j) const
-{
-	if (m_designationPackets[i-26][j] == nullptr)
-		return QByteArray(); // Blank result
-
-	return *m_designationPackets[i-26][j];
-}
-
-
-bool PageBase::setPacket(int i, QByteArray packetContents)
-{
-	if (m_displayPackets[i] == nullptr)
-		m_displayPackets[i] = new QByteArray(40, 0x00);
-	*m_displayPackets[i] = packetContents;
-
-	return true;
-}
-
-bool PageBase::setPacket(int i, int j, QByteArray packetContents)
-{
-	if (m_designationPackets[i-26][j] == nullptr)
-		m_designationPackets[i-26][j] = new QByteArray(40, 0x00);
-	*m_designationPackets[i-26][j] = packetContents;
-
-	return true;
-}
-
-/*
-bool PageBase::deletePacket(int i)
-{
-	if (m_displayPackets[i] != nullptr) {
-		delete m_displayPackets[i];
-		m_displayPackets[i] = nullptr;
-	}
-
-	return true;
-}
-
-bool PageBase::deletePacket(int i)
-{
-	if (m_designationPackets[i-26][j] != nullptr) {
-		delete m_designationPackets[i-26][j];
-		m_designationPackets[i-26][j] = nullptr;
-	}
-
-	return true;
-}
-*/
-
-bool PageBase::setControlBit(int bitNumber, bool active)
-{
-	m_controlBits[bitNumber] = active;
-	return true;
-}

pagebase.h

@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2020-2023 Gavin MacGregor
- *
- * This file is part of QTeletextMaker.
- *
- * QTeletextMaker is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * QTeletextMaker is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#ifndef PAGEBASE_H
-#define PAGEBASE_H
-
-#include <QByteArray>
-
-// If we inherit from QObject then we can't copy construct, so "make a new subpage that's a copy of this one" wouldn't work
-class PageBase //: public QObject
-{
-	//Q_OBJECT
-
-public:
-	enum ControlBitsEnum { C4ErasePage, C5Newsflash, C6Subtitle, C7SuppressHeader, C8Update, C9InterruptedSequence, C10InhibitDisplay, C11SerialMagazine, C12NOS, C13NOS, C14NOS };
-
-	PageBase();
-	virtual ~PageBase();
-
-	virtual bool isEmpty() const;
-
-	virtual QByteArray packet(int) const;
-	virtual QByteArray packet(int, int) const;
-	virtual bool packetExists(int i) const { return m_displayPackets[i] != nullptr; }
-	virtual bool packetExists(int i, int j) const { return m_designationPackets[i-26][j] != nullptr; }
-	virtual bool setPacket(int, QByteArray);
-	virtual bool setPacket(int, int, QByteArray);
-//	bool deletePacket(int);
-//	bool deletePacket(int, int);
-
-	virtual bool controlBit(int bitNumber) const { return m_controlBits[bitNumber]; }
-	virtual bool setControlBit(int, bool);
-
-private:
-	bool m_controlBits[11];
-	QByteArray *m_displayPackets[26], *m_designationPackets[4][16];
-};
-
-#endif

qteletextmaker.pro

@@ -1,47 +0,0 @@
-QT += widgets
-requires(qtConfig(filedialog))
-
-HEADERS       = decode.h \
-                document.h \
-                hamming.h \
-                keymap.h \
-                levelonecommands.h \
-                levelonepage.h \
-                loadsave.h \
-                mainwidget.h \
-                mainwindow.h \
-                pagebase.h \
-                pagex26base.h \
-                pagecomposelinksdockwidget.h \
-                pageenhancementsdockwidget.h \
-                pageoptionsdockwidget.h \
-                palettedockwidget.h \
-                render.h \
-                x26commands.h \
-                x26dockwidget.h \
-                x26model.h \
-                x26triplets.h
-SOURCES       = decode.cpp \
-                document.cpp \
-                levelonecommands.cpp \
-                levelonepage.cpp \
-                loadsave.cpp \
-                main.cpp \
-                mainwidget.cpp \
-                mainwindow.cpp \
-                pagebase.cpp \
-                pagex26base.cpp \
-                pagecomposelinksdockwidget.cpp \
-                pageenhancementsdockwidget.cpp \
-                pageoptionsdockwidget.cpp \
-                palettedockwidget.cpp \
-                render.cpp \
-                x26commands.cpp \
-                x26dockwidget.cpp \
-                x26model.cpp \
-                x26triplets.cpp
-RESOURCES     = qteletextmaker.qrc
-
-# install
-target.path = /usr/local/bin
-INSTALLS += target

render.cpp

@@ -1,491 +0,0 @@
-/*
- * Copyright (C) 2020-2023 Gavin MacGregor
- *
- * This file is part of QTeletextMaker.
- *
- * QTeletextMaker is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * QTeletextMaker is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include <QBitmap>
-#include <QPainter>
-#include <QPixmap>
-
-#include "render.h"
-
-#include "decode.h"
-
-int TeletextFontBitmap::s_instances = 0;
-
-QBitmap *TeletextFontBitmap::s_fontBitmap = nullptr;
-
-TeletextFontBitmap::TeletextFontBitmap()
-{
-	if (s_instances == 0)
-		s_fontBitmap = new QBitmap(":/images/teletextfont.png");
-	s_instances++;
-}
-
-TeletextFontBitmap::~TeletextFontBitmap()
-{
-	s_instances--;
-	if (s_instances == 0)
-		delete s_fontBitmap;
-}
-
-
-TeletextPageRender::TeletextPageRender()
-{
-	for (int i=0; i<6; i++)
-		m_pagePixmap[i] = new QPixmap(864, 250);
-	m_pagePixmap[0]->fill(Qt::transparent);
-
-	m_reveal = false;
-	m_mix = false;
-	m_showControlCodes = false;
-	m_flashBuffersHz = 0;
-
-	for (int r=0; r<25; r++) {
-		m_flashingRow[r] = 0;
-		for (int c=0; c<40; c++)
-			m_controlCodeCache[r][c] = 0x7f;
-	}
-}
-
-TeletextPageRender::~TeletextPageRender()
-{
-	for (int i=0; i<6; i++)
-		delete m_pagePixmap[i];
-}
-
-void TeletextPageRender::setDecoder(TeletextPageDecode *decoder)
-{
-	m_decoder = decoder;
-}
-
-inline void TeletextPageRender::drawFromBitmap(QPainter &pixmapPainter, int r, int c, const QBitmap bitmap, TeletextPageDecode::CharacterFragment characterFragment)
-{
-	switch (characterFragment) {
-		case TeletextPageDecode::NormalSize:
-			pixmapPainter.drawPixmap(c*12, r*10, bitmap);
-			break;
-		case TeletextPageDecode::DoubleHeightTopHalf:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, bitmap, 0, 0, 12, 5);
-			break;
-		case TeletextPageDecode::DoubleHeightBottomHalf:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, bitmap, 0, 5, 12, 5);
-			break;
-		case TeletextPageDecode::DoubleWidthLeftHalf:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, bitmap, 0, 0, 6, 10);
-			break;
-		case TeletextPageDecode::DoubleWidthRightHalf:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, bitmap, 6, 0, 6, 10);
-			break;
-		case TeletextPageDecode::DoubleSizeTopLeftQuarter:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, bitmap, 0, 0, 6, 5);
-			break;
-		case TeletextPageDecode::DoubleSizeTopRightQuarter:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, bitmap, 6, 0, 6, 5);
-			break;
-		case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, bitmap, 0, 5, 6, 5);
-			break;
-		case TeletextPageDecode::DoubleSizeBottomRightQuarter:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, bitmap, 6, 5, 6, 5);
-			break;
-	}
-}
-
-inline void TeletextPageRender::drawFromFontBitmap(QPainter &pixmapPainter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment)
-{
-	switch (characterFragment) {
-		case TeletextPageDecode::NormalSize:
-			pixmapPainter.drawPixmap(c*12, r*10, *m_fontBitmap.rawBitmap(), (characterCode-32)*12, characterSet*10, 12, 10);
-			break;
-		case TeletextPageDecode::DoubleHeightTopHalf:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, *m_fontBitmap.rawBitmap(), (characterCode-32)*12, characterSet*10, 12, 5);
-			break;
-		case TeletextPageDecode::DoubleHeightBottomHalf:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, *m_fontBitmap.rawBitmap(), (characterCode-32)*12, characterSet*10+5, 12, 5);
-			break;
-		case TeletextPageDecode::DoubleWidthLeftHalf:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, *m_fontBitmap.rawBitmap(), (characterCode-32)*12, characterSet*10, 6, 10);
-			break;
-		case TeletextPageDecode::DoubleWidthRightHalf:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, *m_fontBitmap.rawBitmap(), (characterCode-32)*12+6, characterSet*10, 6, 10);
-			break;
-		case TeletextPageDecode::DoubleSizeTopLeftQuarter:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, *m_fontBitmap.rawBitmap(), (characterCode-32)*12, characterSet*10, 6, 5);
-			break;
-		case TeletextPageDecode::DoubleSizeTopRightQuarter:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, *m_fontBitmap.rawBitmap(), (characterCode-32)*12+6, characterSet*10, 6, 5);
-			break;
-		case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, *m_fontBitmap.rawBitmap(), (characterCode-32)*12, characterSet*10+5, 6, 5);
-			break;
-		case TeletextPageDecode::DoubleSizeBottomRightQuarter:
-			pixmapPainter.drawPixmap(c*12, r*10, 12, 10, *m_fontBitmap.rawBitmap(), (characterCode-32)*12+6, characterSet*10+5, 6, 5);
-			break;
-	}
-}
-
-inline void TeletextPageRender::drawCharacter(QPainter &pixmapPainter, int r, int c, unsigned char characterCode, int characterSet, int characterDiacritical, TeletextPageDecode::CharacterFragment characterFragment)
-{
-	const bool dontUnderline = characterCode == 0x00;
-	if (dontUnderline)
-		characterCode = 0x20;
-
-	// If either foreground or background is set to transparent
-	// tinker with the QPainter settings so we get the desired result
-	if (!pixmapPainter.background().isOpaque()) {
-		if (pixmapPainter.pen().color().alpha() == 0) {
-			// Transparent foreground and background
-			pixmapPainter.setCompositionMode(QPainter::CompositionMode_Clear);
-			pixmapPainter.eraseRect(c*12, r*10, 12, 10);
-			pixmapPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
-
-			return;
-		} else
-			// Transparent background, opaque foreground
-			pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
-	} else if (pixmapPainter.pen().color().alpha() == 0) {
-		// Transparent foreground, opaque background
-		// Deal with optimising G1 solid 7/F blocks and spaces now
-		// otherwise the same optimisations later on won't work with
-		// our tinkered QPainter settings
-		if (characterCode == 0x7f && characterSet == 24) {
-			pixmapPainter.setCompositionMode(QPainter::CompositionMode_Clear);
-			pixmapPainter.eraseRect(c*12, r*10, 12, 10);
-			pixmapPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
-
-			return;
-		}
-
-		pixmapPainter.fillRect(c*12, r*10, 12, 10, m_decoder->cellBackgroundQColor(r, c));
-
-		if (characterCode == 0x20 && characterSet < 25 && characterDiacritical == 0)
-			return;
-
-		pixmapPainter.setBackground(QColor(0, 0, 0, 0));
-		pixmapPainter.setPen(QColor(255, 255, 255, 255));
-		pixmapPainter.setCompositionMode(QPainter::CompositionMode_DestinationOut);
-	}
-
-	if (characterCode == 0x20 && characterSet < 25 && characterDiacritical == 0)
-		pixmapPainter.fillRect(c*12, r*10, 12, 10, pixmapPainter.background().color());
-	else if (characterCode == 0x7f && characterSet == 24)
-		pixmapPainter.fillRect(c*12, r*10, 12, 10, pixmapPainter.pen().color());
-	else if ((m_decoder->cellBold(r, c) || m_decoder->cellItalic(r, c)) && characterSet < 24)
-		drawBoldOrItalicCharacter(pixmapPainter, r, c, characterCode, characterSet, characterFragment);
-	else
-		drawFromFontBitmap(pixmapPainter, r, c, characterCode, characterSet, characterFragment);
-
-	if (m_decoder->cellUnderlined(r, c) && !dontUnderline)
-		switch (characterFragment) {
-			case TeletextPageDecode::NormalSize:
-			case TeletextPageDecode::DoubleWidthLeftHalf:
-			case TeletextPageDecode::DoubleWidthRightHalf:
-				pixmapPainter.drawLine(c*12, r*10+9, c*12+11, r*10+9);
-				break;
-			case TeletextPageDecode::DoubleHeightBottomHalf:
-			case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
-			case TeletextPageDecode::DoubleSizeBottomRightQuarter:
-				pixmapPainter.drawRect(c*12, r*10+8, 11, 1);
-				break;
-			default:
-				break;
-		}
-
-	if (characterDiacritical != 0) {
-		pixmapPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
-		pixmapPainter.setBackgroundMode(Qt::TransparentMode);
-		drawFromFontBitmap(pixmapPainter, r, c, characterDiacritical+64, 7, characterFragment);
-		pixmapPainter.setBackgroundMode(Qt::OpaqueMode);
-	}
-
-	if (pixmapPainter.compositionMode() != QPainter::CompositionMode_SourceOver)
-		pixmapPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
-}
-
-inline void TeletextPageRender::drawBoldOrItalicCharacter(QPainter &pixmapPainter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment)
-{
-	QBitmap bitmap = QBitmap(12, 10);
-	QPainter bitmapPainter;
-
-	// TODO italic glyph-making is VERY slow!
-	if (m_decoder->cellItalic(r, c)) {
-		bitmap.clear();
-
-		bitmapPainter.begin(&bitmap);
-		bitmapPainter.setBackgroundMode(Qt::OpaqueMode);
-		bitmapPainter.drawPixmap(1, 0, *m_fontBitmap.rawBitmap(), (characterCode-32)*12, characterSet*10, 11, 3);
-		bitmapPainter.drawPixmap(0, 3, *m_fontBitmap.rawBitmap(), (characterCode-32)*12, characterSet*10+3, 12, 3);
-		bitmapPainter.drawPixmap(0, 6, *m_fontBitmap.rawBitmap(), (characterCode-32)*12+1, characterSet*10+6, 11, 4);
-		bitmapPainter.end();
-	} else
-		bitmap = m_fontBitmap.rawBitmap()->copy((characterCode-32)*12, characterSet*10, 12, 10);
-
-	if (m_decoder->cellBold(r, c)) {
-		QBitmap boldeningBitmap;
-
-		boldeningBitmap = bitmap.copy();
-		bitmapPainter.begin(&bitmap);
-		// No idea why we need this setPen workaround when character is made italic first?!
-		if (!m_decoder->cellItalic(r, c))
-			bitmapPainter.setPen(Qt::color0);
-		bitmapPainter.drawPixmap(1, 0, boldeningBitmap);
-		bitmapPainter.end();
-	}
-	drawFromBitmap(pixmapPainter, r, c, bitmap, characterFragment);
-}
-
-void TeletextPageRender::renderPage(bool force)
-{
-	for (int r=0; r<25; r++)
-		renderRow(r, 0, force);
-}
-
-void TeletextPageRender::renderRow(int r, int ph, bool force)
-{
-	QPainter pixmapPainter;
-	int flashingRow = 0;
-	bool rowRefreshed = false;
-
-	pixmapPainter.begin(m_pagePixmap[ph]);
-	pixmapPainter.setBackgroundMode(Qt::OpaqueMode);
-
-	for (int c=0; c<72; c++) {
-		bool controlCodeChanged = false;
-
-		// Ensure that shown control codes are refreshed
-		if (ph == 0 && m_showControlCodes && c < 40 && (m_controlCodeCache[r][c] != 0x7f || m_decoder->teletextPage()->character(r, c) < 0x20)) {
-			controlCodeChanged = m_controlCodeCache[r][c] != m_decoder->teletextPage()->character(r, c);
-			if (controlCodeChanged) {
-				if (m_decoder->teletextPage()->character(r, c) < 0x20)
-					m_controlCodeCache[r][c] = m_decoder->teletextPage()->character(r, c);
-				else
-					m_controlCodeCache[r][c] = 0x7f;
-			}
-		}
-
-		if (ph == 0) {
-			if (m_decoder->cellFlashMode(r, c) != 0)
-				flashingRow = (m_decoder->cellFlashRatePhase(r, c) == 0) ? 1 : 2;
-		} else
-			force = m_decoder->cellFlashMode(r, c) != 0;
-
-		// If drawing into a flash pixmap buffer, "force" is set on a flashing cell only
-		// and since the refresh and controlCodeChanged variables will be false at this point
-		// only flashing cells will be drawn
-		if (m_decoder->refresh(r, c) || force || controlCodeChanged) {
-			unsigned char characterCode;
-			int characterSet, characterDiacritical;
-
-			rowRefreshed = true;
-
-			if (!m_reveal && m_decoder->cellConceal(r, c)) {
-				characterCode = 0x20;
-				characterSet = 0;
-				characterDiacritical = 0;
-			} else {
-				characterCode = m_decoder->cellCharacterCode(r, c);
-				characterSet = m_decoder->cellCharacterSet(r, c);
-				characterDiacritical = m_decoder->cellCharacterDiacritical(r, c);
-			}
-
-			if (m_decoder->cellFlashMode(r, c) == 0)
-				pixmapPainter.setPen(m_decoder->cellForegroundQColor(r, c));
-			else {
-				// Flashing cell, decide if phase in this cycle is on or off
-				bool phaseOn;
-
-				if (m_decoder->cellFlashRatePhase(r, c) == 0)
-					phaseOn = (ph < 3) ^ (m_decoder->cellFlashMode(r, c) == 2);
-				else
-					phaseOn = ((ph == m_decoder->cellFlash2HzPhaseNumber(r, c)-1) || (ph == m_decoder->cellFlash2HzPhaseNumber(r, c)+2)) ^ (m_decoder->cellFlashMode(r, c) == 2);
-
-				// If flashing to adjacent CLUT select the appropriate foreground colour
-				if (m_decoder->cellFlashMode(r, c) == 3 && !phaseOn)
-					pixmapPainter.setPen(m_decoder->cellFlashForegroundQColor(r, c));
-				else
-					pixmapPainter.setPen(m_decoder->cellForegroundQColor(r, c));
-
-				// If flashing mode is Normal or Invert, draw a space instead of a character on phase
-				if ((m_decoder->cellFlashMode(r, c) == 1 || m_decoder->cellFlashMode(r, c) == 2) && !phaseOn) {
-					// Character 0x00 draws space without underline
-					characterCode = 0x00;
-					characterSet = 0;
-					characterDiacritical = 0;
-				}
-			}
-
-			if (!m_mix || m_decoder->cellBoxed(r, c))
-				pixmapPainter.setBackground(m_decoder->cellBackgroundQColor(r, c));
-			else
-				pixmapPainter.setBackground(Qt::transparent);
-
-			drawCharacter(pixmapPainter, r, c, characterCode, characterSet, characterDiacritical, m_decoder->cellCharacterFragment(r, c));
-
-			if (m_showControlCodes && c < 40 && m_decoder->teletextPage()->character(r, c) < 0x20) {
-				pixmapPainter.setBackground(QColor(0, 0, 0, 128));
-				pixmapPainter.setPen(QColor(255, 255, 255, 224));
-				pixmapPainter.drawPixmap(c*12, r*10, *m_fontBitmap.rawBitmap(), (m_decoder->teletextPage()->character(r, c)+32)*12, 250, 12, 10);
-			}
-		}
-	}
-
-	pixmapPainter.end();
-
-	if (ph != 0)
-		return;
-
-	if (flashingRow == 3)
-		flashingRow = 2;
-	if (flashingRow != m_flashingRow[r])
-		setRowFlashStatus(r, flashingRow);
-
-	for (int c=0; c<72; c++)
-		m_decoder->setRefresh(r, c, false);
-
-	// If row had changes rendered and flashing is present anywhere on the screen,
-	// copy this rendered line into the other flash pixmap buffers and then re-render
-	// the flashing cells in those buffers
-	if (rowRefreshed && m_flashBuffersHz > 0) {
-		pixmapPainter.begin(m_pagePixmap[3]);
-		pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
-		pixmapPainter.drawPixmap(0, r*10, *m_pagePixmap[0], 0, r*10, 864, 10);
-		pixmapPainter.end();
-
-		renderRow(r, 3);
-
-		if (m_flashBuffersHz == 2) {
-			pixmapPainter.begin(m_pagePixmap[1]);
-			pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
-			pixmapPainter.drawPixmap(0, r*10, *m_pagePixmap[0], 0, r*10, 864, 10);
-			pixmapPainter.end();
-			pixmapPainter.begin(m_pagePixmap[2]);
-			pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
-			pixmapPainter.drawPixmap(0, r*10, *m_pagePixmap[0], 0, r*10, 864, 10);
-			pixmapPainter.end();
-			pixmapPainter.begin(m_pagePixmap[4]);
-			pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
-			pixmapPainter.drawPixmap(0, r*10, *m_pagePixmap[3], 0, r*10, 864, 10);
-			pixmapPainter.end();
-			pixmapPainter.begin(m_pagePixmap[5]);
-			pixmapPainter.setCompositionMode(QPainter::CompositionMode_Source);
-			pixmapPainter.drawPixmap(0, r*10, *m_pagePixmap[3], 0, r*10, 864, 10);
-			pixmapPainter.end();
-
-			renderRow(r, 1);
-			renderRow(r, 2);
-			renderRow(r, 4);
-			renderRow(r, 5);
-		}
-	}
-}
-
-void TeletextPageRender::setRowFlashStatus(int r, int rowFlashHz)
-{
-	m_flashingRow[r] = rowFlashHz;
-
-	if (rowFlashHz == m_flashBuffersHz)
-		return;
-
-	if (rowFlashHz < m_flashBuffersHz) {
-		// New flash Hz for this row is lower than the entire screen flash Hz
-		// Check the other rows if they still need flashing at the current flash Hz
-		// If not, reduce the screen flash Hz
-		int highestRowFlashHz = rowFlashHz;
-
-		for (int ri=0; ri<25; ri++)
-			if (m_flashingRow[ri] > highestRowFlashHz) {
-				highestRowFlashHz = m_flashingRow[ri];
-				if (highestRowFlashHz == 2)
-					break;
-			}
-
-		if (highestRowFlashHz > rowFlashHz)
-			rowFlashHz = highestRowFlashHz;
-		if (rowFlashHz == m_flashBuffersHz)
-			return;
-
-		m_flashBuffersHz = rowFlashHz;
-		emit flashChanged(m_flashBuffersHz);
-		return;
-	}
-
-	// If we get here, new flash Hz for this row is higher than the entire flash Hz
-	// so prepare the pixmap flash buffers
-	if (m_flashBuffersHz == 0)
-		*m_pagePixmap[3] = m_pagePixmap[0]->copy();
-	if (rowFlashHz == 2) {
-		*m_pagePixmap[1] = m_pagePixmap[0]->copy();
-		*m_pagePixmap[2] = m_pagePixmap[0]->copy();
-		*m_pagePixmap[4] = m_pagePixmap[3]->copy();
-		*m_pagePixmap[5] = m_pagePixmap[3]->copy();
-	}
-
-	m_flashBuffersHz = rowFlashHz;
-	emit flashChanged(m_flashBuffersHz);
-}
-
-void TeletextPageRender::colourChanged(int index)
-{
-	for (int r=0; r<25; r++)
-		for (int c=0; c<72; c++) {
-			if (m_decoder->cellForegroundCLUT(r, c) == index || m_decoder->cellBackgroundCLUT(r, c) == index || m_decoder->cellForegroundCLUT(r, c) == 8 || m_decoder->cellBackgroundCLUT(r, c) == 8)
-				m_decoder->setRefresh(r, c, true);
-			if (m_decoder->cellFlashMode(r, c) == 3 && ((m_decoder->cellForegroundCLUT(r, c) ^ 8) == index || (m_decoder->cellForegroundCLUT(r, c) ^ 8) == 8))
-				m_decoder->setRefresh(r, c, true);
-		}
-}
-
-void TeletextPageRender::setReveal(bool reveal)
-{
-	if (reveal == m_reveal)
-		return;
-
-	m_reveal = reveal;
-
-	for (int r=0; r<25; r++)
-		for (int c=0; c<72; c++)
-			if (m_decoder->cellConceal(r, c))
-				m_decoder->setRefresh(r, c, true);
-}
-
-void TeletextPageRender::setMix(bool mix)
-{
-	if (mix  == m_mix)
-		return;
-
-	m_mix = mix;
-
-	for (int r=0; r<25; r++)
-		for (int c=0; c<72; c++)
-			if (!m_decoder->cellBoxed(r, c))
-				m_decoder->setRefresh(r, c, true);
-}
-
-
-void TeletextPageRender::setShowControlCodes(bool showControlCodes)
-{
-	if (showControlCodes == m_showControlCodes)
-		return;
-
-	m_showControlCodes = showControlCodes;
-
-	for (int r=0; r<25; r++)
-		for (int c=0; c<40; c++)
-			if (m_decoder->teletextPage()->character(r, c) < 0x20)
-				m_decoder->setRefresh(r, c, true);
-}

render.h

@@ -1,83 +0,0 @@
-/*
- * Copyright (C) 2020-2023 Gavin MacGregor
- *
- * This file is part of QTeletextMaker.
- *
- * QTeletextMaker is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * QTeletextMaker is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-#ifndef RENDER_H
-#define RENDER_H
-
-#include <QBitmap>
-#include <QPixmap>
-
-#include "decode.h"
-
-class TeletextFontBitmap
-{
-public:
-	TeletextFontBitmap();
-	~TeletextFontBitmap();
-
-	QBitmap *rawBitmap() const { return s_fontBitmap; }
-
-private:
-	static int s_instances;
-	static QBitmap* s_fontBitmap;
-};
-
-class TeletextPageRender : public QObject
-{
-	Q_OBJECT
-
-public:
-	TeletextPageRender();
-	~TeletextPageRender();
-
-	QPixmap* pagePixmap(int i) const { return m_pagePixmap[i]; };
-	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 setShowControlCodes(bool);
-
-signals:
-	void flashChanged(int);
-
-protected:
-	TeletextFontBitmap m_fontBitmap;
-	QPixmap* m_pagePixmap[6];
-	unsigned char m_controlCodeCache[25][40];
-	bool m_reveal, m_mix, m_showControlCodes;
-	int m_flashBuffersHz;
-	int m_flashingRow[25];
-
-private:
-	inline void drawFromBitmap(QPainter &, int, int, const QBitmap, TeletextPageDecode::CharacterFragment);
-	inline void drawFromFontBitmap(QPainter &, int, int, unsigned char, int, TeletextPageDecode::CharacterFragment);
-	inline void drawCharacter(QPainter &, int, int, unsigned char, int, int, TeletextPageDecode::CharacterFragment);
-	inline void drawBoldOrItalicCharacter(QPainter &, int, int, unsigned char, int, TeletextPageDecode::CharacterFragment);
-	void renderRow(int, int, bool force=false);
-	void setRowFlashStatus(int, int);
-
-	TeletextPageDecode *m_decoder;
-};
-
-#endif

share/qteletextmaker.desktop

@@ -0,0 +1,9 @@
+[Desktop Entry]
+Type=Application
+Name=QTeletextMaker
+GenericName=Teletext page editor
+Exec=qteletextmaker %F
+TryExec=qteletextmaker
+Categories=Graphics;
+Keywords=teletext;
+MimeType=text/x.teletext.tti;text/x-softel-teletext;

src/qteletextdecoder/CMakeLists.txt

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

src/qteletextdecoder/decode.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -19,9 +19,16 @@
 
 #include "decode.h"
 
+#include <QByteArray>
+#include <QImage>
 #include <QList>
 #include <QMultiMap>
 
+#include "drcspage.h"
+#include "levelonepage.h"
+#include "pagebase.h"
+
+
 TeletextPageDecode::Invocation::Invocation()
 {
 	m_tripletList = nullptr;
@@ -67,7 +74,7 @@ void TeletextPageDecode::Invocation::buildMap(int level)
 	int endTripletNumber;
 
 	if (m_endTripletNumber == -1)
-		endTripletNumber = m_tripletList->size();
+		endTripletNumber = m_tripletList->size()-1;
 	else
 		endTripletNumber = m_endTripletNumber;
 
@@ -98,26 +105,6 @@ void TeletextPageDecode::Invocation::buildMap(int level)
 			continue;
 
 		switch (triplet.modeExt()) {
-			case 0x21: // G1 character
-			case 0x22: // G3 character at Level 1.5
-			case 0x29: // G0 character
-			case 0x2b: // G3 character at Level 2.5
-			case 0x2f: // G2 character
-			case 0x30 ... 0x3f: // G0 character with diacritical
-				m_characterMap.insert(qMakePair(targetRow, targetColumn), triplet);
-				// Store rightmost column in this row for Adaptive Object attribute tracking
-				// QMap stores one value per key, QMap::insert will replace the value if the key already exists
-				m_rightMostColumn.insert(targetRow, targetColumn);
-				break;
-			case 0x20: // Foreground colour
-			case 0x23: // Background colour
-			case 0x27: // Additional flash functions
-			case 0x28: // Modified G0 and G2 character set designation
-			case 0x2c: // Display attributes
-			case 0x2e: // Font style
-				m_attributeMap.insert(qMakePair(targetRow, targetColumn), triplet);
-				m_rightMostColumn.insert(targetRow, targetColumn);
-				break;
 			case 0x00: // Full screen colour
 				if ((triplet.data() & 0x60) != 0x00)
 					break;
@@ -133,6 +120,47 @@ void TeletextPageDecode::Invocation::buildMap(int level)
 				if (targetRow == 0)
 					m_fullRowCLUTMap.insert(targetRow, triplet);
 				break;
+			case 0x18: // DRCS mode
+				// If a DRCS character is already in this cell, move this DRCS mode attribute to the next cell.
+				// Need this workaround in the event of "DRCS character" immediately followed by "DRCS mode" in
+				// the X/26 list as the Active Position for the just-placed DRCS character and the mode-change
+				// for further characters is on the same cell.
+				for (int i=0; i<m_characterMap.values(qMakePair(targetRow, targetColumn)).size(); i++)
+					if (m_characterMap.values(qMakePair(targetRow, targetColumn)).at(i).modeExt() == 0x2d) {
+						targetColumn++;
+						if (targetColumn == 40 || targetColumn == 56 || targetColumn == 72) {
+							if (targetRow == 25)
+								break;
+							targetRow++;
+						}
+					}
+				// fall-through
+			case 0x20: // Foreground colour
+			case 0x23: // Background colour
+			case 0x27: // Additional flash functions
+			case 0x28: // Modified G0 and G2 character set designation
+			case 0x2c: // Display attributes
+			case 0x2e: // Font style
+				m_attributeMap.insert(qMakePair(targetRow, targetColumn), triplet);
+				// Store rightmost column in this row for Adaptive Object attribute tracking
+				// QMap stores one value per key, QMap::insert will replace the value if the key already exists
+				m_rightMostColumn.insert(targetRow, targetColumn);
+				break;
+			case 0x21: // G1 character
+			case 0x22: // G3 character at Level 1.5
+			case 0x29: // G0 character
+			case 0x2b: // G3 character at Level 2.5
+			case 0x2d: // DRCS character
+			case 0x2f: // G2 character
+				m_characterMap.insert(qMakePair(targetRow, targetColumn), triplet);
+				m_rightMostColumn.insert(targetRow, targetColumn);
+				break;
+			default:
+				if (triplet.modeExt() >= 0x30 && triplet.modeExt() <= 0x3f) {
+					// G0 character with diacritical
+					m_characterMap.insert(qMakePair(targetRow, targetColumn), triplet);
+					m_rightMostColumn.insert(targetRow, targetColumn);
+				}
 		}
 	}
 }
@@ -164,7 +192,8 @@ TeletextPageDecode::TeletextPageDecode()
 		m_rowHeight[r] = NormalHeight;
 		for (int c=0; c<72; c++) {
 			if (c < 40) {
-				m_cellLevel1Mosaic[r][c] = false;
+				m_cellLevel1MosaicAttr[r][c] = false;
+				m_cellLevel1MosaicChar[r][c] = false;
 				m_cellLevel1CharSet[r][c] = 0;
 			}
 			m_refresh[r][c] = true;
@@ -178,6 +207,9 @@ TeletextPageDecode::TeletextPageDecode()
 		m_fullRowQColor[r].setRgb(0, 0, 0);
 	}
 	m_leftSidePanelColumns = m_rightSidePanelColumns = 0;
+
+	m_drcsPage[GlobalDRCSPage] = nullptr;
+	m_drcsPage[NormalDRCSPage] = nullptr;
 }
 
 TeletextPageDecode::~TeletextPageDecode()
@@ -197,6 +229,28 @@ void TeletextPageDecode::setTeletextPage(LevelOnePage *newCurrentPage)
 	updateSidePanels();
 }
 
+void TeletextPageDecode::setDRCSPage(DRCSPageType pageType, QList<DRCSPage> *pages)
+{
+	m_drcsPage[pageType] = pages;
+
+	bool refreshRequired = false;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<72; c++)
+			if (m_cell[r][c].character.drcsSource != NoDRCS) {
+				m_refresh[r][c] = true;
+				refreshRequired = true;
+			}
+
+	if (refreshRequired)
+		decodePage();
+}
+
+void TeletextPageDecode::clearDRCSPage(DRCSPageType pageType)
+{
+	setDRCSPage(pageType, nullptr);
+}
+
 void TeletextPageDecode::setLevel(int level)
 {
 	if (level == m_level)
@@ -212,6 +266,117 @@ void TeletextPageDecode::setLevel(int level)
 	decodePage();
 }
 
+QImage TeletextPageDecode::drcsImage(DRCSSource pageType, int subTable, int chr, bool flashPhOn)
+{
+	if (pageType == NoDRCS)
+		return QImage();
+
+	// Check if page is loaded and if the subpage exists
+	const QList<DRCSPage>* drcsPage = m_drcsPage[pageType-1];
+	if (drcsPage == nullptr || subTable >= drcsPage->size())
+		return QImage();
+
+	// Level 2.5: only and always mode 0 (12x10x1) and doesn't use X/28/3
+	// Level 3.5: if X/28/3 is absent, drcsMode below returns mode 0
+	if (m_level == 2 || drcsPage->at(subTable).drcsMode(chr) == 0) {
+		uchar rawData[20];
+
+		if (!drcsPage->at(subTable).ptu(chr, rawData))
+			return QImage();
+
+		QImage result = QImage(rawData, 12, 10, 2, QImage::Format_Mono);
+		return result.copy();
+	}
+
+	// Level 3.5: obey X/28/3 "subsequent PTU" and "no data" values, ignore reserved values
+	const int drcsMode = drcsPage->at(subTable).drcsMode(chr);
+	if (drcsMode > 3)
+		return QImage();
+
+	uchar rawData[120];
+
+	if (drcsMode != 3) {
+		// mode 1 (12x10x2) or mode 2 (12x10x4)
+		// Each complete bitplane stored sequentially across multiple PTUs
+
+		uchar bitplaneArr[4][20] = { };
+
+		// Get the PTUs for each bitplane
+		drcsPage->at(subTable).ptu(chr, bitplaneArr[0]);
+		if (chr < 47)
+			drcsPage->at(subTable).ptu(chr+1, bitplaneArr[1]);
+		if (drcsMode == 2) {
+			if (chr < 46)
+				drcsPage->at(subTable).ptu(chr+2, bitplaneArr[2]);
+			if (chr < 45)
+				drcsPage->at(subTable).ptu(chr+3, bitplaneArr[3]);
+		}
+
+		// Now assemble the bitplanes into byte-per-pixel data
+		for (int x=0; x<12; x++)
+			for (int y=0; y<10; y++) {
+				const int scanByte = y*2 + (x > 7);
+				const int scanBit = 7 - x%8;
+
+				rawData[x + y*12] = bitplaneArr[0][scanByte] >> scanBit & 1;
+				rawData[x + y*12] |= (bitplaneArr[1][scanByte] >> scanBit & 1) << 1;
+				if (drcsMode == 2) {
+					rawData[x + y*12] |= (bitplaneArr[2][scanByte] >> scanBit & 1) << 2;
+					rawData[x + y*12] |= (bitplaneArr[3][scanByte] >> scanBit & 1) << 3;
+				}
+			}
+	} else {
+		// mode 3 (6x5x4)
+		// Interleaved: First row of six pixels is stored four times sequentially, one for
+		// each bitplane, then second row of pixels four times, and so on
+		const int pktNo = (chr+2)/2;
+
+		if (!drcsPage->at(subTable).packetExists(pktNo))
+			return QImage();
+
+		QByteArray pkt;
+
+		if (chr % 2 == 0)
+			pkt = drcsPage->at(subTable).packet(pktNo).first(20);
+		else
+			pkt = drcsPage->at(subTable).packet(pktNo).last(20);
+
+		for (int x=0; x<6; x++)
+			for (int y=0; y<5; y++) {
+				const int scanByte = y * 4;
+				const int scanBit = 5 - x;
+				uchar pixel;
+
+				pixel = pkt.at(scanByte) >> scanBit & 1;
+				pixel |= (pkt.at(scanByte+1) >> scanBit & 1) << 1;
+				pixel |= (pkt.at(scanByte+2) >> scanBit & 1) << 2;
+				pixel |= (pkt.at(scanByte+3) >> scanBit & 1) << 3;
+
+				rawData[x*2   + y*24   ] = pixel;
+				rawData[x*2+1 + y*24   ] = pixel;
+				rawData[x*2   + y*24+12] = pixel;
+				rawData[x*2+1 + y*24+12] = pixel;
+			}
+	}
+
+	QImage result = QImage(rawData, 12, 10, 12, QImage::Format_Indexed8);
+
+	// Now put in the colours
+	for (int i=0; i<16; i++) {
+		const int clr = m_levelOnePage->dCLUT(pageType-1, drcsMode, i);
+
+		if (flashPhOn)
+			result.setColor(i, m_levelOnePage->CLUTtoQColor(clr).rgb());
+		else
+			result.setColor(i, m_levelOnePage->CLUTtoQColor(clr ^ 8).rgb());
+
+		if (i == 3 && drcsMode == 1)
+			break;
+	}
+
+	return result.copy();
+}
+
 void TeletextPageDecode::updateSidePanels()
 {
 	int oldLeftSidePanelColumns = m_leftSidePanelColumns;
@@ -309,7 +474,8 @@ TeletextPageDecode::textCharacter TeletextPageDecode::characterFromTriplets(cons
 	for (int a=triplets.size()-1; a>=0; a--) {
 		const X26Triplet triplet = triplets.at(a);
 
-		if (triplet.data() < 0x20)
+		// Data values below 0x20 are reserved, except for DRCS character
+		if (triplet.data() < 0x20 && triplet.modeExt() != 0x2d)
 			continue;
 
 		const unsigned char charCode = triplet.data();
@@ -322,9 +488,10 @@ TeletextPageDecode::textCharacter TeletextPageDecode::characterFromTriplets(cons
 			case 0x2f: // G2 character
 				result = { charCode, 2, 0 };
 				break;
-			case 0x30 ... 0x3f: // G0 character with diacritical
+			default:
-				result = { charCode, 0, triplet.mode() & 0xf };
+				if (triplet.modeExt() >= 0x30 && triplet.modeExt() <= 0x3f)
-				break;
+					// G0 character with diacritical
+					result = { charCode, 0, triplet.mode() & 0xf };
 		}
 
 		if (m_level == 1)
@@ -346,6 +513,9 @@ TeletextPageDecode::textCharacter TeletextPageDecode::characterFromTriplets(cons
 			case 0x2b: // G3 character at Level 2.5
 				result = { charCode, 26, 0 };
 				break;
+			case 0x2d: // DRCS character
+				result.drcsSource = (charCode & 0x40) == 0x40 ? NormalDRCS : GlobalDRCS;
+				result.drcsChar = charCode & 0x3f;
 		}
 	}
 
@@ -466,8 +636,8 @@ void TeletextPageDecode::decodeRow(int r)
 		if (c == 0 || c == 40 || c == 56) {
 			level1CharSet = m_level1DefaultCharSet;
 
-			m_level1ActivePainter.g0CharSet = m_g0CharacterMap.value(m_defaultG0andG2, 0);
+			m_level1ActivePainter.result.g0Set = m_g0CharacterMap.value(m_defaultG0andG2, 0);
-			m_level1ActivePainter.g2CharSet = m_g2CharacterMap.value(m_defaultG0andG2, 7);
+			m_level1ActivePainter.result.g2Set = m_g2CharacterMap.value(m_defaultG0andG2, 7);
 
 			m_level1ActivePainter.attribute.flash.mode = 0;
 			m_level1ActivePainter.attribute.flash.ratePhase = 0;
@@ -624,6 +794,7 @@ void TeletextPageDecode::decodeRow(int r)
 
 						bool applyAdapt = false;
 
+						drcsMode *drcsModePtr;
 						// Adaptive Invocation that is applying an attribute
 						// If we're not tracking an Adaptive Invocation yet, start tracking this one
 						// Otherwise check if this Invocation is the the same one as we are tracking
@@ -638,6 +809,16 @@ void TeletextPageDecode::decodeRow(int r)
 						}
 
 						switch (triplet.modeExt()) {
+							case 0x18: // DRCS mode
+								drcsModePtr = (triplet.data() & 0x40) == 0x40 ? &painter->nDrcs : &painter->gDrcs;
+								if ((triplet.data() & 0x30) != 0x00) {
+									drcsModePtr->level2p5 = triplet.data() & 0x10;
+									drcsModePtr->level3p5 = triplet.data() & 0x20;
+									// "used" is never set to true on Level 3.5, to allow all 16 sub-tables
+									if (!drcsModePtr->used)
+										drcsModePtr->subTable = triplet.data() & 0x0f;
+								}
+								break;
 							case 0x20: // Foreground colour
 								if (applyAdapt)
 									adapForeground = true;
@@ -661,12 +842,12 @@ void TeletextPageDecode::decodeRow(int r)
 								break;
 							case 0x28: // Modified G0 and G2 character set designation
 								if (m_level == 3 || triplet.data() == m_defaultG0andG2 || triplet.data() == m_secondG0andG2) {
-									painter->g0CharSet = m_g0CharacterMap.value(triplet.data(), 0);
+									painter->result.g0Set = m_g0CharacterMap.value(triplet.data(), 0);
-									painter->g2CharSet = m_g2CharacterMap.value(triplet.data(), 7);
+									painter->result.g2Set = m_g2CharacterMap.value(triplet.data(), 7);
 								} else if (m_secondG0andG2 == -1) {
 									m_secondG0andG2 = triplet.data();
-									painter->g0CharSet = m_g0CharacterMap.value(triplet.data(), 0);
+									painter->result.g0Set = m_g0CharacterMap.value(triplet.data(), 0);
-									painter->g2CharSet = m_g2CharacterMap.value(triplet.data(), 7);
+									painter->result.g2Set = m_g2CharacterMap.value(triplet.data(), 7);
 								}
 								break;
 							case 0x2c: // Display attributes
@@ -717,13 +898,19 @@ void TeletextPageDecode::decodeRow(int r)
 			}
 
 		// Level 1 character
+		if (c < 40) {
+			m_cellLevel1CharSet[r][c] = level1CharSet;
+			m_cellLevel1MosaicAttr[r][c] = level1Mosaics;
+			// Set to true on mosaic CHARACTER - not on blast through alphanumerics
+			m_cellLevel1MosaicChar[r][c] = level1Mosaics && (m_levelOnePage->character(r, c) & 0x20);
+		}
+
 		if (c < 40 && m_rowHeight[r] != BottomHalf) {
 			m_level1ActivePainter.result.character.diacritical = 0;
+			m_level1ActivePainter.result.character.drcsSource = NoDRCS;
 			if (m_levelOnePage->character(r, c) >= 0x20) {
 				m_level1ActivePainter.result.character.code = m_levelOnePage->character(r, c);
-				// Set to true on mosaic character - not on blast through alphanumerics
+				if (m_cellLevel1MosaicChar[r][c]) {
-				m_cellLevel1Mosaic[r][c] = level1Mosaics && (m_levelOnePage->character(r, c) & 0x20);
-				if (m_cellLevel1Mosaic[r][c]) {
 					m_level1ActivePainter.result.character.set = 24 + (level1SeparatedMosaics || m_level1ActivePainter.attribute.display.underlineSeparated);
 					level1HoldMosaicCharacter = m_levelOnePage->character(r, c);
 					level1HoldMosaicSeparated = level1SeparatedMosaics;
@@ -737,9 +924,6 @@ void TeletextPageDecode::decodeRow(int r)
 			// In side panel or on bottom half of Level 1 double height row, no Level 1 characters here
 			m_level1ActivePainter.result.character = { 0x20, 0, 0 };
 
-		if (c < 40)
-			m_cellLevel1CharSet[r][c] = level1CharSet;
-
 		// X/26 characters
 
 		// Used to track if character was placed by X/26 data
@@ -754,9 +938,9 @@ void TeletextPageDecode::decodeRow(int r)
 			if (result.code != 0x00) {
 				m_level1ActivePainter.result.character = result;
 				if (result.set == 0)
-					m_level1ActivePainter.result.character.set = m_level1ActivePainter.g0CharSet;
+					m_level1ActivePainter.result.character.set = m_level1ActivePainter.result.g0Set;
 				else if (result.set == 2)
-					m_level1ActivePainter.result.character.set = m_level1ActivePainter.g2CharSet;
+					m_level1ActivePainter.result.character.set = m_level1ActivePainter.result.g2Set;
 				x26Character = 1;
 			}
 		} else if (m_level >= 2)
@@ -764,7 +948,36 @@ void TeletextPageDecode::decodeRow(int r)
 				for (int i=0; i<m_invocations[t].size(); i++) {
 					painter = (t == 0) ? &m_level1ActivePainter : &m_adapPassPainter[t-1][i];
 
-					const textCharacter result = characterFromTriplets(m_invocations[t].at(i).charactersMappedAt(r, c));
+					textCharacter result = characterFromTriplets(m_invocations[t].at(i).charactersMappedAt(r, c));
+
+					if (result.drcsSource) {
+						drcsMode *drcsModePtr = result.drcsSource == NormalDRCS ? &painter->nDrcs : &painter->gDrcs;
+
+						if ((m_level == 2 && drcsModePtr->level2p5) || (m_level == 3 && drcsModePtr->level3p5)) {
+							// "code" is zero if an X/26 character is NOT invoked in the same cell
+							if (result.code == 0x00)
+								result.code = 0x20;
+							result.drcsSubTable = drcsModePtr->subTable;
+							if (m_level < 3)
+								drcsModePtr->used = true;
+						} else
+							// DRCS character not required at the current level
+							result.drcsSource = NoDRCS;
+					}
+
+					// If the DRCS character in question is not downloaded, scrap all that hard work
+					// looking it up.
+					// Ideally we'd leave it in case somebody wants to find which character was meant
+					// to be invoked, but things like underlying Level 1 characters still needing to
+					// appear when the DRCS characters are not (yet) downloaded are too complex to
+					// figure out with this too complex decoder.
+					if (result.drcsSource) {
+						const QList<DRCSPage>* drcsPage = m_drcsPage[result.drcsSource-1];
+						if (drcsPage == nullptr || result.drcsSubTable >= drcsPage->size() || !drcsPage->at(result.drcsSubTable).ptu(result.drcsChar, nullptr)) {
+							result.drcsSource = NoDRCS;
+							result.code = 0x00;
+						}
+					}
 
 					if (t == 0 && result.code == 0x00)
 						continue;
@@ -779,10 +992,10 @@ void TeletextPageDecode::decodeRow(int r)
 					painter->result.character = result;
 					switch (result.set) {
 						case 0:
-							painter->result.character.set = painter->g0CharSet;
+							painter->result.character.set = painter->result.g0Set;
 							break;
 						case 2:
-							painter->result.character.set = painter->g2CharSet;
+							painter->result.character.set = painter->result.g2Set;
 							break;
 						case 24:
 							if (painter->attribute.display.underlineSeparated)
@@ -848,8 +1061,17 @@ void TeletextPageDecode::decodeRow(int r)
 							painter->bottomHalfCell[c].fragment = DoubleSizeBottomLeftQuarter;
 							painter->rightHalfCell = painter->result;
 							painter->rightHalfCell.fragment = DoubleSizeTopRightQuarter;
-							painter->bottomHalfCell[c+1] = painter->result;
+							// The right half of this "if" statement (without the t != 2) is meant
-							painter->bottomHalfCell[c+1].fragment = DoubleSizeBottomRightQuarter;
+							// to a fix a bug where the bottom half of double-size characters in
+							// Passive Objects didn't appear.
+							// But the fix also caused the bottom right quarter of double-size
+							// characters in Active Objects to go missing when they overlapped
+							// the bottom half of a Level 1 double-height row.
+							// Hence the t != 2
+							if (t != 2 || painter->bottomHalfCell[c+1].character.code == 0x00) {
+								painter->bottomHalfCell[c+1] = painter->result;
+								painter->bottomHalfCell[c+1].fragment = DoubleSizeBottomRightQuarter;
+							}
 						} else {
 							// Double height
 							painter->result.fragment = DoubleHeightTopHalf;
@@ -936,7 +1158,14 @@ void TeletextPageDecode::decodeRow(int r)
 		// Level 1 set-after spacing attributes
 		if (c < 40 && m_rowHeight[r] != BottomHalf)
 			switch (m_levelOnePage->character(r, c)) {
-				case 0x00 ... 0x07: // Alphanumeric and foreground colour
+				case 0x00:
+				case 0x01:
+				case 0x02:
+				case 0x03:
+				case 0x04:
+				case 0x05:
+				case 0x06:
+				case 0x07: // Alphanumeric and foreground colour
 					level1Mosaics = false;
 					level1ForegroundCLUT = m_levelOnePage->character(r, c);
 					if (m_level >= 2)
@@ -948,7 +1177,14 @@ void TeletextPageDecode::decodeRow(int r)
 					level1HoldMosaicCharacter = 0x20;
 					level1HoldMosaicSeparated = false;
 					break;
-				case 0x10 ... 0x17: // Mosaic and foreground colour
+				case 0x10:
+				case 0x11:
+				case 0x12:
+				case 0x13:
+				case 0x14:
+				case 0x15:
+				case 0x16:
+				case 0x17: // Mosaic and foreground colour
 					level1Mosaics = true;
 					level1ForegroundCLUT = m_levelOnePage->character(r, c) & 0x07;
 					if (m_level >= 2)

src/qteletextdecoder/decode.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -20,11 +20,14 @@
 #ifndef DECODE_H
 #define DECODE_H
 
+#include <QImage>
 #include <QList>
 #include <QMap>
 #include <QMultiMap>
 
+#include "drcspage.h"
 #include "levelonepage.h"
+#include "pagebase.h"
 
 class TeletextPageDecode : public QObject
 {
@@ -32,25 +35,41 @@ class TeletextPageDecode : public QObject
 
 public:
 	enum CharacterFragment { NormalSize, DoubleHeightTopHalf, DoubleHeightBottomHalf, DoubleWidthLeftHalf, DoubleWidthRightHalf, DoubleSizeTopLeftQuarter, DoubleSizeTopRightQuarter, DoubleSizeBottomLeftQuarter, DoubleSizeBottomRightQuarter };
+	enum DRCSPageType { NormalDRCSPage, GlobalDRCSPage };
+//	enum ObjectPageType { NormalPOPage = 2, GlobalPOPage };
+	enum DRCSSource { NoDRCS, NormalDRCS, GlobalDRCS };
 	enum RowHeight { NormalHeight, TopHalf, BottomHalf };
 
 	TeletextPageDecode();
 	~TeletextPageDecode();
 	bool refresh(int r, int c) const { return m_refresh[r][c]; }
-	void setRefresh(int, int, bool);
+	void setRefresh(int r, int c, bool refresh);
+	int level() const { return m_level; }
 	void decodePage();
 	LevelOnePage *teletextPage() const { return m_levelOnePage; };
-	void setTeletextPage(LevelOnePage *);
+	void setTeletextPage(LevelOnePage *newCurrentPage);
+	QList<DRCSPage> *drcsPage(DRCSPageType pageType) const { return m_drcsPage[pageType]; };
+	void setDRCSPage(DRCSPageType pageType, QList<DRCSPage> *pages);
+	void clearDRCSPage(DRCSPageType pageType);
 	void updateSidePanels();
 
 	unsigned char cellCharacterCode(int r, int c) const { return m_cell[r][c].character.code; };
 	int cellCharacterSet(int r, int c) const { return m_cell[r][c].character.set; };
 	int cellCharacterDiacritical(int r, int c) const { return m_cell[r][c].character.diacritical; };
+	int cellG0CharacterSet(int r, int c) const { return m_cell[r][c].g0Set; };
+	int cellG2CharacterSet(int r, int c) const { return m_cell[r][c].g2Set; };
+
+	DRCSSource cellDrcsSource(int r, int c) const { return m_cell[r][c].character.drcsSource; };
+	int cellDrcsSubTable(int r, int c) const { return m_cell[r][c].character.drcsSubTable; };
+	int cellDrcsCharacter(int r, int c) const { return m_cell[r][c].character.drcsChar; };
+
+	QImage drcsImage(DRCSSource pageType, int subTable, int chr, bool flashPhOn = true);
+
 	int cellForegroundCLUT(int r, int c) const { return m_cell[r][c].attribute.foregroundCLUT; };
 	int cellBackgroundCLUT(int r, int c) const { return m_cell[r][c].attribute.backgroundCLUT; };
-	QColor cellForegroundQColor(int, int);
+	QColor cellForegroundQColor(int r, int c);
-	QColor cellBackgroundQColor(int, int);
+	QColor cellBackgroundQColor(int r, int c);
-	QColor cellFlashForegroundQColor(int, int);
+	QColor cellFlashForegroundQColor(int r, int c);
 	int cellFlashMode(int r, int c) const { return m_cell[r][c].attribute.flash.mode; };
 	int cellFlashRatePhase(int r, int c) const { return m_cell[r][c].attribute.flash.ratePhase; };
 	int cellFlash2HzPhaseNumber(int r, int c) const { return m_cell[r][c].attribute.flash.phase2HzShown; };
@@ -62,7 +81,8 @@ public:
 	bool cellItalic(int r, int c) const { return m_cell[r][c].attribute.style.italic; };
 	bool cellProportional(int r, int c) const { return m_cell[r][c].attribute.style.proportional; };
 
-	bool level1MosaicAttribute(int r, int c) const { return m_cellLevel1Mosaic[r][c]; };
+	bool level1MosaicAttr(int r, int c) const { return m_cellLevel1MosaicAttr[r][c]; };
+	bool level1MosaicChar(int r, int c) const { return m_cellLevel1MosaicChar[r][c]; };
 	int level1CharSet(int r, int c) const { return m_cellLevel1CharSet[r][c]; };
 
 	RowHeight rowHeight(int r) const { return m_rowHeight[r]; };
@@ -73,16 +93,16 @@ public:
 	int rightSidePanelColumns() const { return m_rightSidePanelColumns; };
 
 public slots:
-	void setLevel(int);
+	void setLevel(int level);
 
 signals:
-	void fullScreenColourChanged(QColor);
+	void fullScreenColourChanged(QColor newColour);
-	void fullRowColourChanged(int, QColor);
+	void fullRowColourChanged(int r, QColor newColour);
 	void sidePanelsChanged();
 
 protected:
-	inline void setFullScreenColour(int);
+	inline void setFullScreenColour(int newColour);
-	inline void setFullRowColour(int, int);
+	inline void setFullRowColour(int row, int newColour);
 
 	int m_finalFullScreenColour, m_level;
 	QColor m_finalFullScreenQColor;
@@ -99,13 +119,19 @@ private:
 		unsigned char code=0x20;
 		int set=0;
 		int diacritical=0;
+		DRCSSource drcsSource=NoDRCS;
+		int drcsSubTable=0;
+		int drcsChar=0;
 	};
 
 	friend inline bool operator!=(const textCharacter &lhs, const textCharacter &rhs)
 	{
-		return lhs.code        != rhs.code ||
+		return lhs.code         != rhs.code         ||
-	           lhs.set         != rhs.set  ||
+		       lhs.set          != rhs.set          ||
-	           lhs.diacritical != rhs.diacritical;
+		       lhs.diacritical  != rhs.diacritical  ||
+		       lhs.drcsSource   != rhs.drcsSource   ||
+		       lhs.drcsSubTable != rhs.drcsSubTable ||
+		       lhs.drcsChar     != rhs.drcsChar;
 	}
 
 	struct flashFunctions {
@@ -164,6 +190,8 @@ private:
 		textCharacter character;
 		textAttributes attribute;
 		CharacterFragment fragment=NormalSize;
+		int g0Set=0;
+		int g2Set=7;
 	};
 
 	friend inline bool operator!=(const textCell &lhs, const textCell &rhs)
@@ -173,14 +201,20 @@ private:
 		       lhs.fragment  != rhs.fragment;
 	}
 
+	struct drcsMode {
+		bool level2p5=true;
+		bool level3p5=true;
+		bool used=false;
+		int subTable=0;
+	};
+
 	struct textPainter {
 		textAttributes attribute;
 		textCell result;
 		textCell rightHalfCell;
 		textCell bottomHalfCell[72];
 
-		int g0CharSet=0;
+		drcsMode gDrcs, nDrcs;
-		int g2CharSet=7;
 
 		int styleSpreadRows=0;
 		int setProportionalRows[72], clearProportionalRows[72];
@@ -218,15 +252,15 @@ private:
 
 		X26TripletList *tripletList() const { return m_tripletList; };
 		void clear();
-		void setTripletList(X26TripletList *);
+		void setTripletList(X26TripletList *tripletList);
 		int startTripletNumber() const { return m_startTripletNumber; };
-		void setStartTripletNumber(int);
+		void setStartTripletNumber(int n);
 		int endTripletNumber() const { return m_endTripletNumber; };
-		void setEndTripletNumber(int);
+		void setEndTripletNumber(int n);
 		int originRow() const { return m_originRow; };
 		int originColumn() const { return m_originColumn; };
-		void setOrigin(int, int);
+		void setOrigin(int row, int column);
-		void buildMap(int);
+		void buildMap(int level);
 
 		QList<QPair<int, int>> charPositions() const { return m_characterMap.uniqueKeys(); };
 		QList<QPair<int, int>> attrPositions() const { return m_attributeMap.uniqueKeys(); };
@@ -252,17 +286,19 @@ private:
 	static textPainter s_blankPainter;
 
 	void decodeRow(int r);
-	QColor cellQColor(int, int, ColourPart);
+	QColor cellQColor(int r, int c, ColourPart colourPart);
-	textCell& cellAtCharacterOrigin(int, int);
+	textCell& cellAtCharacterOrigin(int r, int c);
-	void buildInvocationList(Invocation &, int);
+	void buildInvocationList(Invocation &invocation, int objectType);
-	textCharacter characterFromTriplets(const QList<X26Triplet>);
+	textCharacter characterFromTriplets(const QList<X26Triplet> triplets);
-	inline void rotateFlashMovement(flashFunctions &);
+	inline void rotateFlashMovement(flashFunctions &flash);
 
 	bool m_refresh[25][72];
 	textCell m_cell[25][72];
-	bool m_cellLevel1Mosaic[25][40];
+	bool m_cellLevel1MosaicAttr[25][40];
+	bool m_cellLevel1MosaicChar[25][40];
 	int m_cellLevel1CharSet[25][40];
 	LevelOnePage* m_levelOnePage;
+	QList<DRCSPage>* m_drcsPage[2];
 	int m_fullRowColour[25];
 	QColor m_fullRowQColor[25];
 	QList<Invocation> m_invocations[3];

src/qteletextdecoder/drcspage.cpp

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QByteArray>
+
+#include "drcspage.h"
+
+DRCSPage::DRCSPage(const PageBase &other)
+{
+	for (int y=0; y<26; y++)
+		if (other.packetExists(y))
+			setPacket(y, other.packet(y));
+
+	for (int y=26; y<29; y++)
+		for (int d=0; d<16; d++)
+			if (other.packetExists(y, d))
+				setPacket(y, d, other.packet(y, d));
+
+	for (int b=PageBase::C4ErasePage; b<=PageBase::C14NOS; b++)
+		setControlBit(b, other.controlBit(b));
+}
+
+PageBase::PageFunctionEnum DRCSPage::pageFunction() const
+{
+	return PFGlobalPOP;
+}
+
+int DRCSPage::drcsMode(int c) const
+{
+	if (!packetExists(28, 3))
+		return 0;
+
+	const QByteArray pkt = packet(28, 3);
+
+	// Some tricky bit juggling to extract 4 bits from part of a 6-bit triplet
+	switch (c % 3) {
+		case 0:
+			return pkt.at(c/3*2 + 4) & 0xf;
+		case 1:
+			return ((pkt.at((c-1)/3*2 + 4) & 0x30) >> 4) | ((pkt.at((c-1)/3*2 + 5) & 0x3) << 2);
+		case 2:
+			return pkt.at(((c-2)/3*2 + 5) & 0x3f) >> 2;
+	}
+
+	return 0; // Won't get here; used to suppress a compiler warning
+}
+
+bool DRCSPage::ptu(int c, uchar *data) const
+{
+	const int pktNo = (c+2)/2;
+
+	if (!packetExists(pktNo))
+		return false;
+
+	const int start = c%2 * 20;
+
+	// FIXME should we check all 20 D-bytes for SPACE instead of just the first D-byte?
+	if (packet(pktNo).at(start) < 0x40)
+		return false;
+
+	if (data != nullptr) {
+		const int end = start + 20;
+
+		for (int i=start, j=0; i<end; i+=2, j+=2) {
+			data[j] = ((packet(pktNo).at(i) & 0x3f) << 2) | ((packet(pktNo).at(i+1) & 0x30) >> 4);
+			data[j+1] = (packet(pktNo).at(i+1) & 0x0f) << 4;
+		}
+	}
+
+	return true;
+}

src/qteletextdecoder/drcspage.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2020-2025 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 DRCSPAGE_H
+#define DRCSPAGE_H
+
+#include <QByteArray>
+
+#include "pagebase.h"
+
+class DRCSPage : public PageBase
+{
+public:
+	DRCSPage(const PageBase &other);
+
+	// TODO PFNormalPOP as well?
+	PageFunctionEnum pageFunction() const;
+
+	int drcsMode(int c) const;
+	bool ptu(int c, uchar *data) const;
+};
+
+#endif

src/qteletextdecoder/levelonepage.cpp

@@ -0,0 +1,741 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QByteArray>
+#include <QColor>
+#include <QList>
+#include <QString>
+#include <algorithm>
+
+#include "levelonepage.h"
+
+#include "x26triplets.h"
+
+LevelOnePage::LevelOnePage()
+{
+	m_enhancements.reserve(maxEnhancements());
+	clearPage();
+}
+
+LevelOnePage::LevelOnePage(const PageBase &other)
+{
+	m_enhancements.reserve(maxEnhancements());
+	clearPage();
+
+	for (int y=0; y<26; y++)
+		if (other.packetExists(y))
+			setPacket(y, other.packet(y));
+
+	for (int y=26; y<29; y++)
+		for (int d=0; d<16; d++)
+			if (other.packetExists(y, d))
+				setPacket(y, d, other.packet(y, d));
+
+	for (int b=PageBase::C4ErasePage; b<=PageBase::C14NOS; b++)
+		setControlBit(b, other.controlBit(b));
+}
+
+// So far we only call clearPage() once, within the constructor
+void LevelOnePage::clearPage()
+{
+	for (int b=C4ErasePage; b<=C14NOS; b++)
+		setControlBit(b, false);
+	for (int i=0; i<8; i++)
+		m_composeLink[i] = { (i<4) ? i : 0, false, i>=4, 0x0ff, 0x0000 };
+	for (int i=0; i<6; i++)
+		m_fastTextLink[i] = { 0x0ff, 0x3f7f };
+
+/*	m_subPageNumber = 0x0000; */
+	m_cycleValue = 20;
+	m_cycleType = CTseconds;
+	m_defaultCharSet = 0;
+	m_defaultNOS = 0;
+	m_secondCharSet = 0xf;
+	m_secondNOS = 0x7;
+
+	m_defaultScreenColour = 0;
+	m_defaultRowColour = 0;
+	m_blackBackgroundSubst = false;
+	m_colourTableRemap = 0;
+	m_leftSidePanelDisplayed = m_rightSidePanelDisplayed = false;
+	m_sidePanelStatusL25 = true;
+	m_sidePanelColumns = 0;
+	std::copy(m_defaultCLUT, m_defaultCLUT+32, m_CLUT);
+//	If clearPage() is called outside constructor, we need to implement m_enhancements.clear();
+}
+
+bool LevelOnePage::isEmpty() const
+{
+	if (!m_enhancements.isEmpty())
+		return false;
+
+	if (!isPaletteDefault(0, 31))
+		return false;
+
+	for (int r=0; r<25; r++)
+		if (!PageX26Base::packet(r).isEmpty())
+			return false;
+
+	return true;
+}
+
+QByteArray LevelOnePage::packet(int y, int d) const
+{
+	QByteArray result(40, 0x00);
+
+	if (y == 26) {
+		if (!packetFromEnhancementListNeeded(d))
+			return result; // Blank result
+
+		return packetFromEnhancementList(d);
+	}
+
+	if (y == 27 && d == 0) {
+		for (int i=0; i<6; i++) {
+			result[i*6+1] = m_fastTextLink[i].pageNumber & 0x00f;
+			result[i*6+2] = (m_fastTextLink[i].pageNumber & 0x0f0) >> 4;
+			result[i*6+3] = m_fastTextLink[i].subPageNumber & 0x000f;
+			result[i*6+4] = ((m_fastTextLink[i].subPageNumber & 0x0070) >> 4) | ((m_fastTextLink[i].pageNumber & 0x100) >> 5);
+			result[i*6+5] = (m_fastTextLink[i].subPageNumber & 0x0f00) >> 8;
+			result[i*6+6] = ((m_fastTextLink[i].subPageNumber & 0x3000) >> 12) | ((m_fastTextLink[i].pageNumber & 0x600) >> 7);
+		}
+		result[37] = 0xf;
+		result[38] = result[39] = 0;
+
+		return result;
+	}
+
+	if (y == 27 && (d == 4 || d == 5)) {
+		for (int i=0; i<(d == 4 ? 6 : 2); i++) {
+			int pageLinkNumber = i+(d == 4 ? 0 : 6);
+
+			result[i*6+1] = (m_composeLink[pageLinkNumber].level3p5 << 3) | (m_composeLink[pageLinkNumber].level2p5 << 2) | m_composeLink[pageLinkNumber].function;
+			result[i*6+2] = ((m_composeLink[pageLinkNumber].pageNumber & 0x100) >> 3) | 0x10 | (m_composeLink[pageLinkNumber].pageNumber & 0x00f);
+			result[i*6+3] = ((m_composeLink[pageLinkNumber].pageNumber & 0x0f0) >> 2) | ((m_composeLink[pageLinkNumber].pageNumber & 0x600) >> 9);
+
+			result[i*6+4] = ((m_composeLink[pageLinkNumber].subPageCodes & 0x000f) << 2);
+			result[i*6+5] = ((m_composeLink[pageLinkNumber].subPageCodes & 0x03f0) >> 4);
+			result[i*6+6] = ((m_composeLink[pageLinkNumber].subPageCodes & 0xfc00) >> 10);
+		}
+
+		return result;
+	}
+
+	if (y == 28 && (d == 0 || d == 4)) {
+		int CLUToffset = (d == 0) ? 16 : 0;
+
+		result[1] = 0x00;
+		result[2] = ((m_defaultCharSet & 0x3) << 4) | (m_defaultNOS << 1);
+		result[3] = ((m_secondCharSet & 0x1) << 5) | (m_secondNOS << 2) | (m_defaultCharSet >> 2);
+		result[4] = (m_sidePanelStatusL25 << 5) | (m_rightSidePanelDisplayed << 4) | (m_leftSidePanelDisplayed << 3) | (m_secondCharSet >> 1);
+		result[5] = m_sidePanelColumns | ((m_CLUT[CLUToffset] & 0x300) >> 4);
+
+		for (int c=0; c<16; c++) {
+			result[c*2+6] = ((m_CLUT[CLUToffset+c] & 0x0f0) >> 2) | ((m_CLUT[CLUToffset+c] & 0xf00) >> 10);
+			result[c*2+7] = ((m_CLUT[CLUToffset+c+1] & 0x300) >> 4) | (m_CLUT[CLUToffset+c] & 0x00f);
+		}
+
+		result[37] = ((m_defaultScreenColour & 0x03) << 4) | (m_CLUT[CLUToffset+15] & 0x00f);
+		result[38] = ((m_defaultRowColour & 0x07) << 3) | (m_defaultScreenColour >> 2);
+		result[39] = (m_colourTableRemap << 3) | (m_blackBackgroundSubst << 2) | (m_defaultRowColour >> 3);
+
+		return result;
+	}
+
+	return PageX26Base::packet(y, d);
+}
+
+/*
+bool LevelOnePage::setPacket(int y, QByteArray pkt)
+{
+	if (y == 25)
+		qDebug("LevelOnePage unhandled setPacket X/25");
+
+	return PageX26Base::setPacket(y, pkt);
+}
+*/
+
+bool LevelOnePage::setPacket(int y, int d, QByteArray pkt)
+{
+	if (y == 26) {
+		setEnhancementListFromPacket(d, pkt);
+		return true;
+	}
+
+	if (y == 27 && d == 0) {
+		for (int i=0; i<6; i++) {
+			int relativeMagazine = (pkt.at(i*6+4) >> 3) | ((pkt.at(i*6+6) & 0xc) >> 1);
+			int pageNumber = (pkt.at(i*6+2) << 4) | pkt.at(i*6+1);
+			m_fastTextLink[i].pageNumber = (relativeMagazine << 8) | pageNumber;
+			m_fastTextLink[i].subPageNumber = pkt.at(i*6+3) | ((pkt.at(i*6+4) & 0x7) << 4) | (pkt.at(i*6+5) << 8) | ((pkt.at(i*6+6) & 0x3) << 12);
+			// TODO remove this warning when we can preserve FastText subpage links
+			if (m_fastTextLink[i].subPageNumber != 0x3f7f)
+				qDebug("FastText link %d has custom subPageNumber %x - will NOT be saved!", i, m_fastTextLink[i].subPageNumber);
+		}
+		return true;
+	}
+
+	if (y == 27 && (d == 4 || d == 5)) {
+		for (int i=0; i<(d == 4 ? 6 : 2); i++) {
+			int pageLinkNumber = i+(d == 4 ? 0 : 6);
+			int pageFunction = pkt.at(i*6+1) & 0x03;
+			if (i >= 4)
+				m_composeLink[pageLinkNumber].function = pageFunction;
+			else if (i != pageFunction)
+				qDebug("X/27/4 link number %d fixed at function %d. Attempted to set to %d.", pageLinkNumber, pageLinkNumber, pageFunction);
+
+			m_composeLink[pageLinkNumber].level2p5 = pkt.at(i*6+1) & 0x04;
+			m_composeLink[pageLinkNumber].level3p5 = pkt.at(i*6+1) & 0x08;
+
+			m_composeLink[pageLinkNumber].pageNumber = ((pkt.at(i*6+3) & 0x03) << 9) | ((pkt.at(i*6+2) & 0x20) << 3) | ((pkt.at(i*6+3) & 0x3c) << 2) | (pkt.at(i*6+2) & 0x0f);
+
+			m_composeLink[pageLinkNumber].subPageCodes = (pkt.at(i*6+4) >> 2) | (pkt.at(i*6+5) << 4) | (pkt.at(i*6+6) << 10);
+		}
+		return true;
+	}
+
+	if (y == 28 && (d == 0 || d == 4)) {
+		int CLUToffset = (d == 0) ? 16 : 0;
+
+		m_defaultCharSet = ((pkt.at(2) >> 4) & 0x3) | ((pkt.at(3) << 2) & 0xc);
+		m_defaultNOS = (pkt.at(2) >> 1) & 0x7;
+		m_secondCharSet = ((pkt.at(3) >> 5) & 0x1) | ((pkt.at(4) << 1) & 0xe);
+		m_secondNOS = (pkt.at(3) >> 2) & 0x7;
+
+		m_leftSidePanelDisplayed = (pkt.at(4) >> 3) & 1;
+		m_rightSidePanelDisplayed = (pkt.at(4) >> 4) & 1;
+		m_sidePanelStatusL25 = (pkt.at(4) >> 5) & 1;
+		m_sidePanelColumns = pkt.at(5) & 0xf;
+
+		for (int c=0; c<16; c++)
+			m_CLUT[CLUToffset+c] = ((pkt.at(c*2+5) << 4) & 0x300) | ((pkt.at(c*2+6) << 10) & 0xc00) | ((pkt.at(c*2+6) << 2) & 0x0f0) | (pkt.at(c*2+7) & 0x00f);
+
+		m_defaultScreenColour = (pkt.at(37) >> 4) | ((pkt.at(38) << 2) & 0x1c);
+		m_defaultRowColour = ((pkt.at(38)) >> 3) | ((pkt.at(39) << 3) & 0x18);
+		m_blackBackgroundSubst = (pkt.at(39) >> 2) & 1;
+		m_colourTableRemap = (pkt.at(39) >> 3) & 7;
+
+		return true;
+	}
+
+	return PageX26Base::setPacket(y, d, pkt);
+}
+
+bool LevelOnePage::packetExists(int y, int d) const
+{
+	if (y == 26)
+		return packetFromEnhancementListNeeded(d);
+
+	if (y == 27 && d == 0) {
+		for (int i=0; i<6; i++)
+			if ((m_fastTextLink[i].pageNumber & 0x0ff) != 0xff)
+				return true;
+
+		return false;
+	}
+
+	if (y == 27 && (d == 4 || d == 5)) {
+		for (int i=0; i<(d == 4 ? 6 : 2); i++) {
+			int pageLinkNumber = i+(d == 4 ? 0 : 6);
+			if ((m_composeLink[pageLinkNumber].pageNumber & 0x0ff) != 0x0ff)
+				return true;
+		}
+		return false;
+	}
+
+	if (y == 28) {
+		if (d == 0) {
+			if (m_leftSidePanelDisplayed || m_rightSidePanelDisplayed || m_defaultScreenColour != 0 || m_defaultRowColour != 0 || m_blackBackgroundSubst || m_colourTableRemap != 0 || m_secondCharSet != 0xf)
+				return true;
+			return !isPaletteDefault(16, 31);
+		}
+		if (d == 4)
+			return !isPaletteDefault(0, 15);
+	}
+
+	return PageX26Base::packetExists(y, d);
+}
+
+bool LevelOnePage::setControlBit(int b, bool active)
+{
+	switch (b) {
+		case C12NOS:
+			m_defaultNOS &= 0x6;
+			if (active)
+				m_defaultNOS |= 0x1;
+			break;
+		case C13NOS:
+			m_defaultNOS &= 0x5;
+			if (active)
+				m_defaultNOS |= 0x2;
+			break;
+		case C14NOS:
+			m_defaultNOS &= 0x3;
+			if (active)
+				m_defaultNOS |= 0x4;
+			break;
+	}
+
+	return PageX26Base::setControlBit(b, active);
+}
+
+int LevelOnePage::maxEnhancements() const
+{
+	return 208;
+}
+
+/* void LevelOnePage::setSubPageNumber(int newSubPageNumber) { m_subPageNumber = newSubPageNumber; } */
+
+int LevelOnePage::cycleValue() const
+{
+	return m_cycleValue;
+}
+
+void LevelOnePage::setCycleValue(int newValue)
+{
+	m_cycleValue = newValue;
+}
+
+LevelOnePage::CycleTypeEnum LevelOnePage::cycleType() const
+{
+	return m_cycleType;
+}
+
+void LevelOnePage::setCycleType(CycleTypeEnum newType)
+{
+	m_cycleType = newType;
+}
+
+int LevelOnePage::defaultCharSet() const
+{
+	return m_defaultCharSet;
+}
+
+void LevelOnePage::setDefaultCharSet(int newDefaultCharSet)
+{
+	m_defaultCharSet = newDefaultCharSet;
+}
+
+int LevelOnePage::defaultNOS() const
+{
+	return m_defaultNOS;
+}
+
+void LevelOnePage::setDefaultNOS(int defaultNOS)
+{
+	m_defaultNOS = defaultNOS;
+
+	PageX26Base::setControlBit(C12NOS, m_defaultNOS & 0x1);
+	PageX26Base::setControlBit(C13NOS, m_defaultNOS & 0x2);
+	PageX26Base::setControlBit(C14NOS, m_defaultNOS & 0x4);
+}
+
+int LevelOnePage::secondCharSet() const
+{
+	return m_secondCharSet;
+}
+
+void LevelOnePage::setSecondCharSet(int newSecondCharSet)
+{
+	m_secondCharSet = newSecondCharSet;
+	if (m_secondCharSet == 0xf)
+		m_secondNOS = 0x7;
+}
+
+int LevelOnePage::secondNOS() const
+{
+	return m_secondNOS;
+}
+
+void LevelOnePage::setSecondNOS(int newSecondNOS) { m_secondNOS = newSecondNOS; }
+
+unsigned char LevelOnePage::character(int r, int c) const
+{
+	return PageX26Base::packetExists(r) ? PageX26Base::packet(r).at(c) : 0x20;
+}
+
+void LevelOnePage::setCharacter(int r, int c, unsigned char newCharacter)
+{
+	QByteArray pkt;
+
+	if (!packetExists(r)) {
+		if (newCharacter == 0x20)
+			return;
+		pkt = QByteArray(40, 0x20);
+		pkt[c] = newCharacter;
+		setPacket(r, pkt);
+	} else {
+		pkt = packet(r);
+		pkt[c] = newCharacter;
+		if (pkt == QByteArray(40, 0x20))
+			clearPacket(r);
+		else
+			setPacket(r, pkt);
+	}
+}
+
+int LevelOnePage::defaultScreenColour() const
+{
+	return m_defaultScreenColour;
+}
+
+void LevelOnePage::setDefaultScreenColour(int newDefaultScreenColour)
+{
+	m_defaultScreenColour = newDefaultScreenColour;
+}
+
+int LevelOnePage::defaultRowColour() const
+{
+	return m_defaultRowColour;
+}
+
+void LevelOnePage::setDefaultRowColour(int newDefaultRowColour)
+{
+	m_defaultRowColour = newDefaultRowColour;
+}
+
+int LevelOnePage::colourTableRemap() const
+{
+	return m_colourTableRemap;
+}
+
+void LevelOnePage::setColourTableRemap(int newColourTableRemap)
+{
+	m_colourTableRemap = newColourTableRemap;
+}
+
+bool LevelOnePage::blackBackgroundSubst() const
+{
+	return m_blackBackgroundSubst;
+}
+
+void LevelOnePage::setBlackBackgroundSubst(bool newBlackBackgroundSubst)
+{
+	m_blackBackgroundSubst = newBlackBackgroundSubst;
+}
+
+int LevelOnePage::CLUT(int index, int renderLevel) const
+{
+	if (renderLevel == 2)
+		return index>=16 ? m_CLUT[index] : m_defaultCLUT[index];
+	else
+		return renderLevel==3 ? m_CLUT[index] : m_defaultCLUT[index];
+}
+
+void LevelOnePage::setCLUT(int index, int newColour)
+{
+	if (index == 8)
+		return;
+	m_CLUT[index] = newColour;
+}
+
+QColor LevelOnePage::CLUTtoQColor(int index, int renderLevel) const
+{
+	int colour12Bit = CLUT(index, renderLevel);
+
+	if (index == 8)
+		return QColor(Qt::transparent);
+
+	return QColor(((colour12Bit & 0xf00) >> 8) * 17, ((colour12Bit & 0x0f0) >> 4) * 17, (colour12Bit & 0x00f) * 17);
+}
+
+bool LevelOnePage::isPaletteDefault(int colour) const
+{
+	return m_CLUT[colour] == m_defaultCLUT[colour];
+}
+
+bool LevelOnePage::isPaletteDefault(int fromColour, int toColour) const
+{
+	for (int i=fromColour; i<=toColour; i++)
+		if (m_CLUT[i] != m_defaultCLUT[i])
+			return false;
+
+	return true;
+}
+
+int LevelOnePage::dCLUT(bool globalDrcs, int mode, int index) const
+{
+	if (!packetExists(28, 1))
+		// Return default DCLUT as per D.1.6 and D.2.2 in the ETSI spec
+		return index;
+
+	const QByteArray pkt = packet(28, 1);
+
+	if (mode == 1) {
+		if (!globalDrcs)
+			index += 4;
+	} else if (mode == 2 || mode == 3)
+		index += globalDrcs ? 8 : 24;
+	else
+		return 0;
+
+	// Some tricky bit juggling to extract 5 bits from parts of a 6-bit triplet
+	const int l = index/6*5 + 4;
+
+	switch (index % 6) {
+		case 0:
+			return pkt.at(l) & 0x1f;
+		case 1:
+			return ((pkt.at(l+1) & 0x0f) << 1) | (pkt.at(l) >> 5);
+		case 2:
+			return ((pkt.at(l+2) & 0x07) << 2) | (pkt.at(l+1) >> 4);
+		case 3:
+			return ((pkt.at(l+3) & 0x03) << 3) | (pkt.at(l+2) >> 3);
+		case 4:
+			return ((pkt.at(l+4) & 0x01) << 4) | (pkt.at(l+3) >> 2);
+		case 5:
+			return pkt.at(l+4) >> 1;
+	}
+	return 0; // Won't get here; used to suppress a compiler warning
+}
+
+void LevelOnePage::setDCLUT(bool globalDrcs, int mode, int index, int colour)
+{
+	// Default DCLUT as per D.1.6 and D.2.2 in the ETSI spec
+	const QByteArray defaultPkt = QByteArrayLiteral("\x01\x00\x00\x00\x20\x20\x18\x00\x02\x22\x01\x08\x08\x06\x24\x22\x39\x20\x12\x2a\x05\x2b\x39\x1e\x20\x20\x18\x10\x0a\x26\x03\x0a\x29\x16\x2c\x26\x3b\x01\x00\x00");
+
+	if (!packetExists(28, 1))
+		setPacket(28, 1, defaultPkt);
+
+	if (mode == 1) {
+		if (!globalDrcs)
+			index += 4;
+	} else if (mode == 2 || mode == 3)
+		index += globalDrcs ? 8 : 24;
+	else
+		return;
+
+	QByteArray pkt = packet(28, 1);
+
+	// Some tricky bit juggling to set 5 bits within parts of a 6-bit triplet
+	const int l = index/6*5 + 4;
+
+	switch (index % 6) {
+		case 0:
+			pkt[l] = pkt.at(l) & 0x20 | colour;
+			break;
+		case 1:
+			pkt[l+1] = (pkt.at(l+1) & 0x30) | (colour >> 1);
+			pkt[l] = (pkt.at(l) & 0x1f) | ((colour << 5) & 0x3f);
+			break;
+		case 2:
+			pkt[l+2] = (pkt.at(l+2) & 0x38) | (colour >> 2);
+			pkt[l+1] = (pkt.at(l+1) & 0x0f) | ((colour << 4) & 0x3f);
+			break;
+		case 3:
+			pkt[l+3] = (pkt.at(l+3) & 0x3c) | (colour >> 3);
+			pkt[l+2] = (pkt.at(l+2) & 0x07) | ((colour << 3) & 0x3f);
+			break;
+		case 4:
+			pkt[l+4] = (pkt.at(l+4) & 0x3e) | (colour >> 4);
+			pkt[l+3] = (pkt.at(l+3) & 0x03) | ((colour << 2) & 0x3f);
+			break;
+		case 5:
+			pkt[l+4] = (pkt.at(l+4) & 0x01) | (colour << 1);
+			break;
+	}
+
+	if (pkt == defaultPkt)
+		clearPacket(28, 1);
+	else
+		setPacket(28, 1, pkt);
+}
+
+int LevelOnePage::levelRequired() const
+{
+	// X/28/4 present i.e. CLUTs 0 or 1 redefined - Level 3.5
+	if (!isPaletteDefault(0, 15))
+		return 3;
+
+	// X/28/1 present i.e. DCLUTs for mode 1-3 DRCS characters - Level 3.5
+	if (packetExists(28, 1))
+		return 3;
+
+	// Assume Level 2.5 if any X/28 page enhancements are present, otherwise assume Level 1
+	int levelSeen = (!isPaletteDefault(16, 31) || m_leftSidePanelDisplayed || m_rightSidePanelDisplayed || m_defaultScreenColour !=0 || m_defaultRowColour !=0 || m_blackBackgroundSubst || m_colourTableRemap !=0 || m_defaultCharSet != 0 || m_secondCharSet != 0xf) ? 2 : 0;
+
+	// If there's no X/26 triplets, exit here as Level 1 or 2.5
+	if (m_enhancements.isEmpty())
+		return levelSeen;
+
+	for (int i=0; i<m_enhancements.size(); i++) {
+		// Font style - Level 3.5 only triplet
+		if (m_enhancements.at(i).modeExt() == 0x2e) // Font style
+			return 3;
+
+		if (levelSeen == 0)
+			// Check for Level 1.5 triplets
+			switch (m_enhancements.at(i).modeExt()) {
+				case 0x04: // Set Active Position
+				case 0x07: // Address Row 0
+				case 0x1f: // Termination
+				case 0x22: // G3 character @ Level 1.5
+				case 0x2f: // G2 character
+					levelSeen = 1;
+					break;
+				default:
+					if (m_enhancements.at(i).modeExt() >= 0x30 && m_enhancements.at(i).modeExt() <= 0x3f)
+						// G0 character with diacritical
+						levelSeen = 1;
+			}
+
+		if (levelSeen < 2)
+			switch (m_enhancements.at(i).modeExt()) {
+				// Check for Level 2.5 triplets
+				case 0x00: // Full screen colour
+				case 0x01: // Full row colour
+				case 0x10: // Origin Modifier
+				case 0x11: // Invoke Active Object
+				case 0x12: // Invoke Adaptive Object
+				case 0x13: // Invoke Passive Object
+				case 0x15: // Define Active Object
+				case 0x16: // Define Adaptive Object
+				case 0x17: // Define Passive Object
+				case 0x18: // DRCS Mode
+				case 0x20: // Foreground colour
+				case 0x21: // G1 character
+				case 0x23: // Background colour
+				case 0x27: // Flash functions
+				case 0x28: // G0 and G2 charset designation
+				case 0x29: // G0 character @ Level 2.5
+				case 0x2b: // G3 character @ Level 2.5
+				case 0x2c: // Display attributes
+				case 0x2d: // DRCS character
+					levelSeen = 2;
+					break;
+			}
+
+		if (levelSeen == 2)
+			switch (m_enhancements.at(i).modeExt()) {
+				// Check for triplets with "required at Level 3.5 only" parameters
+				case 0x15: // Define Active Object
+				case 0x16: // Define Adaptive Object
+				case 0x17: // Define Passive Object
+					if ((m_enhancements.at(i).address() & 0x18) == 0x10)
+						return 3;
+					break;
+				case 0x18: // DRCS Mode
+					if ((m_enhancements.at(i).data() & 0x30) == 0x20)
+						return 3;
+					break;
+			}
+	}
+
+	return levelSeen;
+}
+
+bool LevelOnePage::leftSidePanelDisplayed() const
+{
+	return m_leftSidePanelDisplayed;
+}
+
+void LevelOnePage::setLeftSidePanelDisplayed(bool newLeftSidePanelDisplayed)
+{
+	m_leftSidePanelDisplayed = newLeftSidePanelDisplayed;
+}
+
+bool LevelOnePage::rightSidePanelDisplayed() const
+{
+	return m_rightSidePanelDisplayed;
+}
+
+void LevelOnePage::setRightSidePanelDisplayed(bool newRightSidePanelDisplayed)
+{
+	m_rightSidePanelDisplayed = newRightSidePanelDisplayed;
+}
+
+int LevelOnePage::sidePanelColumns() const
+{
+	return m_sidePanelColumns;
+}
+
+void LevelOnePage::setSidePanelColumns(int newSidePanelColumns)
+{
+	m_sidePanelColumns = newSidePanelColumns;
+}
+
+bool LevelOnePage::sidePanelStatusL25() const
+{
+	return m_sidePanelStatusL25;
+}
+
+void LevelOnePage::setSidePanelStatusL25(bool newSidePanelStatusL25)
+{
+	m_sidePanelStatusL25 = newSidePanelStatusL25;
+}
+
+int LevelOnePage::fastTextLinkPageNumber(int linkNumber) const
+{
+	return m_fastTextLink[linkNumber].pageNumber;
+}
+
+void LevelOnePage::setFastTextLinkPageNumber(int linkNumber, int pageNumber)
+{
+	m_fastTextLink[linkNumber].pageNumber = pageNumber;
+}
+
+int LevelOnePage::composeLinkFunction(int linkNumber) const
+{
+	return m_composeLink[linkNumber].function;
+}
+
+void LevelOnePage::setComposeLinkFunction(int linkNumber, int newFunction)
+{
+	m_composeLink[linkNumber].function = newFunction;
+}
+
+bool LevelOnePage::composeLinkLevel2p5(int linkNumber) const
+{
+	return m_composeLink[linkNumber].level2p5;
+}
+
+void LevelOnePage::setComposeLinkLevel2p5(int linkNumber, bool newRequired)
+{
+	m_composeLink[linkNumber].level2p5 = newRequired;
+}
+
+bool LevelOnePage::composeLinkLevel3p5(int linkNumber) const
+{
+	return m_composeLink[linkNumber].level3p5;
+}
+
+void LevelOnePage::setComposeLinkLevel3p5(int linkNumber, bool newRequired)
+{
+	m_composeLink[linkNumber].level3p5 = newRequired;
+}
+
+int LevelOnePage::composeLinkPageNumber(int linkNumber) const
+{
+	return m_composeLink[linkNumber].pageNumber;
+}
+
+void LevelOnePage::setComposeLinkPageNumber(int linkNumber, int newPageNumber)
+{
+	m_composeLink[linkNumber].pageNumber = newPageNumber;
+}
+
+int LevelOnePage::composeLinkSubPageCodes(int linkNumber) const
+{
+	return m_composeLink[linkNumber].subPageCodes;
+}
+
+void LevelOnePage::setComposeLinkSubPageCodes(int linkNumber, int newSubPageCodes)
+{
+	m_composeLink[linkNumber].subPageCodes = newSubPageCodes;
+}

src/qteletextdecoder/levelonepage.h

@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef LEVELONEPAGE_H
+#define LEVELONEPAGE_H
+
+#include <QByteArray>
+#include <QColor>
+#include <QObject>
+#include <QString>
+
+#include "pagex26base.h"
+#include "x26triplets.h"
+
+class LevelOnePage : public PageX26Base //: public QObject
+{
+	//Q_OBJECT
+
+public:
+	using PageX26Base::packet;
+	using PageX26Base::setPacket;
+	using PageX26Base::packetExists;
+
+	enum CycleTypeEnum { CTcycles, CTseconds };
+
+	LevelOnePage();
+	LevelOnePage(const PageBase &other);
+
+	bool isEmpty() const override;
+
+	QByteArray packet(int y, int d) const override;
+	bool setPacket(int y, int d, QByteArray pkt) override;
+	bool packetExists(int y, int d) const override;
+
+	bool setControlBit(int b, bool active) override;
+
+	void clearPage();
+
+	int maxEnhancements() const override;
+
+/*	void setSubPageNumber(int); */
+	int cycleValue() const;
+	void setCycleValue(int newValue);
+	CycleTypeEnum cycleType() const;
+	void setCycleType(CycleTypeEnum newType);
+	int defaultCharSet() const;
+	void setDefaultCharSet(int newDefaultCharSet);
+	int defaultNOS() const;
+	void setDefaultNOS(int defaultNOS);
+	int secondCharSet() const;
+	void setSecondCharSet(int newSecondCharSet);
+	int secondNOS() const;
+	void setSecondNOS(int newSecondNOS);
+	unsigned char character(int r, int c) const;
+	void setCharacter(int r, int c, unsigned char newChar);
+	int defaultScreenColour() const;
+	void setDefaultScreenColour(int newDefaultScreenColour);
+	int defaultRowColour() const;
+	void setDefaultRowColour(int newDefaultRowColour);
+	int colourTableRemap() const;
+	void setColourTableRemap(int newColourTableRemap);
+	bool blackBackgroundSubst() const;
+	void setBlackBackgroundSubst(bool newBlackBackgroundSubst);
+	int CLUT(int index, int renderLevel=3) const;
+	void setCLUT(int index, int newColour);
+	QColor CLUTtoQColor(int index, int renderlevel=3) const;
+	bool isPaletteDefault(int colour) const;
+	bool isPaletteDefault(int fromColour, int toColour) const;
+	int dCLUT(bool globalDrcs, int mode, int index) const;
+	void setDCLUT(bool globalDrcs, int mode, int index, int colour);
+	int levelRequired() const;
+	bool leftSidePanelDisplayed() const;
+	void setLeftSidePanelDisplayed(bool newLeftSidePanelDisplayed);
+	bool rightSidePanelDisplayed() const;
+	void setRightSidePanelDisplayed(bool newRightSidePanelDisplayed);
+	int sidePanelColumns() const;
+	void setSidePanelColumns(int newSidePanelColumns);
+	bool sidePanelStatusL25() const;
+	void setSidePanelStatusL25(bool newSidePanelStatusL25);
+	int fastTextLinkPageNumber(int linkNumber) const;
+	void setFastTextLinkPageNumber(int linkNumber, int pageNumber);
+	int composeLinkFunction(int linkNumber) const;
+	void setComposeLinkFunction(int linkNumber, int newFunction);
+	bool composeLinkLevel2p5(int linkNumber) const;
+	void setComposeLinkLevel2p5(int linkNumber, bool newRequired);
+	bool composeLinkLevel3p5(int linkNumber) const;
+	void setComposeLinkLevel3p5(int linkNumber, bool newRequired);
+	int composeLinkPageNumber(int linkNumber) const;
+	void setComposeLinkPageNumber(int linkNumber, int newPageNumber);
+	int composeLinkSubPageCodes(int linkNumber) const;
+	void setComposeLinkSubPageCodes(int linkNumber, int newSubPageCodes);
+
+private:
+/*	int m_subPageNumber; */
+	int m_cycleValue;
+	CycleTypeEnum m_cycleType;
+	int m_defaultCharSet, m_defaultNOS, m_secondCharSet, m_secondNOS;
+	int m_defaultScreenColour, m_defaultRowColour, m_colourTableRemap, m_sidePanelColumns;
+	bool m_blackBackgroundSubst, m_leftSidePanelDisplayed, m_rightSidePanelDisplayed, m_sidePanelStatusL25;
+	int m_CLUT[32];
+	struct fastTextLink {
+		int pageNumber;
+		int subPageNumber;
+	} m_fastTextLink[6];
+	struct composeLink {
+		int function;
+		bool level2p5, level3p5;
+		int pageNumber, subPageCodes;
+	} m_composeLink[8];
+
+	static constexpr int m_defaultCLUT[32] = {
+		0x000, 0xf00, 0x0f0, 0xff0, 0x00f, 0xf0f, 0x0ff, 0xfff,
+		0x000, 0x700, 0x070, 0x770, 0x007, 0x707, 0x077, 0x777,
+		0xf05, 0xf70, 0x0f7, 0xffb, 0x0ca, 0x500, 0x652, 0xc77,
+		0x333, 0xf77, 0x7f7, 0xff7, 0x77f, 0xf7f, 0x7ff, 0xddd
+	};
+};
+
+#endif

src/qteletextdecoder/pagebase.cpp

@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QByteArray>
+
+#include "pagebase.h"
+
+PageBase::PageBase()
+{
+	for (int b=PageBase::C4ErasePage; b<=PageBase::C14NOS; b++)
+		m_controlBits[b] = false;
+}
+
+PageBase::PageFunctionEnum PageBase::pageFunction() const
+{
+	return PFLevelOnePage;
+}
+
+PageBase::PacketCodingEnum PageBase::packetCoding() const
+{
+	return Coding7bit;
+}
+
+PageBase::PacketCodingEnum PageBase::packetCoding(int y, int d) const
+{
+	if (y == 27 && d < 4)
+		return Coding4bit;
+	else
+		return Coding18bit;
+}
+
+bool PageBase::isEmpty() const
+{
+	for (int y=0; y<26; y++)
+		if (!m_displayPackets[y].isEmpty())
+			return false;
+	for (int y=0; y<3; y++)
+		for (int d=0; d<16; d++)
+			if (!m_designationPackets[y][d].isEmpty())
+				return false;
+
+	return true;
+}
+
+QByteArray PageBase::packet(int y) const
+{
+	return m_displayPackets[y];
+}
+
+QByteArray PageBase::packet(int y, int d) const
+{
+	return m_designationPackets[y-26][d];
+}
+
+bool PageBase::setPacket(int y, QByteArray pkt)
+{
+	m_displayPackets[y] = pkt;
+
+	return true;
+}
+
+bool PageBase::setPacket(int y, int d, QByteArray pkt)
+{
+	m_designationPackets[y-26][d] = pkt;
+
+	return true;
+}
+
+bool PageBase::packetExists(int y) const
+{
+	return !m_displayPackets[y].isEmpty();
+}
+
+bool PageBase::packetExists(int y, int d) const
+{
+	return !m_designationPackets[y-26][d].isEmpty();
+}
+
+bool PageBase::clearPacket(int y)
+{
+	m_displayPackets[y] = QByteArray();
+
+	return true;
+}
+
+bool PageBase::clearPacket(int y, int d)
+{
+	m_designationPackets[y-26][d] = QByteArray();
+
+	return true;
+}
+
+void PageBase::clearAllPackets()
+{
+	for (int y=0; y<26; y++)
+		clearPacket(y);
+	for (int y=0; y<3; y++)
+		for (int d=0; d<16; d++)
+			clearPacket(y, d);
+}
+
+bool PageBase::controlBit(int b) const
+{
+	return m_controlBits[b];
+}
+
+bool PageBase::setControlBit(int b, bool active)
+{
+	m_controlBits[b] = active;
+	return true;
+}

src/qteletextdecoder/pagebase.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef PAGEBASE_H
+#define PAGEBASE_H
+
+#include <QByteArray>
+
+class PageBase
+{
+public:
+	enum ControlBitsEnum { C4ErasePage, C5Newsflash, C6Subtitle, C7SuppressHeader, C8Update, C9InterruptedSequence, C10InhibitDisplay, C11SerialMagazine, C12NOS, C13NOS, C14NOS };
+	// Available Page Functions according to 9.4.2.1 of the spec
+	enum PageFunctionEnum { PFLevelOnePage, PFDataBroadcasting, PFGlobalPOP, PFNormalPOP, PFGlobalDRCS, PFNormalDRCS, PFMOT, PFMIP, PFBasicTOPTable, PFAdditionalInformationTable, PFMultiPageTable, PFMultiPageExtensionTable, PFTriggerMessages };
+	// Available Page Codings of X/1 to X/25 according to 9.4.2.1 of the spec
+	enum PacketCodingEnum { Coding7bit, Coding8bit, Coding18bit, Coding4bit, Coding4bitThen7bit, CodingPerPacket };
+
+	PageBase();
+
+	virtual PageFunctionEnum pageFunction() const;
+	virtual PacketCodingEnum packetCoding() const;
+	virtual PacketCodingEnum packetCoding(int y, int d) const;
+
+	virtual bool isEmpty() const;
+
+	virtual QByteArray packet(int y) const;
+	virtual QByteArray packet(int y, int d) const;
+	virtual bool setPacket(int y, QByteArray pkt);
+	virtual bool setPacket(int y, int d, QByteArray pkt);
+	virtual bool packetExists(int y) const;
+	virtual bool packetExists(int y, int d) const;
+	virtual bool clearPacket(int y);
+	virtual bool clearPacket(int y, int d);
+	virtual void clearAllPackets();
+
+	virtual bool controlBit(int b) const;
+	virtual bool setControlBit(int b, bool active);
+
+private:
+	bool m_controlBits[11];
+	QByteArray m_displayPackets[26], m_designationPackets[3][16];
+};
+
+#endif

src/qteletextdecoder/pagex26base.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -21,20 +21,28 @@
 
 #include "pagex26base.h"
 
-QByteArray PageX26Base::packetFromEnhancementList(int packetNumber) const
+X26TripletList *PageX26Base::enhancements()
+{
+	return &m_enhancements;
+}
+
+QByteArray PageX26Base::packetFromEnhancementList(int p) const
 {
 	QByteArray result(40, 0x00);
 
-	int enhanceListPointer;
 	X26Triplet lastTriplet;
 
-	for (int i=0; i<13; i++) {
+	for (int t=0; t<13; t++) {
-		enhanceListPointer = packetNumber*13+i;
+		const int enhanceListPointer = p*13+t;
 
 		if (enhanceListPointer < m_enhancements.size()) {
-			result[i*3+1] = m_enhancements.at(enhanceListPointer).address();
+			if (!m_enhancements.at(enhanceListPointer).isValid())
-			result[i*3+2] = m_enhancements.at(enhanceListPointer).mode() | ((m_enhancements.at(enhanceListPointer).data() & 1) << 5);
+				result[t*3+1] = result[t*3+2] = result[t*3+3] = 0xff;
-			result[i*3+3] = m_enhancements.at(enhanceListPointer).data() >> 1;
+			else {
+				result[t*3+1] = m_enhancements.at(enhanceListPointer).address();
+				result[t*3+2] = m_enhancements.at(enhanceListPointer).mode() | ((m_enhancements.at(enhanceListPointer).data() & 1) << 5);
+				result[t*3+3] = m_enhancements.at(enhanceListPointer).data() >> 1;
+			}
 
 			// If this is the last triplet, get a copy to repeat to the end of the packet
 			if (enhanceListPointer == m_enhancements.size()-1) {
@@ -48,32 +56,36 @@ QByteArray PageX26Base::packetFromEnhancementList(int packetNumber) const
 			}
 		} else {
 			// We've gone past the end of the triplet list, so repeat the Termination Marker to the end
-			result[i*3+1] = lastTriplet.address();
+			result[t*3+1] = lastTriplet.address();
-			result[i*3+2] = lastTriplet.mode() | ((lastTriplet.data() & 1) << 5);
+			result[t*3+2] = lastTriplet.mode() | ((lastTriplet.data() & 1) << 5);
-			result[i*3+3] = lastTriplet.data() >> 1;
+			result[t*3+3] = lastTriplet.data() >> 1;
 		}
 	}
 
 	return result;
 }
 
-void PageX26Base::setEnhancementListFromPacket(int packetNumber, QByteArray packetContents)
+void PageX26Base::setEnhancementListFromPacket(int p, QByteArray pkt)
 {
 	// Preallocate entries in the m_enhancements list to hold our incoming triplets.
-	// We write "dummy" reserved 11110 Row Triplets in the allocated entries which then get overwritten by the packet contents.
+	// We write invalid triplets in the allocated entries which then get overwritten by the packet contents.
 	// This is in case of missing packets so we can keep Local Object pointers valid.
-	while (m_enhancements.size() < (packetNumber+1)*13)
+	while (m_enhancements.size() < (p+1)*13)
-		m_enhancements.append(m_paddingX26Triplet);
+		m_enhancements.append( X26Triplet{ 0xff, 0xff, 0xff } );
 
-	int enhanceListPointer;
 	X26Triplet newX26Triplet;
 
-	for (int i=0; i<13; i++) {
+	for (int t=0; t<13; t++) {
-		enhanceListPointer = packetNumber*13+i;
+		const int enhanceListPointer = p*13+t;
 
-		newX26Triplet.setAddress(packetContents.at(i*3+1) & 0x3f);
+		// Need the "& 0xff" since QByteArray.at() returns (signed) chars
-		newX26Triplet.setMode(packetContents.at(i*3+2) & 0x1f);
+		if ((pkt.at(t*3+2) & 0xff) == 0xff)
-		newX26Triplet.setData(((packetContents.at(i*3+3) & 0x3f) << 1) | ((packetContents.at(i*3+2) & 0x20) >> 5));
+			newX26Triplet.setInvalid();
+		else {
+			newX26Triplet.setAddress(pkt.at(t*3+1) & 0x3f);
+			newX26Triplet.setMode(pkt.at(t*3+2) & 0x1f);
+			newX26Triplet.setData(((pkt.at(t*3+3) & 0x3f) << 1) | ((pkt.at(t*3+2) & 0x20) >> 5));
+		}
 		m_enhancements.replace(enhanceListPointer, newX26Triplet);
 	}
 	if (newX26Triplet.mode() == 0x1f && newX26Triplet.address() == 0x3f && newX26Triplet.data() & 0x01)
@@ -81,3 +93,8 @@ void PageX26Base::setEnhancementListFromPacket(int packetNumber, QByteArray pack
 		while (m_enhancements.size()>1 && m_enhancements.at(m_enhancements.size()-2).mode() == 0x1f && m_enhancements.at(m_enhancements.size()-2).address() == 0x3f && m_enhancements.at(m_enhancements.size()-2).data() == newX26Triplet.data())
 			m_enhancements.removeLast();
 }
+
+bool PageX26Base::packetFromEnhancementListNeeded(int n) const
+{
+	return ((m_enhancements.size()+12) / 13) > n;
+}

src/qteletextdecoder/pagex26base.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -26,21 +26,18 @@
 #include "pagebase.h"
 #include "x26triplets.h"
 
-class PageX26Base : public PageBase //: public QObject
+class PageX26Base : public PageBase
 {
-	//Q_OBJECT
-
 public:
-	X26TripletList *enhancements() { return &m_enhancements; };
+	X26TripletList *enhancements();
 	virtual int maxEnhancements() const =0;
 
 protected:
-	QByteArray packetFromEnhancementList(int) const;
+	QByteArray packetFromEnhancementList(int p) const;
-	void setEnhancementListFromPacket(int, QByteArray);
+	void setEnhancementListFromPacket(int p, QByteArray pkt);
-	bool packetFromEnhancementListNeeded(int n) const { return ((m_enhancements.size()+12) / 13) > n; };
+	bool packetFromEnhancementListNeeded(int n) const;
 
 	X26TripletList m_enhancements;
-	const X26Triplet m_paddingX26Triplet { 41, 0x1e, 0 };
 };
 
 #endif

src/qteletextdecoder/render.cpp

@@ -0,0 +1,506 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QBitmap>
+#include <QColor>
+#include <QDir>
+#include <QImage>
+#include <QPainter>
+#include <QPixmap>
+
+#include "render.h"
+
+#include "decode.h"
+
+int TeletextFontBitmap::s_instances = 0;
+
+QBitmap *TeletextFontBitmap::s_fontBitmap = nullptr;
+QImage *TeletextFontBitmap::s_fontImage = nullptr;
+
+TeletextFontBitmap::TeletextFontBitmap()
+{
+	Q_INIT_RESOURCE(teletextfonts);
+
+	if (s_instances == 0) {
+		s_fontBitmap = new QBitmap(":/fontimages/teletextfont.png");
+		s_fontImage = new QImage(s_fontBitmap->toImage());
+	}
+	s_instances++;
+}
+
+TeletextFontBitmap::~TeletextFontBitmap()
+{
+	s_instances--;
+	if (s_instances == 0) {
+		delete s_fontImage;
+		delete s_fontBitmap;
+	}
+}
+
+
+TeletextPageRender::TeletextPageRender()
+{
+	for (int i=0; i<6; i++)
+		m_pageImage[i] = new QImage(864, 250, QImage::Format_ARGB32_Premultiplied);
+
+	m_reveal = false;
+	m_renderMode = RenderNormal;
+	m_showControlCodes = false;
+	m_flashBuffersHz = 0;
+
+	for (int r=0; r<25; r++) {
+		m_flashingRow[r] = 0;
+		for (int c=0; c<40; c++)
+			m_controlCodeCache[r][c] = 0x7f;
+	}
+}
+
+TeletextPageRender::~TeletextPageRender()
+{
+	for (int i=0; i<6; i++)
+		delete m_pageImage[i];
+}
+
+void TeletextPageRender::setDecoder(TeletextPageDecode *decoder)
+{
+	m_decoder = decoder;
+}
+
+inline void TeletextPageRender::drawFromBitmap(QPainter &painter, int r, int c, const QImage image, TeletextPageDecode::CharacterFragment characterFragment)
+{
+	switch (characterFragment) {
+		case TeletextPageDecode::NormalSize:
+			painter.drawImage(c*12, r*10, image);
+			break;
+		case TeletextPageDecode::DoubleHeightTopHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 0, 12, 5));
+			break;
+		case TeletextPageDecode::DoubleHeightBottomHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 5, 12, 5));
+			break;
+		case TeletextPageDecode::DoubleWidthLeftHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 0, 6, 10));
+			break;
+		case TeletextPageDecode::DoubleWidthRightHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(6, 0, 6, 10));
+			break;
+		case TeletextPageDecode::DoubleSizeTopLeftQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 0, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeTopRightQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(6, 0, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(0, 5, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeBottomRightQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), image, QRect(6, 5, 6, 5));
+			break;
+	}
+}
+
+inline void TeletextPageRender::drawFromFontBitmap(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment)
+{
+	switch (characterFragment) {
+		case TeletextPageDecode::NormalSize:
+			painter.drawImage(c*12, r*10, *m_fontBitmap.image(), (characterCode-32)*12, characterSet*10, 12, 10);
+			break;
+		case TeletextPageDecode::DoubleHeightTopHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10, 12, 5));
+			break;
+		case TeletextPageDecode::DoubleHeightBottomHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10+5, 12, 5));
+			break;
+		case TeletextPageDecode::DoubleWidthLeftHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10, 6, 10));
+			break;
+		case TeletextPageDecode::DoubleWidthRightHalf:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12+6, characterSet*10, 6, 10));
+			break;
+		case TeletextPageDecode::DoubleSizeTopLeftQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeTopRightQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12+6, characterSet*10, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12, characterSet*10+5, 6, 5));
+			break;
+		case TeletextPageDecode::DoubleSizeBottomRightQuarter:
+			painter.drawImage(QRect(c*12, r*10, 12, 10), *m_fontBitmap.image(), QRect((characterCode-32)*12+6, characterSet*10+5, 6, 5));
+			break;
+	}
+}
+
+inline void TeletextPageRender::drawCharacter(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, int characterDiacritical, TeletextPageDecode::CharacterFragment characterFragment)
+{
+	const bool dontUnderline = characterCode == 0x00;
+	if (dontUnderline)
+		characterCode = 0x20;
+
+	// Set 24 has reduced height Latin G0 capital letters for diacritical marks to sit on top of
+	if (characterDiacritical != 0  && // Not for no-diacritical-mark
+	    characterDiacritical != 9  && // Not for these diacriticals that go under the letter
+	    characterDiacritical != 11 &&
+	    characterDiacritical != 12 &&
+	    characterDiacritical != 14 &&
+	    (characterSet == 0 || characterSet == 6) &&     // Only for Latin G0 and Hebrew G0
+	    characterCode >= 0x41 && characterCode <= 0x5a) // and only for the capital letters A-Z
+		characterSet = 24;
+
+	if (characterCode == 0x20 && characterSet < 25 && characterDiacritical == 0)
+		painter.fillRect(c*12, r*10, 12, 10, m_backgroundQColor);
+	else if (characterCode == 0x7f && characterSet == 24)
+		painter.fillRect(c*12, r*10, 12, 10, m_foregroundQColor);
+	else if ((m_decoder->cellBold(r, c) || m_decoder->cellItalic(r, c)))
+		drawBoldOrItalicCharacter(painter, r, c, characterCode, characterSet, characterFragment);
+	else {
+		m_fontBitmap.image()->setColorTable(QList<QRgb>{m_backgroundQColor.rgba(), m_foregroundQColor.rgba()});
+		drawFromFontBitmap(painter, r, c, characterCode, characterSet, characterFragment);
+	}
+
+	if (m_decoder->cellUnderlined(r, c) && !dontUnderline) {
+		painter.setPen(m_foregroundQColor);
+		switch (characterFragment) {
+			case TeletextPageDecode::NormalSize:
+			case TeletextPageDecode::DoubleWidthLeftHalf:
+			case TeletextPageDecode::DoubleWidthRightHalf:
+				painter.drawLine(c*12, r*10+9, c*12+11, r*10+9);
+				break;
+			case TeletextPageDecode::DoubleHeightBottomHalf:
+			case TeletextPageDecode::DoubleSizeBottomLeftQuarter:
+			case TeletextPageDecode::DoubleSizeBottomRightQuarter:
+				painter.drawRect(c*12, r*10+8, 11, 1);
+				break;
+			default:
+				break;
+		}
+	}
+
+	if (characterDiacritical != 0) {
+		painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+		m_fontBitmap.image()->setColorTable(QList<QRgb>{0x00000000, m_foregroundQColor.rgba()});
+		drawFromFontBitmap(painter, r, c, characterDiacritical+64, 7, characterFragment);
+		painter.setCompositionMode(QPainter::CompositionMode_Source);
+	}
+}
+
+inline bool TeletextPageRender::drawDRCSCharacter(QPainter &painter, int r, int c, TeletextPageDecode::DRCSSource drcsSource, int drcsSubTable, int drcsChar, TeletextPageDecode::CharacterFragment characterFragment, bool flashPhOn)
+{
+	QImage drcsImage = m_decoder->drcsImage(drcsSource, drcsSubTable, drcsChar, flashPhOn);
+
+	if (drcsImage.isNull())
+		return false;
+
+	if (drcsImage.format() == QImage::Format_Mono)
+		// mode 0 (12x10x1) returned here has no colours of its own
+		// so apply the foreground and background colours of the cell it appears in
+		drcsImage.setColorTable(QVector<QRgb>{m_backgroundQColor.rgba(), m_foregroundQColor.rgba()});
+	else if (m_renderMode >= RenderWhiteOnBlack)
+		// modes 1-3: crudely convert colours to monochrome
+		for (int i=0; i<16; i++)
+			drcsImage.setColor(i, qGray(drcsImage.color(i)) > 127 ? 0xffffffff : 0xff000000);
+
+	drawFromBitmap(painter, r, c, drcsImage, characterFragment);
+
+	return true;
+}
+
+inline void TeletextPageRender::drawBoldOrItalicCharacter(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment)
+{
+	QImage styledImage = QImage(12, 10, QImage::Format_Mono);
+	QPainter styledPainter;
+
+	// Don't apply style to mosaics
+	const bool mosaic = characterSet > 24 || (characterSet == 24 && (characterCode < 0x41 || characterCode > 0x5a));
+
+	m_fontBitmap.image()->setColorTable(QList<QRgb>{m_backgroundQColor.rgba(), m_foregroundQColor.rgba()});
+	styledImage.setColorTable(QList<QRgb>{m_backgroundQColor.rgba(), m_foregroundQColor.rgba()});
+
+	if (!mosaic && m_decoder->cellItalic(r, c)) {
+		styledImage.fill(0);
+
+		styledPainter.begin(&styledImage);
+		styledPainter.setCompositionMode(QPainter::CompositionMode_Source);
+		styledPainter.drawImage(1, 0, *m_fontBitmap.image(), (characterCode-32)*12, characterSet*10, 11, 3);
+		styledPainter.drawImage(0, 3, *m_fontBitmap.image(), (characterCode-32)*12, characterSet*10+3, 12, 3);
+		styledPainter.drawImage(0, 6, *m_fontBitmap.image(), (characterCode-32)*12+1, characterSet*10+6, 11, 4);
+		styledPainter.end();
+	} else
+		styledImage = m_fontBitmap.image()->copy((characterCode-32)*12, characterSet*10, 12, 10);
+
+	// We have either an unstyled or italic character. Now bolden if needed.
+	if (!mosaic && m_decoder->cellBold(r, c)) {
+		QImage boldeningImage;
+
+		boldeningImage = styledImage.copy();
+		styledPainter.begin(&styledImage);
+		styledPainter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+		boldeningImage.setColorTable(QList<QRgb>{0x00000000, m_foregroundQColor.rgba()});
+		styledPainter.drawImage(1, 0, boldeningImage);
+		styledPainter.end();
+	}
+	drawFromBitmap(painter, r, c, styledImage, characterFragment);
+}
+
+void TeletextPageRender::renderPage(bool force)
+{
+	if (m_renderMode == RenderWhiteOnBlack) {
+		m_foregroundQColor = Qt::white;
+		m_backgroundQColor = Qt::black;
+	} else if (m_renderMode == RenderBlackOnWhite) {
+		m_foregroundQColor = Qt::black;
+		m_backgroundQColor = Qt::white;
+	}
+	for (int r=0; r<25; r++)
+		renderRow(r, 0, force);
+}
+
+void TeletextPageRender::renderRow(int r, int ph, bool force)
+{
+	QPainter painter;
+	int flashingRow = 0;
+	bool rowRefreshed = false;
+
+	painter.begin(m_pageImage[ph]);
+	painter.setCompositionMode(QPainter::CompositionMode_Source);
+
+	for (int c=0; c<72; c++) {
+		bool controlCodeChanged = false;
+
+		// Ensure that shown control codes are refreshed
+		if (ph == 0 && m_showControlCodes && c < 40 && (m_controlCodeCache[r][c] != 0x7f || m_decoder->teletextPage()->character(r, c) < 0x20)) {
+			controlCodeChanged = m_controlCodeCache[r][c] != m_decoder->teletextPage()->character(r, c);
+			if (controlCodeChanged) {
+				if (m_decoder->teletextPage()->character(r, c) < 0x20)
+					m_controlCodeCache[r][c] = m_decoder->teletextPage()->character(r, c);
+				else
+					m_controlCodeCache[r][c] = 0x7f;
+			}
+		}
+
+		// Second part of "if" suppresses all flashing on monochrome render modes
+		if (ph == 0 && m_renderMode < RenderWhiteOnBlack) {
+			if (m_decoder->cellFlashMode(r, c) != 0)
+				flashingRow = qMax(flashingRow, (m_decoder->cellFlashRatePhase(r, c) == 0) ? 1 : 2);
+//		} else if (!force)
+		} else
+			force = m_decoder->cellFlashMode(r, c) != 0;
+
+		// If drawing into a flash pixmap buffer, "force" is set on a flashing cell only
+		// and since the refresh and controlCodeChanged variables will be false at this point
+		// only flashing cells will be drawn
+		if (m_decoder->refresh(r, c) || force || controlCodeChanged) {
+			bool flashPhOn = true; // Must remain "true" on non-flashing cell
+			const bool concealed = !m_reveal && m_decoder->cellConceal(r, c);
+
+			rowRefreshed = true;
+
+			if (m_renderMode < RenderWhiteOnBlack) {
+				if (m_decoder->cellFlashMode(r, c) == 0)
+					m_foregroundQColor = m_decoder->cellForegroundQColor(r, c);
+				else {
+					// Flashing cell, decide if phase in this cycle is on or off
+					if (m_decoder->cellFlashRatePhase(r, c) == 0)
+						flashPhOn = (ph < 3) ^ (m_decoder->cellFlashMode(r, c) == 2);
+					else
+						flashPhOn = ((ph == m_decoder->cellFlash2HzPhaseNumber(r, c)-1) || (ph == m_decoder->cellFlash2HzPhaseNumber(r, c)+2)) ^ (m_decoder->cellFlashMode(r, c) == 2);
+
+					// If flashing to adjacent CLUT select the appropriate foreground colour
+					if (m_decoder->cellFlashMode(r, c) == 3 && !flashPhOn)
+						m_foregroundQColor = m_decoder->cellFlashForegroundQColor(r, c);
+					else
+						m_foregroundQColor = m_decoder->cellForegroundQColor(r, c);
+				}
+
+				if (m_renderMode != RenderMix || m_decoder->cellBoxed(r, c))
+					m_backgroundQColor = m_decoder->cellBackgroundQColor(r, c);
+				else
+					m_backgroundQColor = Qt::transparent;
+			}
+
+			if (((m_decoder->cellFlashMode(r, c) == 1 || m_decoder->cellFlashMode(r, c) == 2) && !flashPhOn))
+				// If flashing mode is Normal or Invert, draw a space instead of a character on phase
+				// Character 0x00 draws space without underline
+				drawCharacter(painter, r, c, 0x00, 0, 0, m_decoder->cellCharacterFragment(r, c));
+			else if (concealed)
+				drawCharacter(painter, r, c, 0x20, 0, 0, m_decoder->cellCharacterFragment(r, c));
+			else if (m_decoder->cellDrcsSource(r, c) == TeletextPageDecode::NoDRCS || !drawDRCSCharacter(painter, r, c, m_decoder->cellDrcsSource(r, c), m_decoder->cellDrcsSubTable(r, c), m_decoder->cellDrcsCharacter(r, c), m_decoder->cellCharacterFragment(r, c), flashPhOn))
+				drawCharacter(painter, r, c, m_decoder->cellCharacterCode(r, c), m_decoder->cellCharacterSet(r, c), m_decoder->cellCharacterDiacritical(r, c), m_decoder->cellCharacterFragment(r, c));
+
+			if (m_showControlCodes && c < 40 && m_decoder->teletextPage()->character(r, c) < 0x20) {
+				painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
+				m_fontBitmap.image()->setColorTable(QList<QRgb>{0x7f000000, 0xe0ffffff});
+				painter.drawImage(c*12, r*10, *m_fontBitmap.image(), (m_decoder->teletextPage()->character(r, c)+32)*12, 250, 12, 10);
+				painter.setCompositionMode(QPainter::CompositionMode_Source);
+			}
+		}
+	}
+
+	painter.end();
+
+	if (ph != 0)
+		return;
+
+	if (flashingRow == 3)
+		flashingRow = 2;
+	if (flashingRow != m_flashingRow[r])
+		setRowFlashStatus(r, flashingRow);
+
+	for (int c=0; c<72; c++)
+		m_decoder->setRefresh(r, c, false);
+
+	// If row had changes rendered and flashing is present anywhere on the screen,
+	// copy this rendered line into the other flash pixmap buffers and then re-render
+	// the flashing cells in those buffers
+	if (rowRefreshed && m_flashBuffersHz > 0) {
+		painter.begin(m_pageImage[3]);
+		painter.setCompositionMode(QPainter::CompositionMode_Source);
+		painter.drawImage(0, r*10, *m_pageImage[0], 0, r*10, 864, 10);
+		painter.end();
+
+		renderRow(r, 3);
+
+		if (m_flashBuffersHz == 2) {
+			painter.begin(m_pageImage[1]);
+			painter.setCompositionMode(QPainter::CompositionMode_Source);
+			painter.drawImage(0, r*10, *m_pageImage[0], 0, r*10, 864, 10);
+			painter.end();
+			painter.begin(m_pageImage[2]);
+			painter.setCompositionMode(QPainter::CompositionMode_Source);
+			painter.drawImage(0, r*10, *m_pageImage[0], 0, r*10, 864, 10);
+			painter.end();
+			painter.begin(m_pageImage[4]);
+			painter.setCompositionMode(QPainter::CompositionMode_Source);
+			painter.drawImage(0, r*10, *m_pageImage[3], 0, r*10, 864, 10);
+			painter.end();
+			painter.begin(m_pageImage[5]);
+			painter.setCompositionMode(QPainter::CompositionMode_Source);
+			painter.drawImage(0, r*10, *m_pageImage[3], 0, r*10, 864, 10);
+			painter.end();
+
+			renderRow(r, 1);
+			renderRow(r, 2);
+			renderRow(r, 4);
+			renderRow(r, 5);
+		}
+	}
+}
+
+void TeletextPageRender::setRowFlashStatus(int r, int rowFlashHz)
+{
+	m_flashingRow[r] = rowFlashHz;
+
+	if (rowFlashHz == m_flashBuffersHz)
+		return;
+
+	if (rowFlashHz < m_flashBuffersHz) {
+		// New flash Hz for this row is lower than the entire screen flash Hz
+		// Check the other rows if they still need flashing at the current flash Hz
+		// If not, reduce the screen flash Hz
+		int highestRowFlashHz = rowFlashHz;
+
+		for (int ri=0; ri<25; ri++)
+			if (m_flashingRow[ri] > highestRowFlashHz) {
+				highestRowFlashHz = m_flashingRow[ri];
+				if (highestRowFlashHz == 2)
+					break;
+			}
+
+		if (highestRowFlashHz > rowFlashHz)
+			rowFlashHz = highestRowFlashHz;
+		if (rowFlashHz == m_flashBuffersHz)
+			return;
+
+		m_flashBuffersHz = rowFlashHz;
+		emit flashChanged(m_flashBuffersHz);
+		return;
+	}
+
+	// If we get here, new flash Hz for this row is higher than the entire flash Hz
+	// so prepare the pixmap flash buffers
+	if (m_flashBuffersHz == 0)
+		*m_pageImage[3] = m_pageImage[0]->copy();
+	if (rowFlashHz == 2) {
+		*m_pageImage[1] = m_pageImage[0]->copy();
+		*m_pageImage[2] = m_pageImage[0]->copy();
+		*m_pageImage[4] = m_pageImage[3]->copy();
+		*m_pageImage[5] = m_pageImage[3]->copy();
+	}
+
+	m_flashBuffersHz = rowFlashHz;
+	emit flashChanged(m_flashBuffersHz);
+}
+
+void TeletextPageRender::colourChanged(int index)
+{
+	for (int r=0; r<25; r++)
+		for (int c=0; c<72; c++) {
+			if (m_decoder->cellForegroundCLUT(r, c) == index || m_decoder->cellBackgroundCLUT(r, c) == index || m_decoder->cellForegroundCLUT(r, c) == 8 || m_decoder->cellBackgroundCLUT(r, c) == 8)
+				m_decoder->setRefresh(r, c, true);
+			if (m_decoder->cellFlashMode(r, c) == 3 && ((m_decoder->cellForegroundCLUT(r, c) ^ 8) == index || (m_decoder->cellForegroundCLUT(r, c) ^ 8) == 8))
+				m_decoder->setRefresh(r, c, true);
+		}
+
+	if (m_decoder->level() == 3)
+		// TODO don't refresh mode 0 DRCS
+		for (int r=0; r<25; r++)
+			for (int c=0; c<72; c++)
+				if (m_decoder->cellDrcsSource(r, c) != TeletextPageDecode::NoDRCS)
+					m_decoder->setRefresh(r, c, true);
+}
+
+void TeletextPageRender::setReveal(bool reveal)
+{
+	if (reveal == m_reveal)
+		return;
+
+	m_reveal = reveal;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<72; c++)
+			if (m_decoder->cellConceal(r, c))
+				m_decoder->setRefresh(r, c, true);
+}
+
+void TeletextPageRender::setRenderMode(RenderMode renderMode)
+{
+	if (renderMode == m_renderMode)
+		return;
+
+	m_renderMode = renderMode;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<72; c++)
+			m_decoder->setRefresh(r, c, true);
+}
+
+
+void TeletextPageRender::setShowControlCodes(bool showControlCodes)
+{
+	if (showControlCodes == m_showControlCodes)
+		return;
+
+	m_showControlCodes = showControlCodes;
+
+	for (int r=0; r<25; r++)
+		for (int c=0; c<40; c++)
+			if (m_decoder->teletextPage()->character(r, c) < 0x20)
+				m_decoder->setRefresh(r, c, true);
+}

src/qteletextdecoder/render.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef RENDER_H
+#define RENDER_H
+
+#include <QBitmap>
+#include <QColor>
+#include <QIcon>
+#include <QImage>
+#include <QPixmap>
+
+#include "decode.h"
+
+class TeletextFontBitmap
+{
+public:
+	TeletextFontBitmap();
+	~TeletextFontBitmap();
+
+	QImage *image() const { return s_fontImage; }
+	QPixmap charBitmap(int c, int s) const { return s_fontBitmap->copy((c-32)*12, s*10, 12, 10); }
+	QIcon charIcon(int c, int s) const { return QIcon(charBitmap(c, s)); }
+
+private:
+	static int s_instances;
+	static QBitmap* s_fontBitmap;
+	static QImage* s_fontImage;
+};
+
+class TeletextPageRender : public QObject
+{
+	Q_OBJECT
+
+public:
+	enum RenderMode { RenderNormal, RenderMix, RenderWhiteOnBlack, RenderBlackOnWhite };
+
+	TeletextPageRender();
+	~TeletextPageRender();
+
+	QImage* image(int i) const { return m_pageImage[i]; };
+	RenderMode renderMode() const { return m_renderMode; };
+	void setDecoder(TeletextPageDecode *decoder);
+	void renderPage(bool force=false);
+	bool showControlCodes() const { return m_showControlCodes; };
+
+public slots:
+	void colourChanged(int index);
+	void setReveal(bool reveal);
+	void setRenderMode(RenderMode renderMode);
+	void setShowControlCodes(bool showControlCodes);
+
+signals:
+	void flashChanged(int newFlashHz);
+
+protected:
+	TeletextFontBitmap m_fontBitmap;
+	QImage* m_pageImage[6];
+	unsigned char m_controlCodeCache[25][40];
+	RenderMode m_renderMode;
+	bool m_reveal, m_showControlCodes;
+	int m_flashBuffersHz;
+	int m_flashingRow[25];
+
+private:
+	inline void drawFromBitmap(QPainter &painter, int r, int c, const QImage image, TeletextPageDecode::CharacterFragment characterFragment);
+	inline void drawFromFontBitmap(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment);
+	inline void drawCharacter(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, int characterDiacritical, TeletextPageDecode::CharacterFragment characterFragment);
+	inline bool drawDRCSCharacter(QPainter &painter, int r, int c, TeletextPageDecode::DRCSSource drcsSource, int drcsSubTable, int drcsChar, TeletextPageDecode::CharacterFragment characterFragment, bool flashPhOn = true);
+	inline void drawBoldOrItalicCharacter(QPainter &painter, int r, int c, unsigned char characterCode, int characterSet, TeletextPageDecode::CharacterFragment characterFragment);
+	void renderRow(int r, int ph, bool force=false);
+	void setRowFlashStatus(int r, int rowFlashHz);
+
+	QColor m_foregroundQColor, m_backgroundQColor;
+	TeletextPageDecode *m_decoder;
+};
+
+#endif

src/qteletextdecoder/teletextfonts.qrc

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

src/qteletextdecoder/x26triplets.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -26,6 +26,51 @@ X26Triplet::X26Triplet(int address, int mode, int data)
 	m_data = data;
 }
 
+bool X26Triplet::isValid() const
+{
+	return m_mode != 0xff;
+}
+
+int X26Triplet::address() const
+{
+	return m_address;
+}
+
+int X26Triplet::mode() const
+{
+	return m_mode;
+}
+
+int X26Triplet::modeExt() const
+{
+	return (m_address >= 40) ? m_mode : (m_mode | 0x20);
+}
+
+int X26Triplet::data() const
+{
+	return m_data;
+}
+
+int X26Triplet::addressRow() const
+{
+	return (m_address == 40) ? 24 :m_address-40;
+}
+
+int X26Triplet::addressColumn() const
+{
+	return (m_address);
+}
+
+bool X26Triplet::isRowTriplet() const
+{
+	return (m_address >= 40);
+}
+
+void X26Triplet::setInvalid()
+{
+	m_address = m_mode = m_data = 0xff;
+}
+
 void X26Triplet::setAddress(int address)
 {
 	m_address = address;
@@ -51,6 +96,26 @@ void X26Triplet::setAddressColumn(int addressColumn)
 	m_address = addressColumn;
 }
 
+int X26Triplet::objectSource() const
+{
+	return (m_address & 0x18) >> 3;
+}
+
+int X26Triplet::objectLocalDesignationCode() const
+{
+	return (((m_address & 0x01) << 3) | (m_data >> 4));
+}
+
+int X26Triplet::objectLocalTripletNumber() const
+{
+	return m_data & 0x0f;
+}
+
+int X26Triplet::objectLocalIndex() const
+{
+	return objectLocalDesignationCode() * 13 + objectLocalTripletNumber();
+}
+
 void X26Triplet::setObjectLocalDesignationCode(int i)
 {
 	m_address = (m_address & 0x38) | (i >> 3);
@@ -68,12 +133,56 @@ void X26Triplet::setObjectLocalIndex(int i)
 	m_data = (((i / 13) & 0x07) << 4) | (i % 13);
 }
 
+int X26Triplet::activePositionRow() const
+{
+	return m_activePositionRow;
+}
+
+int X26Triplet::activePositionColumn() const
+{
+	return m_activePositionColumn;
+}
+
+int X26Triplet::activePositionRow1p5() const
+{
+	return m_activePositionRow1p5;
+}
+
+int X26Triplet::activePositionColumn1p5() const
+{
+	return m_activePositionColumn1p5;
+}
+
+X26Triplet::X26TripletError X26Triplet::error() const
+{
+	return m_error;
+}
+
+bool X26Triplet::reservedMode() const
+{
+	return m_reservedMode;
+}
+
+bool X26Triplet::reservedData() const
+{
+	return m_reservedData;
+}
+
+bool X26Triplet::activePosition1p5Differs() const
+{
+	return m_activePosition1p5Differs;
+}
+
 
 void X26TripletList::updateInternalData()
 {
 	ActivePosition activePosition;
 	X26Triplet *triplet;
 
+	m_objects[0].clear();
+	m_objects[1].clear();
+	m_objects[2].clear();
+
 	// Check for errors, and fill in where the Active Position goes for Level 2.5 and above
 	for (int i=0; i < m_list.size(); i++) {
 		triplet = &m_list[i];
@@ -81,7 +190,9 @@ void X26TripletList::updateInternalData()
 		triplet->m_reservedMode = false;
 		triplet->m_reservedData = false;
 
-		if (triplet->isRowTriplet()) {
+		if (!triplet->isValid())
+			triplet->m_error = X26Triplet::ErrorDecodingTriplet;
+		else if (triplet->isRowTriplet()) {
 			switch (triplet->modeExt()) {
 				case 0x00: // Full screen colour
 					if (activePosition.isDeployed())
@@ -124,7 +235,9 @@ void X26TripletList::updateInternalData()
 					    m_list.at(i+1).modeExt() > 0x13)
 						triplet->m_error = X26Triplet::OriginModifierAlone;
 					break;
-				case 0x11 ... 0x13: // Invoke Object
+				case 0x11: // Invoke Active Object
+				case 0x12: // Invoke Adaptive Object
+				case 0x13: // Invoke Passive Object
 					if (triplet->objectSource() == X26Triplet::LocalObject) {
 						if (triplet->objectLocalTripletNumber() > 12 ||
 							triplet->objectLocalIndex() > (m_list.size()-1) ||
@@ -135,7 +248,10 @@ void X26TripletList::updateInternalData()
 							triplet->m_error = X26Triplet::InvokeTypeMismatch;
 					}
 					break;
-				case 0x15 ... 0x17: // Define Object
+				case 0x15: // Define Active Object
+				case 0x16: // Define Adaptive Object
+				case 0x17: // Define Passive Object
+					m_objects[triplet->modeExt() - 0x15].append(i);
 					activePosition.reset();
 					// Make sure data field holds correct place of triplet
 					// otherwise the object won't appear
@@ -145,7 +261,12 @@ void X26TripletList::updateInternalData()
 					if ((triplet->m_data & 0x30) == 0x00)
 						triplet->m_reservedData = true;
 				case 0x1f: // Termination marker
-				case 0x08 ... 0x0d: // PDC
+				case 0x08: // PDC country of origin & programme source
+				case 0x09: // PDC month & day
+				case 0x0a: // PDC cursor row & announced start hour
+				case 0x0b: // PDC cursor row & announced finish hour
+				case 0x0c: // PDC cursor row & local time offset
+				case 0x0d: // PDC series ID & series code
 					break;
 				default:
 					triplet->m_reservedMode = true;
@@ -158,18 +279,10 @@ void X26TripletList::updateInternalData()
 		else
 			switch (triplet->modeExt()) {
 				case 0x20: // Foreground colour
-				case 0x23: // Foreground colour
+				case 0x23: // Background 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;
@@ -193,6 +306,19 @@ void X26TripletList::updateInternalData()
 					if ((triplet->m_data & 0x3f) >= 48)
 						// Should really be an error?
 						triplet->m_reservedData = true;
+					break;
+				case 0x21: // G1 mosaic character
+				case 0x22: // G3 mosaic character at level 1.5
+				case 0x29: // G0 character
+				case 0x2b: // G3 mosaic character at level >=2.5
+				case 0x2f: // G2 character
+					if (triplet->m_data < 0x20)
+						triplet->m_reservedData = true;
+					break;
+				default:
+					if (triplet->modeExt() >= 0x30 && triplet->modeExt() <= 0x3f && triplet->m_data < 0x20)
+						// G0 diacritical mark
+						triplet->m_reservedData = true;
 			}
 
 		triplet->m_activePositionRow = activePosition.row();
@@ -217,15 +343,25 @@ void X26TripletList::updateInternalData()
 					activePosition.setColumn(8);
 				break;
 			case 0x22: // G3 mosaic character at level 1.5
-			case 0x2f ... 0x3f: // G2 character or G0 diacritical mark
+			case 0x2f: // G2 character
 				activePosition.setColumn(triplet->addressColumn());
+
+				if (activePosition.row() != triplet->m_activePositionRow || activePosition.column() != triplet->m_activePositionColumn)
+					triplet->m_activePosition1p5Differs = true;
 				break;
+			default:
+				if (triplet->modeExt() >= 0x30 && triplet->modeExt() <= 0x3f) {
+					// G0 diacritical mark
+					activePosition.setColumn(triplet->addressColumn());
+
+					if (activePosition.row() != triplet->m_activePositionRow || activePosition.column() != triplet->m_activePositionColumn)
+						triplet->m_activePosition1p5Differs = true;
+				}
 		}
 
 		triplet->m_activePositionRow1p5 = activePosition.row();
 		triplet->m_activePositionColumn1p5 = activePosition.column();
 	}
-
 }
 
 void X26TripletList::append(const X26Triplet &value)
@@ -253,6 +389,35 @@ void X26TripletList::replace(int i, const X26Triplet &value)
 	updateInternalData();
 }
 
+void X26TripletList::removeLast()
+{
+	m_list.removeLast();
+}
+
+const X26Triplet &X26TripletList::at(int i) const
+{
+	return m_list.at(i);
+}
+
+bool X26TripletList::isEmpty() const
+{
+	return m_list.isEmpty();
+}
+
+void X26TripletList::reserve(int alloc)
+{
+	m_list.reserve(alloc);
+}
+
+int X26TripletList::size() const
+{
+	return m_list.size();
+}
+
+const QList<int> &X26TripletList::objects(int t) const
+{
+	return m_objects[t];
+};
 
 X26TripletList::ActivePosition::ActivePosition()
 {
@@ -264,6 +429,21 @@ void X26TripletList::ActivePosition::reset()
 	m_row = m_column = -1;
 }
 
+int X26TripletList::ActivePosition::row() const
+{
+	return m_row; // return (m_row == -1) ? 0 : m_row;
+}
+
+int X26TripletList::ActivePosition::column() const
+{
+	return m_column; // return (m_column == -1) ? 0 : m_column;
+}
+
+bool X26TripletList::ActivePosition::isDeployed() const
+{
+	return m_row != -1;
+}
+
 bool X26TripletList::ActivePosition::setRow(int row)
 {
 	if (row < m_row)

src/qteletextdecoder/x26triplets.h

@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef X26TRIPLETS_H
+#define X26TRIPLETS_H
+
+#include <QList>
+
+class X26Triplet
+{
+public:
+	// x26model.h has the Plain English descriptions of these errors
+	enum X26TripletError { NoError, ErrorDecodingTriplet, ActivePositionMovedUp, ActivePositionMovedLeft, InvokePointerInvalid, InvokeTypeMismatch, OriginModifierAlone };
+	enum ObjectSource { InvalidObjectSource, LocalObject, POPObject, GPOPObject };
+
+	X26Triplet() {}
+//	X26Triplet(const X26Triplet &other);
+
+//	X26Triplet &operator=(const X26Triplet &other);
+
+	X26Triplet(int address, int mode, int data);
+
+	bool isValid() const;
+	int address() const;
+	int mode() const;
+	int modeExt() const;
+	int data() const;
+	int addressRow() const;
+	int addressColumn() const;
+	bool isRowTriplet() const;
+
+	void setInvalid();
+	void setAddress(int address);
+	void setMode(int mode);
+	void setData(int data);
+	void setAddressRow(int addressRow);
+	void setAddressColumn(int addressColumn);
+
+	int objectSource() const;
+
+	int objectLocalDesignationCode() const;
+	int objectLocalTripletNumber() const;
+	int objectLocalIndex() const;
+	void setObjectLocalDesignationCode(int i);
+	void setObjectLocalTripletNumber(int i);
+	void setObjectLocalIndex(int i);
+
+	int activePositionRow() const;
+	int activePositionColumn() const;
+	int activePositionRow1p5() const;
+	int activePositionColumn1p5() const;
+	X26TripletError error() const;
+	bool reservedMode() const;
+	bool reservedData() const;
+	bool activePosition1p5Differs() const;
+
+	friend class X26TripletList;
+
+private:
+	// Only these variables are manipulated by the X26Triplet class
+	int m_address, m_mode, m_data;
+	// and the following are filled in by X26TripletList::updateInternalData()
+	int m_activePositionRow = -1;
+	int m_activePositionColumn = -1;
+	int m_activePositionRow1p5 = -1;
+	int m_activePositionColumn1p5 = -1;
+	bool m_activePosition1p5Differs = false;
+	X26TripletError m_error = NoError;
+	bool m_reservedMode = false;
+	bool m_reservedData = false;
+};
+
+class X26TripletList
+{
+public:
+	void append(const X26Triplet &value);
+	void insert(int i, const X26Triplet &value);
+	void removeAt(int i);
+	void replace(int i, const X26Triplet &value);
+	void removeLast();
+	const X26Triplet &at(int i) const;
+	bool isEmpty() const;
+	void reserve(int alloc);
+	int size() const;
+
+	const QList<int> &objects(int t) const;
+
+private:
+	void updateInternalData();
+
+	QList<X26Triplet> m_list;
+	QList<int> m_objects[3];
+
+	class ActivePosition
+	{
+	public:
+		ActivePosition();
+		void reset();
+		int row() const;
+		int column() const;
+		bool isDeployed() const;
+		bool setRow(int);
+		bool setColumn(int);
+//		bool setRowAndColumn(int, int);
+
+	private:
+		int m_row, m_column;
+	};
+};
+
+#endif

src/qteletextmaker/actionicons.qrc

@@ -1,6 +1,5 @@
 <!DOCTYPE RCC><RCC version="1.0">
 <qresource>
-	<file>images/teletextfont.png</file>
 	<file>images/copy.png</file>
 	<file>images/cut.png</file>
 	<file>images/new.png</file>

src/qteletextmaker/dclutdockwidget.cpp

@@ -0,0 +1,153 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QApplication>
+#include <QComboBox>
+#include <QDockWidget>
+#include <QGridLayout>
+#include <QMenu>
+#include <QPainter>
+#include <QPushButton>
+#include <QStackedWidget>
+#include <QVBoxLayout>
+
+#include "dclutdockwidget.h"
+
+#include "mainwidget.h"
+#include "x26menus.h"
+#include "x28commands.h"
+
+DClutDockWidget::DClutDockWidget(TeletextWidget *parent): QDockWidget(parent)
+{
+	QVBoxLayout *dClutLayout = new QVBoxLayout;
+	QWidget *dClutWidget = new QWidget;
+
+	m_parentMainWidget = parent;
+
+	this->setObjectName("DClutWidget");
+	this->setWindowTitle("Level 3.5 DCLUTs");
+
+	QStackedWidget *stackedWidget = new QStackedWidget;
+	QGridLayout *pageLayout[4];
+
+	for (int p=0; p<4; p++) {
+		pageLayout[p] = new QGridLayout;
+
+		for (int i=0; i<16; i++) {
+			m_dClutButton[p][i] = new QPushButton;
+			m_dClutButton[p][i]->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
+			pageLayout[p]->addWidget(m_dClutButton[p][i], i/4, i%4);
+
+			m_dClutMenu[p][i] = new TripletCLUTQMenu(false, this);
+			m_dClutButton[p][i]->setMenu(m_dClutMenu[p][i]);
+
+			for (int c=0; c<32; c++)
+				connect(static_cast<TripletCLUTQMenu *>(m_dClutMenu[p][i])->action(c), &QAction::triggered, [=]() { m_parentMainWidget->document()->undoStack()->push(new SetDCLUTCommand(m_parentMainWidget->document(), (p % 2 == 0), p/2 + 1, i, c)); });
+
+			connect(m_dClutMenu[p][i], &QMenu::aboutToShow, [=]() { updateDClutMenu(p, i); });
+
+			if (i == 3 && p < 2)
+				break;
+		}
+
+		QWidget *pageWidget = new QWidget;
+		pageWidget->setLayout(pageLayout[p]);
+		stackedWidget->addWidget(pageWidget);
+	}
+
+	QComboBox *dClutPageSelect = new QComboBox;
+	dClutPageSelect->addItem(tr("Global DRCS mode 1"));
+	dClutPageSelect->addItem(tr("Normal DRCS mode 1"));
+	dClutPageSelect->addItem(tr("Global DRCS modes 2 & 3"));
+	dClutPageSelect->addItem(tr("Normal DRCS modes 2 & 3"));
+	dClutLayout->addWidget(dClutPageSelect);
+
+	dClutLayout->addWidget(stackedWidget);
+
+	dClutWidget->setLayout(dClutLayout);
+	this->setWidget(dClutWidget);
+
+	connect(dClutPageSelect, &QComboBox::activated, stackedWidget, &QStackedWidget::setCurrentIndex);
+
+	connect(m_parentMainWidget->document(), &TeletextDocument::dClutChanged, this, &DClutDockWidget::dClutChanged);
+	connect(m_parentMainWidget->document(), &TeletextDocument::colourChanged, this, &DClutDockWidget::colourChanged);
+}
+
+void DClutDockWidget::updateDClutMenu(int p, int i)
+{
+	for (int c=0; c<32; c++)
+		static_cast<TripletCLUTQMenu *>(m_dClutMenu[p][i])->setColour(c, m_parentMainWidget->document()->currentSubPage()->CLUTtoQColor(c));
+}
+
+void DClutDockWidget::updateColourButton(int p, int i)
+{
+	const int dIndex = m_parentMainWidget->document()->currentSubPage()->dCLUT((p % 2 == 0), p/2 + 1, i);
+	m_dClutButton[p][i]->setText(QString("%1:%2").arg(dIndex / 8).arg(dIndex % 8));
+	const QString colourString = QString("%1").arg(m_parentMainWidget->document()->currentSubPage()->CLUT(dIndex), 3, 16, QChar('0'));
+
+	if (dIndex != 8) {
+		// FIXME duplicated in palettedockwidget.cpp
+		const int r = m_parentMainWidget->document()->currentSubPage()->CLUT(dIndex) >> 8;
+		const int g = (m_parentMainWidget->document()->currentSubPage()->CLUT(dIndex) >> 4) & 0xf;
+		const int b = m_parentMainWidget->document()->currentSubPage()->CLUT(dIndex) & 0xf;
+		// Set text itself to black or white so it can be seen over background colour - http://alienryderflex.com/hsp.html
+		const char blackOrWhite = (sqrt(r*r*0.299 + g*g*0.587 + b*b*0.114) > 7.647) ? '0' : 'f';
+
+		m_dClutButton[p][i]->setStyleSheet(QString("background-color: #%1; color: #%2%2%2; border: none").arg(colourString).arg(blackOrWhite));;
+	} else
+		m_dClutButton[p][i]->setStyleSheet("border: none");
+}
+
+void DClutDockWidget::updateAllColourButtons()
+{
+	for (int p=0; p<4; p++)
+		for (int i=0; i<16; i++) {
+			updateColourButton(p, i);
+
+			if (i == 3 && p < 2)
+				break;
+		}
+}
+
+void DClutDockWidget::dClutChanged(bool g, int m, int i)
+{
+	updateColourButton(!g + m*2-2, i);
+
+	if (m_parentMainWidget->pageDecode()->level() == 3)
+		for (int r=0; r<25; r++)
+			for (int c=0; c<72; c++)
+				if (m_parentMainWidget->pageDecode()->cellDrcsSource(r, c) != TeletextPageDecode::NoDRCS)
+					m_parentMainWidget->pageDecode()->setRefresh(r, c, true);
+
+	emit m_parentMainWidget->document()->contentsChanged();
+}
+
+void DClutDockWidget::colourChanged(int c)
+{
+	const QString searchString = QString("%1:%2").arg(c / 8).arg(c % 8);
+
+	for (int p=0; p<4; p++)
+		for (int i=0; i<16; i++) {
+			if (m_dClutButton[p][i]->text() == searchString)
+				updateColourButton(p, i);
+
+			if (i == 3 && p < 2)
+				break;
+		}
+}

src/qteletextmaker/dclutdockwidget.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2020-2025 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 DCLUTDOCKWIDGET_H
+#define DCLUTDOCKWIDGET_H
+
+#include <QComboBox>
+#include <QDockWidget>
+#include <QMenu>
+#include <QPainter>
+#include <QPushButton>
+
+#include "mainwidget.h"
+
+class DClutDockWidget : public QDockWidget
+{
+	Q_OBJECT
+
+public:
+	DClutDockWidget(TeletextWidget *parent);
+	void updateAllColourButtons();
+
+public slots:
+	void updateColourButton(int p, int i);
+	void dClutChanged(bool g, int m, int i);
+	void colourChanged(int c);
+
+private:
+	void updateDClutMenu(int p, int i);
+
+	TeletextWidget *m_parentMainWidget;
+	QPushButton *m_dClutButton[4][16];
+	QMenu *m_dClutMenu[4][16];
+};
+
+#endif

src/qteletextmaker/document.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -18,7 +18,8 @@
  */
 
 #include <QAbstractListModel>
-#include <vector>
+#include <QList>
+#include <QVariant>
 
 #include "document.h"
 
@@ -52,7 +53,7 @@ void ClutModel::setSubPage(LevelOnePage *subPage)
 {
 	if (subPage != m_subPage) {
 		m_subPage = subPage;
-		emit dataChanged(createIndex(0, 0), createIndex(31, 0), QVector<int>(Qt::DecorationRole));
+		emit dataChanged(createIndex(0, 0), createIndex(31, 0), QList<int>(Qt::DecorationRole));
 	}
 }
 
@@ -61,13 +62,12 @@ TeletextDocument::TeletextDocument()
 {
 	m_pageNumber = 0x199;
 	m_description.clear();
-	m_pageFunction = PFLevelOnePage;
+	m_subPages.append(new LevelOnePage);
-	m_packetCoding = Coding7bit;
-	m_subPages.push_back(new LevelOnePage);
 	m_currentSubPageIndex = 0;
 	m_undoStack = new QUndoStack(this);
 	m_cursorRow = 1;
 	m_cursorColumn = 0;
+	m_rowZeroAllowed = false;
 	m_selectionCornerRow = m_selectionCornerColumn = -1;
 	m_selectionSubPage = nullptr;
 
@@ -96,9 +96,7 @@ bool TeletextDocument::isEmpty() const
 
 void TeletextDocument::clear()
 {
-	LevelOnePage *blankSubPage = new LevelOnePage;
+	m_subPages.prepend(new LevelOnePage);
-
-	m_subPages.insert(m_subPages.begin(), blankSubPage);
 
 	emit aboutToChangeSubPage();
 	m_currentSubPageIndex = 0;
@@ -109,22 +107,10 @@ void TeletextDocument::clear()
 
 	for (int i=m_subPages.size()-1; i>0; i--) {
 		delete(m_subPages[i]);
-		m_subPages.erase(m_subPages.begin()+i);
+		m_subPages.remove(i);
 	}
 }
 
-/*
-void TeletextDocument::setPageFunction(PageFunctionEnum newPageFunction)
-{
-	m_pageFunction = newPageFunction;
-}
-
-void TeletextDocument::setPacketCoding(PacketCodingEnum newPacketEncoding)
-{
-	m_packetCoding = newPacketEncoding;
-}
-*/
-
 void TeletextDocument::selectSubPageIndex(int newSubPageIndex, bool forceRefresh)
 {
 	// forceRefresh overrides "beyond the last subpage" check, so inserting a subpage after the last one still shows - dangerous workaround?
@@ -176,9 +162,9 @@ void TeletextDocument::insertSubPage(int beforeSubPageIndex, bool copySubPage)
 		insertedSubPage = new LevelOnePage;
 
 	if (beforeSubPageIndex == m_subPages.size())
-		m_subPages.push_back(insertedSubPage);
+		m_subPages.append(insertedSubPage);
 	else
-		m_subPages.insert(m_subPages.begin()+beforeSubPageIndex, insertedSubPage);
+		m_subPages.insert(beforeSubPageIndex, insertedSubPage);
 }
 
 void TeletextDocument::deleteSubPage(int subPageToDelete)
@@ -186,19 +172,64 @@ void TeletextDocument::deleteSubPage(int subPageToDelete)
 	m_clutModel->setSubPage(nullptr);
 
 	delete(m_subPages[subPageToDelete]);
-	m_subPages.erase(m_subPages.begin()+subPageToDelete);
+	m_subPages.remove(subPageToDelete);
 }
 
 void TeletextDocument::deleteSubPageToRecycle(int subPageToRecycle)
 {
-	m_recycleSubPages.push_back(m_subPages[subPageToRecycle]);
+	m_recycleSubPages.append(m_subPages[subPageToRecycle]);
-	m_subPages.erase(m_subPages.begin()+subPageToRecycle);
+	m_subPages.remove(subPageToRecycle);
 }
 
 void TeletextDocument::unDeleteSubPageFromRecycle(int subPage)
 {
-	m_subPages.insert(m_subPages.begin()+subPage, m_recycleSubPages.back());
+	m_subPages.insert(subPage, m_recycleSubPages.last());
-	m_recycleSubPages.pop_back();
+	m_recycleSubPages.removeLast();
+}
+
+void TeletextDocument::loadFromList(QList<PageBase> const &subPageList)
+{
+	*m_subPages[0] = subPageList.at(0);
+
+	for (int i=1; i<subPageList.size(); i++)
+		m_subPages.append(new LevelOnePage(subPageList.at(i)));
+}
+
+void TeletextDocument::loadMetaData(QVariantHash const &metadata)
+{
+	bool valueOk;
+
+	if (const QString description = metadata.value("description").toString(); !description.isEmpty())
+		m_description = description;
+
+	if (const int pageNumber = metadata.value("pageNumber").toInt(&valueOk); valueOk)
+		m_pageNumber = pageNumber;
+
+	if (metadata.value("fastextAbsolute").toBool()) {
+		const int magazineFlip = m_pageNumber & 0x700;
+
+		for (auto &subPage : m_subPages)
+			for (int i=0; i<6; i++)
+				subPage->setFastTextLinkPageNumber(i, subPage->fastTextLinkPageNumber(i) ^ magazineFlip);
+	}
+
+	for (int i=0; i<numberOfSubPages(); i++) {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0)
+		const QString subPageStr = QString("%1").arg(i, 3, '0');
+#else
+		const QString subPageStr = QString("%1").arg(i, 3, QChar('0'));
+#endif
+
+		if (int region = metadata.value("region" + subPageStr).toInt(&valueOk); valueOk)
+			subPage(i)->setDefaultCharSet(region);
+		if (int cycleValue = metadata.value("cycleValue" + subPageStr).toInt(&valueOk); valueOk)
+			subPage(i)->setCycleValue(cycleValue);
+		QChar cycleType = metadata.value("cycleType" + subPageStr).toChar();
+		if (cycleType == 'C')
+			subPage(i)->setCycleType(LevelOnePage::CTcycles);
+		else if (cycleType == 'T')
+			subPage(i)->setCycleType(LevelOnePage::CTseconds);
+	}
 }
 
 void TeletextDocument::setPageNumber(int pageNumber)
@@ -252,7 +283,7 @@ void TeletextDocument::cursorUp(bool shiftKey)
 	if (shiftKey && !selectionActive())
 		setSelectionCorner(m_cursorRow, m_cursorColumn);
 
-	if (--m_cursorRow == 0)
+	if (--m_cursorRow == 0 - (int)m_rowZeroAllowed)
 		m_cursorRow = 24;
 
 	if (shiftKey)
@@ -269,7 +300,7 @@ void TeletextDocument::cursorDown(bool shiftKey)
 		setSelectionCorner(m_cursorRow, m_cursorColumn);
 
 	if (++m_cursorRow == 25)
-		m_cursorRow = 1;
+		m_cursorRow = (int)!m_rowZeroAllowed;
 
 	if (shiftKey)
 		emit selectionMoved();
@@ -333,6 +364,13 @@ void TeletextDocument::moveCursor(int cursorRow, int cursorColumn, bool selectio
 	emit cursorMoved();
 }
 
+void TeletextDocument::setRowZeroAllowed(bool allowed)
+{
+	m_rowZeroAllowed = allowed;
+	if (m_cursorRow == 0 && !allowed)
+		cursorDown();
+}
+
 void TeletextDocument::setSelectionCorner(int row, int column)
 {
 	if (m_selectionCornerRow != row || m_selectionCornerColumn != column) {

src/qteletextmaker/document.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -21,9 +21,10 @@
 #define DOCUMENT_H
 
 #include <QAbstractListModel>
+#include <QList>
 #include <QObject>
 #include <QUndoStack>
-#include <vector>
+#include <QVariant>
 
 #include "levelonepage.h"
 
@@ -47,39 +48,31 @@ class TeletextDocument : public QObject
 	Q_OBJECT
 
 public:
-	// Available Page Functions according to 9.4.2.1 of the spec
-	enum PageFunctionEnum { PFLevelOnePage, PFDataBroadcasting, PFGlobalPOP, PFNormalPOP, PFGlobalDRCS, PFNormalDRCS, PFMOT, PFMIP, PFBasicTOPTable, PFAdditionalInformationTable, PFMultiPageTable, PFMultiPageExtensionTable, PFTriggerMessages };
-	// Available Page Codings of X/1 to X/25 according to 9.4.2.1 of the spec
-	enum PacketCodingEnum { Coding7bit, Coding8bit, Coding18bit, Coding4bit, Coding4bitThen7bit, CodingPerPacket };
-
 	TeletextDocument();
 	~TeletextDocument();
 
 	bool isEmpty() const;
 	void clear();
 
-	PageFunctionEnum pageFunction() const { return m_pageFunction; }
-//	void setPageFunction(PageFunctionEnum);
-	PacketCodingEnum packetCoding() const { return m_packetCoding; }
-//	void setPacketCoding(PacketCodingEnum);
-
 	int numberOfSubPages() const { return m_subPages.size(); }
 	LevelOnePage* subPage(int p) const { return m_subPages[p]; }
 	LevelOnePage* currentSubPage() const { return m_subPages[m_currentSubPageIndex]; }
 	int currentSubPageIndex() const { return m_currentSubPageIndex; }
-	void selectSubPageIndex(int, bool=false);
+	void selectSubPageIndex(int newSubPageIndex, bool refresh=false);
 	void selectSubPageNext();
 	void selectSubPagePrevious();
-	void insertSubPage(int, bool);
+	void insertSubPage(int beforeSubPageIndex, bool copySubPage);
-	void deleteSubPage(int);
+	void deleteSubPage(int subPageToDelete);
-	void deleteSubPageToRecycle(int);
+	void deleteSubPageToRecycle(int subPageToRecycle);
-	void unDeleteSubPageFromRecycle(int);
+	void unDeleteSubPageFromRecycle(int subPage);
+	void loadFromList(QList<PageBase> const &subPageList);
+	void loadMetaData(QVariantHash const &metadata);
 	int pageNumber() const { return m_pageNumber; }
-	void setPageNumber(int);
+	void setPageNumber(int pageNumber);
-	void setPageNumberFromString(QString);
+	void setPageNumberFromString(QString pageNumberString);
 	QString description() const { return m_description; }
-	void setDescription(QString);
+	void setDescription(QString newDescription);
-	void setFastTextLinkPageNumberOnAllSubPages(int, int);
+	void setFastTextLinkPageNumberOnAllSubPages(int linkNumber, int pageNumber);
 	QUndoStack *undoStack() const { return m_undoStack; }
 	ClutModel *clutModel() const { return m_clutModel; }
 	int cursorRow() const { return m_cursorRow; }
@@ -88,7 +81,9 @@ public:
 	void cursorDown(bool shiftKey=false);
 	void cursorLeft(bool shiftKey=false);
 	void cursorRight(bool shiftKey=false);
-	void moveCursor(int, int, bool selectionInProgress=false);
+	void moveCursor(int cursorRow, int cursorColumn, bool selectionInProgress=false);
+	bool rowZeroAllowed() const { return m_rowZeroAllowed; };
+	void setRowZeroAllowed(bool allowed);
 	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); }
@@ -98,31 +93,31 @@ public:
 	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 setSelectionCorner(int row, int column);
-	void setSelection(int, int, int, int);
+	void setSelection(int topRow, int leftColumn, int bottomRow, int rightColumn);
 	void cancelSelection();
 	int levelRequired() const;
 
 signals:
 	void cursorMoved();
 	void selectionMoved();
-	void colourChanged(int);
+	void colourChanged(int i);
-	void contentsChange(int);
+	void dClutChanged(bool g, int m, int i);
+	void pageOptionsChanged();
 	void aboutToChangeSubPage();
 	void subPageSelected();
-	void refreshNeeded();
+	void contentsChanged();
 
-	void tripletCommandHighlight(int);
+	void tripletCommandHighlight(int tripletNumber);
 
 private:
 	QString m_description;
 	int m_pageNumber, m_currentSubPageIndex;
-	PageFunctionEnum m_pageFunction;
+	QList<LevelOnePage *> m_subPages;
-	PacketCodingEnum m_packetCoding;
+	QList<LevelOnePage *> m_recycleSubPages;
-	std::vector<LevelOnePage *> m_subPages;
-	std::vector<LevelOnePage *> m_recycleSubPages;
 	QUndoStack *m_undoStack;
 	int m_cursorRow, m_cursorColumn, m_selectionCornerRow, m_selectionCornerColumn;
+	bool m_rowZeroAllowed;
 	LevelOnePage *m_selectionSubPage;
 	ClutModel *m_clutModel;
 };

src/qteletextmaker/hashformats.cpp

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2020-2025 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 "hashformats.h"
+
+#include <QByteArray>
+#include <QString>
+
+#include "levelonepage.h"
+#include "pagebase.h"
+
+QString exportHashStringPage(LevelOnePage *subPage)
+{
+	int hashDigits[1167]={0};
+	int totalBits, charBit;
+	const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+	QString hashString;
+	QByteArray rowPacket;
+
+	// TODO int editTFCharacterSet = 5;
+	bool blackForeground = false;
+
+	for (int r=0; r<25; r++) {
+		if (subPage->packetExists(r))
+			rowPacket = subPage->packet(r);
+		else
+			rowPacket = QByteArray(40, 0x20).constData();
+
+		for (int c=0; c<40; c++) {
+			if (rowPacket.at(c) == 0x00 || rowPacket.at(c) == 0x10)
+				blackForeground = true;
+			for (int b=0; b<7; b++) {
+				totalBits = (r * 40 + c) * 7 + b;
+				charBit = ((rowPacket.at(c)) >> (6 - b)) & 0x01;
+				hashDigits[totalBits / 6] |= charBit << (5 - (totalBits % 6));
+			}
+		}
+	}
+
+	hashString.append(QString("#%1:").arg(blackForeground ? 8 : 0, 1, 16));
+
+	for (int i=0; i<1167; i++)
+		hashString.append(base64[hashDigits[i]]);
+
+	return hashString;
+}
+
+QString exportHashStringPackets(LevelOnePage *subPage)
+{
+	auto colourToHexString=[&](int whichCLUT)
+	{
+		QString resultHexString;
+
+		for (int i=whichCLUT*8; i<whichCLUT*8+8; i++)
+			resultHexString.append(QString("%1").arg(subPage->CLUT(i), 3, 16, QChar('0')));
+		return resultHexString;
+	};
+
+	const char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+	QString result;
+
+	// Assemble PS
+	// C4 Erase page is stored in bit 14
+	int pageStatus = 0x8000 | (subPage->controlBit(PageBase::C4ErasePage) << 14);
+	// C5 to C11 stored in order from bits 1 to 6
+	for (int i=PageBase::C5Newsflash; i<=PageBase::C11SerialMagazine; i++)
+		pageStatus |= subPage->controlBit(i) << (i-1);
+	// Apparently the TTI format stores the NOS bits backwards
+	pageStatus |= subPage->controlBit(PageBase::C12NOS) << 9;
+	pageStatus |= subPage->controlBit(PageBase::C13NOS) << 8;
+	pageStatus |= subPage->controlBit(PageBase::C14NOS) << 7;
+
+	result.append(QString(":PS=%1:RE=%2").arg(0x8000 | pageStatus, 0, 16, QChar('0')).arg(subPage->defaultCharSet(), 1, 16));
+
+	if (subPage->packetExists(28,0) || subPage->packetExists(28,4)) {
+		// X/28/0 and X/28/4 are duplicates apart from the CLUT definitions
+		// Assemble the duplicate beginning and ending of both packets
+		QString x28StringBegin, x28StringEnd;
+
+		x28StringBegin.append(QString("00%1").arg((subPage->defaultCharSet() << 3) | subPage->defaultNOS(), 2, 16, QChar('0')).toUpper());
+		x28StringBegin.append(QString("%1").arg((subPage->secondCharSet() << 3) | subPage->secondNOS(), 2, 16, QChar('0')).toUpper());
+		x28StringBegin.append(QString("%1%2%3%4").arg(subPage->leftSidePanelDisplayed(), 1, 10).arg(subPage->rightSidePanelDisplayed(), 1, 10).arg(subPage->sidePanelStatusL25(), 1, 10).arg(subPage->sidePanelColumns(), 1, 16));
+
+		x28StringEnd = QString("%1%2%3%4").arg(subPage->defaultScreenColour(), 2, 16, QChar('0')).arg(subPage->defaultRowColour(), 2, 16, QChar('0')).arg(subPage->blackBackgroundSubst(), 1, 10).arg(subPage->colourTableRemap(), 1, 10);
+
+		if (subPage->packetExists(28,0))
+			result.append(":X280=" + x28StringBegin + colourToHexString(2) + colourToHexString(3) + x28StringEnd);
+		if (subPage->packetExists(28,4))
+			result.append(":X284=" + x28StringBegin + colourToHexString(0) + colourToHexString(1) + x28StringEnd);
+	}
+
+	if (!subPage->enhancements()->isEmpty()) {
+		result.append(":X26=");
+		for (int i=0; i<subPage->enhancements()->size(); i++) {
+			result.append(base64[subPage->enhancements()->at(i).data() >> 1]);
+			result.append(base64[subPage->enhancements()->at(i).mode() | ((subPage->enhancements()->at(i).data() & 1) << 5)]);
+			result.append(base64[subPage->enhancements()->at(i).address()]);
+		}
+	}
+
+	return result;
+}

src/qteletextmaker/hashformats.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -17,31 +17,16 @@
  * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-#ifndef LOADSAVE_H
+#ifndef HASHFORMATS_H
-#define LOADSAVE_H
+#define HASHFORMATS_H
 
 #include <QByteArray>
-#include <QFile>
-#include <QSaveFile>
 #include <QString>
-#include <QTextStream>
 
-#include "document.h"
 #include "levelonepage.h"
 #include "pagebase.h"
 
-void loadTTI(QFile *, TeletextDocument *);
+QString exportHashStringPage(LevelOnePage *subPage);
-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);
-
-QString exportHashStringPage(LevelOnePage *);
 QString exportHashStringPackets(LevelOnePage *subPage);
 
 #endif

src/qteletextmaker/keymap.h

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

src/qteletextmaker/levelonecommands.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -21,7 +21,10 @@
 #include <QByteArray>
 #include <QByteArrayList>
 #include <QClipboard>
+#include <QImage>
 #include <QMimeData>
+#include <QRegularExpression>
+#include <QSet>
 
 #include "levelonecommands.h"
 
@@ -37,6 +40,51 @@ LevelOneCommand::LevelOneCommand(TeletextDocument *teletextDocument, QUndoComman
 	m_firstDo = true;
 }
 
+QByteArrayList LevelOneCommand::storeCharacters(int topRow, int leftColumn, int bottomRow, int rightColumn)
+{
+	QByteArrayList result;
+
+	for (int r=topRow; r<=bottomRow; r++) {
+		QByteArray rowArray;
+
+		for (int c=leftColumn; c<=rightColumn; c++)
+			// Guard against size of pasted block going beyond last line or column
+			if (r < 25 && c < 40)
+				rowArray.append(m_teletextDocument->currentSubPage()->character(r, c));
+			else
+				// Gone beyond last line or column - store a filler character which we won't see
+				// Not sure if this is really necessary as out-of-bounds access might not occur?
+				rowArray.append(0x7f);
+
+		result.append(rowArray);
+	}
+
+	return result;
+}
+
+void LevelOneCommand::retrieveCharacters(int topRow, int leftColumn, const QByteArrayList &storedChars)
+{
+	const int bottomRow = topRow + storedChars.size() - 1;
+	const int rightColumn = leftColumn + storedChars.at(0).size() - 1;
+
+	int arrayR = 0;
+	int arrayC;
+
+	for (int r=topRow; r<=bottomRow; r++) {
+		arrayC = 0;
+		for (int c=leftColumn; c<=rightColumn; c++)
+			// Guard against size of pasted block going beyond last line or column
+			if (r < 25 && c < 40) {
+				m_teletextDocument->currentSubPage()->setCharacter(r, c, storedChars.at(arrayR).at(arrayC));
+
+				arrayC++;
+			}
+
+		arrayR++;
+	}
+}
+
+
 TypeCharacterCommand::TypeCharacterCommand(TeletextDocument *teletextDocument, unsigned char newCharacter, bool insertMode, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
 	m_columnStart = m_columnEnd = m_column;
@@ -71,7 +119,7 @@ void TypeCharacterCommand::redo()
 
 	m_teletextDocument->moveCursor(m_row, m_columnEnd);
 	m_teletextDocument->cursorRight();
-	emit m_teletextDocument->contentsChange(m_row);
+	emit m_teletextDocument->contentsChanged();
 }
 
 void TypeCharacterCommand::undo()
@@ -82,7 +130,7 @@ void TypeCharacterCommand::undo()
 		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_oldRowContents[c]);
 
 	m_teletextDocument->moveCursor(m_row, m_columnStart);
-	emit m_teletextDocument->contentsChange(m_row);
+	emit m_teletextDocument->contentsChanged();
 }
 
 bool TypeCharacterCommand::mergeWith(const QUndoCommand *command)
@@ -104,12 +152,19 @@ bool TypeCharacterCommand::mergeWith(const QUndoCommand *command)
 ToggleMosaicBitCommand::ToggleMosaicBitCommand(TeletextDocument *teletextDocument, unsigned char bitToToggle, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
 	m_oldCharacter = teletextDocument->currentSubPage()->character(m_row, m_column);
+
 	if (bitToToggle == 0x20 || bitToToggle == 0x7f)
+		// Clear or fill the whole mosaic character
 		m_newCharacter = bitToToggle;
 	else if (bitToToggle == 0x66)
+		// Dither
 		m_newCharacter = (m_row & 1) ? 0x66 : 0x39;
-	else
+	else if (m_oldCharacter & 0x20)
+		// Previous character was mosaic, just toggle the bit(s)
 		m_newCharacter = m_oldCharacter ^ bitToToggle;
+	else
+		// Previous character was blast-through, change to mosaic and set bit alone
+		m_newCharacter = bitToToggle | 0x20;
 
 	setText(QObject::tr("mosaic"));
 
@@ -121,7 +176,7 @@ void ToggleMosaicBitCommand::redo()
 	m_teletextDocument->currentSubPage()->setCharacter(m_row, m_column, m_newCharacter);
 
 	m_teletextDocument->moveCursor(m_row, m_column);
-	emit m_teletextDocument->contentsChange(m_row);
+	emit m_teletextDocument->contentsChanged();
 }
 
 void ToggleMosaicBitCommand::undo()
@@ -130,7 +185,7 @@ void ToggleMosaicBitCommand::undo()
 	m_teletextDocument->currentSubPage()->setCharacter(m_row, m_column, m_oldCharacter);
 
 	m_teletextDocument->moveCursor(m_row, m_column);
-	emit m_teletextDocument->contentsChange(m_row);
+	emit m_teletextDocument->contentsChanged();
 }
 
 bool ToggleMosaicBitCommand::mergeWith(const QUndoCommand *command)
@@ -182,7 +237,7 @@ void BackspaceKeyCommand::redo()
 		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_newRowContents[c]);
 
 	m_teletextDocument->moveCursor(m_row, m_columnEnd);
-	emit m_teletextDocument->contentsChange(m_row);
+	emit m_teletextDocument->contentsChanged();
 }
 
 void BackspaceKeyCommand::undo()
@@ -194,7 +249,7 @@ void BackspaceKeyCommand::undo()
 
 	m_teletextDocument->moveCursor(m_row, m_columnStart);
 	m_teletextDocument->cursorRight();
-	emit m_teletextDocument->contentsChange(m_row);
+	emit m_teletextDocument->contentsChanged();
 }
 
 bool BackspaceKeyCommand::mergeWith(const QUndoCommand *command)
@@ -236,7 +291,7 @@ void DeleteKeyCommand::redo()
 		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_newRowContents[c]);
 
 	m_teletextDocument->moveCursor(m_row, m_column);
-	emit m_teletextDocument->contentsChange(m_row);
+	emit m_teletextDocument->contentsChanged();
 }
 
 void DeleteKeyCommand::undo()
@@ -247,7 +302,7 @@ void DeleteKeyCommand::undo()
 		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_oldRowContents[c]);
 
 	m_teletextDocument->moveCursor(m_row, m_column);
-	emit m_teletextDocument->contentsChange(m_row);
+	emit m_teletextDocument->contentsChanged();
 }
 
 bool DeleteKeyCommand::mergeWith(const QUndoCommand *command)
@@ -264,6 +319,188 @@ bool DeleteKeyCommand::mergeWith(const QUndoCommand *command)
 }
 
 
+ShiftMosaicsCommand::ShiftMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
+{
+	m_selectionTopRow = m_teletextDocument->selectionTopRow();
+	m_selectionLeftColumn = m_teletextDocument->selectionLeftColumn();
+	m_selectionBottomRow = m_teletextDocument->selectionBottomRow();
+	m_selectionRightColumn = m_teletextDocument->selectionRightColumn();
+
+	m_selectionCornerRow = m_teletextDocument->selectionCornerRow();
+	m_selectionCornerColumn = m_teletextDocument->selectionCornerColumn();
+
+	m_mosaicList = mosaicList;
+
+	m_oldCharacters = storeCharacters(m_selectionTopRow, m_selectionLeftColumn, m_selectionBottomRow, m_selectionRightColumn);
+	m_newCharacters = m_oldCharacters;
+}
+
+void ShiftMosaicsCommand::redo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	retrieveCharacters(m_selectionTopRow, m_selectionLeftColumn, m_newCharacters);
+
+	emit m_teletextDocument->contentsChanged();
+
+	m_teletextDocument->setSelectionCorner(m_selectionCornerRow, m_selectionCornerColumn);
+	m_teletextDocument->moveCursor(m_row, m_column, true);
+}
+
+void ShiftMosaicsCommand::undo()
+{
+	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
+	retrieveCharacters(m_selectionTopRow, m_selectionLeftColumn, m_oldCharacters);
+
+	emit m_teletextDocument->contentsChanged();
+
+	m_teletextDocument->setSelectionCorner(m_selectionCornerRow, m_selectionCornerColumn);
+	m_teletextDocument->moveCursor(m_row, m_column, true);
+}
+
+bool ShiftMosaicsCommand::mergeWith(const QUndoCommand *command)
+{
+	const ShiftMosaicsCommand *newerCommand = static_cast<const ShiftMosaicsCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex || m_selectionTopRow != newerCommand->m_selectionTopRow || m_selectionLeftColumn != newerCommand->m_selectionLeftColumn || m_selectionBottomRow != newerCommand->m_selectionBottomRow || m_selectionRightColumn != newerCommand->m_selectionRightColumn)
+		return false;
+
+	m_newCharacters = newerCommand->m_newCharacters;
+
+	return true;
+}
+
+ShiftMosaicsUpCommand::ShiftMosaicsUpCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++)
+		for (int c=m_selectionLeftColumn; c<=m_selectionRightColumn; c++)
+			if (m_mosaicList.contains(qMakePair(r, c))) {
+				const int lr = r - m_selectionTopRow;
+				const int lc = c - m_selectionLeftColumn;
+				unsigned char mosaicWrap = 0x00;
+
+				for (int sr=r+1; sr<=m_selectionBottomRow; sr++)
+					if (m_mosaicList.contains(qMakePair(sr, c))) {
+						mosaicWrap = m_newCharacters[sr - m_selectionTopRow][lc];
+						mosaicWrap = ((mosaicWrap & 0x01) << 4) | ((mosaicWrap & 0x02) << 5);
+						break;
+					}
+
+				m_newCharacters[lr][lc] = ((m_newCharacters[lr][lc] >> 2) & 0x07) | ((m_newCharacters[lr][lc] & 0x40) >> 3) | mosaicWrap | 0x20;
+			}
+
+	setText(QObject::tr("shift mosaics up"));
+}
+
+ShiftMosaicsDownCommand::ShiftMosaicsDownCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (int r=m_selectionBottomRow; r>=m_selectionTopRow; r--)
+		for (int c=m_selectionLeftColumn; c<=m_selectionRightColumn; c++)
+			if (m_mosaicList.contains(qMakePair(r, c))) {
+				const int lr = r - m_selectionTopRow;
+				const int lc = c - m_selectionLeftColumn;
+				unsigned char mosaicWrap = 0x00;
+
+				for (int sr=r-1; sr>=m_selectionTopRow; sr--)
+					if (m_mosaicList.contains(qMakePair(sr, c))) {
+						mosaicWrap = m_newCharacters[sr - m_selectionTopRow][lc];
+						mosaicWrap = ((mosaicWrap & 0x10) >> 4) | ((mosaicWrap & 0x40) >> 5);
+						break;
+					}
+
+				m_newCharacters[lr][lc] = ((m_newCharacters[lr][lc] & 0x07) << 2) | ((m_newCharacters[lr][lc] & 0x08) << 3) | mosaicWrap | 0x20;
+			}
+
+	setText(QObject::tr("shift mosaics down"));
+}
+
+ShiftMosaicsLeftCommand::ShiftMosaicsLeftCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (int c=m_selectionLeftColumn; c<=m_selectionRightColumn; c++)
+		for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++)
+			if (m_mosaicList.contains(qMakePair(r, c))) {
+				const int lr = r - m_selectionTopRow;
+				const int lc = c - m_selectionLeftColumn;
+				unsigned char mosaicWrap = 0x00;
+
+				for (int sc=c+1; sc<=m_selectionRightColumn; sc++)
+					if (m_mosaicList.contains(qMakePair(r, sc))) {
+						mosaicWrap = m_newCharacters[lr][sc - m_selectionLeftColumn];
+						mosaicWrap = ((mosaicWrap & 0x05) << 1) | ((mosaicWrap & 0x10) << 2);
+						break;
+					}
+
+				m_newCharacters[lr][lc] = ((m_newCharacters[lr][lc] & 0x0a) >> 1) | ((m_newCharacters[lr][lc] & 0x40) >> 2) | mosaicWrap | 0x20;
+			}
+
+	setText(QObject::tr("shift mosaics left"));
+}
+
+ShiftMosaicsRightCommand::ShiftMosaicsRightCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (int c=m_selectionRightColumn; c>=m_selectionLeftColumn; c--)
+		for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++)
+			if (m_mosaicList.contains(qMakePair(r, c))) {
+				const int lr = r - m_selectionTopRow;
+				const int lc = c - m_selectionLeftColumn;
+				unsigned char mosaicWrap = 0x00;
+
+				for (int sc=c-1; sc>=m_selectionLeftColumn; sc--)
+					if (m_mosaicList.contains(qMakePair(r, sc))) {
+						mosaicWrap = m_newCharacters[lr][sc - m_selectionLeftColumn];
+						mosaicWrap = ((mosaicWrap & 0x0a) >> 1) | ((mosaicWrap & 0x40) >> 2);
+						break;
+					}
+
+				m_newCharacters[lr][lc] = ((m_newCharacters[lr][lc] & 0x05) << 1) | ((m_newCharacters[lr][lc] & 0x10) << 2) | mosaicWrap | 0x20;
+			}
+
+	setText(QObject::tr("shift mosaics right"));
+}
+
+FillMosaicsCommand::FillMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (const auto &m : m_mosaicList)
+		m_newCharacters[m.first - m_selectionTopRow][m.second - m_selectionLeftColumn] = 0x7f;
+
+	setText(QObject::tr("fill mosaics"));
+}
+
+ClearMosaicsCommand::ClearMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (const auto &m : m_mosaicList)
+		m_newCharacters[m.first - m_selectionTopRow][m.second - m_selectionLeftColumn] = 0x20;
+
+	setText(QObject::tr("clear mosaics"));
+}
+
+InvertMosaicsCommand::InvertMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (const auto &m : m_mosaicList)
+		m_newCharacters[m.first - m_selectionTopRow][m.second - m_selectionLeftColumn] ^= 0x5f;
+
+	setText(QObject::tr("reverse mosaics"));
+}
+
+bool InvertMosaicsCommand::mergeWith(const QUndoCommand *command)
+{
+	const InvertMosaicsCommand *newerCommand = static_cast<const InvertMosaicsCommand *>(command);
+
+	if (m_subPageIndex != newerCommand->m_subPageIndex || m_selectionTopRow != newerCommand->m_selectionTopRow || m_selectionLeftColumn != newerCommand->m_selectionLeftColumn || m_selectionBottomRow != newerCommand->m_selectionBottomRow || m_selectionRightColumn != newerCommand->m_selectionRightColumn)
+		return false;
+
+	setObsolete(true);
+	return true;
+}
+
+DitherMosaicsCommand::DitherMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent) : ShiftMosaicsCommand(teletextDocument, mosaicList, parent)
+{
+	for (const auto &m : m_mosaicList)
+		m_newCharacters[m.first - m_selectionTopRow][m.second - m_selectionLeftColumn] = (m.first & 1) ? 0x66 : 0x39;
+
+	setText(QObject::tr("dither mosaics"));
+}
+
+
 InsertRowCommand::InsertRowCommand(TeletextDocument *teletextDocument, bool copyRow, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
 	m_copyRow = copyRow;
@@ -290,7 +527,7 @@ void InsertRowCommand::redo()
 		for (int c=0; c<40; c++)
 			m_teletextDocument->currentSubPage()->setCharacter(m_row, c, ' ');
 
-	emit m_teletextDocument->refreshNeeded();
+	emit m_teletextDocument->contentsChanged();
 }
 
 void InsertRowCommand::undo()
@@ -305,7 +542,7 @@ void InsertRowCommand::undo()
 	for (int c=0; c<40; c++)
 		m_teletextDocument->currentSubPage()->setCharacter(23, c, m_deletedBottomRow[c]);
 
-	emit m_teletextDocument->refreshNeeded();
+	emit m_teletextDocument->contentsChanged();
 }
 
 
@@ -330,7 +567,7 @@ void DeleteRowCommand::redo()
 		for (int c=0; c<40; c++)
 			m_teletextDocument->currentSubPage()->setCharacter(blankingRow, c, ' ');
 
-	emit m_teletextDocument->refreshNeeded();
+	emit m_teletextDocument->contentsChanged();
 }
 
 void DeleteRowCommand::undo()
@@ -345,7 +582,7 @@ void DeleteRowCommand::undo()
 	for (int c=0; c<40; c++)
 		m_teletextDocument->currentSubPage()->setCharacter(m_row, c, m_deletedRow[c]);
 
-	emit m_teletextDocument->refreshNeeded();
+	emit m_teletextDocument->contentsChanged();
 }
 
 
@@ -360,15 +597,7 @@ CutCommand::CutCommand(TeletextDocument *teletextDocument, QUndoCommand *parent)
 	m_selectionCornerRow = m_teletextDocument->selectionCornerRow();
 	m_selectionCornerColumn = m_teletextDocument->selectionCornerColumn();
 
-	// Store copy of the characters that we're about to blank
+	m_oldCharacters = storeCharacters(m_selectionTopRow, m_selectionLeftColumn, m_selectionBottomRow, m_selectionRightColumn);
-	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"));
 }
@@ -380,25 +609,18 @@ void CutCommand::redo()
 	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);
 	}
+
+	emit m_teletextDocument->contentsChanged();
 }
 
 void CutCommand::undo()
 {
 	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
 
-	int arrayR = 0;
+	retrieveCharacters(m_selectionTopRow, m_selectionLeftColumn, m_oldCharacters);
-	int arrayC;
 
-	for (int r=m_selectionTopRow; r<=m_selectionBottomRow; r++) {
+	emit m_teletextDocument->contentsChanged();
-		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);
@@ -459,7 +681,7 @@ PasteCommand::PasteCommand(TeletextDocument *teletextDocument, int pageCharSet,
 		const int rightColumn = m_selectionActive ? m_pasteRightColumn : 39;
 
 		// Parse line-feeds in the clipboard data
-		QStringList plainTextData = mimeData->text().split(QRegExp("\n|\r\n|\r"));
+		QStringList plainTextData = mimeData->text().split(QRegularExpression("\n|\r\n|\r"));
 
 		// "if" statement will be false if clipboard data is a single line of text
 		// that will fit from the cursor position
@@ -468,10 +690,8 @@ PasteCommand::PasteCommand(TeletextDocument *teletextDocument, int pageCharSet,
 
 			if (!m_selectionActive) {
 				// If selection is NOT active, use the full width of the page to paste.
-				// The second and subsequent lines will start at column 1, unless the
+				// The second and subsequent lines will start at column 1
-				// cursor is explicitly on column 0.
+				m_pasteLeftColumn = 1;
-				if (m_pasteLeftColumn != 0)
-					m_pasteLeftColumn = 1;
 
 				// Check if first word in the first line will fit from the cursor position
 				bool firstWordFits = true;
@@ -552,7 +772,7 @@ PasteCommand::PasteCommand(TeletextDocument *teletextDocument, int pageCharSet,
 				// that won't overwrite what's on the page
 				if (charToConvert == QChar::Null)
 					convertedChar = -1;
-				else if (charToConvert >= 0x01 && charToConvert <= 0x1f)
+				else if (charToConvert >= QChar(0x01) && charToConvert <= QChar(0x1f))
 					convertedChar = ' ';
 				else if (keymapping[pageCharSet].contains(charToConvert))
 					// Remapped character or non-Latin character converted successfully
@@ -561,7 +781,7 @@ PasteCommand::PasteCommand(TeletextDocument *teletextDocument, int pageCharSet,
 					// 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)
+					if (convertedChar <= 0)
 						// Couldn't convert - make it a block character so it doesn't need to be inserted-between later on
 						convertedChar = 0x7f;
 				}
@@ -578,26 +798,81 @@ PasteCommand::PasteCommand(TeletextDocument *teletextDocument, int pageCharSet,
 			m_pasteBottomRow = m_pasteTopRow + m_clipboardDataHeight - 1;
 			m_pasteRightColumn = m_pasteLeftColumn + m_clipboardDataWidth - 1;
 		}
+	} else if (mimeData->hasImage()) {
+		QImage imageData = qvariant_cast<QImage>(mimeData->imageData());
+		m_plainText = false;
+		// Round up when dividing pixel size into character cell size
+		m_clipboardDataHeight = (imageData.height() + 2) / 3;
+		m_clipboardDataWidth = (imageData.width() + 1) / 2;
+
+		// Format_MonoLSB reverses the bits which makes them easier to shuffle into sixels
+		if (imageData.depth() == 1)
+			imageData.convertTo(QImage::Format_MonoLSB);
+		else
+			// Only pure black and white images convert reliably this way...
+			imageData = imageData.convertToFormat(QImage::Format_MonoLSB, QList<QRgb>{0x000000ff, 0xffffffff});
+
+		for (int r=0; r<m_clipboardDataHeight; r++)
+			m_pastingCharacters.append(QByteArray(m_clipboardDataWidth, 0x00));
+
+		// Directly read the pixel-bits and convert them to sixels with some funky bit manipulation
+		for (int y=0; y<imageData.height(); y++) {
+			const unsigned char *bytePointer = imageData.constScanLine(y);
+			// Three rows of sixels per character cell
+			const int r = y / 3;
+			// Where to shuffle the bits into the top, middle or bottom row of sixels
+			// Yes it does put the bottom right sixel into bit 5 instead of bit 6;
+			// this gets remedied further on
+			const int yShift = (y % 3) * 2;
+			// The loop does eight horizontal pixels into four character cells at a time
+			for (int x=0; x<imageData.width(); x+=8) {
+				const unsigned char byteScanned = *bytePointer;
+				const int c = x / 2;
+
+				m_pastingCharacters[r][c] = m_pastingCharacters[r][c] | ((byteScanned & 0x03) << yShift);
+				// Since we're doing four character cells at a time, we need to exit the loop
+				// early before we go out of bounds.
+				// Yes it does leave an undefined last column of sixels from images that are an
+				// odd numbered number of pixels wide; this gets remedied further on
+				if (x + 2 >= imageData.width())
+					continue;
+				m_pastingCharacters[r][c+1] = m_pastingCharacters[r][c+1] | (((byteScanned >> 2) & 0x03) << yShift);
+				if (x + 4 >= imageData.width())
+					continue;
+				m_pastingCharacters[r][c+2] = m_pastingCharacters[r][c+2] | (((byteScanned >> 4) & 0x03) << yShift);
+				if (x + 6 >= imageData.width())
+					continue;
+				m_pastingCharacters[r][c+3] = m_pastingCharacters[r][c+3] | (((byteScanned >> 6) & 0x03) << yShift);
+
+				bytePointer++;
+			}
+		}
+
+		for (int r=0; r<m_clipboardDataHeight; r++) {
+			for (int c=0; c<m_clipboardDataWidth; c++)
+				if (m_pastingCharacters.at(r).at(c) & 0x20)
+					// If bit 5 was set, correct this to bit 6
+					// but we keep bit 5 set as all mosaic characters have bit 5 set
+					m_pastingCharacters[r][c] = m_pastingCharacters.at(r).at(c) | 0x40;
+				else
+					// Set bit 5 to have it recognised as a mosaic character
+					m_pastingCharacters[r][c] = m_pastingCharacters.at(r).at(c) | 0x20;
+			// If image was an odd numbered width, neutralise the undefined sixels
+			// on the right half
+			if (imageData.width() & 0x01)
+				m_pastingCharacters[r][m_clipboardDataWidth-1] = m_pastingCharacters.at(r).at(m_clipboardDataWidth-1) & 0x35;
+		}
+
+		if (!m_selectionActive) {
+			m_pasteBottomRow = m_row + m_clipboardDataHeight - 1;
+			m_pasteRightColumn = m_column + m_clipboardDataWidth - 1;
+		}
 	}
 
 	if (m_clipboardDataWidth == 0 || m_clipboardDataHeight == 0)
 		return;
 
-	// Store copy of the characters that we're about to overwrite
+	m_oldCharacters = storeCharacters(m_pasteTopRow, m_pasteLeftColumn, m_pasteBottomRow, m_pasteRightColumn);
-	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"));
 }
@@ -634,9 +909,6 @@ void PasteCommand::redo()
 				}
 			}
 
-		if (r < 25)
-			emit m_teletextDocument->contentsChange(r);
-
 		arrayR++;
 		// If paste area is taller than clipboard data, repeat the pattern
 		// if it wasn't plain text
@@ -648,6 +920,8 @@ void PasteCommand::redo()
 		}
 	}
 
+	emit m_teletextDocument->contentsChanged();
+
 	if (m_selectionActive) {
 		m_teletextDocument->setSelectionCorner(m_selectionCornerRow, m_selectionCornerColumn);
 		m_teletextDocument->moveCursor(m_row, m_column, true);
@@ -664,24 +938,9 @@ void PasteCommand::undo()
 
 	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
 
-	int arrayR = 0;
+	retrieveCharacters(m_pasteTopRow, m_pasteLeftColumn, m_oldCharacters);
-	int arrayC;
 
-	for (int r=m_pasteTopRow; r<=m_pasteBottomRow; r++) {
+	emit m_teletextDocument->contentsChanged();
-		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));
-
-				arrayC++;
-			}
-
-		if (r < 25)
-			emit m_teletextDocument->contentsChange(r);
-
-		arrayR++;
-	}
 
 	if (!m_selectionActive)
 		m_teletextDocument->moveCursor(m_row, m_column);
@@ -730,64 +989,3 @@ void DeleteSubPageCommand::undo()
 	m_teletextDocument->unDeleteSubPageFromRecycle(m_subPageIndex);
 	m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
 }
-
-
-SetColourCommand::SetColourCommand(TeletextDocument *teletextDocument, int colourIndex, int newColour, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
-{
-	m_colourIndex = colourIndex;
-	m_oldColour = teletextDocument->currentSubPage()->CLUT(colourIndex);
-	m_newColour = newColour;
-
-	setText(QObject::tr("colour change"));
-
-}
-
-void SetColourCommand::redo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setCLUT(m_colourIndex, m_newColour);
-
-	emit m_teletextDocument->colourChanged(m_colourIndex);
-	emit m_teletextDocument->refreshNeeded();
-}
-
-void SetColourCommand::undo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setCLUT(m_colourIndex, m_oldColour);
-
-	emit m_teletextDocument->colourChanged(m_colourIndex);
-	emit m_teletextDocument->refreshNeeded();
-}
-
-
-ResetCLUTCommand::ResetCLUTCommand(TeletextDocument *teletextDocument, int colourTable, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
-{
-	m_colourTable = colourTable;
-	for (int i=m_colourTable*8; i<m_colourTable*8+8; i++)
-		m_oldColourEntry[i&7] = teletextDocument->currentSubPage()->CLUT(i);
-
-	setText(QObject::tr("CLUT %1 reset").arg(m_colourTable));
-}
-
-void ResetCLUTCommand::redo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	for (int i=m_colourTable*8; i<m_colourTable*8+8; i++) {
-		m_teletextDocument->currentSubPage()->setCLUT(i, m_teletextDocument->currentSubPage()->CLUT(i, 0));
-		emit m_teletextDocument->colourChanged(i);
-	}
-
-	emit m_teletextDocument->refreshNeeded();
-}
-
-void ResetCLUTCommand::undo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	for (int i=m_colourTable*8; i<m_colourTable*8+8; i++) {
-		m_teletextDocument->currentSubPage()->setCLUT(i, m_oldColourEntry[i&7]);
-		emit m_teletextDocument->colourChanged(i);
-	}
-
-	emit m_teletextDocument->refreshNeeded();
-}

src/qteletextmaker/levelonecommands.h

@@ -0,0 +1,287 @@
+/*
+ * Copyright (C) 2020-2025 Gavin MacGregor
+ *
+ * This file is part of QTeletextMaker.
+ *
+ * QTeletextMaker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * QTeletextMaker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef LEVELONECOMMANDS_H
+#define LEVELONECOMMANDS_H
+
+#include <QByteArrayList>
+#include <QSet>
+#include <QUndoCommand>
+
+#include "document.h"
+
+class LevelOneCommand : public QUndoCommand
+{
+public:
+	LevelOneCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+protected:
+	QByteArrayList storeCharacters(int topRow, int leftColumn, int bottomRow, int rightColumn);
+	void retrieveCharacters(int topRow, int leftColumn, const QByteArrayList &oldChars);
+
+	TeletextDocument *m_teletextDocument;
+	int m_subPageIndex, m_row, m_column;
+	bool m_firstDo;
+};
+
+class TypeCharacterCommand : public LevelOneCommand
+{
+public:
+	enum { Id = 101 };
+
+	TypeCharacterCommand(TeletextDocument *teletextDocument, unsigned char newCharacter, bool insertMode, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	unsigned char m_newCharacter, m_oldRowContents[40], m_newRowContents[40];
+	int m_columnStart, m_columnEnd;
+	bool m_insertMode;
+};
+
+class ToggleMosaicBitCommand : public LevelOneCommand
+{
+public:
+	enum { Id = 102 };
+
+	ToggleMosaicBitCommand(TeletextDocument *teletextDocument, unsigned char bitToToggle, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	unsigned char m_oldCharacter, m_newCharacter;
+};
+
+class BackspaceKeyCommand : public LevelOneCommand
+{
+public:
+	enum { Id = 103 };
+
+	BackspaceKeyCommand(TeletextDocument *teletextDocument, bool insertMode, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	unsigned char m_oldRowContents[40], m_newRowContents[40];
+	int m_columnStart, m_columnEnd;
+	bool m_insertMode;
+};
+
+class DeleteKeyCommand : public LevelOneCommand
+{
+public:
+	enum { Id = 104 };
+
+	DeleteKeyCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+
+private:
+	unsigned char m_oldRowContents[40], m_newRowContents[40];
+};
+
+class ShiftMosaicsCommand : public LevelOneCommand
+{
+public:
+	ShiftMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+	bool mergeWith(const QUndoCommand *command) override;
+
+protected:
+	QByteArrayList m_oldCharacters, m_newCharacters;
+	QSet<QPair<int, int>> m_mosaicList;
+	int m_selectionTopRow, m_selectionBottomRow, m_selectionLeftColumn, m_selectionRightColumn;
+	int m_selectionCornerRow, m_selectionCornerColumn;
+};
+
+class ShiftMosaicsUpCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 110 };
+
+	ShiftMosaicsUpCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class ShiftMosaicsDownCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 111 };
+
+	ShiftMosaicsDownCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class ShiftMosaicsLeftCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 112 };
+
+	ShiftMosaicsLeftCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class ShiftMosaicsRightCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 113 };
+
+	ShiftMosaicsRightCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class FillMosaicsCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 120 };
+
+	FillMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class ClearMosaicsCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 121 };
+
+	ClearMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class InvertMosaicsCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 122 };
+
+	InvertMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	bool mergeWith(const QUndoCommand *command) override;
+	int id() const override { return Id; }
+};
+
+class DitherMosaicsCommand : public ShiftMosaicsCommand
+{
+public:
+	enum { Id = 123 };
+
+	DitherMosaicsCommand(TeletextDocument *teletextDocument, const QSet<QPair<int, int>> &mosaicList, QUndoCommand *parent = 0);
+
+	int id() const override { return Id; }
+};
+
+class InsertSubPageCommand : public LevelOneCommand
+{
+public:
+	InsertSubPageCommand(TeletextDocument *teletextDocument, bool afterCurrentSubPage, bool copySubPage, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	int m_newSubPageIndex;
+	bool m_copySubPage;
+};
+
+class DeleteSubPageCommand : public LevelOneCommand
+{
+public:
+	DeleteSubPageCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+};
+
+class InsertRowCommand : public LevelOneCommand
+{
+public:
+	InsertRowCommand(TeletextDocument *teletextDocument, bool copyRow, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	bool m_copyRow;
+	unsigned char m_deletedBottomRow[40];
+};
+
+class DeleteRowCommand : public LevelOneCommand
+{
+public:
+	DeleteRowCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	unsigned char m_deletedRow[40];
+};
+
+#ifndef QT_NO_CLIPBOARD
+class CutCommand : public LevelOneCommand
+{
+public:
+	CutCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	QByteArrayList m_oldCharacters;
+	int m_selectionTopRow, m_selectionBottomRow, m_selectionLeftColumn, m_selectionRightColumn;
+	int m_selectionCornerRow, m_selectionCornerColumn;
+};
+
+class PasteCommand : public LevelOneCommand
+{
+public:
+	PasteCommand(TeletextDocument *teletextDocument, int pageCharSet, QUndoCommand *parent = 0);
+
+	void redo() override;
+	void undo() override;
+
+private:
+	QByteArrayList m_oldCharacters, m_pastingCharacters;
+	int m_pasteTopRow, m_pasteBottomRow, m_pasteLeftColumn, m_pasteRightColumn;
+	int m_clipboardDataHeight, m_clipboardDataWidth;
+	int m_selectionCornerRow, m_selectionCornerColumn;
+	bool m_selectionActive, m_plainText;
+};
+#endif // !QT_NO_CLIPBOARD
+
+#endif

src/qteletextmaker/loadformats.cpp

@@ -0,0 +1,656 @@
+/*
+ * Copyright (C) 2020-2025 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 "loadformats.h"
+
+#include <QByteArray>
+#include <QDataStream>
+#include <QFile>
+#include <QList>
+#include <QString>
+#include <QStringList>
+#include <QVariant>
+
+#include "hamming.h"
+#include "levelonepage.h"
+#include "pagebase.h"
+
+bool LoadTTIFormat::load(QFile *inFile, QList<PageBase>& subPages, QVariantHash *metadata)
+{
+	m_warnings.clear();
+	m_error.clear();
+
+	QByteArray inLine;
+	int pageNum = 0;
+	int currentSubPageNum = 0;
+	bool firstSubPageAlreadyFound = false;
+	bool pageBodyPacketsFound = false;
+
+//	subPages.clear();
+	subPages.append(PageBase { } );
+
+	PageBase* loadingPage = &subPages[0];
+
+	for (;;) {
+		inLine = inFile->readLine(160).trimmed();
+		if (inLine.isEmpty())
+			break;
+		if (inLine.startsWith("DE,") && metadata != nullptr)
+			metadata->insert("description", QString(inLine.remove(0, 3)));
+		if (inLine.startsWith("PN,")) {
+			if (!firstSubPageAlreadyFound) {
+				// First PN command found, set the page number
+				bool valueOk;
+
+				if (int pageNumRead = inLine.mid(3, 3).toInt(&valueOk, 16); valueOk)
+					if (pageNumRead >= 0x100 && pageNumRead <= 0x8ff) {
+						// Keep page number: to check if page is xFF if we load M/29
+						pageNum = pageNumRead;
+						if (metadata != nullptr)
+							metadata->insert("pageNumber", pageNum);
+					}
+
+				firstSubPageAlreadyFound = true;
+			} else {
+				// Subsequent PN command found; this assumes that PN is the first command of a new subpage
+				currentSubPageNum++;
+				subPages.append(PageBase { } );
+				loadingPage = &subPages[subPages.size()-1];
+			}
+		}
+/*		if (lineType == "SC,") {
+			bool subPageNumberOk;
+			int subPageNumberRead = inLine.mid(3, 4).toInt(&subPageNumberOk, 16);
+			if ((!subPageNumberOk) || subPageNumberRead > 0x3f7f)
+				subPageNumberRead = 0;
+			loadingPage->setSubPageNumber(subPageNumberRead);
+		}*/
+		if (inLine.startsWith("PS,")) {
+			bool pageStatusOk;
+			const int pageStatusRead = inLine.mid(3, 4).toInt(&pageStatusOk, 16);
+			if (pageStatusOk) {
+				loadingPage->setControlBit(PageBase::C4ErasePage, pageStatusRead & 0x4000);
+
+				for (int i=PageBase::C5Newsflash, pageStatusBit=0x0001; i<=PageBase::C11SerialMagazine; i++, pageStatusBit<<=1)
+					loadingPage->setControlBit(i, pageStatusRead & pageStatusBit);
+
+				loadingPage->setControlBit(PageBase::C12NOS, pageStatusRead & 0x0200);
+				loadingPage->setControlBit(PageBase::C13NOS, pageStatusRead & 0x0100);
+				loadingPage->setControlBit(PageBase::C14NOS, pageStatusRead & 0x0080);
+			}
+		}
+		if (inLine.startsWith("RE,")) {
+			bool regionValueOk;
+			const int regionValueRead = inLine.remove(0, 3).toInt(&regionValueOk);
+			if (regionValueOk && metadata != nullptr && regionValueRead >= 0 && regionValueRead <= 15)
+#if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0)
+				metadata->insert(QString("region%1").arg(currentSubPageNum, 3, '0'), regionValueRead);
+#else
+				metadata->insert(QString("region%1").arg(currentSubPageNum, 3, QChar('0')), regionValueRead);
+#endif
+		}
+		if (inLine.startsWith("CT,") && (inLine.endsWith(",C") || inLine.endsWith(",T"))) {
+			bool cycleValueOk;
+			const int cycleValueRead = inLine.mid(3, inLine.size()-5).toInt(&cycleValueOk);
+			if (cycleValueOk && metadata != nullptr && cycleValueRead >= 1 && cycleValueRead <= 99) {
+#if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0)
+				metadata->insert(QString("cycleValue%1").arg(currentSubPageNum, 3, '0'), cycleValueRead);
+				metadata->insert(QString("cycleType%1").arg(currentSubPageNum, 3, '0'), inLine.at(inLine.size()-1));
+#else
+				metadata->insert(QString("cycleValue%1").arg(currentSubPageNum, 3, QChar('0')), cycleValueRead);
+				metadata->insert(QString("cycleType%1").arg(currentSubPageNum, 3, QChar('0')), inLine.at(inLine.size()-1));
+#endif
+			}
+		}
+		if (inLine.startsWith("FL,")) {
+			const QString flLine = QString(inLine.remove(0, 3));
+			if (flLine.count(',') == 5) {
+				// Init packet to all 0xf's as page xFF:3F7F means no page is specified
+				QByteArray fastTextPacket(40, 0xf);
+				fastTextPacket[0] = 0x0;  // Designation code
+				fastTextPacket[38] = 0x0; // CRC word
+				fastTextPacket[39] = 0x0; // CRC word
+
+				for (int i=0; i<6; i++) {
+					bool fastTextLinkOk;
+					int fastTextLinkRead = flLine.section(',', i, i).toInt(&fastTextLinkOk, 16);
+
+					if (fastTextLinkOk) {
+						if (fastTextLinkRead == 0)
+							fastTextLinkRead = 0x8ff;
+						else if (fastTextLinkRead >= 0x100 && fastTextLinkRead <= 0x8ff) {
+							fastTextPacket[i*6+1] = fastTextLinkRead & 0x00f;
+							fastTextPacket[i*6+2] = (fastTextLinkRead & 0x0f0) >> 4;
+							fastTextPacket[i*6+4] = 0x7 | ((fastTextLinkRead & 0x100) >> 5);
+							fastTextPacket[i*6+6] = 0x3 | ((fastTextLinkRead & 0x600) >> 7);
+						}
+					}
+				}
+				loadingPage->setPacket(27, 0, fastTextPacket);
+
+				if (metadata != nullptr)
+					metadata->insert(QString("fastextAbsolute"), true);
+			}
+		}
+		if (inLine.startsWith("OL,")) {
+			bool lineNumberOk;
+			int lineNumber;
+
+			const int secondCommaPosition = inLine.indexOf(',', 3);
+			if (secondCommaPosition != 4 && secondCommaPosition != 5)
+				continue;
+
+			lineNumber = inLine.mid(3, secondCommaPosition-3).toInt(&lineNumberOk, 10);
+			if (lineNumberOk && lineNumber >= 0 && lineNumber <= 29) {
+				inLine.remove(0, secondCommaPosition+1);
+				if (lineNumber <= 25) {
+					for (int c=0; c<40; c++) {
+						// trimmed() helpfully removes CRLF line endings from the just-read line for us
+						// But it also (un)helpfully removes spaces at the end of a 40 character line, so put them back
+						if (c >= inLine.size())
+							inLine.append(' ');
+						if (inLine.at(c) & 0x80)
+							inLine[c] = inLine.at(c) & 0x7f;
+						else if (inLine.at(c) == 0x10)
+							inLine[c] = 0x0d;
+						else if (inLine.at(c) == 0x1b) {
+							inLine.remove(c, 1);
+							inLine[c] = inLine.at(c) & 0xbf;
+						}
+					}
+					pageBodyPacketsFound = true;
+					loadingPage->setPacket(lineNumber, inLine);
+				} else if (inLine.at(0) >= 0x40 && inLine.at(0) <= 0x4f) {
+					const int designationCode = inLine.at(0) & 0x3f;
+					if (inLine.size() < 40) {
+						// OL is too short!
+						if (lineNumber == 26) {
+							// For a too-short enhancement triplets OL, first trim the line down to nearest whole triplet
+							inLine.resize((inLine.size() / 3 * 3) + 1);
+							// Then use "dummy" enhancement triplets to extend the line to the proper length
+							for (int i=inLine.size(); i<40; i+=3)
+								inLine.append("i^@"); // Address 41, Mode 0x1e, Data 0
+						} else
+							// For other triplet OLs and Hamming 8/4 OLs, just pad with zero data
+							for (int i=inLine.size(); i<40; i++)
+								inLine.append("@");
+					}
+					for (int i=1; i<=39; i++)
+						inLine[i] = inLine.at(i) & 0x3f;
+					// Import M/29 whole-magazine packets as X/28 per-page packets
+					if (lineNumber == 29) {
+						if ((pageNum & 0xff) != 0xff)
+							m_warnings.append(QString("M/29/%1 packet found, but page number was not xFF.").arg(designationCode));
+						lineNumber = 28;
+					}
+					pageBodyPacketsFound = true;
+					loadingPage->setPacket(lineNumber, designationCode, inLine);
+				}
+			}
+		}
+	}
+
+	if (!pageBodyPacketsFound) {
+		m_error = "No OL lines found";
+		return false;
+	}
+
+	return true;
+}
+
+
+bool LoadT42Format::readPacket()
+{
+	return m_inFile->read((char *)m_inLine, 42) == 42;
+}
+
+bool LoadT42Format::load(QFile *inFile, QList<PageBase>& subPages, QVariantHash *metadata)
+{
+	int readMagazineNumber, readPacketNumber;
+	int foundMagazineNumber = -1;
+	int foundPageNumber = -1;
+	bool firstPacket0Found = false;
+	bool pageBodyPacketsFound = false;
+	bool errorEnhancements = false;
+	bool errorLinks = false;
+	bool errorPresentation = false;
+
+	m_inFile = inFile;
+
+	m_warnings.clear();
+	m_error.clear();
+	m_reExportWarning = false;
+
+//	subPages.clear();
+	subPages.append(PageBase { });
+
+	PageBase* loadingPage = &subPages[0];
+
+	for (;;) {
+		if (!readPacket())
+			// Reached end of .t42 file, or less than 42 bytes left
+			break;
+
+		// Magazine and packet numbers
+		m_inLine[0] = hamming_8_4_decode[m_inLine[0]];
+		m_inLine[1] = hamming_8_4_decode[m_inLine[1]];
+		if (m_inLine[0] == 0xff || m_inLine[1] == 0xff)
+			// Error decoding magazine or packet number
+			continue;
+		readMagazineNumber = m_inLine[0] & 0x07;
+		readPacketNumber = (m_inLine[0] >> 3) | (m_inLine[1] << 1);
+
+		if (readPacketNumber == 0) {
+			// Hamming decode page number, subcodes and control bits
+			for (int i=2; i<10; i++)
+				m_inLine[i] = hamming_8_4_decode[m_inLine[i]];
+			// See if the page number is valid
+			if (m_inLine[2] == 0xff || m_inLine[3] == 0xff)
+				// Error decoding page number
+				continue;
+
+			const int readPageNumber = (m_inLine[3] << 4) | m_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
+					m_warnings.append("More than one page in .t42 file, only first full page loaded.");
+					m_reExportWarning = true;
+					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 (metadata != nullptr) {
+					if (foundMagazineNumber == 0)
+						metadata->insert("pageNumber", 0x800 | foundPageNumber);
+					else
+						metadata->insert("pageNumber", (foundMagazineNumber << 8) | foundPageNumber);
+				}
+
+				loadingPage->setControlBit(PageBase::C4ErasePage, m_inLine[5] & 0x08);
+				loadingPage->setControlBit(PageBase::C5Newsflash, m_inLine[7] & 0x04);
+				loadingPage->setControlBit(PageBase::C6Subtitle, m_inLine[7] & 0x08);
+				for (int i=0; i<4; i++)
+					loadingPage->setControlBit(PageBase::C7SuppressHeader+i, m_inLine[8] & (1 << i));
+				loadingPage->setControlBit(PageBase::C11SerialMagazine, m_inLine[9] & 0x01);
+				loadingPage->setControlBit(PageBase::C12NOS, m_inLine[9] & 0x08);
+				loadingPage->setControlBit(PageBase::C13NOS, m_inLine[9] & 0x04);
+				loadingPage->setControlBit(PageBase::C14NOS, m_inLine[9] & 0x02);
+
+				// See if there's text in the header row
+				bool headerText = false;
+
+				for (int i=10; i<42; i++)
+					if (m_inLine[i] != 0x20) {
+						// TODO - obey odd parity?
+						m_inLine[i] &= 0x7f;
+						headerText = true;
+					}
+				if (headerText) {
+					// Clear the page address and control bits to spaces before putting the row in
+					for (int i=0; i<10; i++)
+						m_inLine[i] = 0x20;
+
+					loadingPage->setPacket(0, QByteArray((const char *)&m_inLine[2], 40));
+				}
+				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?
+				m_inLine[i] &= 0x7f;
+			loadingPage->setPacket(readPacketNumber, QByteArray((const char *)&m_inLine[2], 40));
+			continue;
+		}
+
+		// X/26, X/27 or X/28
+		int readDesignationCode = hamming_8_4_decode[m_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++) {
+					m_inLine[b+j] = hamming_8_4_decode[m_inLine[b+j]];
+					if (m_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);
+					errorLinks = true;
+					m_inLine[b]   = 0xf;
+					m_inLine[b+1] = 0xf;
+					m_inLine[b+2] = 0xf;
+					m_inLine[b+3] = 0x7;
+					m_inLine[b+4] = 0xf;
+					m_inLine[b+5] = 0x3;
+				}
+			}
+			loadingPage->setPacket(readPacketNumber, readDesignationCode, QByteArray((const char *)&m_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 = m_inLine[b];
+			const int p1 = m_inLine[b+1];
+			const int p2 = m_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 invalid triplet
+					m_inLine[b]   = 0xff;
+					m_inLine[b+1] = 0xff;
+					m_inLine[b+2] = 0xff;
+					errorEnhancements = true;
+				} else {
+					// Zero out whole decoded triplet, bound to make things go wrong...
+					m_inLine[b]   = 0x00;
+					m_inLine[b+1] = 0x00;
+					m_inLine[b+2] = 0x00;
+					errorPresentation = true;
+				}
+			} else {
+				m_inLine[b]   = d & 0x0003f;
+				m_inLine[b+1] = (d & 0x00fc0) >> 6;
+				m_inLine[b+2] = d >> 12;
+			}
+		}
+		loadingPage->setPacket(readPacketNumber, readDesignationCode, QByteArray((const char *)&m_inLine[2], 40));
+	}
+
+	if (!firstPacket0Found) {
+		m_error = "No X/0 found.";
+		return false;
+	} else if (!pageBodyPacketsFound) {
+		m_error = "X/0 found, but no page body packets were found.";
+		return false;
+	}
+
+	if (errorEnhancements)
+		m_warnings.append("Error decoding triplet(s) in enhancement data.");
+	if (errorLinks)
+		m_warnings.append("Error decoding FLOF links.");
+	if (errorPresentation)
+		m_warnings.append("Error decoding triplet(s) in presentation data.");
+	return true;
+}
+
+
+bool LoadHTTFormat::readPacket()
+{
+	unsigned char httLine[45];
+
+	if (m_inFile->read((char *)httLine, 45) != 45)
+		return false;
+
+	if (httLine[0] != 0xaa || httLine[1] != 0xaa || httLine[2] != 0xe4)
+		return false;
+
+	for (int i=0; i<42; i++) {
+		unsigned char b = httLine[i+3];
+		b = (b & 0xf0) >> 4 | (b & 0x0f) << 4;
+		b = (b & 0xcc) >> 2 | (b & 0x33) << 2;
+		b = (b & 0xaa) >> 1 | (b & 0x55) << 1;
+		m_inLine[i] = b;
+	}
+
+	return true;
+}
+
+
+bool LoadEP1Format::load(QFile *inFile, QList<PageBase>& subPages, QVariantHash *metadata)
+{
+	m_warnings.clear();
+	m_error.clear();
+	m_reExportWarning = false;
+
+	unsigned char inLine[42];
+	unsigned char numOfSubPages = 1;
+
+//	subPages.clear();
+	subPages.append(PageBase { } );
+
+	PageBase* loadingPage = &subPages[0];
+
+	for (;;) {
+		// Read six bytes, will either be a header for a (sub)page
+		// or a start header indicating multiple subpages are within
+		if (inFile->read((char *)inLine, 6) != 6)
+			return false;
+		if (inLine[0] == 'J' || inLine[1] == 'W' || inLine[2] == 'C') {
+			// Multiple subpages: get number of subpages then read
+			// next six bytes that really will be the header of the first subpage
+			numOfSubPages = inLine[3];
+			if (inFile->read((char *)inLine, 6) != 6)
+				return false;
+
+			m_warnings.append("More than one page in EP1/EPX file, only first full page loaded.");
+			m_reExportWarning = true;
+		}
+
+		// Check for header of a (sub)page
+		if (inLine[0] != 0xfe || inLine[1] != 0x01)
+			return false;
+
+		// Deal with language code unique to EP1 - unknown values are mapped to English
+		if (metadata != nullptr)
+#if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0)
+			metadata->insert(QString("region%1").arg(0, 3, '0'), m_languageCode.key(inLine[2], 0x09) >> 3);
+#else
+			metadata->insert(QString("region%1").arg(0, 3, QChar('0')), m_languageCode.key(inLine[2], 0x09) >> 3);
+#endif
+
+		const int nationalOption = m_languageCode.key(inLine[2], 0x09) & 0x7;
+
+		loadingPage->setControlBit(PageBase::C12NOS, nationalOption & 0x1);
+		loadingPage->setControlBit(PageBase::C13NOS, nationalOption & 0x2);
+		loadingPage->setControlBit(PageBase::C14NOS, nationalOption & 0x4);
+
+		// If fourth byte is 0xca then "X/26 enhancements header" follows
+		// Otherwise Level 1 page data follows
+		if (inLine[3] == 0xca) {
+			// Read next four bytes that form the "X/26 enhancements header"
+			if (inFile->read((char *)inLine, 4) != 4)
+				return false;
+			// Third and fourth bytes are little-endian length of enhancement data
+			const int numOfX26Bytes = inLine[2] | (inLine[3] << 8);
+			const int numOfX26Packets = (numOfX26Bytes + 39) / 40;
+
+			QByteArray packet(40, 0x00);
+			packet[0] = 0;
+
+			for (int i=0; i<numOfX26Packets; i++) {
+				bool terminatorFound = false;
+				unsigned char terminatorTriplet[3];
+
+				if (inFile->read((char *)inLine, 40) != 40)
+					return false;
+
+				// Assumes that X/26 packets are saved with ascending designation codes...
+				for (int c=1; c<39; c+=3) {
+					if (!terminatorFound) {
+						// Shuffle triplet bits from 6 bit address, 5 bit mode, 7 bit data
+						packet[c] = inLine[c];
+						packet[c+1] = inLine[c+1] | ((inLine[c+2] & 1) << 5);
+						packet[c+2] = inLine[c+2] >> 1;
+						// Address of termination marker is 7f instead of 3f
+						if (inLine[c+1] == 0x1f && inLine[c] == 0x7f) {
+							packet[c] = 0x3f;
+
+							if (inLine[c+2] & 0x01) {
+								// If a termination marker was found, stop reading the packet
+								// and repeat the marker ourselves to the end
+								terminatorFound = true;
+								terminatorTriplet[0] = packet[c+1];
+								terminatorTriplet[1] = packet[c+2];
+							}
+						}
+					} else {
+						packet[c] = 0x3f;
+						packet[c+1] = terminatorTriplet[0];
+						packet[c+2] = terminatorTriplet[1];
+					}
+				}
+
+				loadingPage->setPacket(26, i, packet);
+			}
+		}
+
+		// Level 1 rows
+		for (int r=0; r<24; r++) {
+			if (inFile->read((char *)inLine, 40) != 40)
+				return false;
+
+			for (int c=0; c<40; c++)
+				if (inLine[c] != 0x20) {
+					loadingPage->setPacket(r, QByteArray((const char *)&inLine, 40));
+					break;
+				}
+		}
+
+		numOfSubPages--;
+
+		// FIXME uncomment "if" statement when we're ready to save multi-page EPX files
+		//if (numOfSubPages == 0)
+		break;
+
+		// There are more subpages coming up so skip over the 40 byte buffer and 2 byte terminator
+		if (inFile->read((char *)inLine, 42) != 42)
+			return false;
+
+		subPages.append(PageBase { } );
+		loadingPage = &subPages[subPages.size()-1];
+	}
+	return true;
+}
+
+
+int LoadFormats::s_instances = 0;
+
+LoadFormats::LoadFormats()
+{
+	if (s_instances == 0) {
+		s_fileFormat[0] = new LoadTTIFormat;
+		s_fileFormat[1] = new LoadT42Format;
+		s_fileFormat[2] = new LoadEP1Format;
+		s_fileFormat[3] = new LoadHTTFormat;
+
+		s_filters = "All Supported Files (*.";
+
+		for (int i=0; i<s_size; i++) {
+			if (i != 0)
+				s_filters.append(" *.");
+			s_filters.append(s_fileFormat[i]->extensions().join(" *."));
+		}
+		s_filters.append(");;");
+
+		for (int i=0; i<s_size; i++) {
+			if (i != 0)
+				s_filters.append(";;");
+			s_filters.append(s_fileFormat[i]->fileDialogFilter());
+		}
+	}
+
+	s_instances++;
+}
+
+LoadFormats::~LoadFormats()
+{
+	s_instances--;
+
+	if (s_instances == 0)
+		for (int i=s_size-1; i>=0; i--)
+			delete s_fileFormat[i];
+}
+
+LoadFormat *LoadFormats::findFormat(const QString &suffix) const
+{
+	for (int i=0; i<s_size; i++)
+		if (s_fileFormat[i]->extensions().contains(suffix, Qt::CaseInsensitive))
+			return s_fileFormat[i];
+
+	return nullptr;
+}

src/qteletextmaker/loadformats.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2020-2025 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 LOADFORMATS_H
+#define LOADFORMATS_H
+
+#include <QByteArray>
+#include <QDataStream>
+#include <QFile>
+#include <QList>
+#include <QString>
+#include <QStringList>
+#include <QVariant>
+
+#include "pagebase.h"
+
+class LoadFormat
+{
+public:
+	virtual ~LoadFormat() {};
+
+	virtual bool load(QFile *inFile, QList<PageBase> &subPages, QVariantHash *metadata = nullptr) =0;
+
+	virtual QString description() const =0;
+	virtual QStringList extensions() const =0;
+	QString fileDialogFilter() const { return QString(description() + " (*." + extensions().join(" *.") + ')'); };
+	QStringList warningStrings() const { return m_warnings; };
+	QString errorString() const { return m_error; };
+	bool reExportWarning() const { return m_reExportWarning; };
+
+protected:
+	QStringList m_warnings;
+	QString m_error;
+	bool m_reExportWarning = false;
+};
+
+class LoadTTIFormat : public LoadFormat
+{
+public:
+	bool load(QFile *inFile, QList<PageBase> &subPages, QVariantHash *metadata = nullptr) override;
+
+	QString description() const override { return QString("MRG Systems TTI"); };
+	QStringList extensions() const override { return QStringList { "tti", "ttix" }; };
+};
+
+class LoadT42Format : public LoadFormat
+{
+public:
+	bool load(QFile *inFile, QList<PageBase> &subPages, QVariantHash *metadata = nullptr) override;
+
+	QString description() const override { return QString("t42 packet stream"); };
+	QStringList extensions() const override { return QStringList { "t42" }; };
+
+protected:
+	virtual bool readPacket();
+
+	QFile *m_inFile;
+	unsigned char m_inLine[42];
+};
+
+class LoadHTTFormat : public LoadT42Format
+{
+public:
+	QString description() const override { return QString("HMS SD-Teletext HTT"); };
+	QStringList extensions() const override { return QStringList { "htt" }; };
+
+protected:
+	bool readPacket() override;
+};
+
+class LoadEP1Format : public LoadFormat
+{
+public:
+	bool load(QFile *inFile, QList<PageBase> &subPages, QVariantHash *metadata = nullptr) override;
+
+	QString description() const override { return QString("Softel EP1"); };
+	QStringList extensions() const override { return QStringList { "ep1", "epx" }; };
+
+protected:
+	// Language codes unique to EP1
+	// FIXME duplicated in saveformats.h
+	const QMap<int, int> m_languageCode {
+		{ 0x00, 0x09 }, { 0x01, 0x0d }, { 0x02, 0x18 }, { 0x03, 0x11 }, { 0x04, 0x0b }, { 0x05, 0x17 }, { 0x06, 0x07 },
+		{ 0x08, 0x14 }, { 0x09, 0x0d }, { 0x0a, 0x18 }, { 0x0b, 0x11 }, { 0x0c, 0x0b }, { 0x0e, 0x07 },
+		{ 0x10, 0x09 }, { 0x11, 0x0d }, { 0x12, 0x18 }, { 0x13, 0x11 }, { 0x14, 0x0b }, { 0x15, 0x17 }, { 0x16, 0x1c },
+		{ 0x1d, 0x1e }, { 0x1f, 0x16 },
+		{ 0x21, 0x0d }, { 0x22, 0xff }, { 0x23, 0xff }, { 0x26, 0x07 },
+		{ 0x36, 0x1c }, { 0x37, 0x0e },
+		{ 0x40, 0x09 }, { 0x44, 0x0b }
+	};
+};
+
+
+class LoadFormats
+{
+public:
+	LoadFormats();
+	~LoadFormats();
+
+	LoadFormat *findFormat(const QString &suffix) const;
+	QString filters() const { return s_filters; };
+
+private:
+	static const inline int s_size = 4;
+	static int s_instances;
+	inline static LoadFormat *s_fileFormat[s_size];
+	inline static QString s_filters;
+};
+
+#endif

src/qteletextmaker/main.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -24,13 +24,13 @@
 
 int main(int argc, char *argv[])
 {
-	Q_INIT_RESOURCE(qteletextmaker);
+	Q_INIT_RESOURCE(actionicons);
 	QApplication app(argc, argv);
 	QApplication::setApplicationName("QTeletextMaker");
 	QApplication::setApplicationDisplayName(QApplication::applicationName());
 	QApplication::setOrganizationName("gkmac.co.uk");
 	QApplication::setOrganizationDomain("gkmac.co.uk");
-	QApplication::setApplicationVersion("0.6.1-alpha");
+	QApplication::setApplicationVersion("0.8.2-beta");
 	QCommandLineParser parser;
 	parser.setApplicationDescription(QApplication::applicationName());
 	parser.addHelpOption();

src/qteletextmaker/mainwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -26,11 +26,13 @@
 #include <QGraphicsProxyWidget>
 #include <QGraphicsScene>
 #include <QGraphicsSceneEvent>
+#include <QImage>
 #include <QKeyEvent>
 #include <QMenu>
 #include <QMimeData>
 #include <QPainter>
 #include <QPair>
+#include <QSet>
 #include <QUndoCommand>
 #include <QWidget>
 #include <vector>
@@ -62,8 +64,7 @@ TeletextWidget::TeletextWidget(QFrame *parent) : QFrame(parent)
 	connect(&m_pageRender, &TeletextPageRender::flashChanged, this, &TeletextWidget::updateFlashTimer);
 	connect(&m_pageDecode, &TeletextPageDecode::sidePanelsChanged, this, &TeletextWidget::changeSize);
 	connect(m_teletextDocument, &TeletextDocument::subPageSelected, this, &TeletextWidget::subPageSelected);
-	connect(m_teletextDocument, &TeletextDocument::contentsChange, this, &TeletextWidget::refreshRow);
+	connect(m_teletextDocument, &TeletextDocument::contentsChanged, this, &TeletextWidget::refreshPage);
-	connect(m_teletextDocument, &TeletextDocument::refreshNeeded, this, &TeletextWidget::refreshPage);
 	connect(m_teletextDocument, &TeletextDocument::colourChanged, &m_pageRender, &TeletextPageRender::colourChanged);
 }
 
@@ -94,15 +95,6 @@ void TeletextWidget::subPageSelected()
 	update();
 }
 
-void TeletextWidget::refreshRow(int rowChanged)
-{
-	Q_UNUSED(rowChanged);
-
-	// TODO trace signals where this is called so we can remove this
-	m_pageDecode.decodePage();
-	update();
-}
-
 void TeletextWidget::refreshPage()
 {
 	m_pageDecode.decodePage();
@@ -115,11 +107,11 @@ void TeletextWidget::paintEvent(QPaintEvent *event)
 	QPainter widgetPainter(this);
 
 	m_pageRender.renderPage();
-	widgetPainter.drawPixmap(m_pageDecode.leftSidePanelColumns()*12, 0, *m_pageRender.pagePixmap(m_flashPhase), 0, 0, 480, 250);
+	widgetPainter.drawImage(m_pageDecode.leftSidePanelColumns()*12, 0, *m_pageRender.image(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);
+		widgetPainter.drawImage(0, 0, *m_pageRender.image(m_flashPhase), 864-m_pageDecode.leftSidePanelColumns()*12, 0, m_pageDecode.leftSidePanelColumns()*12, 250);
 	if (m_pageDecode.rightSidePanelColumns())
-		widgetPainter.drawPixmap(480+m_pageDecode.leftSidePanelColumns()*12, 0, *m_pageRender.pagePixmap(m_flashPhase), 480, 0, m_pageDecode.rightSidePanelColumns()*12, 250);
+		widgetPainter.drawImage(480+m_pageDecode.leftSidePanelColumns()*12, 0, *m_pageRender.image(m_flashPhase), 480, 0, m_pageDecode.rightSidePanelColumns()*12, 250);
 }
 
 void TeletextWidget::updateFlashTimer(int newFlashTimer)
@@ -148,13 +140,18 @@ void TeletextWidget::timerEvent(QTimerEvent *event)
 		QWidget::timerEvent(event);
 }
 
-void TeletextWidget::pauseFlash(bool pauseNow)
+void TeletextWidget::pauseFlash(int p)
 {
-	if (pauseNow && m_flashTiming != 0) {
+	if (m_flashTiming != 0) {
 		m_flashTimer.stop();
-		m_flashPhase = 0;
+		m_flashPhase = p;
 		update();
-	} else if (m_flashTiming != 0)
+	}
+}
+
+void TeletextWidget::resumeFlash()
+{
+	if (m_flashTiming != 0)
 		m_flashTimer.start((m_flashTiming == 1) ? 500 : 167, this);
 }
 
@@ -169,24 +166,25 @@ void TeletextWidget::setReveal(bool reveal)
 	update();
 }
 
-void TeletextWidget::setMix(bool mix)
-{
-	m_pageRender.setMix(mix);
-	update();
-}
-
 void TeletextWidget::setShowControlCodes(bool showControlCodes)
 {
 	m_pageRender.setShowControlCodes(showControlCodes);
 	update();
 }
 
+void TeletextWidget::setRenderMode(TeletextPageRender::RenderMode renderMode)
+{
+	m_pageRender.setRenderMode(renderMode);
+	update();
+}
+
 void TeletextWidget::setControlBit(int bitNumber, bool active)
 {
 	m_levelOnePage->setControlBit(bitNumber, active);
 	if (bitNumber == 1 || bitNumber == 2) {
 		m_pageDecode.decodePage();
 		m_pageRender.renderPage(true);
+		update();
 	}
 }
 
@@ -200,33 +198,6 @@ void TeletextWidget::setDefaultNOS(int newDefaultNOS)
 	m_levelOnePage->setDefaultNOS(newDefaultNOS);
 }
 
-void TeletextWidget::setDefaultScreenColour(int newColour)
-{
-	m_levelOnePage->setDefaultScreenColour(newColour);
-	m_pageDecode.decodePage();
-}
-
-void TeletextWidget::setDefaultRowColour(int newColour)
-{
-	m_levelOnePage->setDefaultRowColour(newColour);
-	m_pageDecode.decodePage();
-	update();
-}
-
-void TeletextWidget::setColourTableRemap(int newMap)
-{
-	m_levelOnePage->setColourTableRemap(newMap);
-	m_pageDecode.decodePage();
-	update();
-}
-
-void TeletextWidget::setBlackBackgroundSubst(bool substOn)
-{
-	m_levelOnePage->setBlackBackgroundSubst(substOn);
-	m_pageDecode.decodePage();
-	update();
-}
-
 void TeletextWidget::setSidePanelWidths(int newLeftSidePanelColumns, int newRightSidePanelColumns)
 {
 	m_levelOnePage->setLeftSidePanelDisplayed(newLeftSidePanelColumns != 0);
@@ -262,8 +233,9 @@ void TeletextWidget::keyPressEvent(QKeyEvent *event)
 		// Map it to block character so it doesn't need to be inserted-between later on
 		if (mappedKeyPress & 0x80)
 			mappedKeyPress = 0x7f;
-		if (m_pageDecode.level1MosaicAttribute(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn()) && (mappedKeyPress < 0x40 || mappedKeyPress > 0x5f)) {
+		if ((m_pageDecode.level1MosaicAttr(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn()) || m_teletextDocument->selectionActive()) && (mappedKeyPress < 0x40 || mappedKeyPress > 0x5f)) {
-			// We're on a mosaic and a blast-through character was NOT pressed
+			// A blast-through character was NOT pressed
+			// and we're either on a mosaic or a selection is active
 			if (event->key() >= Qt::Key_0 && event->key() <= Qt::Key_9 && event->modifiers() & Qt::KeypadModifier) {
 				switch (event->key()) {
 					case Qt::Key_7:
@@ -353,6 +325,7 @@ void TeletextWidget::keyPressEvent(QKeyEvent *event)
 		setCharacter(mappedKeyPress);
 		return;
 	}
+
 	switch (event->key()) {
 		case Qt::Key_Backspace:
 			m_teletextDocument->undoStack()->push(new BackspaceKeyCommand(m_teletextDocument, m_insertMode));
@@ -368,16 +341,28 @@ void TeletextWidget::keyPressEvent(QKeyEvent *event)
 			break;
 
 		case Qt::Key_Up:
-			m_teletextDocument->cursorUp(event->modifiers() & Qt::ShiftModifier);
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
+				m_teletextDocument->cursorUp(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Down:
-			m_teletextDocument->cursorDown(event->modifiers() & Qt::ShiftModifier);
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
+				m_teletextDocument->cursorDown(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Left:
-			m_teletextDocument->cursorLeft(event->modifiers() & Qt::ShiftModifier);
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
+				m_teletextDocument->cursorLeft(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Right:
-			m_teletextDocument->cursorRight(event->modifiers() & Qt::ShiftModifier);
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
+				m_teletextDocument->cursorRight(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Return:
 		case Qt::Key_Enter:
@@ -397,11 +382,6 @@ void TeletextWidget::keyPressEvent(QKeyEvent *event)
 		case Qt::Key_PageDown:
 			m_teletextDocument->selectSubPagePrevious();
 			break;
-		case Qt::Key_F6:
-			m_pageDecode.decodePage();
-			m_pageRender.renderPage(true);
-			update();
-			break;
 		default:
 			QFrame::keyPressEvent(event);
 	}
@@ -414,13 +394,70 @@ void TeletextWidget::setCharacter(unsigned char newCharacter)
 
 void TeletextWidget::toggleCharacterBit(unsigned char bitToToggle)
 {
-	m_teletextDocument->undoStack()->push(new ToggleMosaicBitCommand(m_teletextDocument, bitToToggle));
+	if (!m_teletextDocument->selectionActive())
+		m_teletextDocument->undoStack()->push(new ToggleMosaicBitCommand(m_teletextDocument, bitToToggle));
+	else {
+		const QSet<QPair<int, int>> mosaicList = findMosaics();
+
+		if (!mosaicList.isEmpty())
+			switch (bitToToggle) {
+				case 0x7f:
+					m_teletextDocument->undoStack()->push(new FillMosaicsCommand(m_teletextDocument, mosaicList));
+					break;
+				case 0x20:
+					m_teletextDocument->undoStack()->push(new ClearMosaicsCommand(m_teletextDocument, mosaicList));
+					break;
+				case 0x5f:
+					m_teletextDocument->undoStack()->push(new InvertMosaicsCommand(m_teletextDocument, mosaicList));
+					break;
+				case 0x66:
+					m_teletextDocument->undoStack()->push(new DitherMosaicsCommand(m_teletextDocument, mosaicList));
+					break;
+			}
+	}
+}
+
+QSet<QPair<int, int>> TeletextWidget::findMosaics()
+{
+	QSet<QPair<int, int>> result;
+
+	if (!m_teletextDocument->selectionActive())
+		return result;
+
+	for (int r=m_teletextDocument->selectionTopRow(); r<=m_teletextDocument->selectionBottomRow(); r++)
+		for (int c=m_teletextDocument->selectionLeftColumn(); c<=m_teletextDocument->selectionRightColumn(); c++)
+			if (m_pageDecode.level1MosaicChar(r, c))
+				result.insert(qMakePair(r, c));
+
+	return result;
+}
+
+void TeletextWidget::shiftMosaics(int key)
+{
+	const QSet<QPair<int, int>> mosaicList = findMosaics();
+
+	if (!mosaicList.isEmpty())
+		switch (key) {
+			case Qt::Key_Up:
+				m_teletextDocument->undoStack()->push(new ShiftMosaicsUpCommand(m_teletextDocument, mosaicList));
+				break;
+			case Qt::Key_Down:
+				m_teletextDocument->undoStack()->push(new ShiftMosaicsDownCommand(m_teletextDocument, mosaicList));
+				break;
+			case Qt::Key_Left:
+				m_teletextDocument->undoStack()->push(new ShiftMosaicsLeftCommand(m_teletextDocument, mosaicList));
+				break;
+			case Qt::Key_Right:
+				m_teletextDocument->undoStack()->push(new ShiftMosaicsRightCommand(m_teletextDocument, mosaicList));
+				break;
+		}
 }
 
 void TeletextWidget::selectionToClipboard()
 {
 	QByteArray nativeData;
 	QString plainTextData;
+	QImage *imageData = nullptr;
 	QClipboard *clipboard = QApplication::clipboard();
 
 	nativeData.resize(2 + m_teletextDocument->selectionWidth() * m_teletextDocument->selectionHeight());
@@ -429,16 +466,41 @@ void TeletextWidget::selectionToClipboard()
 
 	plainTextData.reserve((m_teletextDocument->selectionWidth()+1) * m_teletextDocument->selectionHeight() - 1);
 
-	int i=2;
+	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)));
+				plainTextData.append(keymapping[m_pageDecode.level1CharSet(r, c)].key(m_teletextDocument->currentSubPage()->character(r, c), QChar(m_teletextDocument->currentSubPage()->character(r, c))));
 			else
 				plainTextData.append(' ');
+
+			if (m_pageDecode.level1MosaicChar(r, c)) {
+				// A first mosaic character was found so create the image "just in time"
+				if (imageData == nullptr) {
+					imageData = new QImage(m_teletextDocument->selectionWidth() * 2, m_teletextDocument->selectionHeight() * 3, QImage::Format_Mono);
+
+					imageData->fill(0);
+				}
+
+				const int ix = (c - m_teletextDocument->selectionLeftColumn()) * 2;
+				const int iy = (r - m_teletextDocument->selectionTopRow()) * 3;
+
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x01)
+					imageData->setPixel(ix, iy, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x02)
+					imageData->setPixel(ix+1, iy, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x04)
+					imageData->setPixel(ix, iy+1, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x08)
+					imageData->setPixel(ix+1, iy+1, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x10)
+					imageData->setPixel(ix, iy+2, 1);
+				if (m_teletextDocument->currentSubPage()->character(r, c) & 0x40)
+					imageData->setPixel(ix+1, iy+2, 1);
+			}
 		}
 
 		plainTextData.append('\n');
@@ -447,6 +509,11 @@ void TeletextWidget::selectionToClipboard()
 	QMimeData *mimeData = new QMimeData();
 	mimeData->setData("application/x-teletext", nativeData);
 	mimeData->setText(plainTextData);
+	if (imageData != nullptr) {
+		mimeData->setImageData(*imageData);
+		delete imageData;
+	}
+
 	clipboard->setMimeData(mimeData);
 }
 
@@ -472,12 +539,19 @@ void TeletextWidget::paste()
 	m_teletextDocument->undoStack()->push(new PasteCommand(m_teletextDocument, m_pageDecode.level1CharSet(m_teletextDocument->cursorRow(), m_teletextDocument->cursorColumn())));
 }
 
+void TeletextWidget::selectAll()
+{
+	m_teletextDocument->setSelection((int)!m_teletextDocument->rowZeroAllowed(), 0, 24, 39);
+}
+
 QPair<int, int> TeletextWidget::mouseToRowAndColumn(const QPoint &mousePosition)
 {
 	int row = mousePosition.y() / 10;
 	int column = mousePosition.x() / 12 - m_pageDecode.leftSidePanelColumns();
-	if (row < 1)
+	const int topRow = (int)!m_teletextDocument->rowZeroAllowed();
-		row = 1;
+
+	if (row < topRow)
+		row = topRow;
 	if (row > 24)
 		row = 24;
 	if (column < 0)
@@ -580,6 +654,9 @@ LevelOneScene::LevelOneScene(QWidget *levelOneWidget, QObject *parent) : QGraphi
 	m_mainGridItemGroup = new QGraphicsItemGroup;
 	m_mainGridItemGroup->setVisible(false);
 	addItem(m_mainGridItemGroup);
+	m_rowZeroGridItemGroup = new QGraphicsItemGroup;
+	m_rowZeroGridItemGroup->setVisible(false);
+	addItem(m_rowZeroGridItemGroup);
 	// Additional vertical pieces of grid for side panels
 	for (int i=0; i<32; i++) {
 		m_sidePanelGridNeeded[i] = false;
@@ -587,14 +664,17 @@ LevelOneScene::LevelOneScene(QWidget *levelOneWidget, QObject *parent) : QGraphi
 		m_sidePanelGridItemGroup[i]->setVisible(false);
 		addItem(m_sidePanelGridItemGroup[i]);
 	}
-	for (int r=1; r<25; r++) {
+	for (int r=0; 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));
+			gridPiece->setPen(QPen(QBrush(QColor(128, 128, 128, (r != 0 && r != 24) ? 192 : 128)), 0));
-			m_mainGridItemGroup->addToGroup(gridPiece);
+			if (r == 0)
+				m_rowZeroGridItemGroup->addToGroup(gridPiece);
+			else
+				m_mainGridItemGroup->addToGroup(gridPiece);
 		}
 
-		if (r < 24)
+		if (r != 0 && 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));
@@ -619,6 +699,7 @@ void LevelOneScene::setBorderDimensions(int sceneWidth, int sceneHeight, int wid
 
 	// Position grid to cover central 40 columns
 	m_mainGridItemGroup->setPos(leftRightBorders + leftSidePanelColumns*12, topBottomBorders);
+	m_rowZeroGridItemGroup->setPos(leftRightBorders + leftSidePanelColumns*12, topBottomBorders);
 
 	updateCursor();
 	updateSelection();
@@ -671,31 +752,61 @@ void LevelOneScene::updateSelection()
 	m_selectionRectItem->setVisible(true);
 }
 
-void LevelOneScene::setMix(bool mix)
+void LevelOneScene::setRenderMode(TeletextPageRender::RenderMode renderMode)
 {
-	if (mix) {
+	static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->setRenderMode(renderMode);
-		m_fullScreenTopRectItem->setBrush(Qt::transparent);
+
-		m_fullScreenBottomRectItem->setBrush(Qt::transparent);
+	QColor fullColour;
-		for (int r=0; r<25; r++) {
+
-			m_fullRowLeftRectItem[r]->setBrush(Qt::transparent);
+	switch (renderMode) {
-			m_fullRowRightRectItem[r]->setBrush(Qt::transparent);
+		case TeletextPageRender::RenderNormal:
-		}
+			setBackgroundBrush(Qt::NoBrush);
-	} else {
+			setFullScreenColour(static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageDecode()->fullScreenQColor());
-		setFullScreenColour(static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageDecode()->fullScreenQColor());
+			for (int r=0; r<25; r++)
-		for (int r=0; r<25; r++)
+				setFullRowColour(r, static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageDecode()->fullRowQColor(r));
-			setFullRowColour(r, static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageDecode()->fullRowQColor(r));
+			return;
+		case TeletextPageRender::RenderMix:
+			setBackgroundBrush(QColor(40, 54, 96));
+			fullColour = Qt::transparent;
+			break;
+		case TeletextPageRender::RenderWhiteOnBlack:
+			setBackgroundBrush(Qt::black);
+			fullColour = Qt::black;
+			break;
+		case TeletextPageRender::RenderBlackOnWhite:
+			setBackgroundBrush(Qt::white);
+			fullColour = Qt::white;
+			break;
+	}
+
+	m_fullScreenTopRectItem->setBrush(fullColour);
+	m_fullScreenBottomRectItem->setBrush(fullColour);
+	for (int r=0; r<25; r++) {
+		m_fullRowLeftRectItem[r]->setBrush(fullColour);
+		m_fullRowRightRectItem[r]->setBrush(fullColour);
 	}
 }
 
 void LevelOneScene::toggleGrid(bool gridOn)
 {
 	m_grid = gridOn;
+
 	m_mainGridItemGroup->setVisible(gridOn);
+	if (static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->rowZeroAllowed())
+		m_rowZeroGridItemGroup->setVisible(gridOn);
 	for (int i=0; i<32; i++)
 		if (m_sidePanelGridNeeded[i])
 			m_sidePanelGridItemGroup[i]->setVisible(gridOn);
 }
 
+void LevelOneScene::toggleRowZeroAllowed(bool allowed)
+{
+	static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->document()->setRowZeroAllowed(allowed);
+
+	if (m_grid)
+		m_rowZeroGridItemGroup->setVisible(allowed);
+}
+
 void LevelOneScene::hideGUIElements(bool hidden)
 {
 	if (hidden) {
@@ -748,7 +859,7 @@ void LevelOneScene::keyReleaseEvent(QKeyEvent *keyEvent)
 
 void LevelOneScene::setFullScreenColour(const QColor &newColor)
 {
-	if (!static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageRender()->mix()) {
+	if (static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageRender()->renderMode() == TeletextPageRender::RenderNormal) {
 		m_fullScreenTopRectItem->setBrush(newColor);
 		m_fullScreenBottomRectItem->setBrush(newColor);
 	}
@@ -756,7 +867,7 @@ void LevelOneScene::setFullScreenColour(const QColor &newColor)
 
 void LevelOneScene::setFullRowColour(int row, const QColor &newColor)
 {
-	if (!static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageRender()->mix()) {
+	if (static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageRender()->renderMode() == TeletextPageRender::RenderNormal) {
 		m_fullRowLeftRectItem[row]->setBrush(newColor);
 		m_fullRowRightRectItem[row]->setBrush(newColor);
 	}

src/qteletextmaker/mainwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -43,15 +43,16 @@ class TeletextWidget : public QFrame
 public:
 	TeletextWidget(QFrame *parent = 0);
 	~TeletextWidget();
-	void setCharacter(unsigned char);
+	void setCharacter(unsigned char newCharacter);
-	void toggleCharacterBit(unsigned char);
+	void toggleCharacterBit(unsigned char bitToToggle);
 	bool insertMode() const { return m_insertMode; };
-	void setInsertMode(bool);
+	void setInsertMode(bool insertMode);
 	bool showControlCodes() const { return m_pageRender.showControlCodes(); };
+	int flashTiming() const { return m_flashTiming; };
 
 	QSize sizeHint() { return QSize(480+(pageDecode()->leftSidePanelColumns()+pageDecode()->rightSidePanelColumns())*12, 250); }
 
-	void inputMethodEvent(QInputMethodEvent *);
+	void inputMethodEvent(QInputMethodEvent *event) override;
 
 	TeletextDocument* document() const { return m_teletextDocument; }
 	TeletextPageDecode *pageDecode() { return &m_pageDecode; }
@@ -64,27 +65,25 @@ signals:
 public slots:
 	void subPageSelected();
 	void refreshPage();
-	void setReveal(bool);
+	void setReveal(bool reveal);
-	void setMix(bool);
+	void setShowControlCodes(bool showControlCodes);
-	void setShowControlCodes(bool);
+	void setRenderMode(TeletextPageRender::RenderMode renderMode);
-	void updateFlashTimer(int);
+	void updateFlashTimer(int newFlashTimer);
-	void pauseFlash(bool);
+	void pauseFlash(int p);
-	void refreshRow(int);
+	void resumeFlash();
 
-	void setControlBit(int, bool);
+	void setControlBit(int bitNumber, bool active);
-	void setDefaultCharSet(int);
+	void setDefaultCharSet(int newDefaultCharSet);
-	void setDefaultNOS(int);
+	void setDefaultNOS(int newDefaultNOS);
-	void setDefaultScreenColour(int);
+	void setSidePanelWidths(int newLeftSidePanelColumns, int newRightSidePanelColumns);
-	void setDefaultRowColour(int);
+	void setSidePanelAtL35Only(bool newSidePanelAtL35Only);
-	void setColourTableRemap(int);
-	void setBlackBackgroundSubst(bool);
-	void setSidePanelWidths(int, int);
-	void setSidePanelAtL35Only(bool);
 
 	void cut();
 	void copy();
 	void paste();
 
+	void selectAll();
+
 	void changeSize();
 
 protected:
@@ -107,9 +106,11 @@ private:
 	int m_flashTiming, m_flashPhase;
 
 	void timerEvent(QTimerEvent *event) override;
+	QSet<QPair<int, int>> findMosaics();
+	void shiftMosaics(int key);
 	void selectionToClipboard();
 
-	QPair<int, int> mouseToRowAndColumn(const QPoint &);
+	QPair<int, int> mouseToRowAndColumn(const QPoint &mousePosition);
 };
 
 class LevelOneScene : public QGraphicsScene
@@ -117,34 +118,35 @@ class LevelOneScene : public QGraphicsScene
 	Q_OBJECT
 
 public:
-	LevelOneScene(QWidget *, QObject *parent = nullptr);
+	LevelOneScene(QWidget *levelOneWidget, QObject *parent = nullptr);
-	void setBorderDimensions(int, int, int, int, int);
+	void setBorderDimensions(int sceneWidth, int sceneHeight, int widgetWidth, int leftSidePanelColumns, int rightSidePanelColumns);
 	QGraphicsRectItem *cursorRectItem() const { return m_cursorRectItem; }
 
 public slots:
 	void updateCursor();
 	void updateSelection();
-	void setMix(bool);
+	void setRenderMode(TeletextPageRender::RenderMode renderMode);
-	void toggleGrid(bool);
+	void toggleGrid(bool gridOn);
-	void hideGUIElements(bool);
+	void toggleRowZeroAllowed(bool allowed);
-	void setFullScreenColour(const QColor &);
+	void hideGUIElements(bool hidden);
-	void setFullRowColour(int, const QColor &);
+	void setFullScreenColour(const QColor &newColor);
+	void setFullRowColour(int row, const QColor &newColor);
 
 signals:
 	void mouseZoomIn();
 	void mouseZoomOut();
 
 protected:
-	bool eventFilter(QObject *, QEvent *);
+	bool eventFilter(QObject *object, QEvent *event);
-	void keyPressEvent(QKeyEvent *);
+	void keyPressEvent(QKeyEvent *event);
-	void keyReleaseEvent(QKeyEvent *);
+	void keyReleaseEvent(QKeyEvent *keyEvent);
 
 private:
 	QGraphicsRectItem *m_fullScreenTopRectItem, *m_fullScreenBottomRectItem;
 	QGraphicsRectItem *m_fullRowLeftRectItem[25], *m_fullRowRightRectItem[25];
 	QGraphicsProxyWidget *m_levelOneProxyWidget;
 	QGraphicsRectItem *m_cursorRectItem, *m_selectionRectItem;
-	QGraphicsItemGroup *m_mainGridItemGroup, *m_sidePanelGridItemGroup[32];
+	QGraphicsItemGroup *m_mainGridItemGroup, *m_rowZeroGridItemGroup, *m_sidePanelGridItemGroup[32];
 	bool m_grid, m_sidePanelGridNeeded[32];
 };
 

src/qteletextmaker/mainwindow.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -21,20 +21,27 @@
 #define MAINWINDOW_H
 
 #include <QCheckBox>
-#include <QComboBox>
+#include <QFileSystemWatcher>
 #include <QGraphicsProxyWidget>
 #include <QGraphicsScene>
 #include <QGraphicsView>
-#include <QMainWindow>
+#include <QImage>
 #include <QLabel>
+#include <QList>
+#include <QMainWindow>
 #include <QPushButton>
+#include <QSlider>
 #include <QToolButton>
 
+#include "dclutdockwidget.h"
+#include "drcspage.h"
+#include "loadformats.h"
 #include "mainwidget.h"
 #include "pagecomposelinksdockwidget.h"
 #include "pageenhancementsdockwidget.h"
 #include "pageoptionsdockwidget.h"
 #include "palettedockwidget.h"
+#include "saveformats.h"
 #include "x26dockwidget.h"
 
 class QAction;
@@ -61,31 +68,42 @@ private slots:
 	bool saveAs();
 	void reload();
 	void exportAuto();
-	void exportT42(bool);
+	void exportFile(bool fromAuto);
 	void exportZXNet();
 	void exportEditTF();
-	void exportPNG();
+	void exportImage();
 	void exportM29();
 	void updateRecentFileActions();
+	void clearRecentFiles();
 	void updateExportAutoAction();
 	void openRecentFile();
 	void about();
 	void updatePageWidgets();
 	void updateCursorPosition();
 
-	void insertRow(bool);
+#ifndef QT_NO_CLIPBOARD
+	void imageToClipboard();
+#endif // !QT_NO_CLIPBOARD
+	void insertRow(bool copyRow);
 	void deleteRow();
-	void insertSubPage(bool, bool);
+	void insertSubPage(bool afterCurrentSubPage, bool copyCurrentSubPage);
 	void deleteSubPage();
 
 	void setSceneDimensions();
-	void setBorder(int);
+	void setBorder(int newViewBorder);
-	void setAspectRatio(int);
+	void setAspectRatio(int newViewAspectRatio);
-	void setSmoothTransform(bool);
+	void setSmoothTransform(bool smoothTransform);
 	void zoomIn();
 	void zoomOut();
+	void zoomSet(int viewZoom);
 	void zoomReset();
 
+	void loadDRCSFile(int drcsType, QString fileName = "");
+	void clearDRCSFile(int drcsType);
+	void swapDRCS();
+
+	void updateWatchedFile(const QString &path);
+
 	void toggleInsertMode();
 
 private:
@@ -95,14 +113,12 @@ private:
 	void init();
 	void createActions();
 	void createStatusBar();
-	void readSettings();
 	void writeSettings();
 	bool maybeSave();
 	void openFile(const QString &fileName);
 	void loadFile(const QString &fileName);
-	static bool hasRecentFiles();
+	void extractImages(QImage sceneImage[], bool smooth = false, bool flashExtract = false);
 	void prependToRecentFiles(const QString &fileName);
-	void setRecentFilesVisible(bool visible);
 	bool saveFile(const QString &fileName);
 	void setCurrentFile(const QString &fileName);
 	static QString strippedName(const QString &fullFileName);
@@ -112,6 +128,10 @@ private:
 	LevelOneScene *m_textScene;
 	QGraphicsView *m_textView;
 
+	QList<DRCSPage> m_drcsPage[2];
+	QString m_drcsFileName[2];
+	QFileSystemWatcher m_fileWatcher;
+
 	int m_viewBorder, m_viewAspectRatio, m_viewZoom;
 	bool m_viewSmoothTransform;
 	PageOptionsDockWidget *m_pageOptionsDockWidget;
@@ -119,23 +139,29 @@ private:
 	X26DockWidget *m_x26DockWidget;
 	PaletteDockWidget *m_paletteDockWidget;
 	PageComposeLinksDockWidget *m_pageComposeLinksDockWidget;
+	DClutDockWidget *m_dClutDockWidget;
 
 	QAction *m_recentFileActs[m_MaxRecentFiles];
-	QAction *m_recentFileSeparator;
 	QAction *m_recentFileSubMenuAct;
 	QAction *m_exportAutoAct;
 	QAction *m_deleteSubPageAction;
+	QAction *m_rowZeroAct;
 	QAction *m_borderActs[3];
 	QAction *m_aspectRatioActs[4];
 	QAction *m_smoothTransformAction;
+	QAction *m_drcsSection[2], *m_drcsClear[2], *m_drcsSwap;
 
 	QLabel *m_subPageLabel, *m_cursorPositionLabel;
 	QToolButton *m_previousSubPageButton, *m_nextSubPageButton;
+	QSlider *m_zoomSlider;
 	QPushButton *m_insertModePushButton;
 	QRadioButton *m_levelRadioButton[4];
 
-	QString m_curFile, m_exportAutoFileName;
+	QString m_curFile, m_exportAutoFileName, m_exportImageFileName;
-	bool m_isUntitled;
+	bool m_isUntitled, m_reExportWarning;
+
+	LoadFormats m_loadFormats;
+	SaveFormats m_saveFormats;
 };
 
 #endif

src/qteletextmaker/pagecomposelinksdockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -24,7 +24,7 @@
 #include <QLineEdit>
 #include <QMap>
 #include <QPair>
-#include <QRegExpValidator>
+#include <QRegularExpressionValidator>
 #include <QString>
 
 #include "pagecomposelinksdockwidget.h"
@@ -61,17 +61,25 @@ PageComposeLinksDockWidget::PageComposeLinksDockWidget(TeletextWidget *parent):
 	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);
+	m_pageNumberValidator = new QRegularExpressionValidator(QRegularExpression("[1-8][0-9A-Fa-f][0-9A-Fa-f]"), this);
 
 	for (int i=0; i<8; i++) {
 		if (i < 4) {
 			// Required at which Levels
 			m_composeLinkLevelCheckbox[i][0] = new QCheckBox(this);
 			x27Layout->addWidget(m_composeLinkLevelCheckbox[i][0], i+2, 1, 1, 1);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+			connect(m_composeLinkLevelCheckbox[i][0], &QCheckBox::checkStateChanged, [=](bool active) { m_parentMainWidget->document()->currentSubPage()->setComposeLinkLevel2p5(i, active); });
+#else
 			connect(m_composeLinkLevelCheckbox[i][0], &QCheckBox::stateChanged, [=](bool active) { m_parentMainWidget->document()->currentSubPage()->setComposeLinkLevel2p5(i, active); });
+#endif
 			m_composeLinkLevelCheckbox[i][1] = new QCheckBox(this);
 			x27Layout->addWidget(m_composeLinkLevelCheckbox[i][1], i+2, 2, 1, 1);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+			connect(m_composeLinkLevelCheckbox[i][1], &QCheckBox::checkStateChanged, [=](bool active) { m_parentMainWidget->document()->currentSubPage()->setComposeLinkLevel3p5(i, active); });
+#else
 			connect(m_composeLinkLevelCheckbox[i][1], &QCheckBox::stateChanged, [=](bool active) { m_parentMainWidget->document()->currentSubPage()->setComposeLinkLevel3p5(i, active); });
+#endif
 		} else {
 			// Selectable link functions for Level 3.5
 			m_composeLinkFunctionComboBox[i-4] = new QComboBox;
@@ -124,7 +132,7 @@ void PageComposeLinksDockWidget::setComposeLinkSubPageNumbers(int linkNumber, co
 	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);
+		const QStringList items = newSubPagesString.split(QLatin1Char(','), Qt::SkipEmptyParts);
 		// Now see if there's valid single numbers or ranges between the commas
 		for (const QString &item : items) {
 			if (item.isEmpty())

src/qteletextmaker/pagecomposelinksdockwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -24,7 +24,7 @@
 #include <QComboBox>
 #include <QDockWidget>
 #include <QLineEdit>
-#include <QRegExpValidator>
+#include <QRegularExpressionValidator>
 #include <QString>
 
 #include "mainwidget.h"
@@ -38,15 +38,15 @@ public:
 	void updateWidgets();
 
 private:
-	void setComposeLinkPageNumber(int, const QString &);
+	void setComposeLinkPageNumber(int linkNumber, const QString &newPageNumberString);
-	void setComposeLinkSubPageNumbers(int, const QString &);
+	void setComposeLinkSubPageNumbers(int linkNumber, const QString &newSubPagesString);
 
 	TeletextWidget *m_parentMainWidget;
 	QCheckBox *m_composeLinkLevelCheckbox[4][2]; // For links 0-3
 	QComboBox *m_composeLinkFunctionComboBox[4]; // For links 4-7; remember to subtract 4!
 	QLineEdit *m_composeLinkPageNumberLineEdit[8], *m_composeLinkSubPageNumbersLineEdit[8];
 
-	QRegExpValidator *m_pageNumberValidator;
+	QRegularExpressionValidator *m_pageNumberValidator;
 };
 
 #endif

src/qteletextmaker/pageenhancementsdockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -26,6 +26,8 @@
 
 #include "pageenhancementsdockwidget.h"
 
+#include "x28commands.h"
+
 PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent): QDockWidget(parent)
 {
 	QVBoxLayout *pageEnhancementsLayout = new QVBoxLayout;
@@ -48,9 +50,9 @@ PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent):
 	m_defaultRowColourCombo = new QComboBox;
 	m_defaultRowColourCombo->setModel(m_parentMainWidget->document()->clutModel());
 	colourLayout->addWidget(m_defaultScreenColourCombo, 0, 1, 1, 1, Qt::AlignTop);
-	connect(m_defaultScreenColourCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->setDefaultScreenColour(index); });
+	connect(m_defaultScreenColourCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->document()->undoStack()->push(new SetFullScreenColourCommand(m_parentMainWidget->document(), index)); });
 	colourLayout->addWidget(m_defaultRowColourCombo, 1, 1, 1, 1, Qt::AlignTop);
-	connect(m_defaultRowColourCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->setDefaultRowColour(index); });
+	connect(m_defaultRowColourCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->document()->undoStack()->push(new SetFullRowColourCommand(m_parentMainWidget->document(), index)); });
 
 	// CLUT remapping
 	colourLayout->addWidget(new QLabel(tr("CLUT remapping")), 2, 0, 1, 1);
@@ -64,12 +66,16 @@ PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent):
 	m_colourTableCombo->addItem("Fore 2  Back 2");
 	m_colourTableCombo->addItem("Fore 2  Back 3");
 	colourLayout->addWidget(m_colourTableCombo, 2, 1, 1, 1, Qt::AlignTop);
-	connect(m_colourTableCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->setColourTableRemap(index); });
+	connect(m_colourTableCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->document()->undoStack()->push(new SetCLUTRemapCommand(m_parentMainWidget->document(), index)); });
 
 	// Black background colour substitution
 	m_blackBackgroundSubstAct = new QCheckBox("Black background colour substitution");
 	colourLayout->addWidget(m_blackBackgroundSubstAct, 3, 0, 1, 2, Qt::AlignTop);
-	connect(m_blackBackgroundSubstAct, &QCheckBox::stateChanged, m_parentMainWidget, &TeletextWidget::setBlackBackgroundSubst);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+	connect(m_blackBackgroundSubstAct, &QCheckBox::checkStateChanged, [=](int state){ m_parentMainWidget->document()->undoStack()->push(new SetBlackBackgroundSubstCommand(m_parentMainWidget->document(), state)); });
+#else
+	connect(m_blackBackgroundSubstAct, &QCheckBox::stateChanged, [=](int state){ m_parentMainWidget->document()->undoStack()->push(new SetBlackBackgroundSubstCommand(m_parentMainWidget->document(), state)); });
+#endif
 
 	// Add group box to the main layout
 	colourGroupBox->setLayout(colourLayout);
@@ -96,7 +102,11 @@ PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent):
 	// Side panels status
 	m_sidePanelStatusAct = new QCheckBox("Side panels at level 3.5 only");
 	sidePanelsLayout->addWidget(m_sidePanelStatusAct, 2, 0, 1, 2, Qt::AlignTop);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+	connect(m_sidePanelStatusAct, &QCheckBox::checkStateChanged, m_parentMainWidget, &TeletextWidget::setSidePanelAtL35Only);
+#else
 	connect(m_sidePanelStatusAct, &QCheckBox::stateChanged, m_parentMainWidget, &TeletextWidget::setSidePanelAtL35Only);
+#endif
 
 	// Add group box to the main layout
 	sidePanelsGroupBox->setLayout(sidePanelsLayout);

src/qteletextmaker/pageenhancementsdockwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -36,8 +36,8 @@ public:
 	void updateWidgets();
 
 private:
-	void setLeftSidePanelWidth(int);
+	void setLeftSidePanelWidth(int newLeftPanelSize);
-	void setRightSidePanelWidth(int);
+	void setRightSidePanelWidth(int newRightPanelSize);
 
 	TeletextWidget *m_parentMainWidget;
 	QComboBox *m_defaultScreenColourCombo, *m_defaultRowColourCombo, *m_colourTableCombo;

src/qteletextmaker/pageoptionsdockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -24,7 +24,7 @@
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
-#include <QRegExpValidator>
+#include <QRegularExpressionValidator>
 #include <QSpinBox>
 #include <QVBoxLayout>
 
@@ -41,7 +41,7 @@ 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);
+	m_pageNumberValidator = new QRegularExpressionValidator(QRegularExpression("[1-8][0-9A-Fa-f][0-9A-Fa-f]"), this);
 
 	QHBoxLayout *pageNumberLayout = new QHBoxLayout;
 	pageNumberLayout->addWidget(new QLabel(tr("Page number")));
@@ -104,7 +104,11 @@ PageOptionsDockWidget::PageOptionsDockWidget(TeletextWidget *parent): QDockWidge
 
 		m_controlBitsAct[i] = new QCheckBox(controlBitsLabel[i]);
 		subPageOptionsLayout->addWidget(m_controlBitsAct[i]);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+		connect(m_controlBitsAct[i], &QCheckBox::checkStateChanged, [=](bool active) { m_parentMainWidget->setControlBit(i, active); });
+#else
 		connect(m_controlBitsAct[i], &QCheckBox::stateChanged, [=](bool active) { m_parentMainWidget->setControlBit(i, active); });
+#endif
 	}
 
 	// Region and language
@@ -192,7 +196,10 @@ void PageOptionsDockWidget::updateWidgets()
 	m_defaultNOSCombo->setCurrentIndex(m_defaultNOSCombo->findData((m_parentMainWidget->document()->currentSubPage()->defaultCharSet() << 3) | m_parentMainWidget->document()->currentSubPage()->defaultNOS()));
 	m_defaultNOSCombo->blockSignals(false);
 	m_secondRegionCombo->blockSignals(true);
-	m_secondRegionCombo->setCurrentText(QString::number(m_parentMainWidget->document()->currentSubPage()->secondCharSet()));
+	if (m_parentMainWidget->document()->currentSubPage()->secondCharSet() == 15)
+		m_secondRegionCombo->setCurrentIndex(0);
+	else
+		m_secondRegionCombo->setCurrentText(QString::number(m_parentMainWidget->document()->currentSubPage()->secondCharSet()));
 	m_secondRegionCombo->blockSignals(false);
 	m_secondNOSCombo->blockSignals(true);
 	updateSecondNOSOptions();

src/qteletextmaker/pageoptionsdockwidget.h

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

src/qteletextmaker/palettedockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -28,7 +28,7 @@
 
 #include "palettedockwidget.h"
 
-#include "levelonecommands.h"
+#include "x28commands.h"
 #include "document.h"
 #include "mainwidget.h"
 
@@ -65,7 +65,11 @@ PaletteDockWidget::PaletteDockWidget(TeletextWidget *parent): QDockWidget(parent
 
 	m_showHexValuesCheckBox = new QCheckBox(tr("Show colour hex values"));
 	paletteGridLayout->addWidget(m_showHexValuesCheckBox, 5, 1, 1, 8);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+	connect(m_showHexValuesCheckBox, &QCheckBox::checkStateChanged, this, &PaletteDockWidget::updateAllColourButtons);
+#else
 	connect(m_showHexValuesCheckBox, &QCheckBox::stateChanged, this, &PaletteDockWidget::updateAllColourButtons);
+#endif
 
 	paletteGridWidget->setLayout(paletteGridLayout);
 	this->setWidget(paletteGridWidget);

src/qteletextmaker/palettedockwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -35,19 +35,19 @@ public:
 	void updateAllColourButtons();
 
 public slots:
-	void updateColourButton(int);
+	void updateColourButton(int colourIndex);
-	void setLevel3p5Accepted(bool);
+	void setLevel3p5Accepted(bool b);
 
 protected:
-	void showEvent(QShowEvent *);
+	void showEvent(QShowEvent *event);
 
 private slots:
-	void selectColour(int);
+	void selectColour(int colourIndex);
-	void setLevel3p5Seen(bool);
+	void setLevel3p5Seen(bool b);
 	void updateLevel3p5Cursor();
 
 private:
-	void resetCLUT(int);
+	void resetCLUT(int colourTable);
 
 	QPushButton *m_colourButton[32], *m_resetButton[4];
 	QCheckBox *m_showHexValuesCheckBox;