daniel/QTeletextMaker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Port to CMake from qmake, and split decoder into subdirectory

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

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

The teletext decoder with its document storage has been moved to a
subdirectory with the intention of making it possible to use in other
projects, but some further separation of editing stuff will be needed.
This commit is contained in:
G.K.MacGregor
2024-08-11 15:32:45 +01:00
parent cf6c4855ce
commit 40fc1e38d8
59 changed files with 92 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/qteletextmaker/actionicons.qrc Normal file
View File

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

262
src/qteletextmaker/hamming.h Normal file
View File

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

BIN
src/qteletextmaker/images/copy.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.3 KiB

BIN
src/qteletextmaker/images/cut.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.3 KiB

BIN
src/qteletextmaker/images/new.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 852 B

BIN
src/qteletextmaker/images/open.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.0 KiB

BIN
src/qteletextmaker/images/paste.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.6 KiB

BIN
src/qteletextmaker/images/redo.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.7 KiB

BIN
src/qteletextmaker/images/save.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.2 KiB

BIN
src/qteletextmaker/images/undo.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.7 KiB

545
src/qteletextmaker/keymap.h Normal file
View File

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

948
src/qteletextmaker/levelonecommands.cpp Normal file
View File

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

246
src/qteletextmaker/levelonecommands.h Normal file
View File

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

811
src/qteletextmaker/loadsave.cpp Normal file
View File

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

47
src/qteletextmaker/loadsave.h Normal file
View File

@@ -0,0 +1,47 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef LOADSAVE_H
#define LOADSAVE_H
#include <QByteArray>
#include <QFile>
#include <QSaveFile>
#include <QString>
#include <QTextStream>
#include "document.h"
#include "levelonepage.h"
#include "pagebase.h"
void loadTTI(QFile *inFile, TeletextDocument *document);
void importT42(QFile *inFile, TeletextDocument *document);
int controlBitsToPS(PageBase *subPage);
void saveTTI(QSaveFile &file, const TeletextDocument &document);
void exportT42File(QSaveFile &file, const TeletextDocument &document);
void exportM29File(QSaveFile &file, const TeletextDocument &document);
QByteArray rowPacketAlways(PageBase *subPage, int packetNumber);
QString exportHashStringPage(LevelOnePage *subPage);
QString exportHashStringPackets(LevelOnePage *subPage);
#endif

54
src/qteletextmaker/main.cpp Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#include <QApplication>
#include <QCommandLineParser>
#include "mainwindow.h"
int main(int argc, char *argv[])
{
Q_INIT_RESOURCE(actionicons);
QApplication app(argc, argv);
QApplication::setApplicationName("QTeletextMaker");
QApplication::setApplicationDisplayName(QApplication::applicationName());
QApplication::setOrganizationName("gkmac.co.uk");
QApplication::setOrganizationDomain("gkmac.co.uk");
QApplication::setApplicationVersion("0.6.4-beta");
QCommandLineParser parser;
parser.setApplicationDescription(QApplication::applicationName());
parser.addHelpOption();
parser.addVersionOption();
parser.addPositionalArgument("file", "The file(s) to open.");
parser.process(app);
MainWindow *mainWin = Q_NULLPTR;
foreach (const QString &file, parser.positionalArguments()) {
MainWindow *newWin = new MainWindow(file);
newWin->tile(mainWin);
newWin->show();
mainWin = newWin;
}
if (!mainWin)
mainWin = new MainWindow;
mainWin->show();
return app.exec();
}

797
src/qteletextmaker/mainwidget.cpp Normal file
View File

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

147
src/qteletextmaker/mainwidget.h Normal file
View File

@@ -0,0 +1,147 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef MAINWIDGET_H
#define MAINWIDGET_H
#include <QBasicTimer>
#include <QFrame>
#include <QGraphicsItemGroup>
#include <QGraphicsProxyWidget>
#include <QGraphicsScene>
#include <QPair>
#include <QTextStream>
#include <vector>
#include "decode.h"
#include "document.h"
#include "levelonepage.h"
#include "render.h"
class QPaintEvent;
class TeletextWidget : public QFrame
{
Q_OBJECT
public:
TeletextWidget(QFrame *parent = 0);
~TeletextWidget();
void setCharacter(unsigned char newCharacter);
void toggleCharacterBit(unsigned char bitToToggle);
bool insertMode() const { return m_insertMode; };
void setInsertMode(bool insertMode);
bool showControlCodes() const { return m_pageRender.showControlCodes(); };
QSize sizeHint() { return QSize(480+(pageDecode()->leftSidePanelColumns()+pageDecode()->rightSidePanelColumns())*12, 250); }
void inputMethodEvent(QInputMethodEvent *event);
TeletextDocument* document() const { return m_teletextDocument; }
TeletextPageDecode *pageDecode() { return &m_pageDecode; }
TeletextPageRender *pageRender() { return &m_pageRender; }
signals:
void sizeChanged();
void insertKeyPressed();
public slots:
void subPageSelected();
void refreshPage();
void setReveal(bool reveal);
void setMix(bool mix);
void setShowControlCodes(bool showControlCodes);
void updateFlashTimer(int newFlashTimer);
void pauseFlash(bool pauseNow);
void setControlBit(int bitNumber, bool active);
void setDefaultCharSet(int newDefaultCharSet);
void setDefaultNOS(int newDefaultNOS);
void setSidePanelWidths(int newLeftSidePanelColumns, int newRightSidePanelColumns);
void setSidePanelAtL35Only(bool newSidePanelAtL35Only);
void cut();
void copy();
void paste();
void changeSize();
protected:
void paintEvent(QPaintEvent *event) override;
void keyPressEvent(QKeyEvent *event) override;
void mousePressEvent(QMouseEvent *event) override;
void mouseMoveEvent(QMouseEvent *event) override;
void mouseReleaseEvent(QMouseEvent *event) override;
void focusInEvent(QFocusEvent *event) override;
void focusOutEvent(QFocusEvent *event) override;
TeletextPageDecode m_pageDecode;
TeletextPageRender m_pageRender;
private:
TeletextDocument* m_teletextDocument;
LevelOnePage* m_levelOnePage;
bool m_insertMode, m_selectionInProgress;
QBasicTimer m_flashTimer;
int m_flashTiming, m_flashPhase;
void timerEvent(QTimerEvent *event) override;
void shiftMosaics(int key);
void selectionToClipboard();
QPair<int, int> mouseToRowAndColumn(const QPoint &mousePosition);
};
class LevelOneScene : public QGraphicsScene
{
Q_OBJECT
public:
LevelOneScene(QWidget *levelOneWidget, QObject *parent = nullptr);
void setBorderDimensions(int sceneWidth, int sceneHeight, int widgetWidth, int leftSidePanelColumns, int rightSidePanelColumns);
QGraphicsRectItem *cursorRectItem() const { return m_cursorRectItem; }
public slots:
void updateCursor();
void updateSelection();
void setMix(bool mix);
void toggleGrid(bool gridOn);
void hideGUIElements(bool hidden);
void setFullScreenColour(const QColor &newColor);
void setFullRowColour(int row, const QColor &newColor);
signals:
void mouseZoomIn();
void mouseZoomOut();
protected:
bool eventFilter(QObject *object, QEvent *event);
void keyPressEvent(QKeyEvent *event);
void keyReleaseEvent(QKeyEvent *keyEvent);
private:
QGraphicsRectItem *m_fullScreenTopRectItem, *m_fullScreenBottomRectItem;
QGraphicsRectItem *m_fullRowLeftRectItem[25], *m_fullRowRightRectItem[25];
QGraphicsProxyWidget *m_levelOneProxyWidget;
QGraphicsRectItem *m_cursorRectItem, *m_selectionRectItem;
QGraphicsItemGroup *m_mainGridItemGroup, *m_sidePanelGridItemGroup[32];
bool m_grid, m_sidePanelGridNeeded[32];
};
#endif

1270
src/qteletextmaker/mainwindow.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

143
src/qteletextmaker/mainwindow.h Normal file
View File

@@ -0,0 +1,143 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QCheckBox>
#include <QGraphicsProxyWidget>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QMainWindow>
#include <QLabel>
#include <QPushButton>
#include <QSlider>
#include <QToolButton>
#include "mainwidget.h"
#include "pagecomposelinksdockwidget.h"
#include "pageenhancementsdockwidget.h"
#include "pageoptionsdockwidget.h"
#include "palettedockwidget.h"
#include "x26dockwidget.h"
class QAction;
class QMenu;
class TeletextWidget;
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
MainWindow();
explicit MainWindow(const QString &fileName);
void tile(const QMainWindow *previous);
protected:
void closeEvent(QCloseEvent *event) override;
private slots:
void newFile();
void open();
bool save();
bool saveAs();
void reload();
void exportAuto();
void exportT42(bool fromAuto);
void exportZXNet();
void exportEditTF();
void exportPNG();
void exportM29();
void updateRecentFileActions();
void updateExportAutoAction();
void openRecentFile();
void about();
void updatePageWidgets();
void updateCursorPosition();
void insertRow(bool copyRow);
void deleteRow();
void insertSubPage(bool afterCurrentSubPage, bool copyCurrentSubPage);
void deleteSubPage();
void setSceneDimensions();
void setBorder(int newViewBorder);
void setAspectRatio(int newViewAspectRatio);
void setSmoothTransform(bool smoothTransform);
void zoomIn();
void zoomOut();
void zoomSet(int viewZoom);
void zoomReset();
void toggleInsertMode();
private:
enum { m_MaxRecentFiles = 10 };
const float aspectRatioHorizontalScaling[4] = { 0.6, 0.6, 0.8, 0.5 };
void init();
void createActions();
void createStatusBar();
void readSettings();
void writeSettings();
bool maybeSave();
void openFile(const QString &fileName);
void loadFile(const QString &fileName);
static bool hasRecentFiles();
void prependToRecentFiles(const QString &fileName);
void setRecentFilesVisible(bool visible);
bool saveFile(const QString &fileName);
void setCurrentFile(const QString &fileName);
static QString strippedName(const QString &fullFileName);
MainWindow *findMainWindow(const QString &fileName) const;
TeletextWidget *m_textWidget;
LevelOneScene *m_textScene;
QGraphicsView *m_textView;
int m_viewBorder, m_viewAspectRatio, m_viewZoom;
bool m_viewSmoothTransform;
PageOptionsDockWidget *m_pageOptionsDockWidget;
PageEnhancementsDockWidget *m_pageEnhancementsDockWidget;
X26DockWidget *m_x26DockWidget;
PaletteDockWidget *m_paletteDockWidget;
PageComposeLinksDockWidget *m_pageComposeLinksDockWidget;
QAction *m_recentFileActs[m_MaxRecentFiles];
QAction *m_recentFileSeparator;
QAction *m_recentFileSubMenuAct;
QAction *m_exportAutoAct;
QAction *m_deleteSubPageAction;
QAction *m_borderActs[3];
QAction *m_aspectRatioActs[4];
QAction *m_smoothTransformAction;
QLabel *m_subPageLabel, *m_cursorPositionLabel;
QToolButton *m_previousSubPageButton, *m_nextSubPageButton;
QSlider *m_zoomSlider;
QPushButton *m_insertModePushButton;
QRadioButton *m_levelRadioButton[4];
QString m_curFile, m_exportAutoFileName;
bool m_isUntitled;
};
#endif

222
src/qteletextmaker/pagecomposelinksdockwidget.cpp Normal file
View File

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

52
src/qteletextmaker/pagecomposelinksdockwidget.h Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef PAGECOMPOSELINKSDOCKWIDGET_H
#define PAGECOMPOSELINKSDOCKWIDGET_H
#include <QCheckBox>
#include <QComboBox>
#include <QDockWidget>
#include <QLineEdit>
#include <QRegularExpressionValidator>
#include <QString>
#include "mainwidget.h"
class PageComposeLinksDockWidget : public QDockWidget
{
Q_OBJECT
public:
PageComposeLinksDockWidget(TeletextWidget *parent);
void updateWidgets();
private:
void setComposeLinkPageNumber(int linkNumber, const QString &newPageNumberString);
void setComposeLinkSubPageNumbers(int linkNumber, const QString &newSubPagesString);
TeletextWidget *m_parentMainWidget;
QCheckBox *m_composeLinkLevelCheckbox[4][2]; // For links 0-3
QComboBox *m_composeLinkFunctionComboBox[4]; // For links 4-7; remember to subtract 4!
QLineEdit *m_composeLinkPageNumberLineEdit[8], *m_composeLinkSubPageNumbersLineEdit[8];
QRegularExpressionValidator *m_pageNumberValidator;
};
#endif

168
src/qteletextmaker/pageenhancementsdockwidget.cpp Normal file
View File

@@ -0,0 +1,168 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#include <QCheckBox>
#include <QComboBox>
#include <QGridLayout>
#include <QGroupBox>
#include <QLabel>
#include <QSpinBox>
#include "pageenhancementsdockwidget.h"
#include "x28commands.h"
PageEnhancementsDockWidget::PageEnhancementsDockWidget(TeletextWidget *parent): QDockWidget(parent)
{
QVBoxLayout *pageEnhancementsLayout = new QVBoxLayout;
QWidget *pageEnhancementsWidget = new QWidget;
m_parentMainWidget = parent;
this->setObjectName("PageEnhancementsDockWidget");
this->setWindowTitle("X/28 page enhancements");
// Colour group box and layout
QGroupBox *colourGroupBox = new QGroupBox(tr("Colours"));
QGridLayout *colourLayout = new QGridLayout;
// Default screen and default row colours
colourLayout->addWidget(new QLabel(tr("Default screen colour")), 0, 0, 1, 1);
colourLayout->addWidget(new QLabel(tr("Default row colour")), 1, 0, 1, 1);
m_defaultScreenColourCombo = new QComboBox;
m_defaultScreenColourCombo->setModel(m_parentMainWidget->document()->clutModel());
m_defaultRowColourCombo = new QComboBox;
m_defaultRowColourCombo->setModel(m_parentMainWidget->document()->clutModel());
colourLayout->addWidget(m_defaultScreenColourCombo, 0, 1, 1, 1, Qt::AlignTop);
connect(m_defaultScreenColourCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->document()->undoStack()->push(new SetFullScreenColourCommand(m_parentMainWidget->document(), index)); });
colourLayout->addWidget(m_defaultRowColourCombo, 1, 1, 1, 1, Qt::AlignTop);
connect(m_defaultRowColourCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->document()->undoStack()->push(new SetFullRowColourCommand(m_parentMainWidget->document(), index)); });
// CLUT remapping
colourLayout->addWidget(new QLabel(tr("CLUT remapping")), 2, 0, 1, 1);
m_colourTableCombo = new QComboBox;
m_colourTableCombo->addItem("Fore 0 Back 0");
m_colourTableCombo->addItem("Fore 0 Back 1");
m_colourTableCombo->addItem("Fore 0 Back 2");
m_colourTableCombo->addItem("Fore 1 Back 1");
m_colourTableCombo->addItem("Fore 1 Back 2");
m_colourTableCombo->addItem("Fore 2 Back 1");
m_colourTableCombo->addItem("Fore 2 Back 2");
m_colourTableCombo->addItem("Fore 2 Back 3");
colourLayout->addWidget(m_colourTableCombo, 2, 1, 1, 1, Qt::AlignTop);
connect(m_colourTableCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index){ m_parentMainWidget->document()->undoStack()->push(new SetCLUTRemapCommand(m_parentMainWidget->document(), index)); });
// Black background colour substitution
m_blackBackgroundSubstAct = new QCheckBox("Black background colour substitution");
colourLayout->addWidget(m_blackBackgroundSubstAct, 3, 0, 1, 2, Qt::AlignTop);
connect(m_blackBackgroundSubstAct, &QCheckBox::stateChanged, [=](int state){ m_parentMainWidget->document()->undoStack()->push(new SetBlackBackgroundSubstCommand(m_parentMainWidget->document(), state)); });
// Add group box to the main layout
colourGroupBox->setLayout(colourLayout);
pageEnhancementsLayout->addWidget(colourGroupBox);
// Side panels group box and layout
QGroupBox *sidePanelsGroupBox = new QGroupBox(tr("Side panels"));
QGridLayout *sidePanelsLayout = new QGridLayout;
// Side panel columns
sidePanelsLayout->addWidget(new QLabel(tr("Left side panel columns")), 0, 0, 1, 1);
m_leftSidePanelSpinBox = new QSpinBox(this);
m_leftSidePanelSpinBox->setMaximum(16);
sidePanelsLayout->addWidget(m_leftSidePanelSpinBox, 0, 1, 1, 1, Qt::AlignTop);
connect(m_leftSidePanelSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [=](int index){ setLeftSidePanelWidth(index); });
sidePanelsLayout->addWidget(new QLabel(tr("Right side panel columns")), 1, 0, 1, 1);
m_rightSidePanelSpinBox = new QSpinBox(this);
m_rightSidePanelSpinBox->setMaximum(16);
sidePanelsLayout->addWidget(m_rightSidePanelSpinBox, 1, 1, 1, 1, Qt::AlignTop);
connect(m_rightSidePanelSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [=](int index){ setRightSidePanelWidth(index); });
// Side panels status
m_sidePanelStatusAct = new QCheckBox("Side panels at level 3.5 only");
sidePanelsLayout->addWidget(m_sidePanelStatusAct, 2, 0, 1, 2, Qt::AlignTop);
connect(m_sidePanelStatusAct, &QCheckBox::stateChanged, m_parentMainWidget, &TeletextWidget::setSidePanelAtL35Only);
// Add group box to the main layout
sidePanelsGroupBox->setLayout(sidePanelsLayout);
pageEnhancementsLayout->addWidget(sidePanelsGroupBox);
pageEnhancementsLayout->addStretch(1);
pageEnhancementsWidget->setLayout(pageEnhancementsLayout);
this->setWidget(pageEnhancementsWidget);
}
void PageEnhancementsDockWidget::setLeftSidePanelWidth(int newLeftPanelSize)
{
if (newLeftPanelSize && m_rightSidePanelSpinBox->value()) {
int newRightPanelSize = 16-newLeftPanelSize;
m_rightSidePanelSpinBox->blockSignals(true);
m_rightSidePanelSpinBox->setValue(newRightPanelSize);
m_rightSidePanelSpinBox->blockSignals(false);
}
m_parentMainWidget->setSidePanelWidths(newLeftPanelSize, m_rightSidePanelSpinBox->value());
}
void PageEnhancementsDockWidget::setRightSidePanelWidth(int newRightPanelSize)
{
if (newRightPanelSize && m_leftSidePanelSpinBox->value()) {
int newLeftPanelSize = 16-newRightPanelSize;
m_leftSidePanelSpinBox->blockSignals(true);
m_leftSidePanelSpinBox->setValue(newLeftPanelSize);
m_leftSidePanelSpinBox->blockSignals(false);
}
m_parentMainWidget->setSidePanelWidths(m_leftSidePanelSpinBox->value(), newRightPanelSize);
}
void PageEnhancementsDockWidget::updateWidgets()
{
int leftSidePanelColumnsResult = 0;
int rightSidePanelColumnsResult = 0;
m_defaultScreenColourCombo->blockSignals(true);
m_defaultScreenColourCombo->setCurrentIndex(m_parentMainWidget->document()->currentSubPage()->defaultScreenColour());
m_defaultScreenColourCombo->blockSignals(false);
m_defaultRowColourCombo->blockSignals(true);
m_defaultRowColourCombo->setCurrentIndex(m_parentMainWidget->document()->currentSubPage()->defaultRowColour());
m_defaultRowColourCombo->blockSignals(false);
m_colourTableCombo->blockSignals(true);
m_colourTableCombo->setCurrentIndex(m_parentMainWidget->document()->currentSubPage()->colourTableRemap());
m_colourTableCombo->blockSignals(false);
m_blackBackgroundSubstAct->blockSignals(true);
m_blackBackgroundSubstAct->setChecked(m_parentMainWidget->document()->currentSubPage()->blackBackgroundSubst());
m_blackBackgroundSubstAct->blockSignals(false);
if (m_parentMainWidget->document()->currentSubPage()->leftSidePanelDisplayed())
leftSidePanelColumnsResult = (m_parentMainWidget->document()->currentSubPage()->sidePanelColumns() == 0) ? 16 : m_parentMainWidget->document()->currentSubPage()->sidePanelColumns();
if (m_parentMainWidget->document()->currentSubPage()->rightSidePanelDisplayed())
rightSidePanelColumnsResult = 16-m_parentMainWidget->document()->currentSubPage()->sidePanelColumns();
m_leftSidePanelSpinBox->blockSignals(true);
m_leftSidePanelSpinBox->setValue(leftSidePanelColumnsResult);
m_leftSidePanelSpinBox->blockSignals(false);
m_rightSidePanelSpinBox->blockSignals(true);
m_rightSidePanelSpinBox->setValue(rightSidePanelColumnsResult);
m_rightSidePanelSpinBox->blockSignals(false);
m_sidePanelStatusAct->blockSignals(true);
m_sidePanelStatusAct->setChecked(!m_parentMainWidget->document()->currentSubPage()->sidePanelStatusL25());
m_sidePanelStatusAct->blockSignals(false);
}

48
src/qteletextmaker/pageenhancementsdockwidget.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef PAGEENHANCEMENTSDOCKWIDGET_H
#define PAGEENHANCEMENTSDOCKWIDGET_H
#include <QCheckBox>
#include <QComboBox>
#include <QDockWidget>
#include <QSpinBox>
#include "mainwidget.h"
class PageEnhancementsDockWidget : public QDockWidget
{
Q_OBJECT
public:
PageEnhancementsDockWidget(TeletextWidget *parent);
void updateWidgets();
private:
void setLeftSidePanelWidth(int newLeftPanelSize);
void setRightSidePanelWidth(int newRightPanelSize);
TeletextWidget *m_parentMainWidget;
QComboBox *m_defaultScreenColourCombo, *m_defaultRowColourCombo, *m_colourTableCombo;
QCheckBox *m_blackBackgroundSubstAct, *m_sidePanelStatusAct;
QSpinBox *m_leftSidePanelSpinBox, *m_rightSidePanelSpinBox;
};
#endif

271
src/qteletextmaker/pageoptionsdockwidget.cpp Normal file
View File

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

114
src/qteletextmaker/pageoptionsdockwidget.h Normal file
View File

@@ -0,0 +1,114 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef PAGEOPTIONSDOCKWIDGET_H
#define PAGEOPTIONSDOCKWIDGET_H
#include <QCheckBox>
#include <QComboBox>
#include <QDockWidget>
#include <QLineEdit>
#include <QRegularExpressionValidator>
#include <QSpinBox>
#include "mainwidget.h"
class PageOptionsDockWidget : public QDockWidget
{
Q_OBJECT
public:
PageOptionsDockWidget(TeletextWidget *parent);
void updateWidgets();
private:
TeletextWidget *m_parentMainWidget;
QLineEdit *m_pageNumberEdit, *m_pageDescriptionEdit;
QSpinBox *m_cycleValueSpinBox;
QComboBox *m_cycleTypeCombo;
QCheckBox *m_controlBitsAct[8];
QComboBox *m_defaultRegionCombo, *m_defaultNOSCombo, *m_secondRegionCombo, *m_secondNOSCombo;
QLineEdit *m_fastTextEdit[6];
QRegularExpressionValidator *m_pageNumberValidator;
void addRegionList(QComboBox *regionCombo);
void setFastTextLinkPageNumber(int linkNumber, const QString &pageNumberString);
void setDefaultRegion();
void setDefaultNOS();
void setSecondRegion();
void setSecondNOS();
void updateDefaultNOSOptions();
void updateSecondNOSOptions();
};
struct languageComboBoxItem {
QString name;
int bits;
};
static const int languageComboBoxItemCount = 36;
static const languageComboBoxItem languageComboBoxItems[languageComboBoxItemCount] {
{ "English", 0x00 } ,
{ "German", 0x01 } ,
{ "Swedish/Finnish/Hungarian", 0x02 } ,
{ "Italian", 0x03 } ,
{ "French", 0x04 } ,
{ "Portuguese/Spanish", 0x05 } ,
{ "Czech/Slovak", 0x06 } ,
{ "Polish", 0x08 } ,
{ "German", 0x09 } ,
{ "Swedish/Finnish/Hungarian", 0x0a } ,
{ "Italian", 0x0b } ,
{ "French", 0x0c } ,
{ "Czech/Slovak", 0x0e } ,
{ "English", 0x10 } ,
{ "German", 0x11 } ,
{ "Swedish/Finnish/Hungarian", 0x12 } ,
{ "Italian", 0x13 } ,
{ "French", 0x14 } ,
{ "Portuguese/Spanish", 0x15 } ,
{ "Turkish", 0x16 } ,
{ "Serbian/Croatian/Slovenian", 0x1d } ,
{ "Rumanian", 0x1f } ,
{ "Serbian/Croatian", 0x20 } ,
{ "German", 0x21 } ,
{ "Estonian", 0x22 } ,
{ "Lettish/Lithuanian", 0x23 } ,
{ "Russian/Bulgarian", 0x24 } ,
{ "Ukrainian", 0x25 } ,
{ "Czech/Slovak", 0x26 } ,
{ "Turkish", 0x36 } ,
{ "Greek", 0x37 } ,
{ "English", 0x40 } ,
{ "French", 0x44 } ,
{ "Arabic", 0x47 } ,
{ "Hebrew", 0x55 } ,
{ "Arabic", 0x57 } ,
};
#endif

170
src/qteletextmaker/palettedockwidget.cpp Normal file
View File

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

59
src/qteletextmaker/palettedockwidget.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef PALETTEDOCKWIDGET_H
#define PALETTEDOCKWIDGET_H
#include <QCheckBox>
#include <QDockWidget>
#include <QPushButton>
#include "mainwidget.h"
class PaletteDockWidget : public QDockWidget
{
Q_OBJECT
public:
PaletteDockWidget(TeletextWidget *parent);
void updateAllColourButtons();
public slots:
void updateColourButton(int colourIndex);
void setLevel3p5Accepted(bool b);
protected:
void showEvent(QShowEvent *event);
private slots:
void selectColour(int colourIndex);
void setLevel3p5Seen(bool b);
void updateLevel3p5Cursor();
private:
void resetCLUT(int colourTable);
QPushButton *m_colourButton[32], *m_resetButton[4];
QCheckBox *m_showHexValuesCheckBox;
bool m_level3p5Accepted, m_level3p5Seen;
TeletextWidget *m_parentMainWidget;
};
#endif

256
src/qteletextmaker/x26commands.cpp Normal file
View File

@@ -0,0 +1,256 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#include "x26commands.h"
#include <QUndoCommand>
#include "document.h"
#include "x26model.h"
#include "x26triplets.h"
InsertTripletCommand::InsertTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int count, X26Triplet newTriplet, QUndoCommand *parent) : QUndoCommand(parent)
{
m_teletextDocument = teletextDocument;
m_subPageIndex = teletextDocument->currentSubPageIndex();
m_x26Model = x26Model;
m_row = row;
m_count = count;
m_insertedTriplet = newTriplet;
setText(QString("insert triplet d%1 t%2").arg(m_row / 13).arg(m_row % 13));;
m_firstDo = true;
}
void InsertTripletCommand::redo()
{
bool changingSubPage = (m_teletextDocument->currentSubPageIndex() != m_subPageIndex);
if (changingSubPage) {
m_teletextDocument->emit aboutToChangeSubPage();
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
} else
m_x26Model->beginInsertRows(QModelIndex(), m_row, m_row+m_count-1);
for (int i=0; i<m_count; i++)
m_teletextDocument->currentSubPage()->enhancements()->insert(m_row+i, m_insertedTriplet);
if (!changingSubPage)
m_x26Model->endInsertRows();
// Preserve pointers to local object definitions that have moved
for (int i=0; i<m_teletextDocument->currentSubPage()->enhancements()->size(); i++) {
X26Triplet triplet = m_teletextDocument->currentSubPage()->enhancements()->at(i);
if (triplet.modeExt() >= 0x11 && triplet.modeExt() <= 0x13 && ((triplet.address() & 0x18) == 0x08) && triplet.objectLocalIndex() >= m_row) {
triplet.setObjectLocalIndex(triplet.objectLocalIndex() + m_count);
m_teletextDocument->currentSubPage()->enhancements()->replace(i, triplet);
if (!changingSubPage)
m_x26Model->emit dataChanged(m_x26Model->createIndex(i, 0), m_x26Model->createIndex(i, 3));
}
}
if (changingSubPage)
m_teletextDocument->emit subPageSelected();
else
m_teletextDocument->emit contentsChanged();
if (m_firstDo)
m_firstDo = false;
m_teletextDocument->emit tripletCommandHighlight(m_row);
}
void InsertTripletCommand::undo()
{
bool changingSubPage = (m_teletextDocument->currentSubPageIndex() != m_subPageIndex);
if (changingSubPage) {
m_teletextDocument->emit aboutToChangeSubPage();
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
} else
m_x26Model->beginRemoveRows(QModelIndex(), m_row, m_row+m_count-1);
for (int i=0; i<m_count; i++)
m_teletextDocument->currentSubPage()->enhancements()->removeAt(m_row);
if (!changingSubPage)
m_x26Model->endRemoveRows();
// Preserve pointers to local object definitions that have moved
for (int i=0; i<m_teletextDocument->currentSubPage()->enhancements()->size(); i++) {
X26Triplet triplet = m_teletextDocument->currentSubPage()->enhancements()->at(i);
if (triplet.modeExt() >= 0x11 && triplet.modeExt() <= 0x13 && ((triplet.address() & 0x18) == 0x08) && triplet.objectLocalIndex() >= m_row) {
triplet.setObjectLocalIndex(triplet.objectLocalIndex() - m_count);
m_teletextDocument->currentSubPage()->enhancements()->replace(i, triplet);
if (!changingSubPage)
m_x26Model->emit dataChanged(m_x26Model->createIndex(i, 0), m_x26Model->createIndex(i, 3));
}
}
if (changingSubPage)
m_teletextDocument->emit subPageSelected();
else
m_teletextDocument->emit contentsChanged();
}
DeleteTripletCommand::DeleteTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int count, QUndoCommand *parent) : QUndoCommand(parent)
{
m_teletextDocument = teletextDocument;
m_subPageIndex = teletextDocument->currentSubPageIndex();
m_x26Model = x26Model;
m_row = row;
m_count = count;
m_deletedTriplet = m_teletextDocument->subPage(m_subPageIndex)->enhancements()->at(m_row);
setText(QString("delete triplet d%1 t%2").arg(m_row / 13).arg(m_row % 13));;
// BUG we only store one of the deleted triplets
if (m_count > 1)
qDebug("More than one triplet row deleted, undo won't put the lost triplets back!");
}
void DeleteTripletCommand::redo()
{
bool changingSubPage = (m_teletextDocument->currentSubPageIndex() != m_subPageIndex);
if (changingSubPage) {
m_teletextDocument->emit aboutToChangeSubPage();
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
} else
m_x26Model->beginRemoveRows(QModelIndex(), m_row, m_row+m_count-1);
for (int i=0; i<m_count; i++)
m_teletextDocument->currentSubPage()->enhancements()->removeAt(m_row);
if (!changingSubPage)
m_x26Model->endRemoveRows();
// Preserve pointers to local object definitions that have moved
for (int i=0; i<m_teletextDocument->currentSubPage()->enhancements()->size(); i++) {
X26Triplet triplet = m_teletextDocument->currentSubPage()->enhancements()->at(i);
if (triplet.modeExt() >= 0x11 && triplet.modeExt() <= 0x13 && ((triplet.address() & 0x18) == 0x08) && triplet.objectLocalIndex() >= m_row) {
triplet.setObjectLocalIndex(triplet.objectLocalIndex() - m_count);
m_teletextDocument->currentSubPage()->enhancements()->replace(i, triplet);
m_x26Model->emit dataChanged(m_x26Model->createIndex(i, 0), m_x26Model->createIndex(i, 3));
}
}
if (changingSubPage)
m_teletextDocument->emit subPageSelected();
else
m_teletextDocument->emit contentsChanged();
}
void DeleteTripletCommand::undo()
{
bool changingSubPage = (m_teletextDocument->currentSubPageIndex() != m_subPageIndex);
if (changingSubPage) {
m_teletextDocument->emit aboutToChangeSubPage();
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
} else
m_x26Model->beginInsertRows(QModelIndex(), m_row, m_row+m_count-1);
for (int i=0; i<m_count; i++)
m_teletextDocument->currentSubPage()->enhancements()->insert(m_row+i, m_deletedTriplet);
if (!changingSubPage)
m_x26Model->endInsertRows();
// Preserve pointers to local object definitions that have moved
for (int i=0; i<m_teletextDocument->currentSubPage()->enhancements()->size(); i++) {
X26Triplet triplet = m_teletextDocument->currentSubPage()->enhancements()->at(i);
if (triplet.modeExt() >= 0x11 && triplet.modeExt() <= 0x13 && ((triplet.address() & 0x18) == 0x08) && triplet.objectLocalIndex() >= m_row) {
triplet.setObjectLocalIndex(triplet.objectLocalIndex() + m_count);
m_teletextDocument->currentSubPage()->enhancements()->replace(i, triplet);
if (!changingSubPage)
m_x26Model->emit dataChanged(m_x26Model->createIndex(i, 0), m_x26Model->createIndex(i, 3));
}
}
if (changingSubPage)
m_teletextDocument->emit subPageSelected();
else
m_teletextDocument->emit contentsChanged();
m_teletextDocument->emit tripletCommandHighlight(m_row);
}
EditTripletCommand::EditTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int tripletPart, int bitsToKeep, int newValue, int role, QUndoCommand *parent) : QUndoCommand(parent)
{
m_teletextDocument = teletextDocument;
m_subPageIndex = teletextDocument->currentSubPageIndex();
m_x26Model = x26Model;
m_row = row;
m_role = role;
m_oldTriplet = m_newTriplet = teletextDocument->currentSubPage()->enhancements()->at(m_row);
setText(QString("edit triplet d%1 t%2").arg(m_row / 13).arg(m_row % 13));;
switch (tripletPart) {
case ETaddress:
m_newTriplet.setAddress((m_newTriplet.address() & bitsToKeep) | newValue);
break;
case ETmode:
m_newTriplet.setMode((m_newTriplet.mode() & bitsToKeep) | newValue);
break;
case ETdata:
m_newTriplet.setData((m_newTriplet.data() & bitsToKeep) | newValue);
break;
};
m_firstDo = true;
}
void EditTripletCommand::redo()
{
if (m_teletextDocument->currentSubPageIndex() != m_subPageIndex)
m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
m_teletextDocument->currentSubPage()->enhancements()->replace(m_row, m_newTriplet);
m_x26Model->emit dataChanged(m_x26Model->createIndex(m_row, 0), m_x26Model->createIndex(m_row, 3), {m_role});
m_teletextDocument->emit contentsChanged();
if (m_firstDo)
m_firstDo = false;
else
m_teletextDocument->emit tripletCommandHighlight(m_row);
}
void EditTripletCommand::undo()
{
if (m_teletextDocument->currentSubPageIndex() != m_subPageIndex)
m_teletextDocument->selectSubPageIndex(m_subPageIndex, true);
m_teletextDocument->currentSubPage()->enhancements()->replace(m_row, m_oldTriplet);
m_x26Model->emit dataChanged(m_x26Model->createIndex(m_row, 0), m_x26Model->createIndex(m_row, 3), {m_role});
m_teletextDocument->emit contentsChanged();
m_teletextDocument->emit tripletCommandHighlight(m_row);
}
bool EditTripletCommand::mergeWith(const QUndoCommand *command)
{
const EditTripletCommand *newerCommand = static_cast<const EditTripletCommand *>(command);
if (m_subPageIndex != newerCommand->m_subPageIndex || m_row != newerCommand->m_row)
return false;
m_newTriplet = newerCommand->m_newTriplet;
return true;
}

81
src/qteletextmaker/x26commands.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef X26COMMANDS_H
#define X26COMMANDS_H
#include <QUndoCommand>
#include "document.h"
#include "x26model.h"
#include "x26triplets.h"
class InsertTripletCommand : public QUndoCommand
{
public:
InsertTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int count, const X26Triplet newTriplet, QUndoCommand *parent = 0);
void redo() override;
void undo() override;
private:
TeletextDocument *m_teletextDocument;
X26Model *m_x26Model;
int m_subPageIndex, m_row, m_count;
X26Triplet m_insertedTriplet;
bool m_firstDo;
};
class DeleteTripletCommand : public QUndoCommand
{
public:
DeleteTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int count, QUndoCommand *parent = 0);
void redo() override;
void undo() override;
private:
TeletextDocument *m_teletextDocument;
X26Model *m_x26Model;
int m_subPageIndex, m_row, m_count;
X26Triplet m_deletedTriplet;
};
class EditTripletCommand : public QUndoCommand
{
public:
enum { Id = 201 };
enum EditTripletEnum { ETaddress, ETmode, ETdata };
EditTripletCommand(TeletextDocument *teletextDocument, X26Model *x26Model, int row, int tripletPart, int bitsToKeep, int newValue, int role, QUndoCommand *parent = 0);
void redo() override;
void undo() override;
bool mergeWith(const QUndoCommand *) override;
int id() const override { return Id; }
private:
TeletextDocument *m_teletextDocument;
X26Model *m_x26Model;
int m_subPageIndex, m_row, m_role;
X26Triplet m_oldTriplet, m_newTriplet;
bool m_firstDo;
};
#endif

1236
src/qteletextmaker/x26dockwidget.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

131
src/qteletextmaker/x26dockwidget.h Normal file
View File

@@ -0,0 +1,131 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef X26DOCKWIDGET_H
#define X26DOCKWIDGET_H
#include <QAbstractListModel>
#include <QCheckBox>
#include <QComboBox>
#include <QDockWidget>
#include <QGroupBox>
#include <QLabel>
#include <QMenu>
#include <QPushButton>
#include <QRadioButton>
#include <QSpinBox>
#include <QStackedLayout>
#include <QTableView>
#include "mainwidget.h"
#include "render.h"
#include "x26menus.h"
#include "x26model.h"
class CharacterListModel : public QAbstractListModel
{
Q_OBJECT
public:
CharacterListModel(QObject *parent = 0);
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
void setCharacterSet(int characterSet);
void setG1AndBlastCharacterSet(int characterSet);
private:
TeletextFontBitmap m_fontBitmap;
int m_characterSet;
bool m_mosaic;
};
class X26DockWidget : public QDockWidget
{
Q_OBJECT
public:
X26DockWidget(TeletextWidget *parent);
public slots:
void insertTriplet(int modeExt, bool after);
void insertTriplet(int modeExt, int row = -1);
void insertTripletCopy();
void deleteTriplet();
void customMenuRequested(QPoint pos);
void loadX26List();
void unloadX26List();
void rowSelected(const QModelIndex &current, const QModelIndex &previous);
void updateAllRawTripletSpinBoxes(const QModelIndex &index);
void updateRawTripletDataSpinBox(const QModelIndex &index);
void updateAllCookedTripletWidgets(const QModelIndex & index);
void rawTripletAddressSpinBoxChanged(int value);
void rawTripletModeSpinBoxChanged(int value);
void rawTripletDataSpinBoxChanged(int value);
void cookedRowSpinBoxChanged(const int value);
void cookedColumnSpinBoxChanged(const int value);
void cookedModeMenuSelected(const int value);
void updateModelFromCookedWidget(const int value, const int role);
void selectX26ListRow(int row);
protected:
void keyPressEvent(QKeyEvent *event) override;
CharacterListModel m_characterListModel;
private:
QTableView *m_x26View;
X26Model *m_x26Model;
QSpinBox *m_cookedRowSpinBox, *m_cookedColumnSpinBox;
QMenu *m_cookedModeMenu, *m_insertBeforeMenu, *m_insertAfterMenu;
QPushButton *m_cookedModePushButton;
QSpinBox *m_rawTripletAddressSpinBox, *m_rawTripletModeSpinBox, *m_rawTripletDataSpinBox;
QStackedLayout *m_rawOrCookedStackedLayout;
QComboBox *m_colourComboBox;
QRadioButton *m_fullRowColourThisRowOnlyRadioButton, *m_fullRowColourDownToBottomRadioButton;
QComboBox *m_characterCodeComboBox;
QComboBox *m_flashModeComboBox, *m_flashRateComboBox;
QComboBox *m_textSizeComboBox;
QCheckBox *m_displayAttributeBoxingCheckBox, *m_displayAttributeConcealCheckBox, *m_displayAttributeInvertCheckBox, *m_displayAttributeUnderlineCheckBox;
QComboBox *m_objectSourceComboBox, *m_objectRequiredAtLevelsComboBox;
QLabel *m_invokeLocalObjectDesignationCodeLabel, *m_invokeLocalObjectTripletNumberLabel;
QSpinBox *m_invokeLocalObjectDesignationCodeSpinBox, *m_invokeLocalObjectTripletNumberSpinBox;
QSpinBox *m_invokePOPSubPageSpinBox, *m_invokePOPPacketNumberSpinBox;
QComboBox *m_invokePOPTripletNumberComboBox, *m_invokePOPPointerBitsComboBox;
QStackedLayout *m_invokeObjectSourceStackedLayout, *m_tripletParameterStackedLayout;
QComboBox *m_DRCSModeRequiredAtLevelsComboBox;
QRadioButton *m_DRCSModeGlobalRadioButton, *m_DRCSModeNormalRadioButton;
QSpinBox *m_DRCSModeSubPageSpinBox;
QRadioButton *m_DRCSCharacterGlobalRadioButton, *m_DRCSCharacterNormalRadioButton;
QSpinBox *m_DRCSCharacterCodeSpinBox;
QCheckBox *m_fontStyleProportionalCheckBox, *m_fontStyleBoldCheckBox, *m_fontStyleItalicCheckBox;
QSpinBox *m_fontStyleRowsSpinBox;
QSpinBox *m_reservedPDCSpinBox;
QComboBox *m_terminationMarkerPageTypeComboBox;
QCheckBox *m_terminationMarkerMoreFollowsCheckBox;
QPushButton *m_insertBeforePushButton, *m_insertAfterPushButton, *m_insertCopyPushButton, *m_deletePushButton;
ModeTripletNames m_modeTripletNames;
TeletextWidget *m_parentMainWidget;
void disableTripletWidgets();
};
#endif

251
src/qteletextmaker/x26menus.cpp Normal file
View File

@@ -0,0 +1,251 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#include "x26menus.h"
#include <QActionGroup>
#include <QColor>
#include <QIcon>
#include <QMenu>
#include <QPixmap>
#include <QString>
#include "render.h"
TripletModeQMenu::TripletModeQMenu(QWidget *parent): QMenu(parent)
{
addModeAction(this, 0x04);
QMenu *rowTripletSubMenu = this->addMenu(tr("Row triplet"));
addModeAction(rowTripletSubMenu, 0x00);
addModeAction(rowTripletSubMenu, 0x01);
addModeAction(rowTripletSubMenu, 0x07);
addModeAction(rowTripletSubMenu, 0x18);
QMenu *columnTripletSubMenu = this->addMenu(tr("Column triplet"));
addModeAction(columnTripletSubMenu, 0x20);
addModeAction(columnTripletSubMenu, 0x23);
addModeAction(columnTripletSubMenu, 0x27);
addModeAction(columnTripletSubMenu, 0x2c);
addModeAction(columnTripletSubMenu, 0x2e);
addModeAction(columnTripletSubMenu, 0x28);
columnTripletSubMenu->addSeparator();
addModeAction(columnTripletSubMenu, 0x29);
addModeAction(columnTripletSubMenu, 0x2f);
addModeAction(columnTripletSubMenu, 0x21);
addModeAction(columnTripletSubMenu, 0x22);
addModeAction(columnTripletSubMenu, 0x2b);
addModeAction(columnTripletSubMenu, 0x2d);
QMenu *diacriticalSubMenu = columnTripletSubMenu->addMenu(tr("G0 diacritical"));
for (int i=0; i<16; i++)
addModeAction(diacriticalSubMenu, 0x30 + i);
QMenu *objectSubMenu = this->addMenu(tr("Object"));
addModeAction(objectSubMenu, 0x10);
addModeAction(objectSubMenu, 0x11);
addModeAction(objectSubMenu, 0x12);
addModeAction(objectSubMenu, 0x13);
addModeAction(objectSubMenu, 0x15);
addModeAction(objectSubMenu, 0x16);
addModeAction(objectSubMenu, 0x17);
addModeAction(this, 0x1f);
this->addSeparator();
QMenu *pdcSubMenu = this->addMenu(tr("PDC/reserved"));
addModeAction(pdcSubMenu, 0x08);
addModeAction(pdcSubMenu, 0x09);
addModeAction(pdcSubMenu, 0x0a);
addModeAction(pdcSubMenu, 0x0b);
addModeAction(pdcSubMenu, 0x0c);
addModeAction(pdcSubMenu, 0x0d);
addModeAction(pdcSubMenu, 0x26);
QMenu *reservedRowSubMenu = pdcSubMenu->addMenu(tr("Reserved row"));
addModeAction(reservedRowSubMenu, 0x02);
addModeAction(reservedRowSubMenu, 0x03);
addModeAction(reservedRowSubMenu, 0x05);
addModeAction(reservedRowSubMenu, 0x06);
addModeAction(reservedRowSubMenu, 0x0e);
addModeAction(reservedRowSubMenu, 0x0f);
addModeAction(reservedRowSubMenu, 0x14);
addModeAction(reservedRowSubMenu, 0x19);
addModeAction(reservedRowSubMenu, 0x1a);
addModeAction(reservedRowSubMenu, 0x1b);
addModeAction(reservedRowSubMenu, 0x1c);
addModeAction(reservedRowSubMenu, 0x1d);
addModeAction(reservedRowSubMenu, 0x1e);
QMenu *reservedColumnSubMenu = pdcSubMenu->addMenu(tr("Reserved column"));
addModeAction(reservedColumnSubMenu, 0x24);
addModeAction(reservedColumnSubMenu, 0x25);
addModeAction(reservedColumnSubMenu, 0x2a);
}
void TripletModeQMenu::addModeAction(QMenu *menu, int mode)
{
m_actions[mode] = menu->addAction(m_modeTripletNames.modeName(mode));
}
TripletCLUTQMenu::TripletCLUTQMenu(bool rows, QWidget *parent): QMenu(parent)
{
QMenu *clut[4];
for (int c=0; c<4; c++) {
clut[c] = this->addMenu(QString("CLUT %1").arg(c));
for (int e=0; e<8; e++)
m_actions[c*8+e] = clut[c]->addAction(QString("CLUT %1:%2").arg(c).arg(e));
}
if (rows) {
m_actions[32] = this->addAction(tr("This row only"));
m_actions[33] = this->addAction(tr("Down to bottom"));
}
}
void TripletCLUTQMenu::setColour(int i, QColor c)
{
QPixmap menuColour(32, 32); // Should get downscaled to the menu text size
menuColour.fill(c);
m_actions[i]->setIcon(QIcon(menuColour));
}
TripletCharacterQMenu::TripletCharacterQMenu(int charSet, bool mosaic, QWidget *parent): QMenu(parent)
{
QMenu *charRange[6];
for (int r=0; r<6; r++) {
charRange[r] = this->addMenu(QString("0x%010-0x%01f").arg(r+2));
const int charSetInColumn = (mosaic && ((r & 0x2) == 0)) ? 24 : charSet;
for (int c=0; c<16; c++)
m_actions[r*16+c] = charRange[r]->addAction(QIcon(m_fontBitmap.charBitmap(r*16+c+32, charSetInColumn)), QString("0x%1").arg(r*16+c+32, 2, 16, QChar('0')));
}
}
TripletFlashQMenu::TripletFlashQMenu(QWidget *parent): QMenu(parent)
{
QMenu *flashModeMenu = this->addMenu(tr("Flash mode"));
m_actions[0] = flashModeMenu->addAction(tr("Steady"));
m_actions[1] = flashModeMenu->addAction(tr("Normal"));
m_actions[2] = flashModeMenu->addAction(tr("Invert"));
m_actions[3] = flashModeMenu->addAction(tr("Adjacent CLUT"));
m_modeActionGroup = new QActionGroup(this);
for (int i=0; i<4; i++) {
m_actions[i]->setCheckable(true);
m_modeActionGroup->addAction(m_actions[i]);
}
QMenu *flashRatePhaseMenu = this->addMenu(tr("Flash rate/phase"));
m_actions[4] = flashRatePhaseMenu->addAction(tr("Slow 1Hz"));
m_actions[5] = flashRatePhaseMenu->addAction(tr("Fast 2Hz phase 1"));
m_actions[6] = flashRatePhaseMenu->addAction(tr("Fast 2Hz phase 2"));
m_actions[7] = flashRatePhaseMenu->addAction(tr("Fast 2Hz phase 3"));
m_actions[8] = flashRatePhaseMenu->addAction(tr("Fast 2Hz inc/right"));
m_actions[9] = flashRatePhaseMenu->addAction(tr("Fast 2Hz dec/left"));
m_ratePhaseActionGroup = new QActionGroup(this);
for (int i=4; i<10; i++) {
m_actions[i]->setCheckable(true);
m_ratePhaseActionGroup->addAction(m_actions[i]);
}
}
void TripletFlashQMenu::setModeChecked(int n)
{
m_actions[n]->setChecked(true);
}
void TripletFlashQMenu::setRatePhaseChecked(int n)
{
m_actions[n+4]->setChecked(true);
}
TripletDisplayAttrsQMenu::TripletDisplayAttrsQMenu(QWidget *parent): QMenu(parent)
{
QMenu *sizeMenu = this->addMenu(tr("Text size"));
m_actions[0] = sizeMenu->addAction(tr("Normal size"));
m_actions[1] = sizeMenu->addAction(tr("Double height"));
m_actions[2] = sizeMenu->addAction(tr("Double width"));
m_actions[3] = sizeMenu->addAction(tr("Double size"));
m_sizeActionGroup = new QActionGroup(this);
for (int i=0; i<4; i++) {
m_actions[i]->setCheckable(true);
m_sizeActionGroup->addAction(m_actions[i]);
}
m_actions[4] = this->addAction(tr("Boxing/Window"));
m_actions[5] = this->addAction(tr("Conceal"));
m_actions[6] = this->addAction(tr("Invert"));
m_actions[7] = this->addAction(tr("Underline/Separated"));
m_otherActionGroup = new QActionGroup(this);
m_otherActionGroup->setExclusive(false);
for (int i=4; i<8; i++) {
m_actions[i]->setCheckable(true);
m_otherActionGroup->addAction(m_actions[i]);
}
}
void TripletDisplayAttrsQMenu::setTextSizeChecked(int n)
{
m_actions[n]->setChecked(true);
}
void TripletDisplayAttrsQMenu::setOtherAttrChecked(int n, bool b)
{
m_actions[n+4]->setChecked(b);
}
TripletFontStyleQMenu::TripletFontStyleQMenu(QWidget *parent): QMenu(parent)
{
m_actions[0] = this->addAction(tr("Proportional"));
m_actions[1] = this->addAction(tr("Bold"));
m_actions[2] = this->addAction(tr("Italic"));
m_styleActionGroup = new QActionGroup(this);
m_styleActionGroup->setExclusive(false);
for (int i=0; i<3; i++) {
m_actions[i]->setCheckable(true);
m_styleActionGroup->addAction(m_actions[i]);
}
QMenu *rowsMenu = this->addMenu(tr("Next rows"));
m_rowsActionGroup = new QActionGroup(this);
for (int i=3; i<11; i++) {
m_actions[i] = rowsMenu->addAction(QString("%1").arg(i-3));
m_actions[i]->setCheckable(true);
m_rowsActionGroup->addAction(m_actions[i]);
}
}
void TripletFontStyleQMenu::setStyleChecked(int n, bool b)
{
m_actions[n]->setChecked(b);
}
void TripletFontStyleQMenu::setRowsChecked(int n)
{
m_actions[n+3]->setChecked(true);
}

207
src/qteletextmaker/x26menus.h Normal file
View File

@@ -0,0 +1,207 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef X26MENUS_H
#define X26MENUS_H
#include <QActionGroup>
#include <QColor>
#include <QMenu>
#include <QString>
#include "render.h"
class ModeTripletNames
{
public:
static const QString modeName(int i) { return m_modeTripletName[i]; }
private:
static inline const QString m_modeTripletName[64] {
// Row triplet modes
"Full screen colour",
"Full row colour",
"Reserved 0x02",
"Reserved 0x03",
"Set Active Position",
"Reserved 0x05",
"Reserved 0x06",
"Address row 0",
"PDC origin, source",
"PDC month and day",
"PDC cursor and start hour",
"PDC cursor and end hour",
"PDC cursor local offset",
"PDC series ID and code",
"Reserved 0x0e",
"Reserved 0x0f",
"Origin modifier",
"Invoke active object",
"Invoke adaptive object",
"Invoke passive object",
"Reserved 0x14",
"Define active object",
"Define adaptive object",
"Define passive object",
"DRCS mode",
"Reserved 0x19",
"Reserved 0x1a",
"Reserved 0x1b",
"Reserved 0x1c",
"Reserved 0x1d",
"Reserved 0x1e",
"Termination marker",
// Column triplet modes
"Foreground colour",
"G1 block mosaic",
"G3 smooth mosaic, level 1.5",
"Background colour",
"Reserved 0x04",
"Reserved 0x05",
"PDC cursor, start end min",
"Additional flash functions",
"Modified G0/G2 character set",
"G0 character",
"Reserved 0x0a",
"G3 smooth mosaic, level 2.5",
"Display attributes",
"DRCS character",
"Font style, level 3.5",
"G2 supplementary character",
"G0 character no diacritical",
"G0 character diacritical 1",
"G0 character diacritical 2",
"G0 character diacritical 3",
"G0 character diacritical 4",
"G0 character diacritical 5",
"G0 character diacritical 6",
"G0 character diacritical 7",
"G0 character diacritical 8",
"G0 character diacritical 9",
"G0 character diacritical A",
"G0 character diacritical B",
"G0 character diacritical C",
"G0 character diacritical D",
"G0 character diacritical E",
"G0 character diacritical F"
};
};
class TripletModeQMenu : public QMenu
{
Q_OBJECT
public:
TripletModeQMenu(QWidget *parent = nullptr);
QAction *action(int n) const { return m_actions[n]; };
private:
void addModeAction(QMenu *menu, int mode);
QAction *m_actions[64];
ModeTripletNames m_modeTripletNames;
};
class TripletCLUTQMenu : public QMenu
{
Q_OBJECT
public:
TripletCLUTQMenu(bool rows, QWidget *parent = nullptr);
QAction *action(int n) const { return m_actions[n]; };
void setColour(int i, QColor c);
private:
QAction *m_actions[34];
};
class TripletCharacterQMenu : public QMenu
{
Q_OBJECT
public:
TripletCharacterQMenu(int charSet, bool mosaic, QWidget *parent = nullptr);
QAction *action(int n) const { return m_actions[n]; };
private:
QAction *m_actions[96];
TeletextFontBitmap m_fontBitmap;
};
class TripletFlashQMenu : public QMenu
{
Q_OBJECT
public:
TripletFlashQMenu(QWidget *parent = nullptr);
QAction *modeAction(int n) const { return m_actions[n]; };
QAction *ratePhaseAction(int n) const { return m_actions[n+4]; };
void setModeChecked(int n);
void setRatePhaseChecked(int n);
private:
QAction *m_actions[10];
QActionGroup *m_modeActionGroup, *m_ratePhaseActionGroup;
};
class TripletDisplayAttrsQMenu : public QMenu
{
Q_OBJECT
public:
TripletDisplayAttrsQMenu(QWidget *parent = nullptr);
QAction *textSizeAction(int n) const { return m_actions[n]; };
QAction *otherAttrAction(int n) const { return m_actions[n+4]; };
void setTextSizeChecked(int n);
void setOtherAttrChecked(int n, bool b);
private:
QAction *m_actions[8];
QActionGroup *m_sizeActionGroup, *m_otherActionGroup;
};
class TripletFontStyleQMenu : public QMenu
{
Q_OBJECT
public:
TripletFontStyleQMenu(QWidget *parent = nullptr);
QAction *styleAction(int n) const { return m_actions[n]; };
QAction *rowsAction(int n) const { return m_actions[n+3]; };
void setStyleChecked(int n, bool b);
void setRowsChecked(int n);
private:
QAction *m_actions[11];
QActionGroup *m_styleActionGroup, *m_rowsActionGroup;
};
#endif

928
src/qteletextmaker/x26model.cpp Normal file
View File

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

73
src/qteletextmaker/x26model.h Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef X26MODEL_H
#define X26MODEL_H
#include <QAbstractListModel>
#include "mainwidget.h"
#include "x26menus.h"
class X26Model : public QAbstractListModel
{
Q_OBJECT
public:
X26Model(TeletextWidget *parent);
void setX26ListLoaded(bool newListLoaded);
int rowCount(const QModelIndex &parent = QModelIndex()) const override ;
int columnCount(const QModelIndex &parent = QModelIndex()) const override;
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
bool setData(const QModelIndex &index, const QVariant &value, int role);
QVariant headerData(int section, Qt::Orientation orientation, int role) const;
bool insertRows(int position, int rows, const QModelIndex &parent);
bool insertRows(int position, int rows, const QModelIndex &parent, X26Triplet triplet);
bool removeRows(int position, int rows, const QModelIndex &index);
// Qt::ItemFlags flags(const QModelIndex &index) const;
// The x26commands classes manipulate the model but beginInsertRows and endInsertRows
// are protected methods, so we need to friend them
friend class InsertTripletCommand;
friend class DeleteTripletCommand;
friend class EditTripletCommand;
private:
TeletextWidget *m_parentMainWidget;
bool m_listLoaded;
TeletextFontBitmap m_fontBitmap;
ModeTripletNames m_modeTripletNames;
struct tripletErrorShow {
QString message;
int columnHighlight;
};
// Needs to be in the same order as enum X26TripletError in x26triplets.h
const tripletErrorShow m_tripletErrors[6] {
{ "", 0 }, // No error
{ "Active Position can't move up", 0 },
{ "Active Position can't move left within row", 1 },
{ "Invocation not pointing to Object Definition", 3 },
{ "Invoked and Defined Object types don't match", 2 },
{ "Origin Modifier not followed by Object Invocation", 2 }
};
};
#endif

243
src/qteletextmaker/x28commands.cpp Normal file
View File

@@ -0,0 +1,243 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#include "x28commands.h"
#include "document.h"
X28Command::X28Command(TeletextDocument *teletextDocument, QUndoCommand *parent) : QUndoCommand(parent)
{
m_teletextDocument = teletextDocument;
m_subPageIndex = teletextDocument->currentSubPageIndex();
}
SetFullScreenColourCommand::SetFullScreenColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent) : X28Command(teletextDocument, parent)
{
m_oldColour = teletextDocument->currentSubPage()->defaultScreenColour();
m_newColour = newColour;
setText(QObject::tr("full screen colour"));
}
void SetFullScreenColourCommand::redo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setDefaultScreenColour(m_newColour);
emit m_teletextDocument->contentsChanged();
emit m_teletextDocument->pageOptionsChanged();
}
void SetFullScreenColourCommand::undo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setDefaultScreenColour(m_oldColour);
emit m_teletextDocument->contentsChanged();
emit m_teletextDocument->pageOptionsChanged();
}
bool SetFullScreenColourCommand::mergeWith(const QUndoCommand *command)
{
const SetFullScreenColourCommand *newerCommand = static_cast<const SetFullScreenColourCommand *>(command);
if (m_subPageIndex != newerCommand->m_subPageIndex)
return false;
m_newColour = newerCommand->m_newColour;
return true;
}
SetFullRowColourCommand::SetFullRowColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent) : X28Command(teletextDocument, parent)
{
m_oldColour = teletextDocument->currentSubPage()->defaultRowColour();
m_newColour = newColour;
setText(QObject::tr("full row colour"));
}
void SetFullRowColourCommand::redo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setDefaultRowColour(m_newColour);
emit m_teletextDocument->contentsChanged();
emit m_teletextDocument->pageOptionsChanged();
}
void SetFullRowColourCommand::undo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setDefaultRowColour(m_oldColour);
emit m_teletextDocument->contentsChanged();
emit m_teletextDocument->pageOptionsChanged();
}
bool SetFullRowColourCommand::mergeWith(const QUndoCommand *command)
{
const SetFullRowColourCommand *newerCommand = static_cast<const SetFullRowColourCommand *>(command);
if (m_subPageIndex != newerCommand->m_subPageIndex)
return false;
m_newColour = newerCommand->m_newColour;
return true;
}
SetCLUTRemapCommand::SetCLUTRemapCommand(TeletextDocument *teletextDocument, int newMap, QUndoCommand *parent) : X28Command(teletextDocument, parent)
{
m_oldMap = teletextDocument->currentSubPage()->colourTableRemap();
m_newMap = newMap;
setText(QObject::tr("CLUT remapping"));
}
void SetCLUTRemapCommand::redo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setColourTableRemap(m_newMap);
emit m_teletextDocument->contentsChanged();
emit m_teletextDocument->pageOptionsChanged();
}
void SetCLUTRemapCommand::undo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setColourTableRemap(m_oldMap);
emit m_teletextDocument->contentsChanged();
emit m_teletextDocument->pageOptionsChanged();
}
bool SetCLUTRemapCommand::mergeWith(const QUndoCommand *command)
{
const SetCLUTRemapCommand *newerCommand = static_cast<const SetCLUTRemapCommand *>(command);
if (m_subPageIndex != newerCommand->m_subPageIndex)
return false;
m_newMap = newerCommand->m_newMap;
return true;
}
SetBlackBackgroundSubstCommand::SetBlackBackgroundSubstCommand(TeletextDocument *teletextDocument, bool newSub, QUndoCommand *parent) : X28Command(teletextDocument, parent)
{
m_oldSub = teletextDocument->currentSubPage()->blackBackgroundSubst();
m_newSub = newSub;
setText(QObject::tr("black background substitution"));
}
void SetBlackBackgroundSubstCommand::redo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setBlackBackgroundSubst(m_newSub);
emit m_teletextDocument->contentsChanged();
emit m_teletextDocument->pageOptionsChanged();
}
void SetBlackBackgroundSubstCommand::undo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setBlackBackgroundSubst(m_oldSub);
emit m_teletextDocument->contentsChanged();
emit m_teletextDocument->pageOptionsChanged();
}
bool SetBlackBackgroundSubstCommand::mergeWith(const QUndoCommand *command)
{
const SetBlackBackgroundSubstCommand *newerCommand = static_cast<const SetBlackBackgroundSubstCommand *>(command);
if (m_subPageIndex != newerCommand->m_subPageIndex)
return false;
setObsolete(true);
return true;
}
SetColourCommand::SetColourCommand(TeletextDocument *teletextDocument, int colourIndex, int newColour, QUndoCommand *parent) : X28Command(teletextDocument, parent)
{
m_colourIndex = colourIndex;
m_oldColour = teletextDocument->currentSubPage()->CLUT(colourIndex);
m_newColour = newColour;
setText(QObject::tr("colour change"));
}
void SetColourCommand::redo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setCLUT(m_colourIndex, m_newColour);
emit m_teletextDocument->colourChanged(m_colourIndex);
emit m_teletextDocument->contentsChanged();
}
void SetColourCommand::undo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
m_teletextDocument->currentSubPage()->setCLUT(m_colourIndex, m_oldColour);
emit m_teletextDocument->colourChanged(m_colourIndex);
emit m_teletextDocument->contentsChanged();
}
ResetCLUTCommand::ResetCLUTCommand(TeletextDocument *teletextDocument, int colourTable, QUndoCommand *parent) : X28Command(teletextDocument, parent)
{
m_colourTable = colourTable;
for (int i=m_colourTable*8; i<m_colourTable*8+8; i++)
m_oldColourEntry[i&7] = teletextDocument->currentSubPage()->CLUT(i);
setText(QObject::tr("CLUT %1 reset").arg(m_colourTable));
}
void ResetCLUTCommand::redo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
for (int i=m_colourTable*8; i<m_colourTable*8+8; i++) {
m_teletextDocument->currentSubPage()->setCLUT(i, m_teletextDocument->currentSubPage()->CLUT(i, 0));
emit m_teletextDocument->colourChanged(i);
}
emit m_teletextDocument->contentsChanged();
}
void ResetCLUTCommand::undo()
{
m_teletextDocument->selectSubPageIndex(m_subPageIndex);
for (int i=m_colourTable*8; i<m_colourTable*8+8; i++) {
m_teletextDocument->currentSubPage()->setCLUT(i, m_oldColourEntry[i&7]);
emit m_teletextDocument->colourChanged(i);
}
emit m_teletextDocument->contentsChanged();
}

126
src/qteletextmaker/x28commands.h Normal file
View File

@@ -0,0 +1,126 @@
/*
* Copyright (C) 2020-2024 Gavin MacGregor
*
* This file is part of QTeletextMaker.
*
* QTeletextMaker is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QTeletextMaker is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QTeletextMaker. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef X28COMMANDS_H
#define X28COMMANDS_H
#include <QUndoCommand>
#include "document.h"
class X28Command : public QUndoCommand
{
public:
X28Command(TeletextDocument *teletextDocument, QUndoCommand *parent = 0);
protected:
TeletextDocument *m_teletextDocument;
int m_subPageIndex;
};
class SetFullScreenColourCommand : public X28Command
{
public:
enum { Id = 301 };
SetFullScreenColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent = 0);
void redo() override;
void undo() override;
bool mergeWith(const QUndoCommand *command) override;
int id() const override { return Id; }
private:
int m_oldColour, m_newColour;
};
class SetFullRowColourCommand : public X28Command
{
public:
enum { Id = 302 };
SetFullRowColourCommand(TeletextDocument *teletextDocument, int newColour, QUndoCommand *parent = 0);
void redo() override;
void undo() override;
bool mergeWith(const QUndoCommand *command) override;
int id() const override { return Id; }
private:
int m_oldColour, m_newColour;
};
class SetCLUTRemapCommand : public X28Command
{
public:
enum { Id = 303 };
SetCLUTRemapCommand(TeletextDocument *teletextDocument, int newMap, QUndoCommand *parent = 0);
void redo() override;
void undo() override;
bool mergeWith(const QUndoCommand *command) override;
int id() const override { return Id; }
private:
int m_oldMap, m_newMap;
};
class SetBlackBackgroundSubstCommand : public X28Command
{
public:
enum { Id = 304 };
SetBlackBackgroundSubstCommand(TeletextDocument *teletextDocument, bool newSub, QUndoCommand *parent = 0);
void redo() override;
void undo() override;
bool mergeWith(const QUndoCommand *command) override;
int id() const override { return Id; }
private:
int m_oldSub, m_newSub;
};
class SetColourCommand : public X28Command
{
public:
SetColourCommand(TeletextDocument *teletextDocument, int colourIndex, int newColour, QUndoCommand *parent = 0);
void redo() override;
void undo() override;
private:
int m_colourIndex, m_oldColour, m_newColour;
};
class ResetCLUTCommand : public X28Command
{
public:
ResetCLUTCommand(TeletextDocument *teletextDocument, int colourTable, QUndoCommand *parent = 0);
void redo() override;
void undo() override;
private:
int m_colourTable;
int m_oldColourEntry[8];
};
#endif