Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731

1 files changed, 611 insertions, 0 deletions

diff --git a/src/codecs/qrtlcodec.cpp b/src/codecs/qrtlcodec.cpp
new file mode 100644
index 000000000..bd06308a5
--- /dev/null
+++ b/src/codecs/qrtlcodec.cpp
@@ -0,0 +1,611 @@
+/****************************************************************************
+**
+** Implementation of TQTextCodec class
+**
+** Created : 981015
+**
+** Copyright (C) 1998-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the tools module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file.  Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qrtlcodec.h"
+#include <private/qtextengine_p.h>
+
+#ifndef QT_NO_CODEC_HEBREW
+
+// NOT REVISED
+
+static const uchar unkn = '?'; // BLACK STQUARE (94) would be better
+
+static const ushort heb_to_unicode[128] = {
+    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    0x00A0, 0xFFFD, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
+    0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x203E,
+    0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
+    0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0xFFFD,
+    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
+    0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2017,
+    0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
+    0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
+    0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
+    0x05E8, 0x05E9, 0x05EA, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD
+};
+
+static const uchar unicode_to_heb_00[32] = {
+    0xA0, unkn, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
+    0xA8, 0xA9, 0xD7, 0xAB, 0xAC, 0xAD, 0xAE, unkn,
+    0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
+    0xB8, 0xB9, 0xF7, 0xBB, 0xBC, 0xBD, 0xBE, unkn,
+};
+
+static const uchar unicode_to_heb_05[32] = {
+    0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
+    0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
+    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
+    0xF8, 0xF9, 0xFA, unkn, unkn, unkn, unkn, unkn
+};
+
+static bool to8bit(const TQChar ch, TQCString *rstr)
+{
+    bool converted = FALSE;
+
+    if( ch.isMark() ) return TRUE; // ignore marks for conversion
+
+    if ( ch.row() ) {
+	if ( ch.row() == 0x05 ) {
+	    if ( ch.cell() > 0x91 )
+		converted = TRUE;
+	    // 0x0591 - 0x05cf: Hebrew punctuation... dropped
+	    if ( ch.cell() >= 0xD0 )
+		*rstr += (char)unicode_to_heb_05[ch.cell()- 0xD0];
+	} else if ( ch.row() == 0x20 ) {
+	    if ( ch.cell() == 0x3E ) {
+		*rstr += (char)0xAF;
+		converted = TRUE;
+	    } else if ( ch.cell() == 0x17 ) {
+		*rstr += (char)0xCF;
+		converted = TRUE;
+	    }
+	} else {
+	    converted = FALSE;
+	}
+    } else {
+	if ( ch.cell() < 0x80 ) {
+	    *rstr += (char)ch.cell();
+	    converted = TRUE;
+	} else if( ch.cell() < 0xA0 ) {
+	    *rstr += (char)unicode_to_heb_00[ch.cell() - 0x80];
+	    converted = TRUE;
+	}
+    }
+
+    if(converted) return TRUE;
+
+    // couldn't convert the char... lets try its decomposition
+    TQString d = ch.decomposition();
+    if(d.isNull())
+	return FALSE;
+
+    int l = d.length();
+    for (int i=0; i<l; i++) {
+	const TQChar ch = d[i];
+
+	if(to8bit(ch, rstr))
+	    converted = TRUE;
+    }
+
+    return converted;
+}
+
+#if 0
+static TQString run(const TQString &input, unsigned int from, unsigned int to, TQChar::Direction runDir)
+{
+    if ( to <= from )
+	return TQString::null;
+
+    TQString out;
+    if ( runDir == TQChar::DirR ) {
+	const TQChar *ch = input.unicode() + to - 1;
+	int len = to - from;
+	while (len--) {
+	    out += *ch;
+	    ch--;
+	}
+    } else {
+	out = input.mid(from, to - from );
+    }
+    return out;
+}
+
+/*
+  we might do better here, but I'm currently not sure if it's worth the effort. It will hopefully convert
+  90% of the visually ordered Hebrew correctly.
+*/
+static TQString reverseLine(const TQString &str, unsigned int from, unsigned int to, TQChar::Direction dir)
+{
+    TQString out;
+
+    if ( to <= from ) {
+	out += str.at(from);
+	return out;
+    }
+
+    // since we don't have embedding marks, we get around with bidi levels up to 2.
+
+    // simple case: dir = RTL:
+    // go through the line from right to left, and reverse all continuous Hebrew strings.
+    if ( dir == TQChar::DirR ) {
+	unsigned int pos = to;
+	to = from;
+	from = pos;
+	TQChar::Direction runDir = TQChar::DirON;
+
+	while ( pos > to ) {
+	    TQChar::Direction d = str.at(pos).direction();
+	    switch ( d ) {
+		case TQChar::DirL:
+		case TQChar::DirAN:
+		case TQChar::DirEN:
+		    if ( runDir != TQChar::DirL ) {
+			out += run( str, pos, from, runDir );
+			from = pos - 1;
+		    }
+		    runDir = TQChar::DirL;
+		    break;
+		case TQChar::DirON:
+		    if ( runDir == TQChar::DirON ) {
+			runDir = TQChar::DirR;
+			break;
+		    }
+		    // fall through
+		case TQChar::DirR:
+		    if ( runDir != TQChar::DirR ) {
+			out += run( str, pos, from, runDir );
+			from = pos - 1;
+		    }
+		    runDir = TQChar::DirR;
+		default:
+		    break;
+	    }
+	    pos--;
+	}
+	out += run( str, pos, from, runDir );
+    } else {
+	// basicDir == DirL. A bit more complicated, as we might need to reverse two times for numbers.
+	unsigned int pos = from;
+	TQChar::Direction runDir = TQChar::DirON;
+
+	// first reversing. Ignore numbers
+	while ( pos < to ) {
+	    TQChar::Direction d = str.at(pos).direction();
+	    switch ( d ) {
+		case TQChar::DirL:
+		    if ( runDir != TQChar::DirL && runDir != TQChar::DirON ) {
+			out += run( str, from, pos, runDir );
+			qDebug( "out = %s", out.latin1() );
+			from = pos;
+		    }
+		    runDir = TQChar::DirL;
+		    break;
+		case TQChar::DirON:
+		    if ( runDir == TQChar::DirON ) {
+			runDir = TQChar::DirL;
+			break;
+		    }
+		    // fall through
+		case TQChar::DirR:
+		case TQChar::DirAN:
+		case TQChar::DirEN:
+		    if ( runDir != TQChar::DirR && runDir != TQChar::DirON ) {
+			out += run( str, from, pos, runDir );
+			qDebug( "out = %s", out.latin1() );
+			from = pos;
+		    }
+		    runDir = TQChar::DirR;
+		default:
+		    break;
+	    }
+	    pos++;
+	}
+	out += run( str, from, pos, runDir );
+	qDebug( "out = %s", out.latin1() );
+	// second reversing for numbers
+	TQString in = out;
+	out = "";
+	pos = 0;
+	from = 0;
+	to = in.length() - 1;
+	runDir = TQChar::DirON;
+	while ( pos < to ) {
+	    TQChar::Direction d = str.at(pos).direction();
+	    switch ( d ) {
+		case TQChar::DirL:
+		case TQChar::DirON:
+		case TQChar::DirR:
+		    if ( runDir == TQChar::DirEN && runDir != TQChar::DirON ) {
+			out += run( in, from, pos, TQChar::DirR ); //DirR ensures reversing
+			qDebug( "out = %s", out.latin1() );
+			runDir = TQChar::DirR;
+			from = pos;
+		    }
+		    runDir = TQChar::DirL;
+		    break;
+		case TQChar::DirAN:
+		case TQChar::DirEN:
+		    if ( runDir != TQChar::DirEN && runDir != TQChar::DirON ) {
+			out += in.mid(from, pos-from+1);
+			qDebug( "out = %s", out.latin1() );
+			from = pos;
+		    }
+		    runDir = TQChar::DirEN;
+		default:
+		    break;
+	    }
+	    pos++;
+	}
+	out += run( str, from, pos, runDir );
+
+    }
+    return out;
+}
+#endif
+
+/* this function assuems the TQString is still visually ordered.
+ * Finding the basic direction of the text is not easy in this case, since
+ * a string like "my friend MOLAHS" could (in logical order) mean aswell
+ * "SHALOM my friend" or "my friend SHALOM", depending on the basic direction
+ * one assumes for the text.
+ *
+ * So this function uses some heuristics to find the right answer...
+ */
+static TQChar::Direction findBasicDirection(TQString str)
+{
+    unsigned int pos;
+    unsigned int len = str.length();
+    TQChar::Direction dir1 = TQChar::DirON;
+    TQChar::Direction dir2 = TQChar::DirON;
+
+    unsigned int startLine = 0;
+    // If the visual representation of the first line starts and ends with the same
+    // directionality, we know the answer.
+    pos = 0;
+    while (pos < len) {
+	if ( str.at(pos) == '\n' )
+	    startLine = pos;
+	if (str.at(pos).direction() < 2) { // DirR or DirL
+	    dir1 = str.at(pos).direction();
+	    break;
+	}
+	pos++;
+    }
+
+    if( pos == len ) // no directional chars, assume TQChar::DirL
+	return TQChar::DirL;
+
+    // move to end of line
+    while( pos < len && str.at(pos) != '\n' )
+	pos++;
+
+    while (pos > startLine) {
+	if (str.at(pos).direction() < 2) { // DirR or DirL
+	    dir2 = str.at(pos).direction();
+	    break;
+	}
+	pos--;
+    }
+
+    // both are the same, so we have the direction!
+    if ( dir1 == dir2 ) return dir1;
+
+    // guess with the help of punktuation marks...
+    // if the sentence ends with a punktuation, we should have a mark
+    // at one side of the text...
+
+    pos = 0;
+    while (pos < len-1 ) {
+	if(str.at(pos).category() == TQChar::Punctuation_Other) {
+	    if( str.at(pos) != (char)0xbf && str.at(pos) != (char)0xa1 ) // spanish inverted question and exclamation mark
+		if( str.at(pos+1).direction() < 2 ) return TQChar::DirR;
+	}
+	pos++;
+    }
+
+    pos = len;
+    while (pos < 1 && str.at(pos).direction() < 2 ) {
+	if(str.at(pos).category() == TQChar::Punctuation_Other) {
+	    if( str.at(pos-1).direction() < 2 ) return TQChar::DirL;
+	}
+	pos--;
+    }
+
+    // don't know try DirR...
+    return TQChar::DirR;
+}
+
+
+/*!
+    \class TQHebrewCodec qrtlcodec.h
+    \reentrant
+    \ingroup i18n
+
+    \brief The TQHebrewCodec class provides conversion to and from
+    visually ordered Hebrew.
+
+    Hebrew as a semitic language is written from right to left.
+    Because older computer systems couldn't handle reordering a string
+    so that the first letter appears on the right, many older
+    documents were encoded in visual order, so that the first letter
+    of a line is the rightmost one in the string.
+
+    In contrast to this, Unicode defines characters to be in logical
+    order (the order you would read the string). This codec tries to
+    convert visually ordered Hebrew (8859-8) to Unicode. This might
+    not always work perfectly, because reversing the \e bidi
+    (bi-directional) algorithm that transforms from logical to visual
+    order is non-trivial.
+
+    Transformation from Unicode to visual Hebrew (8859-8) is done
+    using the bidi algorithm in TQt, and will produce correct results,
+    so long as the codec is given the text a whole paragraph at a
+    time. Places where newlines are supposed to go can be indicated by
+    a newline character ('\n'). Note that these newline characters
+    change the reordering behaviour of the algorithm, since the bidi
+    reordering only takes place within one line of text, whereas
+    line breaks are determined in visual order.
+
+    Visually ordered Hebrew is still used tquite often in some places,
+    mainly in email communication (since most email programs still
+    don't understand logically ordered Hebrew) and on web pages. The
+    use on web pages is rapidly decreasing, due to the availability of
+    browsers that correctly support logically ordered Hebrew.
+
+    This codec has the name "iso8859-8". If you don't want any bidi
+    reordering to happen during conversion, use the "iso8859-8-i"
+    codec, which assumes logical order for the 8-bit string.
+*/
+
+/*! \reimp */
+int TQHebrewCodec::mibEnum() const
+{
+    return 11;
+}
+
+/*! \reimp */
+const char* TQHebrewCodec::name() const
+{
+    return "ISO 8859-8";
+}
+
+/*!
+    Returns the codec's mime name.
+*/
+const char* TQHebrewCodec::mimeName() const
+{
+    return "ISO-8859-8";
+}
+
+static TQString visualOrder(TQString logical, TQChar::Direction basicDir)
+{
+    logical.replace(TQChar('\n'), TQChar(0x2028));
+
+    TQTextEngine e(logical, 0);
+    e.direction = basicDir;
+    e.itemize();
+    Q_UINT8 l[256];
+    Q_UINT8 *levels = l;
+    int vo[256];
+    int *visualOrder = vo;
+    int nitems = e.items.size();
+    if (nitems > 255) {
+	levels = new Q_UINT8[nitems];
+	visualOrder = new int[nitems];
+    }
+    int i;
+    for (i = 0; i < nitems; ++i) {
+	//qDebug("item %d bidiLevel=%d", i,  e.items[i].analysis.bidiLevel);
+	levels[i] = e.items[i].analysis.bidiLevel;
+    }
+    e.bidiReorder(nitems, levels, visualOrder);
+
+    TQString visual;
+    for (i = 0; i < nitems; ++i) {
+	TQScriptItem &si = e.items[visualOrder[i]];
+	TQString sub = logical.mid(si.position, e.length(visualOrder[i]));
+	if (si.analysis.bidiLevel % 2) {
+	    // reverse sub
+	    TQChar *a = (TQChar *)sub.unicode();
+	    TQChar *b = a + sub.length() - 1;
+	    while (a < b) {
+		TQChar tmp = *a;
+		*a = *b;
+		*b = tmp;
+		++a;
+		--b;
+	    }
+	    a = (TQChar *)sub.unicode();
+	    b = a + sub.length();
+	    while (a<b) {
+		*a = a->mirroredChar();
+		++a;
+	    }
+	}
+	visual += sub;
+    }
+    // replace Unicode newline back with  \n to compare.
+    visual.replace(TQChar(0x2028), TQChar('\n'));
+    if (l != levels) {
+	delete [] levels;
+	delete [] visualOrder;
+    }
+    return visual;
+}
+
+/*!
+    \reimp
+
+    Since Hebrew (and Arabic) is written from left to right, but
+    iso8859-8 assumes visual ordering (as opposed to the logical
+    ordering of Unicode), we must reverse the order of the input
+    string (the first \a len characters of \a chars) to put it into
+    logical order.
+
+    One problem is that the basic text direction is unknown. So this
+    function uses some heuristics to guess it, and if it can't guess
+    the right one, it assumes, the basic text direction is right to
+    left.
+
+    This behaviour can be overridden, by putting a control character
+    at the beginning of the text to indicate which basic text
+    direction to use. If the basic text direction is left-to-right,
+    the control character should be (uchar) 0xFE. For right-to-left it
+    should be 0xFF. Both characters are undefined in the iso 8859-8
+    charset.
+
+    Example: A visually ordered string "english WERBEH american" would
+    be recognized as having a basic left to right direction. So the
+    logically ordered TQString would be "english HEBREW american".
+
+    By prepending a (uchar)0xFF at the start of the string,
+    TQHebrewCodec::toUnicode() would use a basic text direction of
+    right to left, and the string would thus become "american HEBREW
+    english".
+*/
+TQString TQHebrewCodec::toUnicode(const char* chars, int len ) const
+{
+    TQString r;
+    const unsigned char * c = (const unsigned char *)chars;
+    TQChar::Direction basicDir = TQChar::DirON; // neutral, we don't know
+
+    if( len == 0 ) return TQString::null;
+
+    // Test, if the user gives us a directionality.
+    // We use 0xFE and 0xFF in ISO8859-8 for that.
+    // These chars are undefined in the charset, and are mapped to
+    // RTL overwrite
+    if( c[0] == 0xfe ) {
+	basicDir = TQChar::DirL;
+	c++; // skip directionality hint
+    }
+    if( c[0] == 0xff ) {
+	basicDir = TQChar::DirR;
+	c++; // skip directionality hint
+    }
+
+    for( int i=0; i<len; i++ ) {
+	if ( c[i] > 127 )
+	    r[i] = heb_to_unicode[c[i]-128];
+	else
+	    r[i] = c[i];
+    }
+
+    // do transformation from visual byte ordering to logical byte
+    // ordering
+    if( basicDir == TQChar::DirON )
+	basicDir = findBasicDirection(r);
+
+    return visualOrder(r, basicDir);
+}
+
+/*!
+    Transforms the logically ordered TQString, \a uc, into a visually
+    ordered string in the 8859-8 encoding. TQt's bidi algorithm is used
+    to perform this task. Note that newline characters affect the
+    reordering, since reordering is done on a line by line basis.
+
+    The algorithm is designed to work on whole paragraphs of text, so
+    processing a line at a time may produce incorrect results. This
+    approach is taken because the reordering of the contents of a
+    particular line in a paragraph may depend on the previous line in
+    the same paragraph.
+
+    Some encodings (for example Japanese or UTF-8) are multibyte (so
+    one input character is mapped to two output characters). The \a
+    lenInOut argument specifies the number of TQChars that should be
+    converted and is set to the number of characters returned.
+*/
+TQCString TQHebrewCodec::fromUnicode(const TQString& uc, int& lenInOut) const
+{
+    // process only len chars...
+    int l;
+    if( lenInOut > 0 )
+	l = TQMIN((int)uc.length(),lenInOut);
+    else
+	l = (int)uc.length();
+
+    TQCString rstr;
+    if( l == 1 ) {
+	if( !to8bit( uc[0], &rstr ) )
+	    rstr += (char)unkn;
+    } else {
+	TQString tmp = uc;
+	tmp.truncate(l);
+	TQString vis = visualOrder(tmp, TQChar::DirON);
+
+	for (int i=0; i<l; i++) {
+	    const TQChar ch = vis[i];
+
+	    if( !to8bit( ch, &rstr ) )
+		rstr += (char)unkn;
+	}
+	// lenInOut = cursor - result;
+    }
+    if( l > 0 && !rstr.length() )
+	rstr += (char)unkn;
+
+    return rstr;
+}
+
+/*! \reimp
+ */
+int TQHebrewCodec::heuristicContentMatch(const char* chars, int len) const
+{
+    const unsigned char * c = (const unsigned char *)chars;
+
+    int score = 0;
+    for (int i=0; i<len; i++) {
+	if(c[i] > 0x80 ) {
+	    if ( heb_to_unicode[c[i] - 0x80] != 0xFFFD)
+		score++;
+	    else
+		return -1;
+	}
+    }
+    return score;
+}
+
+#endif