You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tqt3/src/codecs/qrtlcodec.cpp

612 lines
18 KiB

/****************************************************************************
**
** 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 quite 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