Tag version 0.7.1-beta

Actually this is a workaround: it does not attempt to copy construct
unhandled packets, to avoid a bug in the base class where pointers were
copy constructed without copying the contents.

A proper fix will need refactoring of the packet storage code.

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

@@ -15,10 +15,12 @@ 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 qteletextdecoder Qt::Widgets)
+target_link_libraries(qteletextmaker PRIVATE QtGifImage::QtGifImage qteletextdecoder Qt::Widgets)
 
 set_target_properties(qteletextmaker PROPERTIES
 	WIN32_EXECUTABLE ON

README.md

@@ -8,7 +8,7 @@ Features
 - 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.

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.
  *

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.
  *

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.
  *
@@ -33,6 +33,7 @@ LevelOnePage::LevelOnePage()
 	clearPage();
 }
 
+// BUG this copy constructor isn't used? Parameter should be LevelOnePage
 LevelOnePage::LevelOnePage(const PageBase &other)
 {
 	m_enhancements.reserve(maxEnhancements());
@@ -186,7 +187,9 @@ bool LevelOnePage::setPacket(int packetNumber, QByteArray packetContents)
 	}
 
 	qDebug("LevelOnePage unhandled setPacket X/%d", packetNumber);
-	return PageBase::setPacket(packetNumber, packetContents);
+	// BUG can't store unhandled packets as default copy constructor uses pointers
+	//return PageBase::setPacket(packetNumber, packetContents);
+	return false;
 }
 
 bool LevelOnePage::setPacket(int packetNumber, int designationCode, QByteArray packetContents)
@@ -253,7 +256,9 @@ bool LevelOnePage::setPacket(int packetNumber, int designationCode, QByteArray p
 	}
 
 	qDebug("LevelOnePage unhandled setPacket X/%d/%d", packetNumber, designationCode);
-	return PageBase::setPacket(packetNumber, designationCode, packetContents);
+	// BUG can't store unhandled packets as default copy constructor uses pointers
+	//return PageBase::setPacket(packetNumber, designationCode, packetContents);
+	return false;
 }
 
 bool LevelOnePage::packetExists(int packetNumber) const

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.
  *
@@ -36,6 +36,7 @@ public:
 	enum CycleTypeEnum { CTcycles, CTseconds };
 
 	LevelOnePage();
+	// BUG this copy constructor isn't used? Parameter should be LevelOnePage
 	LevelOnePage(const PageBase &other);
 
 	bool isEmpty() const override;
@@ -52,7 +53,7 @@ public:
 
 	void clearPage();
 
-	int maxEnhancements() const { return 208; };
+	int maxEnhancements() const override { return 208; };
 
 /*	void setSubPageNumber(int); */
 	int cycleValue() const { return m_cycleValue; };

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.
  *

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.
  *

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.
  *

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.
  *

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.
  *
@@ -457,6 +457,49 @@ ShiftMosaicsRightCommand::ShiftMosaicsRightCommand(TeletextDocument *teletextDoc
 	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)
 {

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.
  *
@@ -164,6 +164,47 @@ public:
 	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:

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.
  *
@@ -30,7 +30,7 @@ int main(int argc, char *argv[])
 	QApplication::setApplicationDisplayName(QApplication::applicationName());
 	QApplication::setOrganizationName("gkmac.co.uk");
 	QApplication::setOrganizationDomain("gkmac.co.uk");
-	QApplication::setApplicationVersion("0.6.5-beta");
+	QApplication::setApplicationVersion("0.7.1-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.
  *
@@ -140,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);
 }
 
@@ -228,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.level1MosaicAttr(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:
@@ -388,20 +394,47 @@ void TeletextWidget::setCharacter(unsigned char newCharacter)
 
 void TeletextWidget::toggleCharacterBit(unsigned char bitToToggle)
 {
-	m_teletextDocument->undoStack()->push(new ToggleMosaicBitCommand(m_teletextDocument, bitToToggle));
+	if (!m_teletextDocument->selectionActive())
+		m_teletextDocument->undoStack()->push(new ToggleMosaicBitCommand(m_teletextDocument, bitToToggle));
+	else {
+		const QSet<QPair<int, int>> mosaicList = findMosaics();
+
+		if (!mosaicList.isEmpty())
+			switch (bitToToggle) {
+				case 0x7f:
+					m_teletextDocument->undoStack()->push(new FillMosaicsCommand(m_teletextDocument, mosaicList));
+					break;
+				case 0x20:
+					m_teletextDocument->undoStack()->push(new ClearMosaicsCommand(m_teletextDocument, mosaicList));
+					break;
+				case 0x5f:
+					m_teletextDocument->undoStack()->push(new InvertMosaicsCommand(m_teletextDocument, mosaicList));
+					break;
+				case 0x66:
+					m_teletextDocument->undoStack()->push(new DitherMosaicsCommand(m_teletextDocument, mosaicList));
+					break;
+			}
+	}
 }
 
-void TeletextWidget::shiftMosaics(int key)
+QSet<QPair<int, int>> TeletextWidget::findMosaics()
 {
-	if (!m_teletextDocument->selectionActive())
+	QSet<QPair<int, int>> result;
-		return;
 
-	QSet<QPair<int, int>> mosaicList;
+	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))
-				mosaicList.insert(qMakePair(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) {

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,10 +48,11 @@ 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); }
 
-	void inputMethodEvent(QInputMethodEvent *event);
+	void inputMethodEvent(QInputMethodEvent *event) override;
 
 	TeletextDocument* document() const { return m_teletextDocument; }
 	TeletextPageDecode *pageDecode() { return &m_pageDecode; }
@@ -68,7 +69,8 @@ public slots:
 	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,7 @@ private:
 	int m_flashTiming, m_flashPhase;
 
 	void timerEvent(QTimerEvent *event) override;
+	QSet<QPair<int, int>> findMosaics();
 	void shiftMosaics(int key);
 	void selectionToClipboard();
 

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.
  *
@@ -50,6 +50,8 @@
 #include "palettedockwidget.h"
 #include "x26dockwidget.h"
 
+#include "gifimage/qgifimage.h"
+
 MainWindow::MainWindow()
 {
 	init();
@@ -179,49 +181,130 @@ 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;
 
+	const QString suffix = QFileInfo(exportFileName).suffix().toLower();
+
+	if (suffix.isEmpty()) {
+		QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("No filename extension specified."));
+		return;
+	} else if (suffix != "png" && suffix != "gif") {
+		QMessageBox::warning(this, QApplication::applicationDisplayName(), tr("Cannot export image of format %1.").arg(suffix));
+		return;
+	}
+
+	// Disable flash exporting if extension is not GIF
+	const int flashTiming = suffix == "gif" ? m_textWidget->flashTiming() : 0;
+
 	// Prepare widget image for extraction
-	m_textWidget->pauseFlash(true);
 	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);
 
-	// Extract the image from the scene
+	// Allocate initial image, with additional images for flashing if necessary
-	QImage interImage = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
+	QImage interImage[6];
-//	This ought to make the background transparent in Mix mode, but it doesn't
+
-//	if (m_textWidget->pageDecode()->mix())
+	interImage[0] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
-//		interImage.fill(QColor(0, 0, 0, 0));
+	if (flashTiming != 0) {
-	QPainter interPainter(&interImage);
+		interImage[3] = QImage(m_textScene->sceneRect().size().toSize(), QImage::Format_RGB32);
-	m_textScene->render(&interPainter);
+		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[p]);
+			m_textScene->render(&interPainter);
+		}
 
 	// Now we've extracted the image we can put the GUI things back
 	m_textScene->hideGUIElements(false);
 	if (reMix)
 		m_textScene->setRenderMode(TeletextPageRender::RenderMix);
-	m_textWidget->pauseFlash(false);
+	m_textWidget->resumeFlash();
 
-	// 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];
 
-	// Double the vertical height first
+	for (int p=0; p<6; p++)
-	const QImage doubleHeightImage = interImage.scaled(interImage.width(), interImage.height()*2, Qt::IgnoreAspectRatio, Qt::FastTransformation);
+		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[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()
@@ -239,7 +322,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()));
 }
@@ -276,6 +359,7 @@ void MainWindow::init()
 		m_textView->setRenderHints(QPainter::SmoothPixmapTransform);
 	m_textView->setBackgroundBrush(QBrush(QColor(32, 48, 96)));
 	m_zoomSlider->setValue(m_viewZoom);
+	setSceneDimensions();
 	setCentralWidget(m_textView);
 
 	connect(m_textWidget->document(), &TeletextDocument::cursorMoved, this, &MainWindow::updateCursorPosition);
@@ -391,9 +475,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");
@@ -874,8 +958,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()
@@ -885,11 +967,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);
@@ -898,17 +980,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.
  *
@@ -64,7 +64,7 @@ private slots:
 	void exportT42(bool fromAuto);
 	void exportZXNet();
 	void exportEditTF();
-	void exportPNG();
+	void exportImage();
 	void exportM29();
 	void updateRecentFileActions();
 	void updateExportAutoAction();
@@ -136,7 +136,7 @@ private:
 	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.
  *
@@ -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.
  *
@@ -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.
  *
@@ -208,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
@@ -280,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;
@@ -422,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);
@@ -454,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

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.
  *

src/qteletextmaker/x26menus.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/x26menus.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/x26model.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/x26model.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Gavin MacGregor
+ * Copyright (C) 2020-2025 Gavin MacGregor
  *
  * This file is part of QTeletextMaker.
  *
@@ -35,11 +35,11 @@ public:
 	int rowCount(const QModelIndex &parent = QModelIndex()) const override ;
 	int columnCount(const QModelIndex &parent = QModelIndex()) const override;
 	QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
-	bool setData(const QModelIndex &index, const QVariant &value, int role);
+	bool setData(const QModelIndex &index, const QVariant &value, int role) override;
-	QVariant headerData(int section, Qt::Orientation orientation, int role) const;
+	QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
-	bool insertRows(int position, int rows, const QModelIndex &parent);
+	bool insertRows(int position, int rows, const QModelIndex &parent) override;
 	bool insertRows(int position, int rows, const QModelIndex &parent, X26Triplet triplet);
-	bool removeRows(int position, int rows, const QModelIndex &index);
+	bool removeRows(int position, int rows, const QModelIndex &index) override;
 //	Qt::ItemFlags flags(const QModelIndex &index) const;
 
 	// The x26commands classes manipulate the model but beginInsertRows and endInsertRows

src/qteletextmaker/x28commands.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/x28commands.h

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