Tag version 0.7-beta

If the filename had a non-TTI extension it would not have been changed to
PNG or GIF.

.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}
+    ${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 = 0;
+	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,62 @@
+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)
+
+qt_standard_project_setup()
+
+add_subdirectory(src/qteletextdecoder)
+
+add_subdirectory(3rdparty/QtGifImage)
+
+file (GLOB SOURCES src/qteletextmaker/*.cpp)
+qt_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}
+)
+
+qt_generate_deploy_app_script(
+	TARGET qteletextmaker
+	FILENAME_VARIABLE deploy_script
+	NO_UNSUPPORTED_PLATFORM_ERROR
+)
+install(SCRIPT ${deploy_script})

README.md

@@ -1,14 +1,14 @@
 # QTeletextMaker
 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 5 widget libraries but should also compile with Qt 6.
+It is written in C++ using the Qt 6 widget libraries.
 
 Features
 - Load and save teletext pages in .tti format.
 - Rendering of teletext pages in Levels 1, 1.5, 2.5 and 3.5
 - Rendering of Local Objects and side panels.
 - Import and export of single pages in .t42 format.
-- Export PNG images of teletext pages.
+- Export PNG and animated GIF images of teletext pages.
 - Undo and redo of editing actions.
 - Interactive X/26 Local Enhancement Data triplet editor.
 - Editing of X/27/4 and X/27/5 compositional links to enhancement data pages.
@@ -16,15 +16,23 @@ Features
 - Configurable zoom.
 - View teletext pages in 4:3, 16:9 pillar-box and 16:9 stretch aspect ratios.
 
-Although designed on and developed for Linux, the Qt 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 version 5 or 6 of 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` or `qmake6 && 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.

examples/Template-ActivePosition.tti

@@ -4,6 +4,6 @@ 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@@kfxD@@kfyD@@kfzD@@kf{D@
+OL,26,BvD@@kfwD@@kfxD@@kfyD@@kfzD@@kf{D@@kf|D@
-OL,26,C@kf|D@@kf}D@@kf~D@@kfD@@kfCCCC
+OL,26,C@kf}D@@kf~D@@kfD@@kfCCCCCC
 OL,1,  Active Position across every row      

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

src/qteletextdecoder/CMakeLists.txt

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

src/qteletextdecoder/decode.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -169,7 +169,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;
@@ -723,13 +724,18 @@ 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;
 			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;
@@ -743,9 +749,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

src/qteletextdecoder/decode.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -64,7 +64,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]; };
@@ -261,7 +262,8 @@ private:
 
 	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;
 	int m_fullRowColour[25];

src/qteletextdecoder/document.cpp

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

src/qteletextdecoder/document.h

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

src/qteletextdecoder/levelonepage.cpp

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

src/qteletextdecoder/levelonepage.h

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

src/qteletextdecoder/pagebase.cpp

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

src/qteletextdecoder/pagebase.h

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

src/qteletextdecoder/pagex26base.cpp

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

src/qteletextdecoder/pagex26base.h

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

src/qteletextdecoder/render.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -19,6 +19,7 @@
 
 #include <QBitmap>
 #include <QColor>
+#include <QDir>
 #include <QImage>
 #include <QPainter>
 #include <QPixmap>
@@ -34,8 +35,10 @@ QImage *TeletextFontBitmap::s_fontImage = nullptr;
 
 TeletextFontBitmap::TeletextFontBitmap()
 {
+	Q_INIT_RESOURCE(teletextfonts);
+
 	if (s_instances == 0) {
-		s_fontBitmap = new QBitmap(":/images/teletextfont.png");
+		s_fontBitmap = new QBitmap(":/fontimages/teletextfont.png");
 		s_fontImage = new QImage(s_fontBitmap->toImage());
 	}
 	s_instances++;
@@ -57,7 +60,7 @@ TeletextPageRender::TeletextPageRender()
 		m_pageImage[i] = new QImage(864, 250, QImage::Format_ARGB32_Premultiplied);
 
 	m_reveal = false;
-	m_mix = false;
+	m_renderMode = RenderNormal;
 	m_showControlCodes = false;
 	m_flashBuffersHz = 0;
 
@@ -223,6 +226,13 @@ inline void TeletextPageRender::drawBoldOrItalicCharacter(QPainter &painter, int
 
 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);
 }
@@ -250,9 +260,11 @@ void TeletextPageRender::renderRow(int r, int ph, bool force)
 			}
 		}
 
-		if (ph == 0) {
+		// 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;
 
@@ -275,6 +287,7 @@ void TeletextPageRender::renderRow(int r, int ph, bool force)
 				characterDiacritical = m_decoder->cellCharacterDiacritical(r, c);
 			}
 
+			if (m_renderMode < RenderWhiteOnBlack) {
 				if (m_decoder->cellFlashMode(r, c) == 0)
 					m_foregroundQColor = m_decoder->cellForegroundQColor(r, c);
 				else {
@@ -301,10 +314,11 @@ void TeletextPageRender::renderRow(int r, int ph, bool force)
 					}
 				}
 
-			if (!m_mix || m_decoder->cellBoxed(r, c))
+				if (m_renderMode != RenderMix || m_decoder->cellBoxed(r, c))
 					m_backgroundQColor = m_decoder->cellBackgroundQColor(r, c);
 				else
 					m_backgroundQColor = Qt::transparent;
+			}
 
 			drawCharacter(painter, r, c, characterCode, characterSet, characterDiacritical, m_decoder->cellCharacterFragment(r, c));
 
@@ -436,16 +450,15 @@ void TeletextPageRender::setReveal(bool reveal)
 				m_decoder->setRefresh(r, c, true);
 }
 
-void TeletextPageRender::setMix(bool mix)
+void TeletextPageRender::setRenderMode(RenderMode renderMode)
 {
-	if (mix  == m_mix)
+	if (renderMode == m_renderMode)
 		return;
 
-	m_mix = mix;
+	m_renderMode = renderMode;
 
 	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);
 }
 

src/qteletextdecoder/render.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -22,6 +22,7 @@
 
 #include <QBitmap>
 #include <QColor>
+#include <QIcon>
 #include <QImage>
 #include <QPixmap>
 
@@ -33,8 +34,9 @@ public:
 	TeletextFontBitmap();
 	~TeletextFontBitmap();
 
-	QBitmap *rawBitmap() const { return s_fontBitmap; }
 	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;
@@ -47,11 +49,13 @@ class TeletextPageRender : public QObject
 	Q_OBJECT
 
 public:
+	enum RenderMode { RenderNormal, RenderMix, RenderWhiteOnBlack, RenderBlackOnWhite };
+
 	TeletextPageRender();
 	~TeletextPageRender();
 
 	QImage* image(int i) const { return m_pageImage[i]; };
-	bool mix() const { return m_mix; };
+	RenderMode renderMode() const { return m_renderMode; };
 	void setDecoder(TeletextPageDecode *decoder);
 	void renderPage(bool force=false);
 	bool showControlCodes() const { return m_showControlCodes; };
@@ -59,7 +63,7 @@ public:
 public slots:
 	void colourChanged(int index);
 	void setReveal(bool reveal);
-	void setMix(bool mix);
+	void setRenderMode(RenderMode renderMode);
 	void setShowControlCodes(bool showControlCodes);
 
 signals:
@@ -69,7 +73,8 @@ protected:
 	TeletextFontBitmap m_fontBitmap;
 	QImage* m_pageImage[6];
 	unsigned char m_controlCodeCache[25][40];
-	bool m_reveal, m_mix, m_showControlCodes;
+	RenderMode m_renderMode;
+	bool m_reveal, m_showControlCodes;
 	int m_flashBuffersHz;
 	int m_flashingRow[25];
 

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-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -74,6 +74,10 @@ 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];
@@ -140,6 +144,7 @@ void X26TripletList::updateInternalData()
 				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
@@ -233,11 +238,18 @@ void X26TripletList::updateInternalData()
 			case 0x22: // G3 mosaic character at level 1.5
 			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)
+				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();

src/qteletextdecoder/x26triplets.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -66,6 +66,7 @@ public:
 	X26TripletError error() const { return m_error; }
 	bool reservedMode() const { return m_reservedMode; }
 	bool reservedData() const { return m_reservedData; }
+	bool activePosition1p5Differs() const { return m_activePosition1p5Differs; }
 
 	friend class X26TripletList;
 
@@ -77,6 +78,7 @@ private:
 	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;
@@ -96,11 +98,13 @@ public:
 	bool isEmpty() const { return m_list.isEmpty(); }
 	void reserve(int alloc) { m_list.reserve(alloc); }
 	int size() const { return m_list.size(); }
+	const QList<int> &objects(int t) const { return m_objects[t]; };
 
 private:
 	void updateInternalData();
 
 	QList<X26Triplet> m_list;
+	QList<int> m_objects[3];
 
 	class ActivePosition
 	{

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/keymap.h

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

src/qteletextmaker/levelonecommands.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -21,8 +21,10 @@
 #include <QByteArray>
 #include <QByteArrayList>
 #include <QClipboard>
+#include <QImage>
 #include <QMimeData>
 #include <QRegularExpression>
+#include <QSet>
 
 #include "levelonecommands.h"
 
@@ -38,13 +40,10 @@ LevelOneCommand::LevelOneCommand(TeletextDocument *teletextDocument, QUndoComman
 	m_firstDo = true;
 }
 
-
+QByteArrayList LevelOneCommand::storeCharacters(int topRow, int leftColumn, int bottomRow, int rightColumn)
-StoreOldCharactersCommand::StoreOldCharactersCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
-}
+	QByteArrayList result;
 
-void StoreOldCharactersCommand::storeOldCharacters(int topRow, int leftColumn, int bottomRow, int rightColumn)
-{
 	for (int r=topRow; r<=bottomRow; r++) {
 		QByteArray rowArray;
 
@@ -57,12 +56,17 @@ void StoreOldCharactersCommand::storeOldCharacters(int topRow, int leftColumn, i
 				// Not sure if this is really necessary as out-of-bounds access might not occur?
 				rowArray.append(0x7f);
 
-		m_oldCharacters.append(rowArray);
+		result.append(rowArray);
-	}
 	}
 
-void StoreOldCharactersCommand::retrieveOldCharacters(int topRow, int leftColumn, int bottomRow, int rightColumn)
+	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;
 
@@ -71,7 +75,7 @@ void StoreOldCharactersCommand::retrieveOldCharacters(int topRow, int leftColumn
 		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, m_oldCharacters[arrayR].at(arrayC));
+				m_teletextDocument->currentSubPage()->setCharacter(r, c, storedChars.at(arrayR).at(arrayC));
 
 				arrayC++;
 			}
@@ -148,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"));
 
@@ -308,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;
@@ -394,7 +587,7 @@ void DeleteRowCommand::undo()
 
 
 #ifndef QT_NO_CLIPBOARD
-CutCommand::CutCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : StoreOldCharactersCommand(teletextDocument, parent)
+CutCommand::CutCommand(TeletextDocument *teletextDocument, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
 	m_selectionTopRow = m_teletextDocument->selectionTopRow();
 	m_selectionBottomRow = m_teletextDocument->selectionBottomRow();
@@ -404,7 +597,7 @@ CutCommand::CutCommand(TeletextDocument *teletextDocument, QUndoCommand *parent)
 	m_selectionCornerRow = m_teletextDocument->selectionCornerRow();
 	m_selectionCornerColumn = m_teletextDocument->selectionCornerColumn();
 
-	storeOldCharacters(m_selectionTopRow, m_selectionLeftColumn, m_selectionBottomRow, m_selectionRightColumn);
+	m_oldCharacters = storeCharacters(m_selectionTopRow, m_selectionLeftColumn, m_selectionBottomRow, m_selectionRightColumn);
 
 	setText(QObject::tr("cut"));
 }
@@ -425,7 +618,7 @@ void CutCommand::undo()
 {
 	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
 
-	retrieveOldCharacters(m_selectionTopRow, m_selectionLeftColumn, m_selectionBottomRow, m_selectionRightColumn);
+	retrieveCharacters(m_selectionTopRow, m_selectionLeftColumn, m_oldCharacters);
 
 	emit m_teletextDocument->contentsChanged();
 
@@ -434,7 +627,7 @@ void CutCommand::undo()
 }
 
 
-PasteCommand::PasteCommand(TeletextDocument *teletextDocument, int pageCharSet, QUndoCommand *parent) : StoreOldCharactersCommand(teletextDocument, parent)
+PasteCommand::PasteCommand(TeletextDocument *teletextDocument, int pageCharSet, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
 {
 	const QClipboard *clipboard = QApplication::clipboard();
 	const QMimeData *mimeData = clipboard->mimeData();
@@ -497,9 +690,7 @@ 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.
-				if (m_pasteLeftColumn != 0)
 				m_pasteLeftColumn = 1;
 
 				// Check if first word in the first line will fit from the cursor position
@@ -607,12 +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, QVector<QRgb>{0x000000ff, 0xffffffff});
+
+		for (int r=0; r<m_clipboardDataHeight; r++)
+			m_pastingCharacters.append(QByteArray(m_clipboardDataWidth, 0x00));
+
+		// Directly read the pixel-bits and convert them to sixels with some funky bit manipulation
+		for (int y=0; y<imageData.height(); y++) {
+			const unsigned char *bytePointer = imageData.constScanLine(y);
+			// Three rows of sixels per character cell
+			const int r = y / 3;
+			// Where to shuffle the bits into the top, middle or bottom row of sixels
+			// Yes it does put the bottom right sixel into bit 5 instead of bit 6;
+			// this gets remedied further on
+			const int yShift = (y % 3) * 2;
+			// The loop does eight horizontal pixels into four character cells at a time
+			for (int x=0; x<imageData.width(); x+=8) {
+				const unsigned char byteScanned = *bytePointer;
+				const int c = x / 2;
+
+				m_pastingCharacters[r][c] = m_pastingCharacters[r][c] | ((byteScanned & 0x03) << yShift);
+				// Since we're doing four character cells at a time, we need to exit the loop
+				// early before we go out of bounds.
+				// Yes it does leave an undefined last column of sixels from images that are an
+				// odd numbered number of pixels wide; this gets remedied further on
+				if (x + 2 >= imageData.width())
+					continue;
+				m_pastingCharacters[r][c+1] = m_pastingCharacters[r][c+1] | (((byteScanned >> 2) & 0x03) << yShift);
+				if (x + 4 >= imageData.width())
+					continue;
+				m_pastingCharacters[r][c+2] = m_pastingCharacters[r][c+2] | (((byteScanned >> 4) & 0x03) << yShift);
+				if (x + 6 >= imageData.width())
+					continue;
+				m_pastingCharacters[r][c+3] = m_pastingCharacters[r][c+3] | (((byteScanned >> 6) & 0x03) << yShift);
+
+				bytePointer++;
+			}
+		}
+
+		for (int r=0; r<m_clipboardDataHeight; r++) {
+			for (int c=0; c<m_clipboardDataWidth; c++)
+				if (m_pastingCharacters.at(r).at(c) & 0x20)
+					// If bit 5 was set, correct this to bit 6
+					// but we keep bit 5 set as all mosaic characters have bit 5 set
+					m_pastingCharacters[r][c] = m_pastingCharacters.at(r).at(c) | 0x40;
+				else
+					// Set bit 5 to have it recognised as a mosaic character
+					m_pastingCharacters[r][c] = m_pastingCharacters.at(r).at(c) | 0x20;
+			// If image was an odd numbered width, neutralise the undefined sixels
+			// on the right half
+			if (imageData.width() & 0x01)
+				m_pastingCharacters[r][m_clipboardDataWidth-1] = m_pastingCharacters.at(r).at(m_clipboardDataWidth-1) & 0x35;
+		}
+
+		if (!m_selectionActive) {
+			m_pasteBottomRow = m_row + m_clipboardDataHeight - 1;
+			m_pasteRightColumn = m_column + m_clipboardDataWidth - 1;
+		}
 	}
 
 	if (m_clipboardDataWidth == 0 || m_clipboardDataHeight == 0)
 		return;
 
-	storeOldCharacters(m_pasteTopRow, m_pasteLeftColumn, m_pasteBottomRow, m_pasteRightColumn);
+	m_oldCharacters = storeCharacters(m_pasteTopRow, m_pasteLeftColumn, m_pasteBottomRow, m_pasteRightColumn);
 
 	setText(QObject::tr("paste"));
 }
@@ -678,7 +938,7 @@ void PasteCommand::undo()
 
 	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
 
-	retrieveOldCharacters(m_pasteTopRow, m_pasteLeftColumn, m_pasteBottomRow, m_pasteRightColumn);
+	retrieveCharacters(m_pasteTopRow, m_pasteLeftColumn, m_oldCharacters);
 
 	emit m_teletextDocument->contentsChanged();
 
@@ -729,219 +989,3 @@ void DeleteSubPageCommand::undo()
 	m_teletextDocument->unDeleteSubPageFromRecycle(m_subPageIndex);
 	m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
 }
-
-
-SetFullScreenColourCommand::SetFullScreenColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
-{
-	m_oldColour = teletextDocument->currentSubPage()->defaultScreenColour();
-	m_newColour = newColour;
-
-	setText(QObject::tr("full screen colour"));
-}
-
-void SetFullScreenColourCommand::redo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setDefaultScreenColour(m_newColour);
-
-	emit m_teletextDocument->contentsChanged();
-	emit m_teletextDocument->pageOptionsChanged();
-}
-
-void SetFullScreenColourCommand::undo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setDefaultScreenColour(m_oldColour);
-
-	emit m_teletextDocument->contentsChanged();
-	emit m_teletextDocument->pageOptionsChanged();
-}
-
-bool SetFullScreenColourCommand::mergeWith(const QUndoCommand *command)
-{
-	const SetFullScreenColourCommand *newerCommand = static_cast<const SetFullScreenColourCommand *>(command);
-
-	if (m_subPageIndex != newerCommand->m_subPageIndex)
-		return false;
-
-	m_newColour = newerCommand->m_newColour;
-
-	return true;
-}
-
-
-SetFullRowColourCommand::SetFullRowColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
-{
-	m_oldColour = teletextDocument->currentSubPage()->defaultRowColour();
-	m_newColour = newColour;
-
-	setText(QObject::tr("full row colour"));
-}
-
-void SetFullRowColourCommand::redo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setDefaultRowColour(m_newColour);
-
-	emit m_teletextDocument->contentsChanged();
-	emit m_teletextDocument->pageOptionsChanged();
-}
-
-void SetFullRowColourCommand::undo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setDefaultRowColour(m_oldColour);
-
-	emit m_teletextDocument->contentsChanged();
-	emit m_teletextDocument->pageOptionsChanged();
-}
-
-bool SetFullRowColourCommand::mergeWith(const QUndoCommand *command)
-{
-	const SetFullRowColourCommand *newerCommand = static_cast<const SetFullRowColourCommand *>(command);
-
-	if (m_subPageIndex != newerCommand->m_subPageIndex)
-		return false;
-
-	m_newColour = newerCommand->m_newColour;
-
-	return true;
-}
-
-
-SetCLUTRemapCommand::SetCLUTRemapCommand(TeletextDocument *teletextDocument, int newMap, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
-{
-	m_oldMap = teletextDocument->currentSubPage()->colourTableRemap();
-	m_newMap = newMap;
-
-	setText(QObject::tr("CLUT remapping"));
-}
-
-void SetCLUTRemapCommand::redo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setColourTableRemap(m_newMap);
-
-	emit m_teletextDocument->contentsChanged();
-	emit m_teletextDocument->pageOptionsChanged();
-}
-
-void SetCLUTRemapCommand::undo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setColourTableRemap(m_oldMap);
-
-	emit m_teletextDocument->contentsChanged();
-	emit m_teletextDocument->pageOptionsChanged();
-}
-
-bool SetCLUTRemapCommand::mergeWith(const QUndoCommand *command)
-{
-	const SetCLUTRemapCommand *newerCommand = static_cast<const SetCLUTRemapCommand *>(command);
-
-	if (m_subPageIndex != newerCommand->m_subPageIndex)
-		return false;
-
-	m_newMap = newerCommand->m_newMap;
-
-	return true;
-}
-
-
-SetBlackBackgroundSubstCommand::SetBlackBackgroundSubstCommand(TeletextDocument *teletextDocument, bool newSub, QUndoCommand *parent) : LevelOneCommand(teletextDocument, parent)
-{
-	m_oldSub = teletextDocument->currentSubPage()->blackBackgroundSubst();
-	m_newSub = newSub;
-
-	setText(QObject::tr("black background substitution"));
-}
-
-void SetBlackBackgroundSubstCommand::redo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setBlackBackgroundSubst(m_newSub);
-
-	emit m_teletextDocument->contentsChanged();
-	emit m_teletextDocument->pageOptionsChanged();
-}
-
-void SetBlackBackgroundSubstCommand::undo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setBlackBackgroundSubst(m_oldSub);
-
-	emit m_teletextDocument->contentsChanged();
-	emit m_teletextDocument->pageOptionsChanged();
-}
-
-bool SetBlackBackgroundSubstCommand::mergeWith(const QUndoCommand *command)
-{
-	const SetBlackBackgroundSubstCommand *newerCommand = static_cast<const SetBlackBackgroundSubstCommand *>(command);
-
-	if (m_subPageIndex != newerCommand->m_subPageIndex)
-		return false;
-
-	setObsolete(true);
-	return true;
-}
-
-
-SetColourCommand::SetColourCommand(TeletextDocument *teletextDocument, int colourIndex, int newColour, QUndoCommand *parent) : 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->contentsChanged();
-}
-
-void SetColourCommand::undo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	m_teletextDocument->currentSubPage()->setCLUT(m_colourIndex, m_oldColour);
-
-	emit m_teletextDocument->colourChanged(m_colourIndex);
-	emit m_teletextDocument->contentsChanged();
-}
-
-
-ResetCLUTCommand::ResetCLUTCommand(TeletextDocument *teletextDocument, int colourTable, QUndoCommand *parent) : 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->contentsChanged();
-}
-
-void ResetCLUTCommand::undo()
-{
-	m_teletextDocument->selectSubPageIndex(m_subPageIndex);
-	for (int i=m_colourTable*8; i<m_colourTable*8+8; i++) {
-		m_teletextDocument->currentSubPage()->setCLUT(i, m_oldColourEntry[i&7]);
-		emit m_teletextDocument->colourChanged(i);
-	}
-
-	emit m_teletextDocument->contentsChanged();
-}

src/qteletextmaker/levelonecommands.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -21,6 +21,7 @@
 #define LEVELONECOMMANDS_H
 
 #include <QByteArrayList>
+#include <QSet>
 #include <QUndoCommand>
 
 #include "document.h"
@@ -31,23 +32,14 @@ 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 StoreOldCharactersCommand : public LevelOneCommand
-{
-public:
-	StoreOldCharactersCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
-
-protected:
-	void storeOldCharacters(int topRow, int leftColumn, int bottomRow, int rightColumn);
-	void retrieveOldCharacters(int topRow, int leftColumn, int bottomRow, int rightColumn);
-
-	QByteArrayList m_oldCharacters;
-};
-
 class TypeCharacterCommand : public LevelOneCommand
 {
 public:
@@ -116,6 +108,103 @@ 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:
@@ -164,7 +253,7 @@ private:
 };
 
 #ifndef QT_NO_CLIPBOARD
-class CutCommand : public StoreOldCharactersCommand
+class CutCommand : public LevelOneCommand
 {
 public:
 	CutCommand(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
@@ -173,11 +262,12 @@ public:
 	void undo() override;
 
 private:
+	QByteArrayList m_oldCharacters;
 	int m_selectionTopRow, m_selectionBottomRow, m_selectionLeftColumn, m_selectionRightColumn;
 	int m_selectionCornerRow, m_selectionCornerColumn;
 };
 
-class PasteCommand : public StoreOldCharactersCommand
+class PasteCommand : public LevelOneCommand
 {
 public:
 	PasteCommand(TeletextDocument *teletextDocument, int pageCharSet, QUndoCommand *parent = 0);
@@ -186,7 +276,7 @@ public:
 	void undo() override;
 
 private:
-	QByteArrayList m_pastingCharacters;
+	QByteArrayList m_oldCharacters, m_pastingCharacters;
 	int m_pasteTopRow, m_pasteBottomRow, m_pasteLeftColumn, m_pasteRightColumn;
 	int m_clipboardDataHeight, m_clipboardDataWidth;
 	int m_selectionCornerRow, m_selectionCornerColumn;
@@ -194,93 +284,4 @@ private:
 };
 #endif // !QT_NO_CLIPBOARD
 
-class SetFullScreenColourCommand : public LevelOneCommand
-{
-public:
-	enum { Id = 105 };
-
-	SetFullScreenColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-	bool mergeWith(const QUndoCommand *command) override;
-	int id() const override { return Id; }
-
-private:
-	int m_oldColour, m_newColour;
-};
-
-class SetFullRowColourCommand : public LevelOneCommand
-{
-public:
-	enum { Id = 106 };
-
-	SetFullRowColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-	bool mergeWith(const QUndoCommand *command) override;
-	int id() const override { return Id; }
-
-private:
-	int m_oldColour, m_newColour;
-};
-
-class SetCLUTRemapCommand : public LevelOneCommand
-{
-public:
-	enum { Id = 107 };
-
-	SetCLUTRemapCommand(TeletextDocument *teletextDocument, int newMap, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-	bool mergeWith(const QUndoCommand *command) override;
-	int id() const override { return Id; }
-
-private:
-	int m_oldMap, m_newMap;
-};
-
-class SetBlackBackgroundSubstCommand : public LevelOneCommand
-{
-public:
-	enum { Id = 108 };
-
-	SetBlackBackgroundSubstCommand(TeletextDocument *teletextDocument, bool newSub, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-	bool mergeWith(const QUndoCommand *command) override;
-	int id() const override { return Id; }
-
-private:
-	int m_oldSub, m_newSub;
-};
-
-class SetColourCommand : public LevelOneCommand
-{
-public:
-	SetColourCommand(TeletextDocument *teletextDocument, int colourIndex, int newColour, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-
-private:
-	int m_colourIndex, m_oldColour, m_newColour;
-};
-
-class ResetCLUTCommand : public LevelOneCommand
-{
-public:
-	ResetCLUTCommand(TeletextDocument *teletextDocument, int colourTable, QUndoCommand *parent = 0);
-
-	void redo() override;
-	void undo() override;
-
-private:
-	int m_colourTable;
-	int m_oldColourEntry[8];
-};
-
 #endif

src/qteletextmaker/loadsave.cpp

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

src/qteletextmaker/loadsave.h

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

src/qteletextmaker/main.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 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.3-beta");
+	QApplication::setApplicationVersion("0.7-beta");
 	QCommandLineParser parser;
 	parser.setApplicationDescription(QApplication::applicationName());
 	parser.addHelpOption();

src/qteletextmaker/mainwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 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>
@@ -138,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);
 }
 
@@ -159,18 +166,18 @@ 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);
@@ -226,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:
@@ -317,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));
@@ -332,15 +341,27 @@ void TeletextWidget::keyPressEvent(QKeyEvent *event)
 			break;
 
 		case Qt::Key_Up:
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
 				m_teletextDocument->cursorUp(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Down:
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
 				m_teletextDocument->cursorDown(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Left:
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
 				m_teletextDocument->cursorLeft(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Right:
+			if (event->modifiers() & Qt::ControlModifier)
+				shiftMosaics(event->key());
+			else
 				m_teletextDocument->cursorRight(event->modifiers() & Qt::ShiftModifier);
 			break;
 		case Qt::Key_Return:
@@ -361,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);
 	}
@@ -378,13 +394,70 @@ void TeletextWidget::setCharacter(unsigned char newCharacter)
 
 void TeletextWidget::toggleCharacterBit(unsigned char 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());
@@ -403,6 +476,31 @@ void TeletextWidget::selectionToClipboard()
 				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');
@@ -411,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);
 }
 
@@ -635,19 +738,34 @@ 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:
-		}
-	} else {
 			setFullScreenColour(static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageDecode()->fullScreenQColor());
 			for (int r=0; r<25; r++)
 				setFullRowColour(r, static_cast<TeletextWidget *>(m_levelOneProxyWidget->widget())->pageDecode()->fullRowQColor(r));
+			return;
+		case TeletextPageRender::RenderMix:
+			fullColour = Qt::transparent;
+			break;
+		case TeletextPageRender::RenderWhiteOnBlack:
+			fullColour = Qt::black;
+			break;
+		case TeletextPageRender::RenderBlackOnWhite:
+			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);
 	}
 }
 
@@ -712,7 +830,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);
 	}
@@ -720,7 +838,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-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -48,6 +48,7 @@ public:
 	bool insertMode() const { return m_insertMode; };
 	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); }
 
@@ -65,10 +66,11 @@ public slots:
 	void subPageSelected();
 	void refreshPage();
 	void setReveal(bool reveal);
-	void setMix(bool mix);
 	void setShowControlCodes(bool showControlCodes);
+	void setRenderMode(TeletextPageRender::RenderMode renderMode);
 	void updateFlashTimer(int newFlashTimer);
-	void pauseFlash(bool pauseNow);
+	void pauseFlash(int p);
+	void resumeFlash();
 
 	void setControlBit(int bitNumber, bool active);
 	void setDefaultCharSet(int newDefaultCharSet);
@@ -102,6 +104,8 @@ 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 &mousePosition);
@@ -119,7 +123,7 @@ public:
 public slots:
 	void updateCursor();
 	void updateSelection();
-	void setMix(bool mix);
+	void setRenderMode(TeletextPageRender::RenderMode renderMode);
 	void toggleGrid(bool gridOn);
 	void hideGUIElements(bool hidden);
 	void setFullScreenColour(const QColor &newColor);

src/qteletextmaker/mainwindow.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -33,6 +33,7 @@
 #include <QScreen>
 #include <QSettings>
 #include <QShortcut>
+#include <QSlider>
 #include <QStatusBar>
 #include <QToolBar>
 #include <QToolButton>
@@ -49,6 +50,8 @@
 #include "palettedockwidget.h"
 #include "x26dockwidget.h"
 
+#include "gifimage/qgifimage.h"
+
 MainWindow::MainWindow()
 {
 	init();
@@ -178,53 +181,129 @@ void MainWindow::reload()
 	m_textWidget->document()->selectSubPageIndex(subPageIndex, true);
 }
 
-void MainWindow::exportPNG()
+void MainWindow::exportImage()
 {
-	QString exportFileName = QFileDialog::getSaveFileName(this, tr("Export PNG"), QString(), "PNG image (*.png)");
+	QString exportFileName, selectedFilter, gifFilter;
+
+	if (!m_exportImageFileName.isEmpty())
+		exportFileName = m_exportImageFileName;
+	else {
+		// Image not exported before: suggest a filename with image extension
+		// If page has flashing, suggest GIF
+		exportFileName = m_curFile.left(m_curFile.lastIndexOf('.'));
+		exportFileName.append(m_textWidget->flashTiming() != 0 ? ".gif" : ".png");
+	}
+
+	if (m_textWidget->flashTiming() != 0)
+		gifFilter = "Animated GIF image (*.gif)";
+	else
+		gifFilter = "GIF image (*.gif)";
+
+	// Set the filter in the file dialog to the same as the current filename extension
+	if (QFileInfo(exportFileName).suffix().toLower() == "gif")
+		selectedFilter = gifFilter;
+	else
+		selectedFilter = "PNG image (*.png)";
+
+	exportFileName = QFileDialog::getSaveFileName(this, tr("Export image"), exportFileName, "PNG image (*.png);;" + gifFilter, &selectedFilter);
 	if (exportFileName.isEmpty())
 		return;
 
-	// Prepare widget image for extraction
+	const QString suffix = QFileInfo(exportFileName).suffix().toLower();
-	m_textWidget->pauseFlash(true);
+
-	m_textScene->hideGUIElements(true);
+	if (suffix.isEmpty()) {
-	// Disable exporting in Mix mode as it corrupts the background
+		QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("No filename extension specified."));
-	bool reMix = m_textWidget->pageRender()->mix();
+		return;
-	if (reMix) {
+	} else if (suffix != "png" && suffix != "gif") {
-		m_textWidget->setMix(false);
+		QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export image of format %1.").arg(suffix));
-		m_textScene->setMix(false);
+		return;
 	}
 
-	// Extract the image from the scene
+	// Disable flash exporting if extension is not GIF
-	QImage interImage = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
+	const int flashTiming = suffix == "gif" ? m_textWidget->flashTiming() : 0;
+
+	// Prepare widget image for extraction
+	m_textScene->hideGUIElements(true);
+	// Disable exporting in Mix mode as it corrupts the background
+	bool reMix = m_textWidget->pageRender()->renderMode() == TeletextPageRender::RenderMix;
+	if (reMix)
+		m_textScene->setRenderMode(TeletextPageRender::RenderNormal);
+
+	// Allocate initial image, with additional images for flashing if necessary
+	QImage interImage[6];
+
+	interImage[0] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
+	if (flashTiming != 0) {
+		interImage[3] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
+		if (flashTiming == 2) {
+			interImage[1] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
+			interImage[2] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
+			interImage[4] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
+			interImage[5] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
+		}
+	}
+
+	// Now extract the image(s) from the scene
+	for (int p=0; p<6; p++)
+		if (!interImage[p].isNull()) {
+			m_textWidget->pauseFlash(p);
 			//	This ought to make the background transparent in Mix mode, but it doesn't
 			//	if (m_textWidget->pageDecode()->mix())
 			//		interImage.fill(QColor(0, 0, 0, 0));
-	QPainter interPainter(&interImage);
+			QPainter interPainter(&interImage[p]);
 			m_textScene->render(&interPainter);
+		}
 
 	// Now we've extracted the image we can put the GUI things back
 	m_textScene->hideGUIElements(false);
-	if (reMix) {
+	if (reMix)
-		m_textWidget->setMix(true);
+		m_textScene->setRenderMode(TeletextPageRender::RenderMix);
-		m_textScene->setMix(true);
+	m_textWidget->resumeFlash();
-	}
-	m_textWidget->pauseFlash(false);
 
-	// Now scale the extracted image to the selected aspect ratio
+	// Now scale the extracted image(s) to the selected aspect ratio
-	// We do this in two steps so that anti-aliasing only occurs on vertical lines
+	QImage scaledImage[6];
 
+	for (int p=0; p<6; p++)
+		if (!interImage[p].isNull())
+			if (m_viewAspectRatio == 3)
+				// Aspect ratio is Pixel 1:2 so we only need to double the vertical height
+				scaledImage[p] = interImage[p].scaled(interImage[p].width(), interImage[p].height()*2, Qt::IgnoreAspectRatio, Qt::FastTransformation);
+			else {
+				// Scale the image in two steps so that smoothing only occurs on vertical lines
 				// Double the vertical height first
-	const QImage doubleHeightImage = interImage.scaled(interImage.width(), interImage.height()*2, Qt::IgnoreAspectRatio, Qt::FastTransformation);
+				const QImage doubleHeightImage = interImage[p].scaled(interImage[p].width(), interImage[p].height()*2, Qt::IgnoreAspectRatio, Qt::FastTransformation);
+				// then scale it horizontally to the selected aspect ratio
+				// Don't smooth GIF as it's bound to break the 256 colour limit
+				scaledImage[p] = doubleHeightImage.scaled((int)((float)doubleHeightImage.width() * aspectRatioHorizontalScaling[m_viewAspectRatio] * 2), doubleHeightImage.height(), Qt::IgnoreAspectRatio, (suffix == "gif") ? Qt::FastTransformation : Qt::SmoothTransformation);
+			}
 
-	// If aspect ratio is Pixel 1:2 we're already at the correct scale
+	if (suffix == "png") {
-	if (m_viewAspectRatio != 3) {
+		if (scaledImage[0].save(exportFileName, "PNG"))
-		// Scale it horizontally to the selected aspect ratio
+			m_exportImageFileName = exportFileName;
-		const QImage scaledImage = doubleHeightImage.scaled((int)((float)doubleHeightImage.width() * aspectRatioHorizontalScaling[m_viewAspectRatio] * 2), doubleHeightImage.height(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+		else
+			QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export image %1.").arg(QDir::toNativeSeparators(exportFileName)));
+	}
 
-		if (!scaledImage.save(exportFileName, "PNG"))
+	if (suffix == "gif") {
-			QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export file %1.").arg(QDir::toNativeSeparators(exportFileName)));
+		QGifImage gif(scaledImage[0].size());
-	} else if (!doubleHeightImage.save(exportFileName, "PNG"))
+
-		QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export file %1.").arg(QDir::toNativeSeparators(exportFileName)));
+		if (scaledImage[3].isNull())
+			// No flashing
+			gif.addFrame(scaledImage[0], 0);
+		else if (interImage[1].isNull()) {
+			// 1Hz flashing
+			gif.addFrame(scaledImage[0], 500);
+			gif.addFrame(scaledImage[3], 500);
+		} else
+			// 2Hz flashing
+			for (int p=0; p<6; p++)
+				gif.addFrame(scaledImage[p], (p % 3 == 0) ? 166 : 167);
+
+		if (gif.save(exportFileName))
+			m_exportImageFileName = exportFileName;
+		else
+			QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export image %1.").arg(QDir::toNativeSeparators(exportFileName)));
+	}
 }
 
 void MainWindow::exportZXNet()
@@ -242,7 +321,7 @@ void MainWindow::about()
 	QMessageBox::about(this, tr("About"), QString("<b>%1</b><br>"
 	"An open source Level 2.5 teletext page editor.<br>"
 	"<i>Version %2</i><br><br>"
-	"Copyright (C) 2020-2024 Gavin MacGregor<br><br>"
+	"Copyright (C) 2020-2025 Gavin MacGregor<br><br>"
 	"Released under the GNU General Public License version 3<br>"
 	"<a href=\"https://github.com/gkthemac/qteletextmaker\">https://github.com/gkthemac/qteletextmaker</a>").arg(QApplication::applicationDisplayName()).arg(QApplication::applicationVersion()));
 }
@@ -278,6 +357,7 @@ void MainWindow::init()
 	if (m_viewSmoothTransform)
 		m_textView->setRenderHints(QPainter::SmoothPixmapTransform);
 	m_textView->setBackgroundBrush(QBrush(QColor(32, 48, 96)));
+	m_zoomSlider->setValue(m_viewZoom);
 	setSceneDimensions();
 	setCentralWidget(m_textView);
 
@@ -394,9 +474,9 @@ void MainWindow::createActions()
 	exportEditTFAct->setStatusTip("Export and open this subpage in the edit.tf online editor");
 	connect(exportEditTFAct, &QAction::triggered, this, &MainWindow::exportEditTF);
 
-	QAction *exportPNGAct = fileMenu->addAction(tr("Export subpage as PNG..."));
+	QAction *exportImageAct = fileMenu->addAction(tr("Export subpage as image..."));
-	exportPNGAct->setStatusTip("Export a PNG image of this subpage");
+	exportImageAct->setStatusTip("Export an image of this subpage");
-	connect(exportPNGAct, &QAction::triggered, this, &MainWindow::exportPNG);
+	connect(exportImageAct, &QAction::triggered, this, &MainWindow::exportImage);
 
 	QAction *exportM29Act = fileMenu->addAction(tr("Export subpage X/28 as M/29..."));
 	exportM29Act->setStatusTip("Export this subpage's X/28 packets as a tti file with M/29 packets");
@@ -502,13 +582,6 @@ void MainWindow::createActions()
 	revealAct->setStatusTip(tr("Toggle reveal"));
 	connect(revealAct, &QAction::toggled, m_textWidget, &TeletextWidget::setReveal);
 
-	QAction *mixAct = viewMenu->addAction(tr("&Mix"));
-	mixAct->setCheckable(true);
-	mixAct->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_M));
-	mixAct->setStatusTip(tr("Toggle mix"));
-	connect(mixAct, &QAction::toggled, m_textWidget, &TeletextWidget::setMix);
-	connect(mixAct, &QAction::toggled, m_textScene, &LevelOneScene::setMix);
-
 	QAction *gridAct = viewMenu->addAction(tr("&Grid"));
 	gridAct->setCheckable(true);
 	gridAct->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_G));
@@ -523,6 +596,17 @@ void MainWindow::createActions()
 
 	viewMenu->addSeparator();
 
+	QMenu *renderModeSubMenu = viewMenu->addMenu(tr("Render mode"));
+	QAction *renderModeActs[4];
+	renderModeActs[0] = renderModeSubMenu->addAction(tr("Normal"));
+	renderModeActs[0]->setStatusTip(tr("Render page normally"));
+	renderModeActs[1] = renderModeSubMenu->addAction(tr("Mix"));
+	renderModeActs[1]->setStatusTip(tr("Render page in mix mode"));
+	renderModeActs[2] = renderModeSubMenu->addAction(tr("White on black"));
+	renderModeActs[2]->setStatusTip(tr("Render page with white foreground on black background"));
+	renderModeActs[3] = renderModeSubMenu->addAction(tr("Black on white"));
+	renderModeActs[3]->setStatusTip(tr("Render page with black foreground on white background"));
+
 	QMenu *borderSubMenu = viewMenu->addMenu(tr("Border"));
 	m_borderActs[0] = borderSubMenu->addAction(tr("None"));
 	m_borderActs[0]->setStatusTip(tr("View with no border"));
@@ -541,18 +625,26 @@ void MainWindow::createActions()
 	m_aspectRatioActs[3] = aspectRatioSubMenu->addAction(tr("Pixel 1:2"));
 	m_aspectRatioActs[3]->setStatusTip(tr("View with 1:2 pixel mapping"));
 
+	QActionGroup *renderModeGroup = new QActionGroup(this);
 	QActionGroup *borderGroup = new QActionGroup(this);
 	QActionGroup *aspectRatioGroup = new QActionGroup(this);
 	for (int i=0; i<=3; i++) {
+		renderModeActs[i]->setCheckable(true);
+		connect(renderModeActs[i], &QAction::triggered, [=]() { m_textScene->setRenderMode(static_cast<TeletextPageRender::RenderMode>(i)); });
+		renderModeGroup->addAction(renderModeActs[i]);
+
 		m_aspectRatioActs[i]->setCheckable(true);
 		connect(m_aspectRatioActs[i], &QAction::triggered, [=]() { setAspectRatio(i); });
 		aspectRatioGroup->addAction(m_aspectRatioActs[i]);
+
 		if (i == 3)
 			break;
+
 		m_borderActs[i]->setCheckable(true);
 		connect(m_borderActs[i], &QAction::triggered, [=]() { setBorder(i); });
 		borderGroup->addAction(m_borderActs[i]);
 	}
+	renderModeActs[0]->setChecked(true);
 
 	viewMenu->addSeparator();
 
@@ -766,26 +858,36 @@ void MainWindow::setSmoothTransform(bool smoothTransform)
 
 void MainWindow::zoomIn()
 {
-	if (m_viewZoom < 4)
+	if (m_viewZoom < 4) {
 		m_viewZoom++;
-	else if (m_viewZoom < 12)
+		m_zoomSlider->setValue(m_viewZoom);
+	} else if (m_viewZoom < 12) {
 		m_viewZoom += 2;
-	setSceneDimensions();
+		m_zoomSlider->setValue(m_viewZoom / 2 + 2);
+	}
 }
 
 void MainWindow::zoomOut()
 {
-	if (m_viewZoom > 4)
+	if (m_viewZoom > 4) {
 		m_viewZoom -= 2;
-	else if (m_viewZoom > 0)
+		m_zoomSlider->setValue(m_viewZoom == 4 ? 4 : m_viewZoom / 2 + 2);
+	} else if (m_viewZoom > 0) {
 		m_viewZoom--;
+		m_zoomSlider->setValue(m_viewZoom);
+	}
+}
+
+void MainWindow::zoomSet(int viewZoom)
+{
+	m_viewZoom = (viewZoom < 5) ? viewZoom : (viewZoom - 2) * 2;
 	setSceneDimensions();
 }
 
 void MainWindow::zoomReset()
 {
 	m_viewZoom = 2;
-	setSceneDimensions();
+	m_zoomSlider->setValue(2);
 }
 
 void MainWindow::toggleInsertMode()
@@ -821,6 +923,17 @@ void MainWindow::createStatusBar()
 	m_cursorPositionLabel = new QLabel("1, 1");
 	statusBar()->insertWidget(3, m_cursorPositionLabel);
 
+	m_zoomSlider = new QSlider;
+	m_zoomSlider->setOrientation(Qt::Horizontal);
+	m_zoomSlider->setMinimumHeight(m_subPageLabel->height());
+	m_zoomSlider->setMaximumHeight(m_subPageLabel->height());
+	m_zoomSlider->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
+	m_zoomSlider->setRange(0, 8);
+	m_zoomSlider->setPageStep(1);
+	m_zoomSlider->setFocusPolicy(Qt::NoFocus);
+	statusBar()->insertWidget(4, m_zoomSlider);
+	connect(m_zoomSlider, &QSlider::valueChanged, this, &MainWindow::zoomSet);
+
 	m_insertModePushButton = new QPushButton("OVERWRITE");
 	m_insertModePushButton->setFlat(true);
 	m_insertModePushButton->setMinimumHeight(m_subPageLabel->height());
@@ -844,8 +957,6 @@ void MainWindow::createStatusBar()
 	connect(m_levelRadioButton[1], &QAbstractButton::clicked, [=]() { m_textWidget->pageDecode()->setLevel(1); m_textWidget->update(); m_paletteDockWidget->setLevel3p5Accepted(false);});
 	connect(m_levelRadioButton[2], &QAbstractButton::clicked, [=]() { m_textWidget->pageDecode()->setLevel(2); m_textWidget->update(); m_paletteDockWidget->setLevel3p5Accepted(false);});
 	connect(m_levelRadioButton[3], &QAbstractButton::clicked, [=]() { m_textWidget->pageDecode()->setLevel(3); m_textWidget->update(); m_paletteDockWidget->setLevel3p5Accepted(true);});
-
-	statusBar()->showMessage(tr("Ready"));
 }
 
 void MainWindow::readSettings()
@@ -855,11 +966,11 @@ void MainWindow::readSettings()
 	const QByteArray geometry = settings.value("geometry", QByteArray()).toByteArray();
 	const QByteArray windowState = settings.value("windowState", QByteArray()).toByteArray();
 
-	m_viewBorder = settings.value("border", 2).toInt();
+	m_viewBorder = settings.value("border", 1).toInt();
-	m_viewBorder = (m_viewBorder < 0 || m_viewBorder > 2) ? 2 : m_viewBorder;
+	m_viewBorder = (m_viewBorder < 0 || m_viewBorder > 2) ? 1 : m_viewBorder;
 	m_borderActs[m_viewBorder]->setChecked(true);
 	m_viewAspectRatio = settings.value("aspectratio", 0).toInt();
-	m_viewAspectRatio = (m_viewAspectRatio < 0 || m_viewAspectRatio > 2) ? 0 : m_viewAspectRatio;
+	m_viewAspectRatio = (m_viewAspectRatio < 0 || m_viewAspectRatio > 3) ? 0 : m_viewAspectRatio;
 	m_aspectRatioActs[m_viewAspectRatio]->setChecked(true);
 	m_viewSmoothTransform = settings.value("smoothTransform", 0).toBool();
 	m_smoothTransformAction->blockSignals(true);
@@ -868,17 +979,17 @@ void MainWindow::readSettings()
 	m_viewZoom = settings.value("zoom", 2).toInt();
 	m_viewZoom = (m_viewZoom < 0 || m_viewZoom > 12) ? 2 : m_viewZoom;
 
-	// zoom 0 = 420,426px, 1 = 620,570px, 2 = 780,720px
+	// zoom 0 = 430,385px, 1 = 500,530px, 2 = 650,670px
 	if (geometry.isEmpty()) {
 		const QRect availableGeometry = QGuiApplication::primaryScreen()->availableGeometry();
-		if (availableGeometry.width() < 620 || availableGeometry.height() < 570) {
+		if (availableGeometry.width() < 500 || availableGeometry.height() < 530) {
-			resize(430, 430);
+			resize(430, 385);
 			m_viewZoom = 0;
-		} else if (availableGeometry.width() < 780 || availableGeometry.height() < 720) {
+		} else if (availableGeometry.width() < 650 || availableGeometry.height() < 670) {
-			resize(620, 570);
+			resize(500, 530);
 			m_viewZoom = 1;
 		} else
-			resize(780, 720);
+			resize(650, 670);
 //			m_viewZoom = 2;
 		move((availableGeometry.width() - width()) / 2, (availableGeometry.height() - height()) / 2);
 	} else

src/qteletextmaker/mainwindow.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -21,13 +21,13 @@
 #define MAINWINDOW_H
 
 #include <QCheckBox>
-#include <QComboBox>
 #include <QGraphicsProxyWidget>
 #include <QGraphicsScene>
 #include <QGraphicsView>
 #include <QMainWindow>
 #include <QLabel>
 #include <QPushButton>
+#include <QSlider>
 #include <QToolButton>
 
 #include "mainwidget.h"
@@ -64,7 +64,7 @@ private slots:
 	void exportT42(bool fromAuto);
 	void exportZXNet();
 	void exportEditTF();
-	void exportPNG();
+	void exportImage();
 	void exportM29();
 	void updateRecentFileActions();
 	void updateExportAutoAction();
@@ -84,6 +84,7 @@ private slots:
 	void setSmoothTransform(bool smoothTransform);
 	void zoomIn();
 	void zoomOut();
+	void zoomSet(int viewZoom);
 	void zoomReset();
 
 	void toggleInsertMode();
@@ -131,10 +132,11 @@ private:
 
 	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;
 };
 

src/qteletextmaker/pagecomposelinksdockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -68,10 +68,18 @@ PageComposeLinksDockWidget::PageComposeLinksDockWidget(TeletextWidget *parent):
 			// 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;

src/qteletextmaker/pagecomposelinksdockwidget.h

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

src/qteletextmaker/pageenhancementsdockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -26,7 +26,7 @@
 
 #include "pageenhancementsdockwidget.h"
 
-#include "levelonecommands.h"
+#include "x28commands.h"
 
 PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent): QDockWidget(parent)
 {
@@ -71,7 +71,11 @@ PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent):
 	// Black background colour substitution
 	m_blackBackgroundSubstAct = new QCheckBox("Black background colour substitution");
 	colourLayout->addWidget(m_blackBackgroundSubstAct, 3, 0, 1, 2, Qt::AlignTop);
+#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);
@@ -98,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-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *

src/qteletextmaker/pageoptionsdockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -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

src/qteletextmaker/pageoptionsdockwidget.h

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

src/qteletextmaker/palettedockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 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-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *

src/qteletextmaker/x26commands.cpp

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

src/qteletextmaker/x26commands.h

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

src/qteletextmaker/x26dockwidget.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -17,6 +17,8 @@
  * along with QTeletextMaker.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+#include "x26dockwidget.h"
+
 #include <QAbstractListModel>
 #include <QActionGroup>
 #include <QButtonGroup>
@@ -36,11 +38,12 @@
 #include <QVBoxLayout>
 
 #include "render.h"
-#include "x26dockwidget.h"
+#include "x26menus.h"
 
 CharacterListModel::CharacterListModel(QObject *parent): QAbstractListModel(parent)
 {
 	m_characterSet = 0;
+	m_mosaic = true;
 }
 
 int CharacterListModel::rowCount(const QModelIndex & /*parent*/) const
@@ -56,16 +59,30 @@ QVariant CharacterListModel::data(const QModelIndex &index, int role) const
 	if (role == Qt::DisplayRole)
 		return QString("0x%1").arg(index.row()+0x20, 2, 16);
 
-	if (role == Qt::DecorationRole)
+	if (role == Qt::DecorationRole) {
-		return m_fontBitmap.rawBitmap()->copy(index.row()*12, m_characterSet*10, 12, 10);
+		if (m_mosaic && (index.row()+32) & 0x20)
+			return m_fontBitmap.charBitmap(index.row()+32, 24);
+		else
+			return m_fontBitmap.charBitmap(index.row()+32, m_characterSet);
+	}
 
 	return QVariant();
 }
 
 void CharacterListModel::setCharacterSet(int characterSet)
 {
-	if (characterSet != m_characterSet) {
+	if (characterSet != m_characterSet || m_mosaic) {
 		m_characterSet = characterSet;
+		m_mosaic = false;
+		emit dataChanged(createIndex(0, 0), createIndex(95, 0), QVector<int>(Qt::DecorationRole));
+	}
+}
+
+void CharacterListModel::setG1AndBlastCharacterSet(int characterSet)
+{
+	if (characterSet != m_characterSet || !m_mosaic) {
+		m_characterSet = characterSet;
+		m_mosaic = true;
 		emit dataChanged(createIndex(0, 0), createIndex(95, 0), QVector<int>(Qt::DecorationRole));
 	}
 }
@@ -134,91 +151,15 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	cookedTripletLayout->addWidget(m_cookedModePushButton);
 
 	// Cooked triplet menu
-	// We build the menus for both "Insert" buttons at the same time
+	// We connect the menus for both "Insert" buttons at the same time
-	m_cookedModeMenu = new QMenu(this);
+	m_cookedModeMenu = new TripletModeQMenu(this);
-	m_insertBeforeMenu = new QMenu(this);
+	m_insertBeforeMenu = new TripletModeQMenu(this);
-	m_insertAfterMenu = new QMenu(this);
+	m_insertAfterMenu = new TripletModeQMenu(this);
 
-	for (int m=0; m<3; m++) {
+	for (int m=0; m<64; m++) {
-		QMenu *menuToBuild;
+		connect(static_cast<TripletModeQMenu *>(m_cookedModeMenu)->action(m), &QAction::triggered, [=]() { cookedModeMenuSelected(m); });
-
+		connect(static_cast<TripletModeQMenu *>(m_insertBeforeMenu)->action(m), &QAction::triggered, [=]() { insertTriplet(m, false); });
-		if (m == 0)
+		connect(static_cast<TripletModeQMenu *>(m_insertAfterMenu)->action(m), &QAction::triggered, [=]() { insertTriplet(m, true); });
-			menuToBuild = m_cookedModeMenu;
-		else if (m == 1)
-			menuToBuild = m_insertBeforeMenu;
-		else // if (m == 2)
-			menuToBuild = m_insertAfterMenu;
-
-		auto newModeMenuAction=[&](QMenu *menu, int mode)
-		{
-			QAction *action = menu->addAction(m_x26Model->modeTripletName(mode));
-			if (m == 0)
-				connect(action, &QAction::triggered, [=]() { cookedModeMenuSelected(mode); });
-			else if (m == 1)
-				connect(action, &QAction::triggered, [=]() { insertTriplet(mode, false); });
-			else // if (m == 2)
-				connect(action, &QAction::triggered, [=]() { insertTriplet(mode, true); });
-		};
-
-		newModeMenuAction(menuToBuild, 0x04);
-		QMenu *rowTripletSubMenu = menuToBuild->addMenu(tr("Row triplet"));
-		newModeMenuAction(rowTripletSubMenu, 0x00);
-		newModeMenuAction(rowTripletSubMenu, 0x01);
-		newModeMenuAction(rowTripletSubMenu, 0x07);
-		newModeMenuAction(rowTripletSubMenu, 0x18);
-		QMenu *columnTripletSubMenu = menuToBuild->addMenu(tr("Column triplet"));
-		newModeMenuAction(columnTripletSubMenu, 0x20);
-		newModeMenuAction(columnTripletSubMenu, 0x23);
-		newModeMenuAction(columnTripletSubMenu, 0x27);
-		newModeMenuAction(columnTripletSubMenu, 0x2c);
-		newModeMenuAction(columnTripletSubMenu, 0x2e);
-		newModeMenuAction(columnTripletSubMenu, 0x28);
-		columnTripletSubMenu->addSeparator();
-		newModeMenuAction(columnTripletSubMenu, 0x29);
-		newModeMenuAction(columnTripletSubMenu, 0x2f);
-		newModeMenuAction(columnTripletSubMenu, 0x21);
-		newModeMenuAction(columnTripletSubMenu, 0x22);
-		newModeMenuAction(columnTripletSubMenu, 0x2b);
-		newModeMenuAction(columnTripletSubMenu, 0x2d);
-		QMenu *diacriticalSubMenu = columnTripletSubMenu->addMenu(tr("G0 diacritical"));
-		for (int i=0; i<16; i++)
-			newModeMenuAction(diacriticalSubMenu, 0x30 + i);
-		QMenu *objectSubMenu = menuToBuild->addMenu(tr("Object"));
-		newModeMenuAction(objectSubMenu, 0x10);
-		newModeMenuAction(objectSubMenu, 0x11);
-		newModeMenuAction(objectSubMenu, 0x12);
-		newModeMenuAction(objectSubMenu, 0x13);
-		newModeMenuAction(objectSubMenu, 0x15);
-		newModeMenuAction(objectSubMenu, 0x16);
-		newModeMenuAction(objectSubMenu, 0x17);
-		newModeMenuAction(menuToBuild, 0x1f);
-		menuToBuild->addSeparator();
-		QMenu *pdcSubMenu = menuToBuild->addMenu(tr("PDC/reserved"));
-		newModeMenuAction(pdcSubMenu, 0x08);
-		newModeMenuAction(pdcSubMenu, 0x09);
-		newModeMenuAction(pdcSubMenu, 0x0a);
-		newModeMenuAction(pdcSubMenu, 0x0b);
-		newModeMenuAction(pdcSubMenu, 0x0c);
-		newModeMenuAction(pdcSubMenu, 0x0d);
-		newModeMenuAction(pdcSubMenu, 0x26);
-		QMenu *reservedRowSubMenu = pdcSubMenu->addMenu(tr("Reserved row"));
-		newModeMenuAction(reservedRowSubMenu, 0x02);
-		newModeMenuAction(reservedRowSubMenu, 0x03);
-		newModeMenuAction(reservedRowSubMenu, 0x05);
-		newModeMenuAction(reservedRowSubMenu, 0x06);
-		newModeMenuAction(reservedRowSubMenu, 0x0e);
-		newModeMenuAction(reservedRowSubMenu, 0x0f);
-		newModeMenuAction(reservedRowSubMenu, 0x14);
-		newModeMenuAction(reservedRowSubMenu, 0x19);
-		newModeMenuAction(reservedRowSubMenu, 0x1a);
-		newModeMenuAction(reservedRowSubMenu, 0x1b);
-		newModeMenuAction(reservedRowSubMenu, 0x1c);
-		newModeMenuAction(reservedRowSubMenu, 0x1d);
-		newModeMenuAction(reservedRowSubMenu, 0x1e);
-		QMenu *reservedColumnSubMenu = pdcSubMenu->addMenu(tr("Reserved column"));
-		newModeMenuAction(reservedColumnSubMenu, 0x24);
-		newModeMenuAction(reservedColumnSubMenu, 0x25);
-		newModeMenuAction(reservedColumnSubMenu, 0x2a);
 	}
 
 	m_cookedModePushButton->setMenu(m_cookedModeMenu);
@@ -267,7 +208,11 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 
 	x26Layout->addLayout(tripletSelectLayout);
 
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+	connect(rawOrCookedCheckBox, &QCheckBox::checkStateChanged,[=](const int value) { m_rawOrCookedStackedLayout->setCurrentIndex(value == 2); } );
+#else
 	connect(rawOrCookedCheckBox, &QCheckBox::stateChanged,[=](const int value) { m_rawOrCookedStackedLayout->setCurrentIndex(value == 2); } );
+#endif
 
 
 	// Widgets that alter the parameters of triplets which will all be stacked
@@ -339,10 +284,17 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	displayAttributesLayout->addWidget(m_displayAttributeConcealCheckBox);
 	displayAttributesLayout->addWidget(m_displayAttributeInvertCheckBox);
 	displayAttributesLayout->addWidget(m_displayAttributeUnderlineCheckBox);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+	connect(m_displayAttributeBoxingCheckBox, &QCheckBox::checkStateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+2); } );
+	connect(m_displayAttributeConcealCheckBox, &QCheckBox::checkStateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+3); } );
+	connect(m_displayAttributeInvertCheckBox, &QCheckBox::checkStateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+4); } );
+	connect(m_displayAttributeUnderlineCheckBox, &QCheckBox::checkStateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+5); } );
+#else
 	connect(m_displayAttributeBoxingCheckBox, &QCheckBox::stateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+2); } );
 	connect(m_displayAttributeConcealCheckBox, &QCheckBox::stateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+3); } );
 	connect(m_displayAttributeInvertCheckBox, &QCheckBox::stateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+4); } );
 	connect(m_displayAttributeUnderlineCheckBox, &QCheckBox::stateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+5); } );
+#endif
 
 	// Index 5 - Invoke Object
 	QHBoxLayout *invokeObjectLayout = new QHBoxLayout;
@@ -481,9 +433,15 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 	fontStyleLayout->addWidget(m_fontStyleProportionalCheckBox);
 	fontStyleLayout->addWidget(m_fontStyleBoldCheckBox);
 	fontStyleLayout->addWidget(m_fontStyleItalicCheckBox);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+	connect(m_fontStyleProportionalCheckBox, &QCheckBox::checkStateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+1); } );
+	connect(m_fontStyleBoldCheckBox, &QCheckBox::checkStateChanged, this, [=](const int value) { updateModelFromCookedWidget((value == 2), Qt::UserRole+2);; } );
+	connect(m_fontStyleItalicCheckBox, &QCheckBox::checkStateChanged, this, [=](const int value) { updateModelFromCookedWidget((value == 2), Qt::UserRole+3); } );
+#else
 	connect(m_fontStyleProportionalCheckBox, &QCheckBox::stateChanged, this, [=](const int value) {  updateModelFromCookedWidget((value == 2), Qt::UserRole+1); } );
 	connect(m_fontStyleBoldCheckBox, &QCheckBox::stateChanged, this, [=](const int value) { updateModelFromCookedWidget((value == 2), Qt::UserRole+2);; } );
 	connect(m_fontStyleItalicCheckBox, &QCheckBox::stateChanged, this, [=](const int value) { updateModelFromCookedWidget((value == 2), Qt::UserRole+3); } );
+#endif
 	m_fontStyleRowsSpinBox = new QSpinBox;
 	m_fontStyleRowsSpinBox->setRange(0, 7);
 	fontStyleLayout->addWidget(m_fontStyleRowsSpinBox);
@@ -513,7 +471,11 @@ X26DockWidget::X26DockWidget(TeletextWidget *parent): QDockWidget(parent)
 
 	m_terminationMarkerMoreFollowsCheckBox = new QCheckBox(tr("Objects follow"));
 	terminationMarkerLayout->addWidget(m_terminationMarkerMoreFollowsCheckBox);
+#if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
+	connect(m_terminationMarkerMoreFollowsCheckBox, &QCheckBox::checkStateChanged, this, [=](const int value) {  updateModelFromCookedWidget(value != 2, Qt::UserRole+2); } );
+#else
 	connect(m_terminationMarkerMoreFollowsCheckBox, &QCheckBox::stateChanged, this, [=](const int value) {  updateModelFromCookedWidget(value != 2, Qt::UserRole+2); } );
+#endif
 
 
 	// Stack all the triplet parameter layouts together
@@ -661,15 +623,14 @@ void X26DockWidget::selectX26ListRow(int row)
 
 void X26DockWidget::loadX26List()
 {
+	disableTripletWidgets();
 	m_x26Model->setX26ListLoaded(true);
 }
 
 void X26DockWidget::unloadX26List()
 {
+	disableTripletWidgets();
 	m_x26Model->setX26ListLoaded(false);
-	m_rawTripletAddressSpinBox->setEnabled(false);
-	m_rawTripletDataSpinBox->setEnabled(false);
-	m_rawTripletModeSpinBox->setEnabled(false);
 }
 
 void X26DockWidget::rowSelected(const QModelIndex &current, const QModelIndex &previous)
@@ -718,7 +679,7 @@ void X26DockWidget::updateAllCookedTripletWidgets(const QModelIndex &index)
 	const int modeExt = index.model()->data(index.model()->index(index.row(), 2), Qt::EditRole).toInt();
 
 	m_cookedModePushButton->setEnabled(true);
-	m_cookedModePushButton->setText(m_x26Model->modeTripletName(modeExt));
+	m_cookedModePushButton->setText(m_modeTripletNames.modeName(modeExt));
 
 	switch (modeExt) {
 		case 0x04: // Set active position
@@ -767,7 +728,7 @@ void X26DockWidget::updateAllCookedTripletWidgets(const QModelIndex &index)
 		case 0x3f: // G0 character with diacritical
 			m_characterCodeComboBox->blockSignals(true);
 			if (modeExt == 0x21)
-				m_characterListModel.setCharacterSet(24);
+				m_characterListModel.setG1AndBlastCharacterSet(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+3).toInt());
 			else if (modeExt == 0x22 || modeExt == 0x2b)
 				m_characterListModel.setCharacterSet(26);
 			else
@@ -1052,12 +1013,21 @@ void X26DockWidget::updateModelFromCookedWidget(const int value, const int role)
 void X26DockWidget::insertTriplet(int modeExt, bool after)
 {
 	QModelIndex index = m_x26View->currentIndex();
+
+	if (index.isValid())
+		insertTriplet(modeExt, index.row()+after);
+	else
+		insertTriplet(modeExt);
+}
+
+void X26DockWidget::insertTriplet(int modeExt, int row)
+{
 	X26Triplet newTriplet(modeExt < 0x20 ? 41 : 0, modeExt & 0x1f, 0);
-	int newListRow;
+
+	if (row != -1) {
+		QModelIndex index = m_x26View->currentIndex();
 
 		if (index.isValid()) {
-		newListRow = index.row()+after;
-
 			// If we're inserting a column triplet next to another column triplet,
 			// duplicate the column number
 			// Avoid the PDC and reserved mode triplets
@@ -1070,7 +1040,7 @@ void X26DockWidget::insertTriplet(int modeExt, bool after)
 			// If we're inserting a Set Active Position or Full Row Colour triplet,
 			// look for a previous row setting triplet and set this one to the row after
 			if (modeExt == 0x04 || modeExt == 0x01) {
-			for (int i=newListRow-1; i>=0; i--) {
+				for (int i=row-1; i>=0; i--) {
 					const int scanTripletModeExt = index.model()->data(index.model()->index(i, 2), Qt::EditRole).toInt();
 
 					if (scanTripletModeExt == 0x04 || scanTripletModeExt == 0x01) {
@@ -1085,8 +1055,9 @@ void X26DockWidget::insertTriplet(int modeExt, bool after)
 					}
 				}
 			}
+		}
 	} else
-		newListRow = 0;
+		row = 0;
 
 	// For character triplets, ensure Data is not reserved
 	if (modeExt == 0x21 || modeExt == 0x22 || modeExt == 0x29 || modeExt == 0x2b || modeExt >= 0x2f)
@@ -1100,7 +1071,7 @@ void X26DockWidget::insertTriplet(int modeExt, bool after)
 		newTriplet.setData(7);
 	}
 
-	m_x26Model->insertRows(newListRow, 1, QModelIndex(), newTriplet);
+	m_x26Model->insertRows(row, 1, QModelIndex(), newTriplet);
 }
 
 void X26DockWidget::insertTripletCopy()
@@ -1123,17 +1094,161 @@ void X26DockWidget::deleteTriplet()
 
 void X26DockWidget::customMenuRequested(QPoint pos)
 {
+	QMenu *customMenu = nullptr;
+
 	QModelIndex index = m_x26View->indexAt(pos);
 
-	QMenu *menu = new QMenu(this);
-
-	QAction *insertAct = new QAction("Insert triplet copy", this);
-	menu->addAction(insertAct);
-	connect(insertAct, &QAction::triggered, this, &X26DockWidget::insertTripletCopy);
 	if (index.isValid()) {
+		const int modeExt = index.model()->data(index.model()->index(index.row(), 2), Qt::EditRole).toInt();
+
+		switch (modeExt) {
+			case 0x11:
+			case 0x12:
+			case 0x13: {  // Invoke Object
+				QMenu *localDefMenu;
+				const QList objectList = m_parentMainWidget->document()->currentSubPage()->enhancements()->objects(modeExt - 0x11);
+
+				for (int i=0; i<objectList.size(); i++) {
+					// Messy way to create submenu only if definitions exist
+					if (i == 0) {
+						customMenu = new QMenu(this);
+						localDefMenu = customMenu->addMenu(tr("Local definition"));
+					}
+
+					const int d = objectList.at(i) / 13;
+					const int t = objectList.at(i) % 13;
+					QAction *action = localDefMenu->addAction(QString("d%1 t%2").arg(d).arg(t));
+					connect(action, &QAction::triggered, [=]() {
+						updateModelFromCookedWidget(0, Qt::UserRole+1);
+						updateModelFromCookedWidget(d, Qt::UserRole+2);
+						updateModelFromCookedWidget(t, Qt::UserRole+3);
+						updateAllCookedTripletWidgets(index);
+					} );
+				}
+			} break;
+			case 0x01: // Full Row colour
+			case 0x07: // Address row 0
+				customMenu = new TripletCLUTQMenu(true, this);
+
+				connect(static_cast<TripletCLUTQMenu *>(customMenu)->action(32), &QAction::triggered, [=]() { updateModelFromCookedWidget(0, Qt::UserRole+2); updateAllCookedTripletWidgets(index); });
+				connect(static_cast<TripletCLUTQMenu *>(customMenu)->action(33), &QAction::triggered, [=]() { updateModelFromCookedWidget(1, Qt::UserRole+2); updateAllCookedTripletWidgets(index); });
+				// fall-through
+			case 0x00: // Full Screen colour
+			case 0x20: // Foreground colour
+			case 0x23: // Background colour
+				if (!customMenu)
+					customMenu = new TripletCLUTQMenu(false, this);
+
+				for (int i=0; i<32; i++) {
+					static_cast<TripletCLUTQMenu *>(customMenu)->setColour(i, m_parentMainWidget->document()->currentSubPage()->CLUTtoQColor(i));
+					connect(static_cast<TripletCLUTQMenu *>(customMenu)->action(i), &QAction::triggered, [=]() { updateModelFromCookedWidget(i, Qt::UserRole+1); updateAllCookedTripletWidgets(index); });
+				}
+				break;
+			case 0x27: // Additional flash functions
+				customMenu = new TripletFlashQMenu(this);
+
+				static_cast<TripletFlashQMenu *>(customMenu)->setModeChecked(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+1).toInt());
+				static_cast<TripletFlashQMenu *>(customMenu)->setRatePhaseChecked(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+2).toInt());
+
+				for (int i=0; i<4; i++)
+					connect(static_cast<TripletFlashQMenu *>(customMenu)->modeAction(i), &QAction::triggered, [=]() { updateModelFromCookedWidget(i, Qt::UserRole+1); updateAllCookedTripletWidgets(index); });
+				for (int i=0; i<6; i++)
+					connect(static_cast<TripletFlashQMenu *>(customMenu)->ratePhaseAction(i), &QAction::triggered, [=]() { updateModelFromCookedWidget(i, Qt::UserRole+2); updateAllCookedTripletWidgets(index); });
+				break;
+			case 0x2c: // Display attributes
+				customMenu = new TripletDisplayAttrsQMenu(this);
+
+				static_cast<TripletDisplayAttrsQMenu *>(customMenu)->setTextSizeChecked(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+1).toInt());
+				for (int i=0; i<4; i++) {
+					static_cast<TripletDisplayAttrsQMenu *>(customMenu)->setOtherAttrChecked(i, index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+i+2).toBool());
+					connect(static_cast<TripletDisplayAttrsQMenu *>(customMenu)->textSizeAction(i), &QAction::triggered, [=]() { updateModelFromCookedWidget(i, Qt::UserRole+1); updateAllCookedTripletWidgets(index); });
+					connect(static_cast<TripletDisplayAttrsQMenu *>(customMenu)->otherAttrAction(i), &QAction::toggled, [=](const int checked) { updateModelFromCookedWidget(checked, Qt::UserRole+i+2); updateAllCookedTripletWidgets(index); });
+				}
+				break;
+			case 0x2e: // Font style
+				customMenu = new TripletFontStyleQMenu(this);
+
+				for (int i=0; i<3; i++) {
+					static_cast<TripletFontStyleQMenu *>(customMenu)->setStyleChecked(i, index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+i+1).toBool());
+					connect(static_cast<TripletFontStyleQMenu *>(customMenu)->styleAction(i), &QAction::toggled, [=](const int checked) { updateModelFromCookedWidget(checked, Qt::UserRole+i+1); updateAllCookedTripletWidgets(index); });
+				}
+				static_cast<TripletFontStyleQMenu *>(customMenu)->setRowsChecked(index.model()->data(index.model()->index(index.row(), 0), Qt::UserRole+4).toInt());
+				for (int i=0; i<8; i++)
+					connect(static_cast<TripletFontStyleQMenu *>(customMenu)->rowsAction(i), &QAction::triggered, [=]() { updateModelFromCookedWidget(i, Qt::UserRole+4); updateAllCookedTripletWidgets(index); });
+				break;
+			case 0x21: // G1 mosaic character
+				customMenu = new TripletCharacterQMenu(m_x26Model->data(index.model()->index(index.row(), 2), Qt::UserRole+3).toInt(), true, this);
+				// fall-through
+			case 0x22: // G3 mosaic character at level 1.5
+			case 0x2b: // G3 mosaic character at level >=2.5
+			case 0x29: // G0 character
+			case 0x2f: // G2 character
+			case 0x30:
+			case 0x31:
+			case 0x32:
+			case 0x33:
+			case 0x34:
+			case 0x35:
+			case 0x36:
+			case 0x37:
+			case 0x38:
+			case 0x39:
+			case 0x3a:
+			case 0x3b:
+			case 0x3c:
+			case 0x3d:
+			case 0x3e:
+			case 0x3f: // G0 character with diacritical
+				if (!customMenu)
+					customMenu = new TripletCharacterQMenu(m_x26Model->data(index.model()->index(index.row(), 2), Qt::UserRole+2).toInt(), false, this);
+
+				for (int i=0; i<96; i++)
+					connect(static_cast<TripletCharacterQMenu *>(customMenu)->action(i), &QAction::triggered, [=]() { updateModelFromCookedWidget(i+32, Qt::UserRole+1); updateAllCookedTripletWidgets(index); });
+				break;
+		}
+
+		if (customMenu)
+			customMenu->addSeparator();
+		else
+			customMenu = new QMenu(this);
+
+		TripletModeQMenu *modeChangeMenu = new TripletModeQMenu(this);
+		modeChangeMenu->setTitle(tr("Change triplet mode"));
+		customMenu->addMenu(modeChangeMenu);
+
+		customMenu->addSeparator();
+
+		TripletModeQMenu *insertBeforeQMenu = new TripletModeQMenu(this);
+		insertBeforeQMenu->setTitle(tr("Insert before"));
+		customMenu->addMenu(insertBeforeQMenu);
+
+		TripletModeQMenu *insertAfterQMenu = new TripletModeQMenu(this);
+		insertAfterQMenu->setTitle(tr("Insert after"));
+		customMenu->addMenu(insertAfterQMenu);
+
+		for (int i=0; i<64; i++) {
+			connect(static_cast<TripletModeQMenu *>(modeChangeMenu)->action(i), &QAction::triggered, [=]() { cookedModeMenuSelected(i); });
+			connect(static_cast<TripletModeQMenu *>(insertBeforeQMenu)->action(i), &QAction::triggered, [=]() { insertTriplet(i, false); });
+			connect(static_cast<TripletModeQMenu *>(insertAfterQMenu)->action(i), &QAction::triggered, [=]() { insertTriplet(i, true); });
+		}
+
+		QAction *insertCopyAct = new QAction(tr("Insert copy"), this);
+		customMenu->addAction(insertCopyAct);
+		connect(insertCopyAct, &QAction::triggered, this, &X26DockWidget::insertTripletCopy);
+
 		QAction *deleteAct = new QAction("Delete triplet", this);
-		menu->addAction(deleteAct);
+		customMenu->addAction(deleteAct);
 		connect(deleteAct, &QAction::triggered, this, &X26DockWidget::deleteTriplet);
+	} else {
+		customMenu = new QMenu(this);
+
+		TripletModeQMenu *appendModeMenu = new TripletModeQMenu(this);
+		appendModeMenu->setTitle(tr("Append"));
+		customMenu->addMenu(appendModeMenu);
+
+		for (int i=0; i<64; i++)
+			connect(static_cast<TripletModeQMenu *>(appendModeMenu)->action(i), &QAction::triggered, [=]() { insertTriplet(i, m_x26Model->rowCount()); });
 	}
-	menu->popup(m_x26View->viewport()->mapToGlobal(pos));
+
+	customMenu->popup(m_x26View->viewport()->mapToGlobal(pos));
 }

src/qteletextmaker/x26dockwidget.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -35,6 +35,7 @@
 
 #include "mainwidget.h"
 #include "render.h"
+#include "x26menus.h"
 #include "x26model.h"
 
 class CharacterListModel : public QAbstractListModel
@@ -47,10 +48,12 @@ public:
 	int rowCount(const QModelIndex &parent = QModelIndex()) const override;
 	QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 	void setCharacterSet(int characterSet);
+	void setG1AndBlastCharacterSet(int characterSet);
 
 private:
 	TeletextFontBitmap m_fontBitmap;
 	int m_characterSet;
+	bool m_mosaic;
 };
 
 class X26DockWidget : public QDockWidget
@@ -62,6 +65,7 @@ public:
 
 public slots:
 	void insertTriplet(int modeExt, bool after);
+	void insertTriplet(int modeExt, int row = -1);
 	void insertTripletCopy();
 	void deleteTriplet();
 	void customMenuRequested(QPoint pos);
@@ -116,6 +120,8 @@ private:
 	QCheckBox *m_terminationMarkerMoreFollowsCheckBox;
 	QPushButton *m_insertBeforePushButton, *m_insertAfterPushButton, *m_insertCopyPushButton, *m_deletePushButton;
 
+	ModeTripletNames m_modeTripletNames;
+
 	TeletextWidget *m_parentMainWidget;
 
 	void disableTripletWidgets();

src/qteletextmaker/x26menus.cpp

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

src/qteletextmaker/x26menus.h

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

src/qteletextmaker/x26model.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -19,9 +19,11 @@
 
 #include "x26model.h"
 
+#include <QIcon>
 #include <QList>
 
 #include "x26commands.h"
+#include "x26menus.h"
 
 X26Model::X26Model(TeletextWidget *parent): QAbstractListModel(parent)
 {
@@ -67,19 +69,27 @@ QVariant X26Model::data(const QModelIndex &index, int role) const
 	if (role == Qt::ForegroundRole) {
 		if (triplet.error() != X26Triplet::NoError && index.column() == m_tripletErrors[triplet.error()].columnHighlight)
 			return QColor(252, 252, 252);
-		else if ((index.column() == 2 && triplet.reservedMode()) || (index.column() == 3 && triplet.reservedData()))
+		if ((index.column() == 2 && triplet.reservedMode()) || (index.column() == 3 && triplet.reservedData()))
+			return QColor(35, 38, 39);
+		if (index.column() <= 1 && triplet.activePosition1p5Differs())
 			return QColor(35, 38, 39);
 	}
 
 	if (role == Qt::BackgroundRole) {
 		if (triplet.error() != X26Triplet::NoError && index.column() == m_tripletErrors[triplet.error()].columnHighlight)
 			return QColor(218, 68, 63);
-		else if ((index.column() == 2 && triplet.reservedMode()) || (index.column() == 3 && triplet.reservedData()))
+		if ((index.column() == 2 && triplet.reservedMode()) || (index.column() == 3 && triplet.reservedData()))
+			return QColor(246, 116, 0);
+		if (index.column() <= 1 && triplet.activePosition1p5Differs())
 			return QColor(246, 116, 0);
 	}
 
-	if (role == Qt::ToolTipRole && triplet.error() != X26Triplet::NoError)
+	if (role == Qt::ToolTipRole) {
+		if (triplet.error() != X26Triplet::NoError)
 			return m_tripletErrors[triplet.error()].message;
+		if (triplet.activePosition1p5Differs())
+			return "Active Position differs between Level 1.5 and higher levels";
+	}
 
 	if (role == Qt::DisplayRole || role == Qt::EditRole)
 		switch (index.column()) {
@@ -113,7 +123,7 @@ QVariant X26Model::data(const QModelIndex &index, int role) const
 
 	if (role == Qt::DisplayRole) {
 		if (index.column() == 2)
-			return (m_modeTripletName[triplet.modeExt()]);
+			return (m_modeTripletNames.modeName(triplet.modeExt()));
 		// Column 3 - describe effects of data/address triplet parameters in plain English
 		switch (triplet.modeExt()) {
 			case 0x01: // Full row colour
@@ -374,22 +384,25 @@ QVariant X26Model::data(const QModelIndex &index, int role) const
 				break;
 			case 0x21: // G1 mosaic character
 				if (triplet.data() & 0x20)
-					return m_fontBitmap.rawBitmap()->copy((triplet.data()-32)*12, 24*10, 12, 10);
+					return m_fontBitmap.charIcon(triplet.data(), 24);
+				else if (triplet.data() >= 0x20)
+					// Blast-through
+					return m_fontBitmap.charIcon(triplet.data(), m_parentMainWidget->pageDecode()->cellG0CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn()));
 				break;
 			case 0x22: // G3 mosaic character at level 1.5
 			case 0x2b: // G3 mosaic character at level >=2.5
 				if (triplet.data() >= 0x20)
-					return m_fontBitmap.rawBitmap()->copy((triplet.data()-32)*12, 26*10, 12, 10);
+					return m_fontBitmap.charIcon(triplet.data(), 26);
 				break;
 			case 0x2f: // G2 character
 				if (triplet.data() >= 0x20)
-					return m_fontBitmap.rawBitmap()->copy((triplet.data()-32)*12, m_parentMainWidget->pageDecode()->cellG2CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn())*10, 12, 10);
+					return m_fontBitmap.charIcon(triplet.data(), m_parentMainWidget->pageDecode()->cellG2CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn()));
 				break;
 			default:
 				if (triplet.modeExt() == 0x29 || (triplet.modeExt() >= 0x30 && triplet.modeExt() <= 0x3f))
 					// G0 character or G0 diacritical mark
 					if (triplet.data() >= 0x20)
-						return m_fontBitmap.rawBitmap()->copy((triplet.data()-32)*12, m_parentMainWidget->pageDecode()->cellG0CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn())*10, 12, 10);
+						return m_fontBitmap.charIcon(triplet.data(), m_parentMainWidget->pageDecode()->cellG0CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn()));
 		}
 
 	if (role == Qt::EditRole && index.column() == 2)
@@ -466,6 +479,21 @@ QVariant X26Model::data(const QModelIndex &index, int role) const
 					return (triplet.data() & 0x01) == 0x01;
 			}
 			break;
+		case 0x21: // G1 character
+			// Qt::UserRole+1 is character number, returned by default below
+			switch (role) {
+				case Qt::UserRole+2: // G1 character set
+					return 24;
+				case Qt::UserRole+3: // G0 character set for blast-through
+					return m_parentMainWidget->pageDecode()->cellG0CharacterSet(triplet.activePositionRow(), triplet.activePositionColumn());
+			}
+			break;
+		case 0x22: // G3 character at Level 1.5
+		case 0x2b: // G3 character at Level 2.5
+			// Qt::UserRole+1 is character number, returned by default below
+			if (role == Qt::UserRole+2) // G3 character set
+				return 26;
+			break;
 		case 0x27: // Flash functions
 			switch (role) {
 				case Qt::UserRole+1: // Flash mode

src/qteletextmaker/x26model.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -21,7 +21,9 @@
 #define X26MODEL_H
 
 #include <QAbstractListModel>
+
 #include "mainwidget.h"
+#include "x26menus.h"
 
 class X26Model : public QAbstractListModel
 {
@@ -40,8 +42,6 @@ public:
 	bool removeRows(int position, int rows, const QModelIndex &index);
 //	Qt::ItemFlags flags(const QModelIndex &index) const;
 
-	const QString modeTripletName(int i) const { return m_modeTripletName[i]; }
-
 	// The x26commands classes manipulate the model but beginInsertRows and endInsertRows
 	// are protected methods, so we need to friend them
 	friend class InsertTripletCommand;
@@ -52,87 +52,7 @@ private:
 	TeletextWidget *m_parentMainWidget;
 	bool m_listLoaded;
 	TeletextFontBitmap m_fontBitmap;
-
+	ModeTripletNames m_modeTripletNames;
-	const QString m_modeTripletName[64] {
-		// Row triplet modes
-		"Full screen colour",
-		"Full row colour",
-		"Reserved 0x02",
-		"Reserved 0x03",
-
-		"Set Active Position",
-		"Reserved 0x05",
-		"Reserved 0x06",
-		"Address row 0",
-
-		"PDC origin, source",
-		"PDC month and day",
-		"PDC cursor and start hour",
-		"PDC cursor and end hour",
-
-		"PDC cursor local offset",
-		"PDC series ID and code",
-		"Reserved 0x0e",
-		"Reserved 0x0f",
-
-		"Origin modifier",
-		"Invoke active object",
-		"Invoke adaptive object",
-		"Invoke passive object",
-
-		"Reserved 0x14",
-		"Define active object",
-		"Define adaptive object",
-		"Define passive object",
-
-		"DRCS mode",
-		"Reserved 0x19",
-		"Reserved 0x1a",
-		"Reserved 0x1b",
-
-		"Reserved 0x1c",
-		"Reserved 0x1d",
-		"Reserved 0x1e",
-		"Termination marker",
-
-		// Column triplet modes
-		"Foreground colour",
-		"G1 block mosaic",
-		"G3 smooth mosaic, level 1.5",
-		"Background colour",
-
-		"Reserved 0x04",
-		"Reserved 0x05",
-		"PDC cursor, start end min",
-		"Additional flash functions",
-
-		"Modified G0/G2 character set",
-		"G0 character",
-		"Reserved 0x0a",
-		"G3 smooth mosaic, level 2.5",
-
-		"Display attributes",
-		"DRCS character",
-		"Font style, level 3.5",
-		"G2 supplementary character",
-
-		"G0 character no diacritical",
-		"G0 character diacritical 1",
-		"G0 character diacritical 2",
-		"G0 character diacritical 3",
-		"G0 character diacritical 4",
-		"G0 character diacritical 5",
-		"G0 character diacritical 6",
-		"G0 character diacritical 7",
-		"G0 character diacritical 8",
-		"G0 character diacritical 9",
-		"G0 character diacritical A",
-		"G0 character diacritical B",
-		"G0 character diacritical C",
-		"G0 character diacritical D",
-		"G0 character diacritical E",
-		"G0 character diacritical F"
-	};
 
 	struct tripletErrorShow {
 		QString message;

src/qteletextmaker/x28commands.cpp

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

src/qteletextmaker/x28commands.h

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